jig-ui 0.12.0 → 0.14.0

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync28 } from "fs";
-import { homedir } from "os";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync30 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join37 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -387,8 +387,8 @@ function render(template, vars) {
 function escapeTableCell(value) {
   return value.replace(/\|/g, "\\|");
 }
-function renderCommandTable(metadata) {
-  const rows = Object.entries(metadata).map(([name, meta]) => {
+function renderCommandTable(metadata2) {
+  const rows = Object.entries(metadata2).map(([name, meta]) => {
     const signature = meta.argumentHint ? `${name} ${meta.argumentHint}` : name;
     const status = meta.status === "planned" ? "planned \u2014 not yet implemented" : meta.status === "agent" ? "agent procedure \u2014 no CLI to run" : "available";
     return `| \`${escapeTableCell(signature)}\` | ${escapeTableCell(meta.description)} | ${status} |`;
@@ -522,7 +522,7 @@ function bundleFiles(packageRoot2, dir) {
 var ASK_INSTRUCTION = "Ask the user directly in chat, one question at a time, and wait for an answer before continuing.";
 function buildSkillBody(packageRoot2, rulesPath, version2) {
   const template = readFileSync4(join7(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
-  const metadata = JSON.parse(
+  const metadata2 = JSON.parse(
     readFileSync4(join7(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
   return render(template, {
@@ -533,16 +533,16 @@ function buildSkillBody(packageRoot2, rulesPath, version2) {
     // — so a reader following the skill could never upgrade.
     update_path: "npx jig-ui@latest",
     ask_instruction: ASK_INSTRUCTION,
-    available_commands: renderCommandTable(metadata),
+    available_commands: renderCommandTable(metadata2),
     config_file: "jig.config.json",
     rules_path: rulesPath
   });
 }
 function buildCommandBody(packageRoot2, rulesPath, version2, argsPlaceholder) {
-  const metadata = JSON.parse(
+  const metadata2 = JSON.parse(
     readFileSync4(join7(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
-  const subcommands = Object.entries(metadata).filter(([, meta]) => meta.status === "available" || meta.status === "agent").map(([name]) => name).sort();
+  const subcommands = Object.entries(metadata2).filter(([, meta]) => meta.status === "available" || meta.status === "agent").map(([name]) => name).sort();
   const templatePath = join7(packageRoot2, "templates", "COMMAND.md.tmpl");
   if (!existsSync5(templatePath)) return { body: "", subcommands };
   const template = readFileSync4(templatePath, "utf8");
@@ -1472,7 +1472,17 @@ var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "out",
   "coverage",
   ".svelte-kit",
-  "vendor"
+  "vendor",
+  // Where the agent harnesses keep their own files, including the copy of
+  // Jig's rules and slash command that `install` vendors. Those are the
+  // system's own text, not the project's interface: scanning them reported
+  // 115 em dashes in Jig's command file and called them the user's copy.
+  ".claude",
+  ".codex",
+  ".cursor",
+  ".opencode",
+  ".gemini",
+  ".github"
 ]);
 function isGitRepo(root) {
   try {
@@ -1796,6 +1806,41 @@ var STYLE_HOST_EXTENSIONS = [
 function isStyleBearing(file) {
   return hasExtension(file, CSS_EXTENSIONS) || hasExtension(file, STYLE_HOST_EXTENSIONS);
 }
+var MARKDOWN_EXTENSIONS = [".md", ".markdown", ".mdx"];
+var REPO_DOCUMENTS = /* @__PURE__ */ new Set([
+  "readme",
+  "changelog",
+  "contributing",
+  "license",
+  "licence",
+  "notice",
+  "code_of_conduct",
+  "security",
+  "support",
+  "governance",
+  "maintainers",
+  "authors",
+  "agents",
+  "claude",
+  "gemini",
+  "copilot-instructions",
+  // Jig's own: the project's decisions live beside the token layer, in
+  // `jig/DECISIONS.md`, and are written for whoever builds here.
+  "decisions",
+  "reconcile",
+  "coverage",
+  "drift"
+]);
+function isRepoDocument(file) {
+  const base = file.split("/").pop() ?? file;
+  const name = base.replace(/\.[^.]+$/, "");
+  if (REPO_DOCUMENTS.has(name.toLowerCase())) return true;
+  return !file.includes("/") && /^[A-Z0-9][A-Z0-9._-]*$/.test(name);
+}
+function isReaderText(file) {
+  if (hasExtension(file, MARKDOWN_EXTENSIONS)) return !isRepoDocument(file);
+  return hasExtension(file, STYLE_HOST_EXTENSIONS);
+}
 
 // src/check/run.ts
 import { readFileSync as readFileSync13 } from "fs";
@@ -3300,58 +3345,283 @@ var undeclaredToken = {
 };
 
 // src/check/detectors/em-dash.ts
-var MARKUP = [".html", ".htm", ".vue", ".svelte", ".astro", ".jsx", ".tsx", ".php", ".erb", ".twig", ".hbs"];
+var MARKDOWN = /\.(md|markdown|mdx)$/i;
+var INDENTED = /\.(pug|jade|haml|slim)$/i;
+var SCRIPT = /\.(js|mjs|cjs|ts|mts|cts)$/i;
+var CODEY = /[;{}`]|\$\{|=>/;
 var TEXT_ATTRS = /\b(aria-label|aria-description|aria-placeholder|title|placeholder|alt|label|value|content)\s*=\s*("([^"]*)"|'([^']*)')/gi;
 var EM_DASH = /—/;
+var TAG = /<\/?[A-Za-z][\w.:-]*(?:\s[^<>]*)?\/?>/g;
 function maskNonProse(source) {
   const blank3 = (m) => " ".repeat(m.length);
-  return source.replace(/<script\b[\s\S]*?<\/script\s*>/gi, blank3).replace(/<style\b[\s\S]*?<\/style\s*>/gi, blank3).replace(/<!--[\s\S]*?-->/g, blank3).replace(/\/\*[\s\S]*?\*\//g, blank3).replace(/(^|[^:])\/\/[^\n]*/g, (m, p1) => p1 + " ".repeat(m.length - p1.length));
+  return source.replace(/^---\n[\s\S]*?\n---/, blank3).replace(/<script\b[\s\S]*?<\/script\s*>/gi, blank3).replace(/<style\b[\s\S]*?<\/style\s*>/gi, blank3).replace(/<!--[\s\S]*?-->/g, blank3).replace(/\/\*[\s\S]*?\*\//g, blank3).replace(/(^|[^:])\/\/[^\n]*/g, (m, p1) => p1 + " ".repeat(m.length - p1.length));
+}
+function markdownProse(source) {
+  const blank3 = (m) => " ".repeat(m.length);
+  return source.replace(/^ {0,3}(`{3,}|~{3,})[\s\S]*?^ {0,3}\1[^\n]*$/gm, blank3).replace(/`[^`\n]*`/g, blank3).replace(/<!--[\s\S]*?-->/g, blank3).replace(/\]\([^)\s]*/g, blank3);
 }
-function proseSpans(masked) {
+function proseSpans(masked, edges) {
   const spans = [];
+  const tags = [...masked.matchAll(TAG)];
   let last = 0;
-  for (const tag of masked.matchAll(/<[^>]*>/g)) {
+  tags.forEach((tag, i) => {
     const between = masked.slice(last, tag.index);
-    if (between.trim()) spans.push({ index: last, text: between });
+    if (between.trim() && (edges || i > 0)) spans.push({ index: last, text: between });
     for (const attr of tag[0].matchAll(TEXT_ATTRS)) {
       const value = attr[3] ?? attr[4] ?? "";
       spans.push({ index: tag.index + attr.index + attr[0].indexOf(value), text: value });
     }
     last = tag.index + tag[0].length;
-  }
+  });
   const tail = masked.slice(last);
-  if (tail.trim()) spans.push({ index: last, text: tail });
+  if (tail.trim() && edges && tags.length > 0) spans.push({ index: last, text: tail });
   return spans;
 }
+function indentedProse(source) {
+  const blank3 = (m) => " ".repeat(m.length);
+  return source.split("\n").map((line) => /^\s*(-|\/\/|#(?!\w)|=)/.test(line) ? blank3(line) : line).join("\n");
+}
 var emDash = {
   name: "em-dash",
-  appliesTo: (file) => hasExtension(file, MARKUP),
+  appliesTo: (file) => isReaderText(file),
   run(_source, file, ctx) {
-    const masked = maskNonProse(ctx.raw);
+    const markdown = MARKDOWN.test(file);
+    const indented = INDENTED.test(file);
+    const masked = markdown ? markdownProse(ctx.raw) : indented ? indentedProse(maskNonProse(ctx.raw)) : maskNonProse(ctx.raw);
     const starts = buildLineIndex(ctx.raw);
     const findings = [];
     const seen = /* @__PURE__ */ new Set();
-    for (const span of proseSpans(masked)) {
+    const script = SCRIPT.test(file);
+    const spans = markdown || indented ? [{ index: 0, text: masked }] : proseSpans(masked, !script).filter((span) => !script || !CODEY.test(span.text));
+    for (const span of spans) {
       if (!EM_DASH.test(span.text)) continue;
-      const offset = span.index + span.text.indexOf("\u2014");
+      for (const hit of span.text.matchAll(/\u2014/g)) {
+        const line = lineForOffset(starts, span.index + hit.index);
+        if (seen.has(line)) continue;
+        seen.add(line);
+        findings.push(
+          mkFinding(
+            ctx,
+            "em-dash",
+            file,
+            line,
+            "an em dash in interface text: use a full stop, a comma, a colon, or a second element",
+            sourceLine(ctx.raw, line)
+          )
+        );
+      }
+    }
+    return findings.sort((a, b) => a.line - b.line);
+  }
+};
+
+// src/check/detectors/semantic-element.ts
+var BODY = /<body\b/i;
+var MAIN = /<main\b|role\s*=\s*["']main["']/i;
+var NAV_ELEMENT = /<nav\b|role\s*=\s*["']navigation["']/i;
+var CHROME = /<(header|footer)\b[\s\S]*?<\/\1\s*>/gi;
+var NAV_CONTAINER = /<(div|section|ul|span)\b[^>]*\b(?:class|className|id)\s*=\s*["'][^"']*\b(?:nav|navigation|navbar|menu)\b[^"']*["'][^>]*>/i;
+var LINK = /<a\b[^>]*\bhref\b/gi;
+var HEADING_SHAPED = /<(div|span|p)\b[^>]*\b(?:class|className)\s*=\s*["']([^"']*\b(?:title|heading|headline|text-(?:2xl|3xl|4xl|5xl))\b[^"']*)["'][^>]*>([\s\S]{0,120}?)<\/\1\s*>/gi;
+var HEADING_INSIDE = /<h[1-6]\b/i;
+var REPEATED = /<(div|article|section|a)\b[^>]*\b(?:class|className)\s*=\s*["']([^"']+)["']/gi;
+var LIST_OR_TABLE = /<(ul|ol|dl|table|tbody|menu)\b/i;
+var semanticElement = {
+  name: "semantic-element",
+  appliesTo: (file) => isReaderText(file),
+  run(_source, file, ctx) {
+    const raw = ctx.raw;
+    if (!BODY.test(raw)) return [];
+    const starts = buildLineIndex(raw);
+    const findings = [];
+    const at = (offset, message) => {
       const line = lineForOffset(starts, offset);
-      if (seen.has(line)) continue;
-      seen.add(line);
-      findings.push(
-        mkFinding(
-          ctx,
-          "em-dash",
-          file,
-          line,
-          "an em dash in interface text: use a full stop, a comma, a colon, or a second element",
-          sourceLine(ctx.raw, line)
-        )
+      findings.push(mkFinding(ctx, "semantic-element", file, line, message, sourceLine(raw, line)));
+    };
+    if (!MAIN.test(raw)) {
+      at(
+        BODY.exec(raw).index,
+        "this page has no <main> \u2014 nothing tells a reader skipping the chrome where the page itself starts"
       );
     }
+    if (!NAV_ELEMENT.test(raw)) {
+      const container = NAV_CONTAINER.exec(raw);
+      const links = (raw.match(LINK) ?? []).length;
+      if (container && links >= 3) {
+        at(container.index, "navigation links in a generic container, with no <nav> on the page \u2014 the element is what makes it a landmark, not the class name");
+      } else {
+        for (const region of raw.matchAll(CHROME)) {
+          if ((region[0].match(LINK) ?? []).length < 3) continue;
+          at(region.index, `the ${region[1].toLowerCase()} holds a row of links and the page has no <nav> \u2014 a set of destinations is a navigation landmark, and the element is what makes it one`);
+          break;
+        }
+      }
+    }
+    for (const m of raw.matchAll(HEADING_SHAPED)) {
+      if (HEADING_INSIDE.test(m[3])) continue;
+      const text = m[3].replace(/<[^>]*>/g, "").trim();
+      if (!text || text.length > 80) continue;
+      at(m.index, `"${text.slice(0, 40)}" is a ${m[1].toLowerCase()} named and styled as a heading \u2014 if it is the heading, it is an h1-h6, and CSS gives it the size`);
+    }
+    if (!LIST_OR_TABLE.test(raw)) {
+      const counts = /* @__PURE__ */ new Map();
+      for (const m of raw.matchAll(REPEATED)) {
+        const key = `${m[1].toLowerCase()}.${m[2].trim()}`;
+        const seen = counts.get(key) ?? { n: 0, index: m.index };
+        counts.set(key, { n: seen.n + 1, index: seen.index });
+      }
+      const repeated = [...counts.entries()].filter(([, v]) => v.n >= 3).sort((a, b) => a[1].index - b[1].index)[0];
+      if (repeated) {
+        at(repeated[1].index, `${repeated[1].n} sibling ${repeated[0]} elements are a repeated set, and nothing on this page is a list or a table \u2014 decide which collection this is (ul, ol, dl, table) before using a generic container`);
+      }
+    }
     return findings;
   }
 };
 
+// src/check/metadata.ts
+var QUOTED = `(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`;
+var HTML_TITLE = /<title[^>]*>([\s\S]*?)<\/title\s*>/i;
+var HTML_DESCRIPTION = /<meta[^>]+name\s*=\s*["']description["'][^>]*content\s*=\s*["']([^"']*)["']/i;
+var HTML_DESCRIPTION_REVERSED = /<meta[^>]+content\s*=\s*["']([^"']*)["'][^>]*name\s*=\s*["']description["']/i;
+var KEYED_TITLE = new RegExp(`(?:^|[\\s{,])(?:title|ogTitle|og:title)\\s*:\\s*${QUOTED}`, "m");
+var KEYED_TITLE_ALL = new RegExp(`(?:^|[\\s{,])(?:title|ogTitle|og:title)\\s*:\\s*${QUOTED}`, "gm");
+var HTML_TITLE_ALL = /<title[^>]*>([\s\S]*?)<\/title\s*>/gi;
+var KEYED_DESCRIPTION = new RegExp(`(?:^|[\\s{,])(?:description|ogDescription|og:description)\\s*:\\s*${QUOTED}`, "m");
+var COMPUTED_TITLE = /(?:^|[\s{,])(?:title|ogTitle)\s*:\s*(?!["'`])[A-Za-z_$][\w$.?[\]()]*|(?:^|[\s{,])(?:title|ogTitle)\s*:\s*`[^`]*\$\{/m;
+var ANY_TITLE = /<title[\s>]|(?:^|[\s{,])(?:title|ogTitle)\s*:|['"]title['"]\s*[,:]|titleTemplate/im;
+var ANY_DESCRIPTION = /name\s*=\s*["']description["']|(?:^|[\s{,])(?:description|ogDescription)\s*:|['"]description['"]\s*[,:]/im;
+var DECLARES = /export\s+(?:const|async\s+function|function)\s+(?:metadata|generateMetadata|meta)\b|useSeoMeta\s*\(|useHead\s*\(|defineRouteMeta\s*\(|<svelte:head|<Head\b|next\/head|react-helmet|<title[^>]*>|<meta\b/i;
+var NOINDEX = [
+  /<meta[^>]+name\s*=\s*["']robots["'][^>]*content\s*=\s*["'][^"']*noindex/i,
+  /robots\s*:\s*{[^}]*index\s*:\s*false/i,
+  /robots\s*:\s*["'][^"']*noindex/i,
+  /["']noindex["']/i,
+  /X-Robots-Tag[^\n]*noindex/i,
+  /noindex\s*:\s*true/i
+];
+function firstGroup(match) {
+  if (!match) return void 0;
+  const value = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+  if (!value) return void 0;
+  return { value, index: match.index ?? 0 };
+}
+function readMetadata(source) {
+  const htmlTitle = firstGroup(HTML_TITLE.exec(source));
+  const title = htmlTitle ?? firstGroup(KEYED_TITLE.exec(source));
+  const description = firstGroup(HTML_DESCRIPTION.exec(source)) ?? firstGroup(HTML_DESCRIPTION_REVERSED.exec(source)) ?? firstGroup(KEYED_DESCRIPTION.exec(source));
+  const titles = [];
+  for (const re of [HTML_TITLE_ALL, KEYED_TITLE_ALL]) {
+    for (const match of source.matchAll(re)) {
+      const found = firstGroup(match);
+      if (found && !/^\{|\$\{/.test(found.value)) titles.push(found);
+    }
+  }
+  return {
+    titles,
+    title: title && !/^\{|\$\{/.test(title.value) ? title : void 0,
+    description: description && !/^\{|\$\{/.test(description.value) ? description : void 0,
+    hasTitle: ANY_TITLE.test(source),
+    hasDescription: ANY_DESCRIPTION.test(source),
+    declares: DECLARES.test(source),
+    computedTitle: COMPUTED_TITLE.test(source),
+    noindex: NOINDEX.some((re) => re.test(source))
+  };
+}
+function isWholeDocument(source) {
+  return /<html[\s>]/i.test(source) && /<head[\s>]/i.test(source);
+}
+var TITLE_BUDGET = 60;
+var DESCRIPTION_BUDGET = 155;
+
+// src/check/detectors/metadata.ts
+var INVENTED_DATE = /(?:lastModified|datePublished|dateModified|publishedTime|modifiedTime)\s*:\s*(?:new Date\(\s*\)|Date\.now\(\s*\))/;
+var metadata = {
+  name: "metadata",
+  appliesTo: (file) => isReaderText(file),
+  run(_source, file, ctx) {
+    const raw = ctx.raw;
+    const found = readMetadata(raw);
+    const starts = buildLineIndex(raw);
+    const findings = [];
+    const at = (rule, offset, message) => {
+      const line = lineForOffset(starts, offset);
+      findings.push({ ...mkFinding(ctx, "metadata", file, line, message, sourceLine(raw, line)), ruleId: rule });
+    };
+    for (const title of found.titles) {
+      if (title.value.length > TITLE_BUDGET) {
+        at("J-122", title.index, `the title is ${title.value.length} characters, past the ${TITLE_BUDGET} a search result shows \u2014 the end is cut, mid-sentence`);
+      }
+    }
+    if (found.description && found.description.value.length > DESCRIPTION_BUDGET) {
+      at("J-122", found.description.index, `the description is ${found.description.value.length} characters, past the ${DESCRIPTION_BUDGET} a search result shows`);
+    }
+    const invented = INVENTED_DATE.exec(raw);
+    if (invented) {
+      at("J-125", invented.index, "a date generated at request time is false on every request, and repeated daily it teaches the crawler to disbelieve the field");
+    }
+    if (isWholeDocument(raw)) {
+      const indexable = ctx.mode !== "product" && ctx.mode !== "operator";
+      if (indexable && !found.hasTitle) {
+        at("J-121", 0, "this page has no <title> \u2014 a search result then shows a truncated URL");
+      }
+      if (indexable && !found.hasDescription) {
+        at("J-121", 0, "this page has no meta description \u2014 the search engine writes one from whatever text it finds first, usually the navigation");
+      }
+      if (!indexable && !found.noindex) {
+        at("J-123", 0, `this surface is ${ctx.mode}, which is what somebody reaches after signing in, and the page carries no noindex \u2014 robots.txt is public and advisory, and is not this`);
+      }
+    }
+    return findings.filter((f) => f.ruleId === ctx.ruleId);
+  }
+};
+
+// src/check/detectors/interface-safety.ts
+var BLANK_LINK = /<a\b[^>]*\btarget\s*=\s*["']_blank["'][^>]*>/gi;
+var HAS_NOOPENER = /\brel\s*=\s*["'][^"']*\bno(?:opener|referrer)\b/i;
+var HTML_SINK = /\bdangerouslySetInnerHTML|\bv-html|\binnerHTML\s*=|\{@html\b/g;
+var IN_SCRIPT = /<script\b[^>]*$/i;
+var SERIALISED = /JSON\.stringify\s*\(/;
+var LITERAL_SINK = /dangerouslySetInnerHTML\s*=\s*\{\{\s*__html:\s*["'`]|innerHTML\s*=\s*["'`]/;
+var CREDENTIAL_FIELD = /<input\b[^>]*\btype\s*=\s*["'](?:password)["'][^>]*>/gi;
+var AUTOCOMPLETE_OFF = /\bautocomplete\s*=\s*["'](?:off|false)["']/i;
+var IFRAME = /<iframe\b[^>]*>/gi;
+var HAS_SANDBOX = /\bsandbox\s*=/i;
+var EXTERNAL_SRC = /\bsrc\s*=\s*["'](?:https?:)?\/\//i;
+var interfaceSafety = {
+  name: "interface-safety",
+  appliesTo: (file) => isReaderText(file),
+  run(_source, file, ctx) {
+    const raw = ctx.raw;
+    const starts = buildLineIndex(raw);
+    const findings = [];
+    const at = (rule, offset, message) => {
+      const line = lineForOffset(starts, offset);
+      findings.push({ ...mkFinding(ctx, "interface-safety", file, line, message, sourceLine(raw, line)), ruleId: rule });
+    };
+    for (const link of raw.matchAll(BLANK_LINK)) {
+      if (HAS_NOOPENER.test(link[0])) continue;
+      at("K-128", link.index, 'a link opening a new tab with no rel="noopener" \u2014 the page it opens gets a handle on this window and can navigate it elsewhere');
+    }
+    for (const sink of raw.matchAll(HTML_SINK)) {
+      const context = raw.slice(sink.index, sink.index + 120);
+      if (LITERAL_SINK.test(context) || SERIALISED.test(context)) continue;
+      const before = raw.slice(Math.max(0, sink.index - 400), sink.index);
+      if (IN_SCRIPT.test(before.slice(before.lastIndexOf("<")))) continue;
+      at("K-129", sink.index, `${sink[0].replace(/\s*=$/, "")} writes a value into the page as markup \u2014 render it as text, or sanitise on the way in`);
+    }
+    for (const field of raw.matchAll(CREDENTIAL_FIELD)) {
+      if (!AUTOCOMPLETE_OFF.test(field[0])) continue;
+      at("K-130", field.index, "a password field with autocomplete off \u2014 this stops the password manager, not an attacker, and the reader falls back to one they can remember");
+    }
+    for (const frame of raw.matchAll(IFRAME)) {
+      if (HAS_SANDBOX.test(frame[0]) || !EXTERNAL_SRC.test(frame[0])) continue;
+      at("K-131", frame.index, "a frame of somebody else's page with no sandbox \u2014 give it only the capabilities the embed needs");
+    }
+    return findings.filter((f) => f.ruleId === ctx.ruleId);
+  }
+};
+
 // src/check/registry.ts
 var DETECTORS = [
   gradientText,
@@ -3370,7 +3640,10 @@ var DETECTORS = [
   safeArea,
   menuState,
   undeclaredToken,
-  emDash
+  emDash,
+  semanticElement,
+  metadata,
+  interfaceSafety
 ];
 function getDetector(name) {
   return DETECTORS.find((d) => d.name === name);
@@ -4934,8 +5207,8 @@ Could not write to ${wireTarget}: ${err.message}`);
 }
 
 // src/commands/verdicts.ts
-import { existsSync as existsSync18, readFileSync as readFileSync25 } from "fs";
-import { join as join31, resolve as resolve4 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync26 } from "fs";
+import { join as join33, resolve as resolve4 } from "path";
 
 // src/rules/citations.ts
 import { join as join28 } from "path";
@@ -4949,16 +5222,16 @@ function citableIds(packageRoot2) {
 }
 
 // src/probe/check.ts
-import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync24 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync13, readFileSync as readFileSync24 } from "fs";
+import { join as join31 } from "path";
 
 // src/probe/save.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync23, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readdirSync as readdirSync12, readFileSync as readFileSync23, writeFileSync as writeFileSync6 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join29, relative as relative3, resolve as resolve3 } from "path";
+import { join as join30, relative as relative3, resolve as resolve3 } from "path";
 
 // src/probe/script.ts
-var PROBE_VERSION = 2;
+var PROBE_VERSION = 5;
 var PROBE_SCRIPT = `(async () => {
   const doc = document.documentElement;
   const vis = (e) => { const r = e.getBoundingClientRect(); const s = getComputedStyle(e); return r.width > 0 && r.height > 0 && s.visibility !== 'hidden' && s.display !== 'none'; };
@@ -4978,6 +5251,62 @@ var PROBE_SCRIPT = `(async () => {
       }
     }
   }
+  // Markup order against reading order (H-119). Only a vertical inversion
+  // counts: an element that sits entirely ABOVE another on screen while coming
+  // after it in the markup. Two columns side by side are not an inversion \u2014
+  // putting the sidebar after the main content and moving it left with CSS is
+  // the correct pattern, and flagging it would punish the right answer.
+  // What to call a region in a report: its own label, else its heading, else
+  // nothing. Its whole text content reads as gibberish inside a finding.
+  const label = (el) => {
+    const aria = (el.getAttribute('aria-label') || '').trim();
+    if (aria) return aria;
+    const id = el.getAttribute('aria-labelledby');
+    const target = id ? document.getElementById(id) : null;
+    const heading = target || (/^h[1-6]$/i.test(el.tagName) ? el : el.querySelector('h1, h2, h3, h4, h5, h6'));
+    const t = (heading ? heading.textContent : '').replace(/\\s+/g, ' ').trim();
+    return t.length > 42 ? t.slice(0, 40).trimEnd() + '\u2026' : t;
+  };
+  const all = [...document.querySelectorAll('main, nav, aside, header, footer, section, article, h1, h2, h3')].filter(vis);
+  // Only the outermost regions. A nested heading inverts with its own parent
+  // and with every sibling of it, so one swapped column reported four times.
+  const landmarks = all
+    .filter((el) => !all.some((other) => other !== el && other.contains(el)))
+    .map((el, order) => {
+      const r = el.getBoundingClientRect();
+      return {
+        order,
+        tag: el.tagName.toLowerCase(),
+        name: label(el),
+        top: Math.round(r.top + scrollY),
+        bottom: Math.round(r.bottom + scrollY),
+      };
+    });
+  const describe = (l) => '<' + l.tag + '>' + (l.name ? ' \u201C' + l.name + '\u201D' : '');
+  const inversions = [];
+  for (let i = 0; i < landmarks.length; i++) {
+    for (let j = i + 1; j < landmarks.length; j++) {
+      const earlier = landmarks[i], later = landmarks[j];
+      // The later element sits wholly above the earlier one, past a rounding wobble.
+      if (later.bottom - earlier.top <= 8 && later.top < earlier.top) {
+        inversions.push({ markupFirst: describe(earlier), seenFirst: describe(later) });
+      }
+    }
+  }
+  // What a wide screen exposes: a layout with no upper bound, and the lines it
+  // stretches. Measured rather than guessed \u2014 a paragraph's own width and font
+  // size give its length in characters, which is what B-11 is written about.
+  const region = document.querySelector('main') || document.body;
+  const prose = [...document.querySelectorAll('p, li, dd, blockquote')].filter(vis)
+    .map((el) => {
+      const r = el.getBoundingClientRect();
+      const size = parseFloat(getComputedStyle(el).fontSize) || 16;
+      const text = (el.textContent || '').trim();
+      // 0.5em per character is the usual approximation for a text face.
+      return { width: Math.round(r.width), chars: Math.round(r.width / (size * 0.5)), text: text.slice(0, 40), long: text.length > 80 };
+    })
+    .filter((p) => p.long)
+    .sort((a, b) => b.chars - a.chars)[0] || null;
   const navLinks = () => [...document.querySelectorAll('nav a, header a, [role=navigation] a')].filter(vis).length;
   // Measured before anything is clicked: what a reader sees on arrival.
   const navAtRest = navLinks();
@@ -5022,12 +5351,194 @@ var PROBE_SCRIPT = `(async () => {
     defaultFont: getComputedStyle(document.body).fontFamily === defaultFont,
     unresolvedTokens: [...unresolved],
     junkText: junk,
+    emDashes: [...new Set((text.match(/[^.!?\\n]{0,28}\u2014[^.!?\\n]{0,28}/g) || []).map((t) => t.trim()))].slice(0, 5),
     brokenImages: [...document.images].filter((i) => i.complete && i.naturalWidth === 0).length,
     navLinksVisible: navAtRest,
+    head: {
+      title: (document.title || '').trim(),
+      description: (document.querySelector('meta[name=description]') || {}).content || '',
+      canonical: (document.querySelector('link[rel=canonical]') || {}).href || '',
+      robots: (document.querySelector('meta[name=robots]') || {}).content || '',
+      ogTitle: (document.querySelector('meta[property="og:title"]') || {}).content || '',
+      ogImage: (document.querySelector('meta[property="og:image"]') || {}).content || '',
+    },
+    contentWidth: Math.round(region.getBoundingClientRect().width),
+    contentMaxWidth: getComputedStyle(region).maxWidth,
+    longestLine: prose,
+    landmarks: landmarks.map(describe),
+    orderInversions: inversions.slice(0, 5),
     menu,
   });
 })()`;
 
+// src/probe/browser.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync16, mkdtempSync, readdirSync as readdirSync11, rmSync as rmSync3 } from "fs";
+import { homedir, tmpdir } from "os";
+import { join as join29 } from "path";
+var CHROME_ENV = ["JIG_CHROME", "CHROME_PATH", "PUPPETEER_EXECUTABLE_PATH", "CHROMIUM_PATH"];
+var CHROME_COMMANDS = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"];
+var CHROME_APPS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+  "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+];
+function cachedBrowsers() {
+  const roots = [
+    join29(homedir(), ".cache", "ms-playwright"),
+    join29(homedir(), "Library", "Caches", "ms-playwright"),
+    join29(homedir(), "AppData", "Local", "ms-playwright"),
+    join29(homedir(), ".cache", "puppeteer", "chrome")
+  ];
+  const found = [];
+  for (const root of roots) {
+    let entries;
+    try {
+      entries = readdirSync11(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries.sort().reverse()) {
+      for (const rel of [
+        ["chrome-linux", "chrome"],
+        ["chrome-linux64", "chrome"],
+        ["chrome-headless-shell-linux64", "chrome-headless-shell"],
+        ["chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium"],
+        ["chrome-mac-arm64", "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing"],
+        ["chrome-win", "chrome.exe"],
+        ["chrome-win64", "chrome.exe"]
+      ]) {
+        const candidate = join29(root, entry, ...rel);
+        if (existsSync16(candidate)) found.push(candidate);
+      }
+    }
+  }
+  return found;
+}
+function findChrome() {
+  for (const key of CHROME_ENV) {
+    const value = process.env[key];
+    if (value && existsSync16(value)) return value;
+  }
+  for (const command of CHROME_COMMANDS) {
+    const resolved = which(command);
+    if (resolved) return resolved;
+  }
+  for (const app of CHROME_APPS) if (existsSync16(app)) return app;
+  return cachedBrowsers()[0];
+}
+function which(command) {
+  const dirs = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+  for (const dir of dirs) {
+    if (!dir) continue;
+    const candidate = join29(dir, command);
+    if (existsSync16(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function runProbe(opts) {
+  const chrome = opts.chrome ?? findChrome();
+  if (!chrome) {
+    throw new Error(
+      "No browser found to run the probe. Install one, or set JIG_CHROME to a Chrome, Chromium or Edge binary. A project with Playwright or Puppeteer already has one, and Jig will find it."
+    );
+  }
+  const profile = mkdtempSync(join29(tmpdir(), "jig-probe-"));
+  const child = spawn(chrome, [
+    "--headless=new",
+    "--remote-debugging-port=0",
+    `--user-data-dir=${profile}`,
+    "--no-first-run",
+    "--no-default-browser-check",
+    "--disable-gpu",
+    "--hide-scrollbars",
+    "--disable-extensions",
+    "--disable-background-networking",
+    "--no-sandbox",
+    "about:blank"
+  ], { stdio: ["ignore", "ignore", "pipe"] });
+  const timeoutMs = opts.timeoutMs ?? 3e4;
+  try {
+    const endpoint = await new Promise((done, fail) => {
+      const timer = setTimeout(() => fail(new Error(`${chrome} did not start within ${timeoutMs / 1e3}s.`)), timeoutMs);
+      let buffered = "";
+      child.stderr.on("data", (chunk) => {
+        buffered += chunk.toString();
+        const match = /ws:\/\/[^\s]+/.exec(buffered);
+        if (match) {
+          clearTimeout(timer);
+          done(match[0]);
+        }
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        fail(new Error(`${chrome} exited with code ${code} before it was ready.`));
+      });
+    });
+    return await evaluate(endpoint, opts.url, opts.width, opts.height ?? 900, timeoutMs);
+  } finally {
+    child.kill();
+    rmSync3(profile, { recursive: true, force: true });
+  }
+}
+async function evaluate(endpoint, url, width, height, timeoutMs) {
+  const socket = new WebSocket(endpoint);
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const loaded = { fired: false, waiters: [] };
+  await new Promise((done, fail) => {
+    socket.addEventListener("open", () => done(), { once: true });
+    socket.addEventListener("error", () => fail(new Error("Could not connect to the browser.")), { once: true });
+  });
+  socket.addEventListener("message", (event) => {
+    const message = JSON.parse(String(event.data));
+    if (message.id && pending.has(message.id)) {
+      const { done, fail } = pending.get(message.id);
+      pending.delete(message.id);
+      if (message.error) fail(new Error(message.error.message));
+      else done(message.result ?? {});
+    }
+    if (message.method === "Page.loadEventFired") {
+      loaded.fired = true;
+      for (const waiter of loaded.waiters.splice(0)) waiter();
+    }
+  });
+  const send = (method, params = {}, sessionId) => new Promise((done, fail) => {
+    const id = nextId++;
+    pending.set(id, { done, fail });
+    socket.send(JSON.stringify({ id, method, params, sessionId }));
+    setTimeout(() => {
+      if (pending.delete(id)) fail(new Error(`${method} timed out.`));
+    }, timeoutMs);
+  });
+  try {
+    const target = await send("Target.createTarget", { url: "about:blank" });
+    const attached = await send("Target.attachToTarget", { targetId: target.targetId, flatten: true });
+    const session = attached.sessionId;
+    await send("Page.enable", {}, session);
+    await send("Emulation.setDeviceMetricsOverride", { width, height, deviceScaleFactor: 1, mobile: false }, session);
+    await send("Page.navigate", { url }, session);
+    if (!loaded.fired) {
+      await Promise.race([
+        new Promise((done) => loaded.waiters.push(done)),
+        new Promise((done) => setTimeout(done, timeoutMs / 2))
+      ]);
+    }
+    await new Promise((done) => setTimeout(done, 250));
+    const result = await send("Runtime.evaluate", { expression: PROBE_SCRIPT, awaitPromise: true, returnByValue: true }, session);
+    const value = result.result?.value;
+    if (typeof value !== "string") {
+      const description = result.exceptionDetails?.text;
+      throw new Error(`The probe returned nothing${description ? `: ${description}` : ""}. Is ${url} a page this browser can open?`);
+    }
+    return value;
+  } finally {
+    socket.close();
+  }
+}
+
 // src/probe/save.ts
 function saveProbe(opts) {
   let probe;
@@ -5049,9 +5560,9 @@ function saveProbe(opts) {
   probe.pageFile = relative3(opts.projectRoot, page).split("\\").join("/");
   probe.pageChecksum = checksum(readFileSync23(page, "utf8"));
   probe.recordedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join29(opts.projectRoot, ".jig", "critique", opts.surface);
+  const dir = join30(opts.projectRoot, ".jig", "critique", opts.surface);
   mkdirSync7(dir, { recursive: true });
-  const path = join29(dir, `probe-${width}.json`);
+  const path = join30(dir, `probe-${width}.json`);
   writeFileSync6(path, JSON.stringify(probe), "utf8");
   return { path: `.jig/critique/${opts.surface}/probe-${width}.json`, width, page: probe.pageFile };
 }
@@ -5065,7 +5576,49 @@ function pageFile(projectRoot, url) {
   }
   const abs = resolve3(path);
   if (!abs.startsWith(resolve3(projectRoot))) return void 0;
-  return existsSync16(abs) ? abs : void 0;
+  return existsSync17(abs) ? abs : void 0;
+}
+var PROBE_WIDTHS = [360, 768, 1280, 1600];
+async function runAndSaveProbes(opts) {
+  const abs = resolve3(opts.projectRoot, opts.page);
+  if (!existsSync17(abs)) throw new Error(`${opts.page} does not exist, so there is nothing to render.`);
+  const url = /^https?:/i.test(opts.page) ? opts.page : `file://${abs}`;
+  const saved = [];
+  for (const width of opts.widths ?? PROBE_WIDTHS) {
+    const json = await runProbe({ url, width });
+    saved.push(saveProbe({ projectRoot: opts.projectRoot, surface: opts.surface, json }));
+  }
+  return saved;
+}
+async function ensureProbes(opts) {
+  const dir = join30(opts.projectRoot, ".jig", "critique", opts.surface);
+  const abs = resolve3(opts.projectRoot, opts.page);
+  let current;
+  try {
+    current = checksum(readFileSync23(abs, "utf8"));
+  } catch {
+    return { recorded: [], reason: `${opts.page} could not be read` };
+  }
+  const missing = PROBE_WIDTHS.filter((width) => {
+    try {
+      const probe = JSON.parse(readFileSync23(join30(dir, `probe-${width}.json`), "utf8"));
+      return probe.jigProbe !== PROBE_VERSION || probe.pageChecksum !== current;
+    } catch {
+      return true;
+    }
+  });
+  if (missing.length === 0) return { recorded: [] };
+  if (!findChrome()) return { recorded: [], reason: "no browser on this machine" };
+  const url = /^https?:/i.test(opts.page) ? opts.page : `file://${abs}`;
+  for (const width of missing) {
+    saveProbe({ projectRoot: opts.projectRoot, surface: opts.surface, json: await runProbe({ url, width }) });
+  }
+  return { recorded: missing };
+}
+function critiquedSurfaces(projectRoot) {
+  const root = join30(projectRoot, ".jig", "critique");
+  if (!existsSync17(root)) return [];
+  return readdirSync12(root).filter((surface) => existsSync17(join30(root, surface, "screen.json")) || existsSync17(join30(root, surface, "code.json")));
 }
 
 // src/probe/check.ts
@@ -5087,11 +5640,11 @@ function stampProblem(projectRoot, file, p) {
   return void 0;
 }
 function readProbes(projectRoot, dir, errors) {
-  if (!existsSync17(dir)) return [];
+  if (!existsSync18(dir)) return [];
   const probes = [];
-  for (const f of readdirSync11(dir).filter((n) => /^probe-\d+\.json$/.test(n)).sort()) {
+  for (const f of readdirSync13(dir).filter((n) => /^probe-\d+\.json$/.test(n)).sort()) {
     try {
-      const p = JSON.parse(readFileSync24(join30(dir, f), "utf8"));
+      const p = JSON.parse(readFileSync24(join31(dir, f), "utf8"));
       if (p.jigProbe !== PROBE_VERSION || typeof p.width !== "number") {
         errors.push(`${f} is not output of \`jig probe\` (version ${PROBE_VERSION}). Re-run the probe; do not write it by hand.`);
         continue;
@@ -5108,7 +5661,9 @@ function readProbes(projectRoot, dir, errors) {
   }
   return probes;
 }
-function probeContradictions(probes, verdictOf) {
+var TITLE_BUDGET2 = 60;
+var DESCRIPTION_BUDGET2 = 155;
+function probeContradictions(probes, verdictOf, indexable = true) {
   const errors = [];
   const clean = (id) => ["ok", "n/a"].includes(verdictOf(id) ?? "");
   const at = (p) => `probe-${p.width}.json`;
@@ -5122,6 +5677,29 @@ function probeContradictions(probes, verdictOf) {
     if (p.unresolvedTokens.length) {
       errors.push(`${at(p)}: ${p.unresolvedTokens.length} token(s) have no value in the browser (${p.unresolvedTokens.slice(0, 6).join(", ")}) \u2014 every property using them is dropped (H-117).`);
     }
+    for (const inv of p.orderInversions ?? []) {
+      errors.push(`${at(p)}: "${inv.seenFirst}" is read first on screen but comes after "${inv.markupFirst}" in the markup. At this width the markup order is not the reading order (H-119) \u2014 reorder the document, or move it with CSS that leaves the order intact.`);
+    }
+    if (p.emDashes?.length) {
+      errors.push(`${at(p)}: the rendered page shows an em dash in ${p.emDashes.map((t) => `"${t}"`).join(", ")} (I-118) \u2014 use a full stop, a comma, a colon, or a second element.`);
+    }
+    const line = p.longestLine;
+    if (line && line.chars > 90 && clean("B-11")) {
+      errors.push(`B-11 is "${verdictOf("B-11")}", but ${at(p)} measured a line of about ${line.chars} characters ("${line.text}\u2026") \u2014 past every mode's measure. Cap prose at \`--measure-prose\`.`);
+    }
+    const head = p.head;
+    if (head && p.width === probes[0]?.width) {
+      const noindex = /noindex/i.test(head.robots);
+      if (indexable && !noindex) {
+        if (!head.title) errors.push(`${at(p)}: the page served no <title> (J-121) \u2014 a search result then shows a truncated URL.`);
+        else if (head.title.length > TITLE_BUDGET2) errors.push(`${at(p)}: the title served is ${head.title.length} characters, past the ${TITLE_BUDGET2} a search result shows (J-122): "${head.title}".`);
+        if (!head.description) errors.push(`${at(p)}: the page served no meta description (J-121) \u2014 the search engine writes one from whatever text it finds first, usually the navigation.`);
+        else if (head.description.length > DESCRIPTION_BUDGET2) errors.push(`${at(p)}: the description served is ${head.description.length} characters, past the ${DESCRIPTION_BUDGET2} (J-122).`);
+      }
+      if (!indexable && !noindex) {
+        errors.push(`${at(p)}: this page is not indexable, and the page served no noindex (J-123). robots.txt is public and advisory, and is not this.`);
+      }
+    }
     if (p.junkText.length) {
       errors.push(`${at(p)}: the rendered text contains ${p.junkText.map((j) => `"${j}"`).join(", ")} \u2014 template code or a failed value is showing to readers.`);
     }
@@ -5157,22 +5735,64 @@ function probeContradictions(probes, verdictOf) {
   return errors;
 }
 
+// src/check/decisions.ts
+import { existsSync as existsSync19, readFileSync as readFileSync25 } from "fs";
+import { join as join32 } from "path";
+var HEADING3 = /^(#{2,3})\s+(.+?)\s*$/gm;
+var NOT_A_DECISION = /^(unresolved|open questions?|undecided|contents?|index)$/i;
+function decisionsFile(projectRoot) {
+  for (const candidate of ["jig/DECISIONS.md", "DECISIONS.md", "src/jig/DECISIONS.md", "src/styles/jig/DECISIONS.md", ".jig/DECISIONS.md"]) {
+    if (existsSync19(join32(projectRoot, candidate))) return candidate;
+  }
+  return void 0;
+}
+function decisionNames(projectRoot) {
+  const path = decisionsFile(projectRoot);
+  if (!path) return [];
+  let body;
+  try {
+    body = readFileSync25(join32(projectRoot, path), "utf8");
+  } catch {
+    return [];
+  }
+  const names = [];
+  for (const match of body.matchAll(HEADING3)) {
+    const name = match[2].replace(/[`*]/g, "").trim();
+    if (!name || NOT_A_DECISION.test(name)) continue;
+    if (!names.includes(name)) names.push(name);
+  }
+  return names;
+}
+
 // src/commands/verdicts.ts
 var VERDICTS = ["ok", "finding", "n/a"];
 var ABSENCE = /\b(rule (not found|does not exist)|context unavailable|cannot (find|read|access) (the )?rule|not in (the )?(accessible )?corpus)\b/i;
 function readJson(path, errors) {
-  if (!existsSync18(path)) return null;
+  if (!existsSync20(path)) return null;
   try {
-    return JSON.parse(readFileSync25(path, "utf8"));
+    return JSON.parse(readFileSync26(path, "utf8"));
   } catch (e) {
     errors.push(`${path}: not valid JSON (${e.message})`);
     return {};
   }
 }
+function specIndexable(projectRoot, surface) {
+  const path = join33(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+  let front = "";
+  try {
+    front = readFileSync26(path, "utf8").split(/^---\s*$/m)[1] ?? "";
+  } catch {
+  }
+  const declared = /^\s*indexable\s*:\s*(\w+)/im.exec(front)?.[1]?.toLowerCase();
+  if (declared === "true" || declared === "yes") return true;
+  if (declared === "false" || declared === "no") return false;
+  const mode = /^\s*mode\s*:\s*(\w+)/im.exec(front)?.[1]?.toLowerCase();
+  return mode !== "product" && mode !== "operator";
+}
 function specNeedsNav(projectRoot, surface) {
-  const path = join31(projectRoot, ".jig", "specs", `${surface}.spec.md`);
-  if (!existsSync18(path)) return false;
-  const front = readFileSync25(path, "utf8").split(/^---\s*$/m)[1] ?? "";
+  const path = join33(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+  if (!existsSync20(path)) return false;
+  const front = readFileSync26(path, "utf8").split(/^---\s*$/m)[1] ?? "";
   const navField = [...front.matchAll(/^\s*nav:\s*(.+)$/gim)].some((m) => !/^\s*(none|n\/a|-)\b/i.test(m[1]));
   const navRegion = /^\s*-\s*(nav|navigation)\s*:/im.test(front);
   return navField || navRegion;
@@ -5220,10 +5840,55 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
   const judged = total - missing.length;
   return { state: missing.length ? "incomplete" : "ran", judged, total, findings };
 }
+function checkDecisions(projectRoot, dir, errors) {
+  const required = decisionNames(projectRoot);
+  if (required.length === 0) return { state: "ran", judged: 0, total: 0, findings: 0 };
+  const file = readJson(join33(dir, "decisions.json"), errors);
+  if (!file) {
+    errors.push(
+      `decisions.json is missing. Every decision in DECISIONS.md is judged against the built page, one verdict each: ${required.slice(0, 4).join(", ")}${required.length > 4 ? `, and ${required.length - 4} more` : ""}. A page can satisfy every rule and still break what this project decided.`
+    );
+    return { state: "missing", judged: 0, total: required.length, findings: 0 };
+  }
+  const list = Array.isArray(file.verdicts) ? file.verdicts : [];
+  if (!Array.isArray(file.verdicts)) errors.push('decisions.json has no "verdicts" array.');
+  const seen = /* @__PURE__ */ new Set();
+  let findings = 0;
+  for (const v of list) {
+    const name = typeof v.decision === "string" ? v.decision.trim() : "";
+    if (!name) {
+      errors.push("decisions.json: a verdict names no decision.");
+      continue;
+    }
+    const match = required.find((r) => r.toLowerCase() === name.toLowerCase());
+    if (!match) {
+      errors.push(`decisions.json: "${name}" is not a heading in DECISIONS.md. Judge the decisions the project made, not ones you name yourself.`);
+      continue;
+    }
+    if (seen.has(match)) {
+      errors.push(`decisions.json: "${match}" is judged more than once.`);
+      continue;
+    }
+    seen.add(match);
+    if (typeof v.verdict !== "string" || !VERDICTS.includes(v.verdict)) {
+      errors.push(`decisions.json: "${match}" has verdict ${JSON.stringify(v.verdict)} \u2014 it must be ok, finding or n/a.`);
+      continue;
+    }
+    const reason = typeof v.reason === "string" ? v.reason.trim() : "";
+    if (!reason) errors.push(`decisions.json: "${match}" has no reason. Name what on the page satisfies it, or what does not.`);
+    else if (ABSENCE.test(reason)) errors.push(`decisions.json: "${match}" \u2014 "${reason}" says the decision was not read.`);
+    if (v.verdict === "finding") findings++;
+  }
+  const missing = required.filter((r) => !seen.has(r));
+  if (missing.length) {
+    errors.push(`decisions.json: ${missing.length} of ${required.length} decisions have no verdict: ${missing.join(", ")}.`);
+  }
+  return { state: missing.length ? "incomplete" : "ran", judged: required.length - missing.length, total: required.length, findings };
+}
 function verifyVerdicts(opts) {
   const root = opts.packageRoot ?? assetRoot();
   const errors = [];
-  const index = JSON.parse(readFileSync25(join31(root, "rules.index.json"), "utf8"));
+  const index = JSON.parse(readFileSync26(join33(root, "rules.index.json"), "utf8"));
   const judgment = index.filter((r) => r.bucket === "judgment");
   const screenIds = judgment.filter((r) => r.pass === "screen").map((r) => r.id);
   const codeIds = judgment.filter((r) => r.pass === "code").map((r) => r.id);
@@ -5232,16 +5897,16 @@ function verifyVerdicts(opts) {
     ...judgment.map((r) => [r.id, r.pass ?? ""])
   ]);
   const specIds = new Set(citableIds(root).filter((id) => /^[PMLRT]-\d+$/.test(id)));
-  const dir = join31(opts.projectRoot, ".jig", "critique", opts.surface);
-  const screenFile = readJson(join31(dir, "screen.json"), errors);
-  const codeFile = readJson(join31(dir, "code.json"), errors);
+  const dir = join33(opts.projectRoot, ".jig", "critique", opts.surface);
+  const screenFile = readJson(join33(dir, "screen.json"), errors);
+  const codeFile = readJson(join33(dir, "code.json"), errors);
   const screenExtraRequired = specNeedsNav(opts.projectRoot, opts.surface) ? ["P-14"] : [];
   const screen = checkArm("screen", screenFile, screenIds, passOf, specIds, screenExtraRequired, errors);
   const code = checkArm("code", codeFile, codeIds, passOf, specIds, [], errors);
   let rendered = false;
   if (screenFile && screenFile.rendered === true) {
     const artefacts = Array.isArray(screenFile.artefacts) ? screenFile.artefacts.filter((a) => typeof a === "string") : [];
-    const absent = artefacts.filter((a) => !existsSync18(resolve4(opts.projectRoot, a)));
+    const absent = artefacts.filter((a) => !existsSync20(resolve4(opts.projectRoot, a)));
     if (artefacts.length === 0) errors.push("screen.json says rendered: true but lists no artefacts. A render leaves a screenshot.");
     else if (absent.length) errors.push(`screen.json says rendered: true, but these artefacts do not exist: ${absent.join(", ")}.`);
     else rendered = true;
@@ -5249,7 +5914,7 @@ function verifyVerdicts(opts) {
   const probes = readProbes(opts.projectRoot, dir, errors);
   if (screenFile && screenFile.rendered === true) {
     const widths = new Set(probes.map((p) => p.width));
-    const missing = [360, 768, 1280].filter((w) => !widths.has(w));
+    const missing = PROBE_WIDTHS.filter((w) => !widths.has(w));
     if (missing.length) {
       errors.push(`screen.json says rendered: true, but there is no probe at ${missing.join(", ")}px. At each width run \`jig probe\` in the browser and save its output as probe-<width>.json.`);
       rendered = false;
@@ -5260,28 +5925,29 @@ function verifyVerdicts(opts) {
     const v = screenVerdicts.find((x) => typeof x.id === "string" && x.id.trim().toUpperCase() === id);
     return typeof v?.verdict === "string" ? v.verdict : void 0;
   };
-  errors.push(...probeContradictions(probes, verdictOf));
+  errors.push(...probeContradictions(probes, verdictOf, specIndexable(opts.projectRoot, opts.surface)));
   if (screen.state === "ran" && !rendered) screen.state = "skipped";
+  const decisions = checkDecisions(opts.projectRoot, dir, errors);
   const field = (a) => a.state === "ran" ? `ran:${a.judged}` : `${a.state}:${a.judged}${a.state === "incomplete" ? `/${a.total}` : ""}`;
-  const line = `JIG_VERDICTS: surface=${opts.surface} screen=${field(screen)} code=${field(code)} rendered=${rendered ? "yes" : "no"} findings=${screen.findings + code.findings}`;
-  return { ok: errors.length === 0, errors, screen, code, rendered, line };
+  const line = `JIG_VERDICTS: surface=${opts.surface} screen=${field(screen)} code=${field(code)} decisions=${field(decisions)} rendered=${rendered ? "yes" : "no"} findings=${screen.findings + code.findings + decisions.findings}`;
+  return { ok: errors.length === 0, errors, screen, code, decisions, rendered, line };
 }
 
 // src/commands/gate.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync8, readdirSync as readdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync8, readdirSync as readdirSync15, readFileSync as readFileSync28, writeFileSync as writeFileSync7 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join33 } from "path";
+import { join as join35 } from "path";
 
 // src/check/spec-shape.ts
-import { existsSync as existsSync19, readFileSync as readFileSync26, readdirSync as readdirSync12, statSync as statSync2 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync27, readdirSync as readdirSync14, statSync as statSync2 } from "fs";
+import { join as join34 } from "path";
 function newestSpec(projectRoot) {
-  const dir = join32(projectRoot, ".jig", "specs");
-  if (!existsSync19(dir)) return void 0;
-  const files = readdirSync12(dir).filter((f) => f.endsWith(".md"));
+  const dir = join34(projectRoot, ".jig", "specs");
+  if (!existsSync21(dir)) return void 0;
+  const files = readdirSync14(dir).filter((f) => f.endsWith(".md"));
   if (files.length === 0) return void 0;
-  const newest = files.map((f) => ({ f, at: statSync2(join32(dir, f)).mtimeMs })).sort((a, b) => b.at - a.at)[0].f;
-  return { path: `.jig/specs/${newest}`, slug: newest.replace(/\.spec\.md$|\.md$/, ""), body: readFileSync26(join32(dir, newest), "utf8") };
+  const newest = files.map((f) => ({ f, at: statSync2(join34(dir, f)).mtimeMs })).sort((a, b) => b.at - a.at)[0].f;
+  return { path: `.jig/specs/${newest}`, slug: newest.replace(/\.spec\.md$|\.md$/, ""), body: readFileSync27(join34(dir, newest), "utf8") };
 }
 function specProblems(spec) {
   const parts = spec.body.split(/^---\s*$/m);
@@ -5295,7 +5961,7 @@ function specProblems(spec) {
     if (!has(field)) problems.push(`${spec.path} frontmatter has no \`${field}:\`.`);
   }
   const sizes = front.split(/^sizes\s*:/im)[1] ?? "";
-  for (const size of ["phone", "tablet", "desktop"]) {
+  for (const size of ["phone", "tablet", "desktop", "wide"]) {
     const line = new RegExp(`^\\s+${size}\\s*:(.*)$`, "im").exec(sizes);
     if (!line) {
       problems.push(`${spec.path} has no \`${size}:\` composition under \`sizes:\`. Every size is written in full, phone first; \`same-as:\` needs a \`why:\`.`);
@@ -5336,7 +6002,7 @@ function navProblems(spec) {
   const front = spec.body.split(/^---\s*$/m)[1] ?? "";
   const sizes = front.split(/^sizes\s*:/im)[1] ?? "";
   const problems = [];
-  for (const size of ["tablet", "desktop"]) {
+  for (const size of ["tablet", "landscape", "desktop", "wide"]) {
     const block = sizeBlock(sizes, size);
     const nav = /^\s*nav\s*:\s*(.+)$/im.exec(block)?.[1]?.trim();
     if (!nav || NONE_RE.test(nav)) continue;
@@ -5350,10 +6016,10 @@ function navProblems(spec) {
 // src/commands/gate.ts
 var MAX_BLOCKS = 3;
 function lastJigCommand(transcriptPath) {
-  if (!transcriptPath || !existsSync20(transcriptPath)) return void 0;
+  if (!transcriptPath || !existsSync22(transcriptPath)) return void 0;
   let text;
   try {
-    text = readFileSync27(transcriptPath, "utf8");
+    text = readFileSync28(transcriptPath, "utf8");
   } catch {
     return void 0;
   }
@@ -5371,10 +6037,10 @@ function commandProblems(root, command) {
   const problems = [];
   const spec = newestSpec(root);
   if (command === "decide") {
-    const file = ["jig/DECISIONS.md", "DECISIONS.md", ".jig/DECISIONS.md"].map((p) => join33(root, p)).find((p) => existsSync20(p));
+    const file = ["jig/DECISIONS.md", "DECISIONS.md", ".jig/DECISIONS.md"].map((p) => join35(root, p)).find((p) => existsSync22(p));
     if (!file) problems.push("decide wrote no DECISIONS.md beside the token layer.");
     else {
-      const body = readFileSync27(file, "utf8");
+      const body = readFileSync28(file, "utf8");
       if (!/^##\s+Unresolved\s*$/im.test(body)) {
         problems.push("DECISIONS.md has no `## Unresolved` section. Round 3 asks by name what is still undecided; write what the owner named, or `None named by the owner.`");
       }
@@ -5395,15 +6061,18 @@ function commandProblems(root, command) {
     const at = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
     if (/^approved/i.test(mockup)) {
       if (!at) problems.push(`${spec.path}: \`mockup_at:\` is empty. Record where the approved drawing is.`);
-      else if (!/^https?:/i.test(at) && !existsSync20(join33(root, at))) problems.push(`${spec.path}: \`mockup_at: ${at}\` does not exist.`);
+      else if (!/^https?:/i.test(at) && !existsSync22(join35(root, at))) problems.push(`${spec.path}: \`mockup_at: ${at}\` does not exist.`);
       else if (!/^https?:/i.test(at) && !at.startsWith(".jig/mockups/")) problems.push(`The drawing is at ${at}. A mockup lives in .jig/mockups/, outside what check scans and outside what ships.`);
     }
   }
   if (command === "critique") {
-    const dir = join33(root, ".jig", "critique");
-    const surfaces = existsSync20(dir) ? readdirSync13(dir).filter((s) => existsSync20(join33(dir, s, "screen.json")) || existsSync20(join33(dir, s, "code.json"))) : [];
+    const dir = join35(root, ".jig", "critique");
+    const surfaces = existsSync22(dir) ? readdirSync15(dir).filter((s) => existsSync22(join35(dir, s, "screen.json")) || existsSync22(join35(dir, s, "code.json"))) : [];
     for (const surface of surfaces) {
       const v = verifyVerdicts({ projectRoot: root, surface });
+      if (v.ok && v.decisions.state !== "ran" && v.decisions.total > 0) {
+        problems.push(`${surface}: ${v.decisions.total - v.decisions.judged} of ${v.decisions.total} decisions in DECISIONS.md have no verdict. A page can satisfy every rule and still break what this project decided.`);
+      }
       if (v.ok && v.screen.state === "skipped") {
         problems.push(`${surface}: the screen pass judged ${v.screen.judged} rules with rendered: false. Those rules are judged on a render \u2014 open the page at 360, 768 and 1280, run \`jig probe\` at each, and judge them there.`);
       }
@@ -5414,9 +6083,19 @@ function commandProblems(root, command) {
   }
   return problems;
 }
+function surfacePage(projectRoot, surface) {
+  const spec = newestSpec(projectRoot);
+  const front = spec?.body.split(/^---\s*$/m)[1] ?? "";
+  const declared = /^\s*surface\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "");
+  const candidates = [declared, `${surface}.html`, declared ? `${declared.replace(/^\//, "")}.html` : void 0].filter((c) => !!c && /\.\w+$/.test(c) === (c === declared ? /\.\w+$/.test(c) : true));
+  for (const candidate of candidates) {
+    if (candidate && existsSync22(join35(projectRoot, candidate))) return candidate;
+  }
+  return void 0;
+}
 function gate(opts) {
   const root = opts.projectRoot;
-  if (!existsSync20(join33(root, "jig.config.json")) && !existsSync20(join33(root, ".jig"))) {
+  if (!existsSync22(join35(root, "jig.config.json")) && !existsSync22(join35(root, ".jig"))) {
     return { block: false, reason: "" };
   }
   const command = lastJigCommand(opts.input.transcript_path);
@@ -5435,11 +6114,11 @@ function gate(opts) {
       );
     }
   }
-  const critiqueDir = join33(root, ".jig", "critique");
-  if (existsSync20(critiqueDir)) {
-    for (const surface of readdirSync13(critiqueDir)) {
-      const dir = join33(critiqueDir, surface);
-      if (!existsSync20(join33(dir, "screen.json")) && !existsSync20(join33(dir, "code.json"))) continue;
+  const critiqueDir = join35(root, ".jig", "critique");
+  if (existsSync22(critiqueDir)) {
+    for (const surface of readdirSync15(critiqueDir)) {
+      const dir = join35(critiqueDir, surface);
+      if (!existsSync22(join35(dir, "screen.json")) && !existsSync22(join35(dir, "code.json"))) continue;
       const v = verifyVerdicts({ projectRoot: root, surface });
       if (!v.ok) {
         const shown = v.errors.slice(0, 6).map((e) => `  ${e}`);
@@ -5453,10 +6132,10 @@ function gate(opts) {
   }
   const session = opts.input.session_id ?? "unknown";
   const key = `${session}:${createHash2("sha256").update(problems.join("\n")).digest("hex").slice(0, 12)}`;
-  const stateFile = join33(root, ".jig", "gate.json");
+  const stateFile = join35(root, ".jig", "gate.json");
   let state = {};
   try {
-    state = JSON.parse(readFileSync27(stateFile, "utf8"));
+    state = JSON.parse(readFileSync28(stateFile, "utf8"));
   } catch {
   }
   if (problems.length === 0) {
@@ -5486,15 +6165,94 @@ ${problems.join("\n\n")}`
 }
 function save(file, state) {
   try {
-    mkdirSync8(join33(file, ".."), { recursive: true });
+    mkdirSync8(join35(file, ".."), { recursive: true });
     writeFileSync7(file, JSON.stringify(state), "utf8");
   } catch {
   }
 }
 
+// src/commands/seo.ts
+import { readFileSync as readFileSync29 } from "fs";
+import { join as join36 } from "path";
+var SITEMAP_FILE = /(^|\/)sitemap(-index)?\.(xml|ts|js|mjs|tsx|jsx|rb|php|py)$/i;
+var ROBOTS_FILE = /(^|\/)robots\.(txt|ts|js|mjs|tsx|jsx)$/i;
+var ROUTE_IN_SITEMAP = /(?:<loc>\s*([^<\s]+)\s*<\/loc>)|(?:url\s*:\s*["'`]([^"'`]+)["'`])/gi;
+function routeOf(file) {
+  const path = file.replace(/^(src|app|pages|public|content|routes)\//, "").replace(/(^|\/)(index|page)\.(html?|astro|vue|svelte|[jt]sx?|md|mdx)$/i, "$1").replace(/\.(html?|astro|vue|svelte|[jt]sx?|md|mdx)$/i, "").replace(/\/$/, "");
+  return `/${path}`.replace(/\/+/g, "/");
+}
+function seo(opts) {
+  const root = opts.projectRoot;
+  const files = selectFiles(root, true).files;
+  const findings = [];
+  const add = (file, ruleId, severity, message) => findings.push({ file, ruleId, severity, message });
+  const pages = [];
+  let sitemapFiles = [];
+  let robotsFiles = [];
+  const sitemapRoutes = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let raw;
+    try {
+      raw = readFileSync29(join36(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (SITEMAP_FILE.test(file)) {
+      sitemapFiles.push(file);
+      for (const match of raw.matchAll(ROUTE_IN_SITEMAP)) {
+        const value = (match[1] ?? match[2] ?? "").trim();
+        if (!value) continue;
+        const path = value.replace(/^https?:\/\/[^/]+/i, "") || "/";
+        sitemapRoutes.set(path.replace(/\/$/, "") || "/", file);
+      }
+      continue;
+    }
+    if (ROBOTS_FILE.test(file)) {
+      robotsFiles.push(file);
+      continue;
+    }
+    if (!isReaderText(file)) continue;
+    const found = readMetadata(raw);
+    if (!found.declares && !isWholeDocument(raw)) continue;
+    const settled = found.titles.length === 1 && !found.computedTitle ? found.titles[0].value : void 0;
+    pages.push({ file, route: routeOf(file), title: settled, noindex: found.noindex });
+  }
+  for (const page of pages.filter((p) => p.noindex)) {
+    const listed = sitemapRoutes.get(page.route) ?? sitemapRoutes.get(`${page.route}/`);
+    if (listed) {
+      add(listed, "J-124", "error", `the sitemap lists ${page.route}, and ${page.file} says noindex. One answer per route: a crawler reading two picks one.`);
+    }
+  }
+  const byTitle = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    if (!page.title || page.noindex) continue;
+    byTitle.set(page.title, [...byTitle.get(page.title) ?? [], page.file]);
+  }
+  for (const [title, where] of byTitle) {
+    if (where.length > 1) {
+      add(where[1], "J-121", "warning", `"${title}" is the title of ${where.length} pages (${where.join(", ")}). A result page showing the same line twice tells a reader nothing about either.`);
+    }
+  }
+  const indexable = pages.filter((p) => !p.noindex);
+  const publicSurface = opts.mode !== "product" && opts.mode !== "operator";
+  if (publicSurface && indexable.length > 0) {
+    if (sitemapFiles.length === 0) {
+      add(".", "J-124", "warning", `${indexable.length} indexable page(s) and no sitemap. A crawler then finds what it happens to link to.`);
+    } else if (sitemapRoutes.size === 0) {
+      add(sitemapFiles[0], "J-127", "error", "the sitemap lists no routes. An empty sitemap is not a missing one: it is a claim that the site has nothing.");
+    }
+    if (robotsFiles.length === 0) {
+      add(".", "J-123", "note", "no robots file. Nothing is blocked by its absence, but nothing points at the sitemap either.");
+    }
+  }
+  const titleBudget = pages.filter((p) => p.title && p.title.length > TITLE_BUDGET).length;
+  const line = `JIG_SEO: pages=${pages.length} indexable=${indexable.length} noindex=${pages.length - indexable.length} sitemap=${sitemapFiles.length > 0 ? sitemapRoutes.size : "none"} robots=${robotsFiles.length > 0 ? "yes" : "no"} overlong=${titleBudget} findings=${findings.length}`;
+  return { findings, pages: pages.length, indexable: indexable.length, line };
+}
+
 // src/index.ts
 var packageRoot = getPackageRoot();
-var { version } = JSON.parse(readFileSync28(join34(packageRoot, "package.json"), "utf8"));
+var { version } = JSON.parse(readFileSync30(join37(packageRoot, "package.json"), "utf8"));
 function warnIfUnpublishedPin() {
   if (isPublishedBuild(packageRoot)) return;
   console.warn(
@@ -5532,7 +6290,7 @@ program.command("install").description("Install Jig rules and the agent skill fi
       projectRoot,
       packageRoot: assetRoot(),
       version,
-      homeDir: homedir(),
+      homeDir: homedir2(),
       hook
     });
     if (result.warning) {
@@ -5570,7 +6328,7 @@ program.command("update").description("Update vendored Jig rules, skipping files
       projectRoot,
       packageRoot: assetRoot(),
       version,
-      homeDir: homedir()
+      homeDir: homedir2()
     });
     const label = result.targets.map((t) => `${t.agent} (${t.scope}, ${t.fromVersion})`).join(", ");
     warnIfUnpublishedPin();
@@ -5608,7 +6366,7 @@ program.command("check").description("Check the repo against Jig's mechanical +
   try {
     const result = check({
       projectRoot,
-      homeDir: homedir(),
+      homeDir: homedir2(),
       version,
       all: opts.all,
       ci: opts.ci
@@ -5620,7 +6378,41 @@ program.command("check").description("Check the repo against Jig's mechanical +
     process.exit(1);
   }
 });
-program.command("probe").description("Print the render probe. With --save, read what it returned on stdin and record it for `jig verdicts`.").option("--save <surface>", "record the probe's output (piped in) under .jig/critique/<surface>/").action(async (opts) => {
+program.command("seo").description("Audit what a search engine and a link preview read, across the whole project.").option("--json", "emit findings as JSON", false).action((opts) => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = seo({ projectRoot, mode: resolveSurfaceMode(projectRoot) });
+    if (opts.json) {
+      console.log(JSON.stringify(result.findings, null, 2));
+    } else {
+      const symbol = { error: "\u2717", warning: "\u26A0", note: "\xB7" };
+      for (const f of result.findings) console.log(`  ${symbol[f.severity]} ${f.ruleId} ${f.message}  ${f.file}`);
+      if (result.findings.length === 0) console.log("  Nothing to fix in what a search engine reads.");
+      console.log(`  ${result.line}`);
+    }
+    process.exit(result.findings.some((f) => f.severity === "error") ? 1 : 0);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.command("probe").description("Print the render probe. With --save, read what it returned on stdin and record it for `jig verdicts`.").option("--save <surface>", "record the probe's output (piped in) under .jig/critique/<surface>/").option("--run <page>", "render this page here, at 360, 768 and 1280, and record each (needs --save)").action(async (opts) => {
+  if (opts.run) {
+    if (!opts.save) {
+      console.error("  \u2717 --run records what it measures, so it needs --save <surface>.");
+      process.exit(1);
+    }
+    const projectRoot2 = findProjectRoot(process.cwd());
+    try {
+      for (const saved of await runAndSaveProbes({ projectRoot: projectRoot2, surface: opts.save, page: opts.run })) {
+        console.log(`  Recorded ${saved.path} \u2014 ${saved.page} at ${saved.width}px.`);
+      }
+    } catch (err) {
+      console.error(`  \u2717 ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
   if (!opts.save) {
     console.log(PROBE_SCRIPT);
     return;
@@ -5643,15 +6435,24 @@ program.command("probe").description("Print the render probe. With --save, read
     process.exit(1);
   }
 });
-program.command("gate").description("Run by the Claude Code Stop hook: block stopping while check or a critique fails.").action(() => {
+program.command("gate").description("Run by the Claude Code Stop hook: block stopping while check or a critique fails.").action(async () => {
   let input = {};
   try {
-    if (!process.stdin.isTTY) input = JSON.parse(readFileSync28(0, "utf8") || "{}");
+    if (!process.stdin.isTTY) input = JSON.parse(readFileSync30(0, "utf8") || "{}");
   } catch {
   }
   const cwd = input.cwd ?? process.cwd();
   try {
-    const result = gate({ projectRoot: findProjectRoot(cwd), version, input });
+    const projectRoot = findProjectRoot(cwd);
+    for (const surface of critiquedSurfaces(projectRoot)) {
+      const page = surfacePage(projectRoot, surface);
+      if (!page) continue;
+      try {
+        await ensureProbes({ projectRoot, surface, page });
+      } catch {
+      }
+    }
+    const result = gate({ projectRoot, version, input });
     if (result.block) console.log(JSON.stringify({ decision: "block", reason: result.reason }));
     else if (result.reason) console.error(result.reason);
   } catch (err) {
@@ -5665,7 +6466,7 @@ program.command("init").description("Set the project up to use Jig: a brand file
     await init({
       projectRoot,
       packageRoot: assetRoot(),
-      homeDir: homedir(),
+      homeDir: homedir2(),
       version,
       yes: opts.yes
     });
@@ -5674,4 +6475,13 @@ program.command("init").description("Set the project up to use Jig: a brand file
     process.exit(1);
   }
 });
+function resolveSurfaceMode(projectRoot) {
+  try {
+    const config = JSON.parse(readFileSync30(join37(projectRoot, "jig.config.json"), "utf8"));
+    const modes = [...new Set((config.surfaces ?? []).map((s) => s.mode).filter(Boolean))];
+    return modes.length === 1 ? modes[0] : void 0;
+  } catch {
+    return void 0;
+  }
+}
 program.parse();