jig-ui 0.9.0 → 0.11.0

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 import { homedir } from "os";
-import { join as join24 } from "path";
+import { join as join34 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -42,11 +42,11 @@ function isPublishedBuild(packageRoot2) {
 }
 
 // src/commands/install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
 
 // src/adapters/types.ts
-var COMMAND_DESCRIPTION = "Run a Jig design-system command: set the project up, review the UI against the rules, or refresh the install.";
+var COMMAND_DESCRIPTION = "Run a Jig design-system command: set the project up, plan and build one feature at a time (decide, spec, mockup, make, critique), check the UI against the rules, or refresh the install.";
 var SKILL_DESCRIPTION = "Design system rules for generating and reviewing UI. Load before building any interface.";
 function assertSafeRelPath(relPath, adapterName) {
   const isAbsolute2 = relPath.startsWith("/") || /^[A-Za-z]:/.test(relPath);
@@ -390,7 +390,7 @@ function escapeTableCell(value) {
 function renderCommandTable(metadata) {
   const rows = Object.entries(metadata).map(([name, meta]) => {
     const signature = meta.argumentHint ? `${name} ${meta.argumentHint}` : name;
-    const status = meta.status === "planned" ? "planned \u2014 not yet implemented" : "available";
+    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} |`;
   });
   return ["| Command | Description | Status |", "| --- | --- | --- |", ...rows].join("\n");
@@ -542,11 +542,17 @@ function buildCommandBody(packageRoot2, rulesPath, version2, argsPlaceholder) {
   const metadata = JSON.parse(
     readFileSync4(join7(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
-  const subcommands = Object.entries(metadata).filter(([, meta]) => meta.status === "available").map(([name]) => name).sort();
+  const subcommands = Object.entries(metadata).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");
-  const body = template.replace(/\{\{command_prefix\}\}/g, "/jig ").replace(/\{\{args_placeholder\}\}/g, argsPlaceholder).replace(/\{\{subcommand_list\}\}/g, subcommands.join(", ")).replace(/\{\{scripts_path\}\}/g, `npx jig-ui@${version2}`).replace(/\{\{update_path\}\}/g, "npx jig-ui@latest").replace(/\{\{rules_path\}\}/g, rulesPath);
+  const body = template.replace(/\{\{command_prefix\}\}/g, "/jig ").replace(/\{\{args_placeholder\}\}/g, argsPlaceholder).replace(/\{\{subcommand_list\}\}/g, subcommands.join(", ")).replace(/\{\{scripts_path\}\}/g, `npx jig-ui@${version2}`).replace(/\{\{update_path\}\}/g, "npx jig-ui@latest").replace(/\{\{rules_path\}\}/g, rulesPath).replace(/\{\{config_file\}\}/g, "jig.config.json");
+  const unresolved = [...new Set(body.match(/\{\{[a-z_]+\}\}/g) ?? [])];
+  if (unresolved.length > 0) {
+    throw new Error(
+      `COMMAND.md.tmpl has placeholders nothing substitutes: ${unresolved.join(", ")}. Add them to the replace chain in buildCommandBody, or remove them from the template.`
+    );
+  }
   return { body, subcommands };
 }
 function rulesPathFor(referenceDir, scope) {
@@ -653,7 +659,36 @@ function install(opts) {
   };
   writeManifest(installRoot, manifest, referenceDir);
   written.push(relKey(referenceDir, "manifest.json"));
-  return { written, skipped };
+  const stopHook = opts.hook && opts.agent === "claude" && opts.scope === "project" ? installStopHook(installRoot, opts.version) : void 0;
+  return { written, skipped, stopHook };
+}
+function hasStopHook(projectRoot) {
+  try {
+    const settings = readFileSync4(join7(projectRoot, ".claude", "settings.json"), "utf8");
+    return /\bjig-ui@[^\s"]+ gate\b/.test(settings);
+  } catch {
+    return false;
+  }
+}
+function installStopHook(projectRoot, version2) {
+  const path = join7(projectRoot, ".claude", "settings.json");
+  let settings = {};
+  if (existsSync5(path)) {
+    try {
+      settings = JSON.parse(readFileSync4(path, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  const command = `npx --yes jig-ui@${version2} gate`;
+  const hooks = settings.hooks ?? {};
+  const isJig = (h) => /\bjig-ui@[^\s]+ gate\b/.test(h.command ?? "");
+  const stop = (hooks.Stop ?? []).map((group) => ({ ...group, hooks: group.hooks.filter((h) => !isJig(h)) })).filter((group) => group.hooks.length > 0);
+  stop.push({ hooks: [{ type: "command", command }] });
+  settings.hooks = { ...hooks, Stop: stop };
+  mkdirSync4(join7(projectRoot, ".claude"), { recursive: true });
+  writeFileSync3(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return true;
 }
 
 // src/commands/update.ts
@@ -701,7 +736,7 @@ function resolveAllInstalled(projectRoot, homeDir) {
 }
 
 // src/init/state.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname5, join as join8 } from "path";
 var INIT_MANIFEST_REL = join8(".jig", "state.json");
 function readInitManifest(projectRoot) {
@@ -724,7 +759,7 @@ function readInitManifest(projectRoot) {
 var MERGE_ATTEMPTS2 = 5;
 function writeInitManifest(projectRoot, m) {
   const path = join8(projectRoot, INIT_MANIFEST_REL);
-  mkdirSync4(dirname5(path), { recursive: true });
+  mkdirSync5(dirname5(path), { recursive: true });
   for (let attempt = 0; attempt < MERGE_ATTEMPTS2; attempt++) {
     const onDisk = readInitManifest(projectRoot);
     const merged = {
@@ -884,6 +919,9 @@ function update(opts) {
 function updateTarget(opts, resolved) {
   const { installRoot, scope: discoveredScope, manifest: existing, referenceDir } = resolved;
   const adapter = getAdapter(existing.agent);
+  if (existing.agent === "claude" && discoveredScope === "project" && hasStopHook(installRoot)) {
+    installStopHook(installRoot, opts.version);
+  }
   const updated = [];
   const skipped = [];
   const writer = createWriter(installRoot, existing.files);
@@ -985,7 +1023,7 @@ function updateInitFiles(opts) {
 }
 
 // src/commands/explain.ts
-import { join as join13 } from "path";
+import { join as join15 } from "path";
 
 // src/rules/load.ts
 import { readFileSync as readFileSync8, readdirSync as readdirSync4 } from "fs";
@@ -1041,6 +1079,7 @@ function parseRules(markdown, sourceFile) {
 
 // src/rules/schema.ts
 var BUCKETS = ["mechanical", "judgment", "hybrid"];
+var PASSES = ["code", "screen"];
 var SEVERITIES = ["error", "warning", "note"];
 function validateIndex(entries) {
   if (!Array.isArray(entries)) throw new Error("rules.index.json must be an array");
@@ -1059,13 +1098,22 @@ function validateIndex(entries) {
     if (typeof e.since !== "string") {
       throw new Error(`${at} (${e.id}): since is required`);
     }
+    if (e.bucket === "judgment" && !PASSES.includes(e.pass)) {
+      throw new Error(
+        `${at} (${e.id}): judgment rules need pass: ${PASSES.join(" or ")} \u2014 'code' if it can be decided by reading files, 'screen' if it needs the rendered page`
+      );
+    }
+    if (e.pass !== void 0 && !PASSES.includes(e.pass)) {
+      throw new Error(`${at} (${e.id}): pass must be one of ${PASSES.join(", ")}`);
+    }
     return {
       id: e.id,
       bucket: e.bucket,
       severity: e.severity,
       detector: typeof e.detector === "string" ? e.detector : void 0,
       fix: typeof e.fix === "string" ? e.fix : void 0,
-      since: e.since
+      since: e.since,
+      pass: e.pass
     };
   });
 }
@@ -1101,7 +1149,26 @@ function loadRules(rulesDir, indexPath) {
 // src/rules/specs.ts
 import { readFileSync as readFileSync9, readdirSync as readdirSync5 } from "fs";
 import { join as join12 } from "path";
-var HEADING2 = /^##\s+([PM]-\d+)\s*(?:·\s*)?(.*?)\s*$/;
+var KINDS = {
+  P: "pattern",
+  M: "mode",
+  L: "method",
+  // `R` — principles. Both halves of `04-principles.md`: the five frames, which
+  // are generative (how to recognise a failure no rule covers yet), and the
+  // seven tiebreakers, which are adjudicative (which rule yields when two
+  // conflict). The file itself was 0% addressable, so `04` could be cited by
+  // nothing and loaded only as a whole — and the protocol says to load it only
+  // when two rules conflict, which is exactly when a reader wants one entry and
+  // not 141 lines.
+  R: "principle",
+  // `T` — token guidance. The contracts and conventions around the token layer:
+  // what the names mean, what the contrast floor is, how dark mode resolves.
+  // 02-tokens.md was 517 lines at 0% addressable, the largest single block in
+  // the corpus, and the protocol sends readers there "for setup or when adding a
+  // token" — both of which want one contract, not the file.
+  T: "token"
+};
+var HEADING2 = /^##\s+([PMLRT]-\d+)\s*(?:·\s*)?(.*?)\s*$/;
 function parseSpecs(markdown, sourceFile) {
   const lines = markdown.split("\n");
   const specs = [];
@@ -1117,7 +1184,13 @@ function parseSpecs(markdown, sourceFile) {
     if (heading) {
       push();
       const [, id, title] = heading;
-      current = { id, title, body: "", source: `${sourceFile}#${id.toLowerCase()}` };
+      current = {
+        id,
+        title,
+        kind: KINDS[id[0]],
+        body: "",
+        source: `${sourceFile}#${id.toLowerCase()}`
+      };
       continue;
     }
     if (current && /^##\s/.test(line)) {
@@ -1139,6 +1212,61 @@ function loadSpecs(rulesDir) {
   return specs;
 }
 
+// src/rules/sections.ts
+import { readFileSync as readFileSync10, readdirSync as readdirSync6 } from "fs";
+import { join as join13 } from "path";
+var RULE_HEADING = /^###\s+[A-Z]-\d+\b/;
+var SPEC_HEADING = /^##\s+[PMLRT]-\d+\b/;
+var ANY_HEADING = /^(#{1,6})\s+(.*?)\s*$/;
+function anchorOf(file, heading) {
+  const slug = heading.toLowerCase().replace(/[`*_]/g, "").replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
+  return `${file}#${slug}`;
+}
+function parseSections(markdown, file) {
+  const sections = [];
+  let owner = null;
+  let heading = "";
+  let body = [];
+  const push = () => {
+    if (owner !== "section") return;
+    const text = body.map((l) => l.trim()).filter((l) => !/^-{3,}$/.test(l)).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    if (text) sections.push({ file, heading, anchor: anchorOf(file, heading), body: text });
+  };
+  for (const line of markdown.split("\n")) {
+    const h = ANY_HEADING.exec(line);
+    if (h) {
+      const level = h[1].length;
+      if (owner === "spec" && level >= 3) continue;
+      push();
+      body = [];
+      if (RULE_HEADING.test(line)) owner = "rule";
+      else if (SPEC_HEADING.test(line)) owner = "spec";
+      else {
+        owner = "section";
+        heading = h[2];
+      }
+      continue;
+    }
+    if (owner === "section") body.push(line);
+  }
+  push();
+  return sections;
+}
+function loadSections(rulesDir) {
+  const out = [];
+  for (const file of readdirSync6(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    out.push(...parseSections(readFileSync10(join13(rulesDir, file), "utf8"), file));
+  }
+  return out;
+}
+
+// src/rules/layers.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join14 } from "path";
+function loadLayers(packageRoot2) {
+  return JSON.parse(readFileSync11(join14(packageRoot2, "layers.json"), "utf8"));
+}
+
 // src/commands/explain.ts
 var ID_SHAPE = /^([A-Z])-?(\d+)$/;
 var SECTION_SHAPE = /^([A-Z])$/;
@@ -1167,28 +1295,97 @@ function renderRule(rule) {
     `   since ${rule.since} \xB7 ${rule.source}`
   ].join("\n");
 }
+var KIND_NOTE = {
+  pattern: [
+    "specification \u2014 component anatomy and behaviour, not a single rule,",
+    "so it carries no \u274C/\u2705 pair and no detector."
+  ],
+  mode: [
+    "mode profile \u2014 the character a surface inherits, not a single rule,",
+    "so it carries no \u274C/\u2705 pair and no detector."
+  ],
+  method: [
+    "method \u2014 a procedure to follow before building, not a component to build.",
+    "It applies to any screen, so nothing selects it for you: run it."
+  ],
+  principle: [
+    "principle \u2014 for the case no rule covers, or the case two rules answer",
+    "differently. Not a rule: it has no \u274C/\u2705 pair and nothing detects it."
+  ],
+  token: [
+    "token contract \u2014 what the token layer guarantees and what it expects back.",
+    "Values live in the token files; this is what they mean and how they resolve."
+  ]
+};
 function renderSpec(spec) {
+  const [what, more] = KIND_NOTE[spec.kind];
   return [
     `${spec.id}  ${spec.title}`,
     "",
     spec.body,
     "",
-    `   specification \u2014 component anatomy and behaviour, not a single rule,`,
-    `   so it carries no \u274C/\u2705 pair and no detector.`,
+    `   ${what}`,
+    `   ${more}`,
     `   ${spec.source}`
   ].join("\n");
 }
+function searchEntries(rules, specs, sections = []) {
+  return [
+    ...rules.map((r) => ({
+      id: r.id,
+      title: r.title,
+      text: [...r.preamble, r.wrong, r.correction, ...r.notes].join("\n")
+    })),
+    ...specs.map((s) => ({ id: s.id, title: s.title, text: s.body })),
+    ...sections.map((s) => ({ id: s.anchor, title: s.heading, text: s.body, section: s }))
+  ];
+}
+function renderSection(s) {
+  return [s.heading, "", s.body, "", `   ${s.anchor}`].join("\n");
+}
 function explain(opts) {
   const raw = opts.ruleId.trim().toUpperCase();
   const root = opts.packageRoot ?? assetRoot();
-  const rulesDir = join13(root, "rules");
-  const rules = loadRules(rulesDir, join13(root, "rules.index.json"));
+  const rulesDir = join15(root, "rules");
+  const rules = loadRules(rulesDir, join15(root, "rules.index.json"));
   const specs = loadSpecs(rulesDir);
-  const entries = [
-    ...rules.map((r) => ({ id: r.id, title: r.title, text: `${r.wrong}
-${r.correction}` })),
-    ...specs.map((s) => ({ id: s.id, title: s.title, text: s.body }))
-  ];
+  const sections = loadSections(rulesDir);
+  const entries = searchEntries(rules, specs, sections);
+  if (opts.layer) {
+    const l = loadLayers(root);
+    if (!raw) {
+      const rows = Object.entries(l.layers).map(
+        ([name2, layer2]) => `${name2.padEnd(14)} ${layer2.ids.length === 0 ? String(rules.length).padStart(3) : String(layer2.ids.length).padStart(3)}  ${layer2.question}`
+      );
+      const extra = Object.entries(l.not_a_layer).filter(([, g]) => Array.isArray(g.ids)).map(([name2, g]) => `${name2.padEnd(14)} ${String(g.ids.length).padStart(3)}  ${g.question ?? ""}`);
+      return [
+        "The six layers \u2014 a view over the corpus, not where anything is stored.",
+        "",
+        ...rows,
+        "",
+        "Not one of the six \u2014 the machinery, rather than the design knowledge:",
+        "",
+        ...extra,
+        "",
+        "Run 'jig explain --layer <name>' for one, or 'jig explain <id>' for an entry."
+      ].join("\n");
+    }
+    const name = raw.toLowerCase();
+    const layer = l.layers[name] ?? l.not_a_layer[name];
+    if (!layer) {
+      throw new Error(
+        `No layer '${raw}'. The six are: ${Object.keys(l.layers).join(", ")}; plus ${Object.keys(l.not_a_layer).filter((k) => !k.startsWith("_")).join(" and ")}.`
+      );
+    }
+    const members = "ids" in layer && layer.ids && layer.ids.length > 0 ? entries.filter((e) => layer.ids.includes(e.id)) : entries.filter((e) => rules.some((r) => r.id === e.id));
+    return [
+      `${name} \u2014 ${members.length} entries`,
+      ..."question" in layer && layer.question ? ["", layer.question] : [],
+      ..."note" in layer && layer.note ? ["", layer.note] : [],
+      "",
+      ...members.sort((a, b) => byNumber(a.id, b.id)).map((e) => `${e.id.padEnd(6)} ${e.title}`)
+    ].join("\n");
+  }
   if (opts.list) {
     const section = SECTION_SHAPE.exec(raw)?.[1];
     const shown = entries.filter((e) => !section || e.id.startsWith(`${section}-`)).sort((a, b) => byNumber(a.id, b.id));
@@ -1219,11 +1416,19 @@ ${r.correction}` })),
     );
   }
   const needle = opts.ruleId.trim();
-  const inTitle = entries.filter((e) => matches(e.title, needle) || matches(e.id, needle));
-  const inBody = entries.filter((e) => !inTitle.includes(e) && matches(e.text, needle));
+  const byAnchor = sections.find((sec) => sec.anchor === needle.toLowerCase());
+  if (byAnchor) return renderSection(byAnchor);
+  const ids = entries.filter((e) => !e.section);
+  const secs = entries.filter((e) => e.section);
+  const idTitle = ids.filter((e) => matches(e.title, needle) || matches(e.id, needle));
+  const idBody = ids.filter((e) => !idTitle.includes(e) && matches(e.text, needle));
+  const secTitle = secs.filter((e) => matches(e.title, needle));
+  const secBody = secs.filter((e) => !secTitle.includes(e) && matches(e.text, needle));
   const hits = [
-    ...inTitle.sort((a, b) => byNumber(a.id, b.id)),
-    ...inBody.sort((a, b) => byNumber(a.id, b.id))
+    ...idTitle.sort((a, b) => byNumber(a.id, b.id)),
+    ...idBody.sort((a, b) => byNumber(a.id, b.id)),
+    ...secTitle,
+    ...secBody
   ];
   if (hits.length === 0) {
     throw new Error(
@@ -1231,6 +1436,7 @@ ${r.correction}` })),
     );
   }
   if (hits.length === 1) {
+    if (hits[0].section) return renderSection(hits[0].section);
     const rule = rules.find((r) => r.id === hits[0].id);
     return rule ? renderRule(rule) : renderSpec(specs.find((s) => s.id === hits[0].id));
   }
@@ -1239,7 +1445,7 @@ ${r.correction}` })),
     // otherwise C-19 sitting above A-02 reads as a sorting bug.
     `${hits.length} entries match '${needle}' \u2014 title matches first:`,
     "",
-    ...hits.map((e) => `${e.id.padEnd(6)} ${e.title}`),
+    ...hits.map((e) => e.section ? `${e.id}  ${e.title}` : `${e.id.padEnd(6)} ${e.title}`),
     "",
     `Run 'jig explain <id>' for any of them.`
   ].join("\n");
@@ -1249,13 +1455,13 @@ function sectionsOf(entries) {
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync12, readFileSync as readFileSync14 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync18 } from "fs";
+import { join as join23 } from "path";
 
 // src/check/files.ts
 import { execFileSync } from "child_process";
-import { readdirSync as readdirSync6, realpathSync, statSync } from "fs";
-import { join as join14, relative, sep } from "path";
+import { readdirSync as readdirSync7, realpathSync, statSync } from "fs";
+import { join as join16, relative, sep } from "path";
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1314,13 +1520,13 @@ function isExcluded(relPath) {
 function walk(root, dir, out, seen) {
   let entries;
   try {
-    entries = readdirSync6(dir, { withFileTypes: true });
+    entries = readdirSync7(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (EXCLUDE_DIRS.has(entry.name)) continue;
-    const abs = join14(dir, entry.name);
+    const abs = join16(dir, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -1441,7 +1647,7 @@ function formatReport(findings, meta) {
     }
   }
   const errors = findings.filter((f) => f.severity === "error").length;
-  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length + (meta.modeUnwired?.length ?? 0);
   const notes = findings.filter((f) => f.severity === "note").length;
   const summaryParts = [plural(errors, "error")];
   if (warnings > 0) summaryParts.push(plural(warnings, "warning"));
@@ -1480,10 +1686,19 @@ function formatReport(findings, meta) {
       `  ${meta.unscanned.count} file(s) were not scanned (${exts}) \u2014 no style extraction exists for them, so any CSS they carry is invisible to this check and a clean result above does not cover it.`
     );
   }
+  if (meta.modeUnwired && meta.modeUnwired.length > 0) {
+    lines.push("");
+    for (const p of meta.modeUnwired) lines.push(`  \u26A0 ${p.message}.`);
+    if (meta.modeUnwired.some((p) => p.barrel === "jig.config.json")) {
+      lines.push(`  Fix jig.config.json by hand \u2014 init leaves an edited config alone \u2014 then run 'jig init' again.`);
+    } else {
+      lines.push(`  Run 'jig init' again: it rewrites the token layer for the modes jig.config.json declares.`);
+    }
+  }
   const mechanicalErrors = findings.filter((f) => f.bucket === "mechanical" && f.severity === "error").length;
   const mechStatus = `${mechanicalErrors > 0 ? "fail" : "pass"}:${mechanicalErrors}`;
   lines.push(
-    `  JIG_CHECK: version=${meta.version} mode=${meta.mode ?? "unknown"} mechanical=${mechStatus} judgment=not-run files=${meta.scanned ?? "unknown"} styled=${meta.withStyles ?? "unknown"}`
+    `  JIG_CHECK: version=${meta.version} mode=${meta.mode ?? "unknown"} mechanical=${mechStatus} warnings=${warnings} judgment=not-run files=${meta.scanned ?? "unknown"} styled=${meta.withStyles ?? "unknown"}`
   );
   return lines.join("\n");
 }
@@ -1583,8 +1798,8 @@ function isStyleBearing(file) {
 }
 
 // src/check/run.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join18 } from "path";
 
 // src/check/css.ts
 function maskComments(source) {
@@ -2772,6 +2987,318 @@ var violetBandHue = {
   }
 };
 
+// src/check/detectors/fixed-width.ts
+var PHONE_WIDTH_PX = 480;
+var GRID_COLUMNS_RE = /\bgrid-template-columns\s*:\s*([^;}]+)/i;
+var FLEX_RE = /\bdisplay\s*:\s*(?:inline-)?flex\b/i;
+var COLUMN_DIRECTION_RE = /\bflex-direction\s*:\s*column(?:-reverse)?\b|\bflex-flow\s*:\s*column\b/i;
+var FIXED_WIDTH_RE = /(?<![-\w])(?:min-)?width\s*:\s*(\d+(?:\.\d+)?)px\b/i;
+function isMultiTrack(value) {
+  const v = value.trim();
+  const repeat = /repeat\s*\(\s*(\d+)\s*,/i.exec(v);
+  if (repeat) return Number(repeat[1]) > 1;
+  const tracks = v.replace(/\([^)]*\)/g, "()").split(/\s+/).filter(Boolean);
+  return tracks.length > 1;
+}
+var fixedWidth = {
+  name: "fixed-width",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (ctx.projectResponsive !== false) return [];
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      const body = block.body;
+      let offset = -1;
+      let message = "";
+      const grid = GRID_COLUMNS_RE.exec(body);
+      const width = FIXED_WIDTH_RE.exec(body);
+      if (grid && isMultiTrack(grid[1])) {
+        offset = grid.index;
+        message = "multi-column grid, and nothing in the project changes it at a narrow width";
+      } else if (FLEX_RE.test(body) && !COLUMN_DIRECTION_RE.test(body)) {
+        offset = FLEX_RE.exec(body).index;
+        message = "row of flex items with no wrap, and nothing in the project changes it at a narrow width";
+      } else if (width && Number(width[1]) > PHONE_WIDTH_PX) {
+        offset = width.index;
+        message = `fixed ${width[1]}px width, wider than a phone, and nothing in the project adapts it`;
+      }
+      if (offset < 0) continue;
+      const line = lineOfOffset(block, offset);
+      findings.push(mkFinding(ctx, "fixed-width", file, line, message, sourceLine(source, line)));
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/viewport-height.ts
+var VH_DECL_RE = /(?<![-\w])((?:min-|max-)?height)\s*:\s*([^;}]*\b100vh\b[^;}]*)/gi;
+var MODERN_UNIT_RE = /\b\d*\.?\d+(?:dvh|svh|lvh)\b/i;
+var viewportHeight = {
+  name: "viewport-height",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (MODERN_UNIT_RE.test(source)) return [];
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      VH_DECL_RE.lastIndex = 0;
+      let m;
+      while (m = VH_DECL_RE.exec(block.body)) {
+        const line = lineOfOffset(block, m.index);
+        findings.push(
+          mkFinding(
+            ctx,
+            "viewport-height",
+            file,
+            line,
+            `${m[1]} uses 100vh, which is taller than the visible area on a phone while its browser bars show`,
+            sourceLine(source, line)
+          )
+        );
+      }
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/input-zoom.ts
+var SELECTOR_RE = /(?:^|[\s,>+~(])(?:input|select|textarea)\b(?![-\w])|\[contenteditable/i;
+var SIZE_RE = /(?<![-\w])font-size\s*:\s*([^;}]+)/gi;
+var TOUCH_QUERY_RE = /@media[^{]*\b(?:pointer\s*:\s*coarse|hover\s*:\s*none)\b/i;
+var ROOT_PX = 16;
+function pixels(value, mode) {
+  const v = value.trim().replace(/\s*!important$/i, "");
+  const unit = /^(\d*\.?\d+)(px|rem|em)$/i.exec(v);
+  if (unit) return unit[2].toLowerCase() === "px" ? Number(unit[1]) : Number(unit[1]) * ROOT_PX;
+  if (/^var\(\s*--text-caption\s*\)$/i.test(v)) return 14;
+  if (/^var\(\s*--text-body\s*\)$/i.test(v) && mode === "operator") return 14;
+  return void 0;
+}
+var inputZoom = {
+  name: "input-zoom",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (TOUCH_QUERY_RE.test(source)) return [];
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      if (!SELECTOR_RE.test(block.selector)) continue;
+      SIZE_RE.lastIndex = 0;
+      let m;
+      while (m = SIZE_RE.exec(block.body)) {
+        const px = pixels(m[1], ctx.mode);
+        if (px === void 0 || px >= ROOT_PX) continue;
+        const line = lineOfOffset(block, m.index);
+        findings.push(
+          mkFinding(
+            ctx,
+            "input-zoom",
+            file,
+            line,
+            `form control text resolves to ${px}px; iOS zooms the page on focus below 16px`,
+            sourceLine(source, line)
+          )
+        );
+      }
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/safe-area.ts
+var PINNED_RE = /\bposition\s*:\s*(?:fixed|sticky)\b/i;
+var EDGE_RE = /(?<![-\w])(top|bottom|left|right|inset(?:-block|-inline)?(?:-start|-end)?)\s*:\s*0(?:px|rem|em)?\s*(?:[;}]|$)/i;
+var INSET_RE = /\b(?:env|constant)\(\s*safe-area-inset-/i;
+var safeArea = {
+  name: "safe-area",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (ctx.viewportFitCover !== true) return [];
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      const body = block.body;
+      if (!PINNED_RE.test(body) || INSET_RE.test(body)) continue;
+      const edge = EDGE_RE.exec(body);
+      if (!edge) continue;
+      const line = lineOfOffset(block, PINNED_RE.exec(body).index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "safe-area",
+          file,
+          line,
+          `pinned to the ${edge[1]} edge of a page that extends under the notch, with no safe-area inset`,
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/menu-state.ts
+var HIDDEN_RE = /(?<![-\w])display\s*:\s*none\b/i;
+var NAV_SELECTOR_RE = /(?:^|[\s>+~.#])(?:nav|[\w-]*(?:nav|navigation|menu)[\w-]*)(?:$|[\s.#:[>+~])/i;
+var SKIP_RE = /sub-?menu|dropdown|flyout|mega|button|btn|toggle|trigger|burger|icon/i;
+var NESTED_LIST_RE = /\bli\b[^,]*\b(?:ul|ol)\b/i;
+function navSelectors(selectorList) {
+  return selectorList.split(",").map((s) => s.trim()).filter((s) => s && !SKIP_RE.test(s) && !NESTED_LIST_RE.test(s) && !/:hover|:focus/i.test(s)).filter((s) => s.split(/\s+|>|\+|~/).some((c) => NAV_SELECTOR_RE.test(c)));
+}
+var MENU_BUTTON_RE = /<button\b([^>]*)>([\s\S]{0,200}?)<\/button>/gi;
+var MENU_NAME_RE = /^\s*(?:open |toggle |show )?(?:the )?(?:site |main )?(?:menu|navigation|nav)\s*$/i;
+function deadMenuButtons(raw) {
+  const offsets = [];
+  for (const m of raw.matchAll(MENU_BUTTON_RE)) {
+    const label = /\baria-label\s*=\s*["']([^"']*)["']/i.exec(m[1])?.[1];
+    const text = m[2].replace(/<[^>]*>/g, "").trim();
+    if (MENU_NAME_RE.test(label ?? "") || MENU_NAME_RE.test(text)) offsets.push(m.index);
+  }
+  return offsets;
+}
+var menuState = {
+  name: "menu-state",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (ctx.projectMenuToggle !== false) return [];
+    const findings = [];
+    if (/\.(html?|vue|svelte|astro|jsx|tsx|php|erb|twig|hbs)$/i.test(file)) {
+      const starts = buildLineIndex(ctx.raw);
+      for (const offset of deadMenuButtons(ctx.raw)) {
+        const line = lineForOffset(starts, offset);
+        findings.push(
+          mkFinding(
+            ctx,
+            "menu-state",
+            file,
+            line,
+            "a Menu button that nothing opens \u2014 no script or binding ever changes aria-expanded, and no <details>",
+            sourceLine(ctx.raw, line)
+          )
+        );
+      }
+    }
+    for (const block of leafBlocks(source)) {
+      const hidden = HIDDEN_RE.exec(block.body);
+      if (!hidden) continue;
+      const names = navSelectors(block.selector.replace(/^[\s\S]*[;}]/, ""));
+      if (names.length === 0) continue;
+      const line = lineOfOffset(block, hidden.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "menu-state",
+          file,
+          line,
+          `${names[0]} is hidden, and nothing in the project opens it with aria-expanded or <details>`,
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/declared-properties.ts
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
+import { join as join17 } from "path";
+var DECLARATION_RE = /(?<![\w-])['"]?(--[A-Za-z_][\w-]*)['"]?\s*:/g;
+var AT_PROPERTY_RE = /@property\s+(--[\w-]+)/g;
+var SET_PROPERTY_RE = /setProperty\(\s*['"`](--[\w-]+)/g;
+var IMPORT_RE2 = /@import\s+(?:url\(\s*)?["']([^"')]+)["']/g;
+var TAILWIND_RE = /@import\s+["']tailwindcss["']/;
+function addAll(names, text) {
+  for (const re of [DECLARATION_RE, AT_PROPERTY_RE, SET_PROPERTY_RE]) {
+    for (const m of text.matchAll(re)) names.add(m[1]);
+  }
+}
+function readPackageImport(projectRoot, spec) {
+  const base = join17(projectRoot, "node_modules", spec);
+  for (const candidate of [base, `${base}.css`]) {
+    try {
+      if (existsSync9(candidate) && candidate.endsWith(".css")) return readFileSync12(candidate, "utf8");
+    } catch {
+    }
+  }
+  try {
+    const pkg = JSON.parse(readFileSync12(join17(base, "package.json"), "utf8"));
+    if (pkg.style) return readFileSync12(join17(base, pkg.style), "utf8");
+  } catch {
+  }
+  return void 0;
+}
+function collectDeclaredProperties(projectRoot, files, tokenNames = []) {
+  const names = new Set(tokenNames.map((n) => `--${n}`));
+  let tailwind = false;
+  let complete = true;
+  for (const file of files) {
+    let raw;
+    try {
+      raw = readFileSync12(join17(projectRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    addAll(names, raw);
+    if (TAILWIND_RE.test(raw)) tailwind = true;
+    for (const m of raw.matchAll(IMPORT_RE2)) {
+      const spec = m[1];
+      if (spec === "tailwindcss" || /^(\.|\/|https?:)/.test(spec)) continue;
+      const imported = readPackageImport(projectRoot, spec);
+      if (imported === void 0) complete = false;
+      else addAll(names, imported);
+    }
+  }
+  return { names, tailwind, complete };
+}
+var PALETTE2 = "slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose|mauve|olive|mist|taupe";
+var SIZE = "3xs|2xs|xs|sm|md|lg|xl|[2-9]xl|base";
+var TAILWIND_DEFAULT_RE = new RegExp(
+  `^--(?:tw-[\\w-]+|color-(?:(?:${PALETTE2})-(?:50|[1-9]00|950)|black|white)|spacing|container-(?:${SIZE})|text-(?:${SIZE})(?:--line-height|--letter-spacing|--font-weight)?|font-(?:sans|serif|mono)|font-weight-(?:thin|extralight|light|normal|medium|semibold|bold|extrabold|black)|tracking-(?:tighter|tight|normal|wide|wider|widest)|leading-(?:tight|snug|normal|relaxed|loose)|breakpoint-(?:${SIZE})|radius-(?:${SIZE})|(?:inset-shadow|drop-shadow|text-shadow|shadow|blur|perspective|ease|animate|aspect|default)-[\\w-]+|shadow|blur)$`
+);
+function isTailwindDefault(name) {
+  return TAILWIND_DEFAULT_RE.test(name);
+}
+
+// src/check/detectors/undeclared-token.ts
+var VAR_RE2 = /var\(\s*(--[\w-]+)\s*([,)])/g;
+var CLASS_ATTR_RE = /\bclass(?:Name)?\s*=\s*(?:"[^"]*"|'[^']*'|\{`[^`]*`\})/g;
+var CLASS_REF_RE = /(?:-\(\s*|var\(\s*)(--[\w-]+)\s*\)/g;
+var undeclaredToken = {
+  name: "undeclared-token",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const declared = ctx.declaredProperties;
+    if (!declared || !declared.complete) return [];
+    const known = (name) => declared.names.has(name) || declared.tailwind && isTailwindDefault(name) || name.startsWith("--tw-");
+    const hits = /* @__PURE__ */ new Map();
+    const note = (name, offset, text) => {
+      if (known(name)) return;
+      const key = `${name}@${offset}`;
+      if (!hits.has(key)) hits.set(key, { name, offset, text });
+    };
+    for (const m of source.matchAll(VAR_RE2)) {
+      if (m[2] === ",") continue;
+      note(m[1], m.index, source);
+    }
+    for (const attr of ctx.raw.matchAll(CLASS_ATTR_RE)) {
+      for (const m of attr[0].matchAll(CLASS_REF_RE)) note(m[1], attr.index + m.index, ctx.raw);
+    }
+    const lines = buildLineIndex(ctx.raw);
+    const findings = [];
+    for (const { name, offset } of hits.values()) {
+      const line = lineForOffset(lines, offset);
+      findings.push(
+        mkFinding(
+          ctx,
+          "undeclared-token",
+          file,
+          line,
+          `${name} is not declared anywhere in the project, so every property using it is dropped`,
+          sourceLine(ctx.raw, line)
+        )
+      );
+    }
+    return findings.sort((a, b) => a.line - b.line);
+  }
+};
+
 // src/check/registry.ts
 var DETECTORS = [
   gradientText,
@@ -2783,14 +3310,20 @@ var DETECTORS = [
   contrastFloor,
   focusRemoved,
   hardcodedValue,
-  violetBandHue
+  violetBandHue,
+  fixedWidth,
+  viewportHeight,
+  inputZoom,
+  safeArea,
+  menuState,
+  undeclaredToken
 ];
 function getDetector(name) {
   return DETECTORS.find((d) => d.name === name);
 }
 
 // src/check/run.ts
-function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParticipates = false, mode) {
+function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParticipates = false, mode, projectResponsive, viewportFitCover, projectMenuToggle, declaredProperties) {
   const findings = [];
   const active = index.filter(
     (e) => !!e.detector && !!getDetector(e.detector)
@@ -2802,13 +3335,13 @@ function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParti
     if (applicable.length === 0) continue;
     let raw;
     try {
-      raw = readFileSync10(join15(projectRoot, file), "utf8");
+      raw = readFileSync13(join18(projectRoot, file), "utf8");
     } catch {
       continue;
     }
     const source = maskComments(maskNonStyleRegions(raw, file));
     for (const { entry, detector } of applicable) {
-      const ctx = { ruleId: entry.id, bucket: entry.bucket, severity: entry.severity, tokens, projectParticipates, raw, mode };
+      const ctx = { ruleId: entry.id, bucket: entry.bucket, severity: entry.severity, tokens, projectParticipates, raw, mode, projectResponsive, viewportFitCover, projectMenuToggle, declaredProperties };
       findings.push(...detector.run(source, file, ctx));
     }
   }
@@ -2816,8 +3349,8 @@ function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParti
 }
 
 // src/check/tokens.ts
-import { existsSync as existsSync9, readdirSync as readdirSync7, readFileSync as readFileSync11 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
+import { join as join19 } from "path";
 function rootDeclarations(source) {
   const out = {};
   for (const block of splitRuleBlocks(source)) {
@@ -2832,20 +3365,20 @@ function rootDeclarations(source) {
 }
 function loadTokenMap(projectRoot, consumerFiles = []) {
   const jig = {};
-  const tokensDir = join16(projectRoot, ".jig", "tokens");
-  if (existsSync9(tokensDir)) {
-    for (const file of readdirSync7(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
-      Object.assign(jig, rootDeclarations(readFileSync11(join16(tokensDir, file), "utf8")));
+  const tokensDir = join19(projectRoot, ".jig", "tokens");
+  if (existsSync10(tokensDir)) {
+    for (const file of readdirSync8(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
+      Object.assign(jig, rootDeclarations(readFileSync14(join19(tokensDir, file), "utf8")));
     }
   }
   const consumer = {};
   const ambiguous = /* @__PURE__ */ new Set();
-  const vendored = join16(".jig", "tokens");
+  const vendored = join19(".jig", "tokens");
   for (const file of consumerFiles) {
     if (file.includes(vendored)) continue;
     let source;
     try {
-      source = readFileSync11(join16(projectRoot, file), "utf8");
+      source = readFileSync14(join19(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -2864,8 +3397,8 @@ function loadTokenMap(projectRoot, consumerFiles = []) {
 }
 
 // src/check/exempt.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync15 } from "fs";
+import { join as join20 } from "path";
 function globToRegExp(glob) {
   let out = "";
   for (let i = 0; i < glob.length; i++) {
@@ -2884,11 +3417,11 @@ function globToRegExp(glob) {
   return new RegExp(`^${out}$`);
 }
 function readExemptions(projectRoot) {
-  const configPath = join17(projectRoot, "jig.config.json");
-  if (!existsSync10(configPath)) return [];
+  const configPath = join20(projectRoot, "jig.config.json");
+  if (!existsSync11(configPath)) return [];
   let declared;
   try {
-    declared = JSON.parse(readFileSync12(configPath, "utf8")).exempt;
+    declared = JSON.parse(readFileSync15(configPath, "utf8")).exempt;
   } catch {
     return [];
   }
@@ -2919,9 +3452,114 @@ function applyExemptions(files, patterns) {
   };
 }
 
+// src/check/responsive.ts
+var MEDIA_RE = /@media\b([^{]*)\{/gi;
+var VIEWPORT_FEATURE_RE = /\b(?:min-|max-)?(?:width|height|aspect-ratio|orientation|resolution)\b|\b(?:any-)?(?:pointer|hover)\b/i;
+var INTRINSIC_RE = [
+  /@container\b/i,
+  /\bminmax\s*\(/i,
+  /\bauto-(?:fit|fill)\b/i,
+  /\bflex-wrap\s*:\s*wrap(?:-reverse)?\b/i,
+  /\bclamp\s*\(/i
+];
+var TAILWIND_BREAKPOINT_RE = /(?:^|[\s"'`{])(?:max-)?(?:sm|md|lg|xl|2xl|@(?:xs|sm|md|lg|xl))(?:\/[\w-]+)?:[\w[-]/;
+function isResponsive(source, raw) {
+  MEDIA_RE.lastIndex = 0;
+  let m;
+  while (m = MEDIA_RE.exec(source)) {
+    if (VIEWPORT_FEATURE_RE.test(m[1])) return true;
+  }
+  if (INTRINSIC_RE.some((re) => re.test(source))) return true;
+  return TAILWIND_BREAKPOINT_RE.test(raw);
+}
+
+// src/check/menu-toggle.ts
+var NAV_REGION_RE = /<(nav|header)\b[\s\S]*?<\/\1\s*>/gi;
+var DETAILS_RE = /<details\b/i;
+var BOUND_RE = /(?::|x-bind:|\[attr\.)aria-expanded\b|\baria-expanded\s*=\s*(?:\{|["'][^"']*[{$@])/i;
+var EXPANDED_TAG_RE = /<[a-z][\w-]*\b[^>]*\baria-expanded\b[^>]*>/gi;
+var NAMES_MENU_RE = /menu|nav/i;
+var SCRIPT_STATE_RE = /setAttribute\(\s*['"`]aria-expanded['"`]|toggleAttribute\(\s*['"`]aria-expanded|\.ariaExpanded\s*=|dataset\.expanded|\[['"]aria-expanded['"]\]\s*=/;
+function hasMenuToggle(raw) {
+  const scripted = SCRIPT_STATE_RE.test(raw);
+  for (const region of raw.match(NAV_REGION_RE) ?? []) {
+    if (DETAILS_RE.test(region)) return true;
+    if (/\baria-expanded\b/i.test(region) && (scripted || BOUND_RE.test(region))) return true;
+  }
+  for (const tag of raw.match(EXPANDED_TAG_RE) ?? []) {
+    if (!NAMES_MENU_RE.test(tag.replace(/\baria-expanded\b/i, ""))) continue;
+    if (scripted || BOUND_RE.test(tag)) return true;
+  }
+  return scripted;
+}
+
+// src/check/mode-wiring.ts
+import { existsSync as existsSync12, readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname6, join as join21 } from "path";
+var MODES = ["editorial", "product", "operator"];
+function configProblems(config) {
+  const problems = [];
+  const at = "jig.config.json";
+  if (config.brand !== void 0) {
+    if (typeof config.brand !== "string" || !config.brand.endsWith(".css")) {
+      problems.push({ mode: "", barrel: at, message: `jig.config.json "brand" is ${JSON.stringify(config.brand)}, which is not a brand .css file in this project` });
+    }
+  }
+  if (config.surfaces !== void 0) {
+    const ok = Array.isArray(config.surfaces) && config.surfaces.every(
+      (x) => x && typeof x === "object" && typeof x.match === "string" && MODES.includes(x.mode ?? "")
+    );
+    if (!ok) {
+      problems.push({ mode: "", barrel: at, message: `jig.config.json "surfaces" must be a list of {"match": "/", "mode": "${MODES.join("|")}"} \u2014 as written, no mode applies and mode-gated rules are silent` });
+    }
+  }
+  return problems;
+}
+function modeWiringProblems(projectRoot) {
+  let config;
+  const path = join21(projectRoot, "jig.config.json");
+  if (!existsSync12(path)) return [];
+  try {
+    config = JSON.parse(readFileSync16(path, "utf8"));
+  } catch {
+    return [{ mode: "", barrel: "jig.config.json", message: "jig.config.json is not valid JSON, so nothing in it applies" }];
+  }
+  const invalid = configProblems(config);
+  if (invalid.length > 0) return invalid;
+  if (typeof config.brand !== "string" || !Array.isArray(config.surfaces)) return [];
+  const modes = [...new Set(config.surfaces.map((s) => s?.mode).filter((m) => typeof m === "string"))];
+  if (modes.length === 0) return [];
+  const dir = dirname6(config.brand);
+  const rel = (f) => dir === "." ? f : `${dir}/${f}`;
+  if (!existsSync12(join21(projectRoot, rel("theme.css")))) return [];
+  const problems = [];
+  modes.forEach((mode, i) => {
+    const barrel = rel(i === 0 ? "theme.css" : `theme.${mode}.css`);
+    const modeFile = `mode.${mode}.css`;
+    let body;
+    try {
+      body = readFileSync16(join21(projectRoot, barrel), "utf8");
+    } catch {
+      problems.push({ mode, barrel, message: `jig.config.json declares ${mode}, but ${barrel} does not exist` });
+      return;
+    }
+    const imported = /@import\s+["'][^"']*mode\.(\w+)\.css["']/.exec(body)?.[1];
+    if (imported !== mode) {
+      problems.push({
+        mode,
+        barrel,
+        message: `jig.config.json declares ${mode}, but ${barrel} imports ${imported ? `mode.${imported}.css` : "no mode file"} \u2014 the page is styled at ${imported ?? "no"} density`
+      });
+    } else if (!existsSync12(join21(projectRoot, rel(modeFile)))) {
+      problems.push({ mode, barrel, message: `jig.config.json declares ${mode}, but ${rel(modeFile)} does not exist` });
+    }
+  });
+  return problems;
+}
+
 // src/check/token-audit.ts
-import { existsSync as existsSync11, readdirSync as readdirSync8, readFileSync as readFileSync13 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
+import { join as join22 } from "path";
 var TEXT_FLOOR = 4.5;
 var UI_FLOOR = 3;
 var FOREGROUNDS = [
@@ -2977,24 +3615,24 @@ function floorFor(token) {
 function tokenFiles(projectRoot) {
   const read = (rel) => {
     try {
-      return readFileSync13(join18(projectRoot, ...rel.split("/")), "utf8");
+      return readFileSync17(join22(projectRoot, ...rel.split("/")), "utf8");
     } catch {
       return null;
     }
   };
-  const statePath = join18(projectRoot, ".jig", "state.json");
-  if (existsSync11(statePath)) {
+  const statePath = join22(projectRoot, ".jig", "state.json");
+  if (existsSync13(statePath)) {
     try {
-      const state = JSON.parse(readFileSync13(statePath, "utf8"));
+      const state = JSON.parse(readFileSync17(statePath, "utf8"));
       const recorded = Object.keys(state.files ?? {}).filter((f) => f.endsWith(".css")).sort();
       const out = recorded.map((path) => ({ path, source: read(path) })).filter((f) => f.source !== null);
       if (out.length > 0) return out;
     } catch {
     }
   }
-  const legacy = join18(projectRoot, ".jig", "tokens");
-  if (!existsSync11(legacy)) return [];
-  return readdirSync8(legacy).filter((f) => f.endsWith(".css")).sort().map((f) => ({ path: `.jig/tokens/${f}`, source: readFileSync13(join18(legacy, f), "utf8") }));
+  const legacy = join22(projectRoot, ".jig", "tokens");
+  if (!existsSync13(legacy)) return [];
+  return readdirSync9(legacy).filter((f) => f.endsWith(".css")).sort().map((f) => ({ path: `.jig/tokens/${f}`, source: readFileSync17(join22(legacy, f), "utf8") }));
 }
 function auditTokenLayer(projectRoot) {
   const files = tokenFiles(projectRoot);
@@ -3062,15 +3700,15 @@ function auditTokenLayer(projectRoot) {
 }
 
 // src/commands/check.ts
-var LEGACY_INDEX_REL = join19(".jig", "rules.index.json");
+var LEGACY_INDEX_REL = join23(".jig", "rules.index.json");
 function resolveIndexPath(projectRoot) {
-  const legacy = join19(projectRoot, LEGACY_INDEX_REL);
-  if (existsSync12(legacy)) return legacy;
-  return join19(assetRoot(), "rules.index.json");
+  const legacy = join23(projectRoot, LEGACY_INDEX_REL);
+  if (existsSync14(legacy)) return legacy;
+  return join23(assetRoot(), "rules.index.json");
 }
 function resolveMode(projectRoot) {
   try {
-    const config = JSON.parse(readFileSync14(join19(projectRoot, "jig.config.json"), "utf8"));
+    const config = JSON.parse(readFileSync18(join23(projectRoot, "jig.config.json"), "utf8"));
     const modes = [...new Set((config.surfaces ?? []).map((s) => s.mode).filter(Boolean))];
     if (modes.length === 1) return modes[0];
     return modes.length > 1 ? "mixed" : "unknown";
@@ -3087,14 +3725,14 @@ function summariseUnscanned(files) {
 }
 function countSpecs() {
   try {
-    return loadSpecs(join19(assetRoot(), "rules")).length;
+    return loadSpecs(join23(assetRoot(), "rules")).length;
   } catch {
     return 0;
   }
 }
 function check(opts) {
   const indexPath = resolveIndexPath(opts.projectRoot);
-  const index = validateIndex(JSON.parse(readFileSync14(indexPath, "utf8")));
+  const index = validateIndex(JSON.parse(readFileSync18(indexPath, "utf8")));
   const selection = selectFiles(opts.projectRoot, opts.all);
   const exemptions = readExemptions(opts.projectRoot);
   const { scanned: files, exempt, byPattern } = applyExemptions(selection.files, exemptions);
@@ -3104,21 +3742,46 @@ function check(opts) {
   const projectParticipates = stylesheets.some((f) => {
     if (!hasExtension(f, CSS_EXTENSIONS)) return false;
     try {
-      return participatesInTokenLayer(readFileSync14(join19(opts.projectRoot, f), "utf8"), tokens);
+      return participatesInTokenLayer(readFileSync18(join23(opts.projectRoot, f), "utf8"), tokens);
+    } catch {
+      return false;
+    }
+  });
+  const projectResponsive = stylesheets.some((f) => {
+    if (!isStyleBearing(f)) return false;
+    try {
+      const raw = readFileSync18(join23(opts.projectRoot, f), "utf8");
+      return isResponsive(maskComments(maskNonStyleRegions(raw, f)), raw);
+    } catch {
+      return false;
+    }
+  });
+  const viewportFitCover = stylesheets.some((f) => {
+    if (!isStyleBearing(f)) return false;
+    try {
+      return /viewport-fit\s*=\s*cover|viewportFit\s*:\s*['"]cover['"]/i.test(readFileSync18(join23(opts.projectRoot, f), "utf8"));
+    } catch {
+      return false;
+    }
+  });
+  const projectMenuToggle = stylesheets.some((f) => {
+    try {
+      return hasMenuToggle(readFileSync18(join23(opts.projectRoot, f), "utf8"));
     } catch {
       return false;
     }
   });
+  const declaredProperties = collectDeclaredProperties(opts.projectRoot, stylesheets, Object.keys(tokens));
   const withStyles = files.filter((f) => {
     try {
-      const src = readFileSync14(join19(opts.projectRoot, f), "utf8");
+      const src = readFileSync18(join23(opts.projectRoot, f), "utf8");
       return hasExtension(f, CSS_EXTENSIONS) ? src.trim().length > 0 : maskNonStyleRegions(src, f).trim().length > 0;
     } catch {
       return false;
     }
   }).length;
   const resolvedMode = resolveMode(opts.projectRoot);
-  const findings = runChecks(opts.projectRoot, files, index, tokens, bucketFilter, projectParticipates, resolvedMode);
+  const findings = runChecks(opts.projectRoot, files, index, tokens, bucketFilter, projectParticipates, resolvedMode, projectResponsive, viewportFitCover, projectMenuToggle, declaredProperties);
   const TOKEN_RULE = {
     "--text-prose": "B-75",
     "--size-touch-target": "E-51"
@@ -3143,7 +3806,7 @@ function check(opts) {
     // told to add a token @import it has nowhere to put.
     cssFiles.length > 0 && cssFiles.every((f) => {
       try {
-        return !participatesInTokenLayer(readFileSync14(join19(opts.projectRoot, f), "utf8"), tokens);
+        return !participatesInTokenLayer(readFileSync18(join23(opts.projectRoot, f), "utf8"), tokens);
       } catch {
         return true;
       }
@@ -3163,18 +3826,19 @@ function check(opts) {
     withStyles,
     exempt,
     exemptPatterns: byPattern,
-    scope: selection.mode
+    scope: selection.mode,
+    modeUnwired: modeWiringProblems(opts.projectRoot)
   });
   return { findings, report, hasError };
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readdirSync as readdirSync9, readFileSync as readFileSync18, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname6, isAbsolute, join as join23, resolve as resolve2, sep as sep3 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync10, readFileSync as readFileSync22, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, isAbsolute, join as join27, resolve as resolve2, sep as sep3 } from "path";
 
 // src/init/detect.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import { join as join24 } from "path";
 var TAILWIND_CONFIG_RE = /^tailwind\.config\.(js|ts|mjs|cjs)$/;
 var TAILWIND_V4_IMPORT_RE = /@import\s+["']tailwindcss["']/;
 var TAILWIND_V4_THEME_RE = /@theme\b/;
@@ -3191,7 +3855,7 @@ var FRAMEWORK_DEPS = [
 function detectFramework(projectRoot) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync15(join20(projectRoot, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync19(join24(projectRoot, "package.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -3209,7 +3873,7 @@ function detect(projectRoot) {
   for (const f of cssFiles) {
     let source;
     try {
-      source = readFileSync15(join20(projectRoot, f), "utf8");
+      source = readFileSync19(join24(projectRoot, f), "utf8");
     } catch {
       continue;
     }
@@ -3244,8 +3908,8 @@ function isIgnored(projectRoot, relPath) {
 }
 
 // src/init/derive.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join25 } from "path";
 var DEFAULT_PROPOSAL = {
   h: 264,
   s: 0,
@@ -3278,7 +3942,7 @@ function fromCssCustomProperties(projectRoot, cssFiles) {
   for (const file of cssFiles) {
     let source;
     try {
-      source = readFileSync16(join21(projectRoot, file), "utf8");
+      source = readFileSync20(join25(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -3327,7 +3991,7 @@ function balancedBraceBody(source, openIdx) {
 function fromTailwindConfig(projectRoot, tailwindConfigFile) {
   let source;
   try {
-    source = readFileSync16(join21(projectRoot, tailwindConfigFile), "utf8");
+    source = readFileSync20(join25(projectRoot, tailwindConfigFile), "utf8");
   } catch {
     return null;
   }
@@ -3383,7 +4047,7 @@ function fromLiteralFrequency(projectRoot, cssFiles) {
   for (const file of cssFiles) {
     let source;
     try {
-      source = readFileSync16(join21(projectRoot, file), "utf8");
+      source = readFileSync20(join25(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -3543,8 +4207,8 @@ function relativeImportPath(fromAbsDir, toAbsFile) {
 }
 
 // src/init/project-name.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { basename, join as join22 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { basename, join as join26 } from "path";
 function slugify(name) {
   const withoutScope = name.replace(/^@[^/]+\//, "");
   const slug = withoutScope.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -3552,7 +4216,7 @@ function slugify(name) {
 }
 function deriveProjectSlug(projectRoot) {
   try {
-    const pkg = JSON.parse(readFileSync17(join22(projectRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync21(join26(projectRoot, "package.json"), "utf8"));
     if (typeof pkg.name === "string" && pkg.name.trim()) return slugify(pkg.name);
   } catch {
   }
@@ -3635,7 +4299,7 @@ ${lines.join("\n")}
 }
 
 // src/commands/init.ts
-var MODES = ["editorial", "product", "operator"];
+var MODES2 = ["editorial", "product", "operator"];
 var DEFAULT_SURFACES = [{ match: "/", mode: "product" }];
 async function defaultPrompt(question) {
   const { createInterface } = await import("readline/promises");
@@ -3687,28 +4351,28 @@ function parseSurfaces(answer, fallback) {
     if (idx === -1) return fallback;
     const match = part.slice(0, idx).trim();
     const mode = part.slice(idx + 1).trim();
-    if (!match || !MODES.includes(mode)) return fallback;
+    if (!match || !MODES2.includes(mode)) return fallback;
     parsed.push({ match, mode });
   }
   return parsed.length > 0 ? parsed : fallback;
 }
 function fileState(projectRoot, absPath, relPath, initManifest) {
-  const existsOnDisk = existsSync13(absPath);
+  const existsOnDisk = existsSync15(absPath);
   const tracked = !!initManifest && relPath in initManifest.files;
   const modified = tracked && isInitFileModified(projectRoot, relPath, initManifest);
   return { existsOnDisk, tracked, modified };
 }
 function isValidSurfaceArray(v) {
   return Array.isArray(v) && v.length > 0 && v.every(
-    (s) => typeof s === "object" && s !== null && typeof s.match === "string" && MODES.includes(s.mode)
+    (s) => typeof s === "object" && s !== null && typeof s.match === "string" && MODES2.includes(s.mode)
   );
 }
 function loadEffectiveConfig(projectRoot, configAbsPath, fallbackBrand, fallbackSurfaces) {
-  if (!existsSync13(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
+  if (!existsSync15(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
   try {
-    const parsed = JSON.parse(readFileSync18(configAbsPath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(configAbsPath, "utf8"));
     const brandCandidate = typeof parsed.brand === "string" && parsed.brand ? parsed.brand : void 0;
-    const brandResolves = brandCandidate ? existsSync13(join23(projectRoot, ...brandCandidate.split("/"))) : false;
+    const brandResolves = brandCandidate ? existsSync15(join27(projectRoot, ...brandCandidate.split("/"))) : false;
     return {
       brand: brandResolves ? brandCandidate : fallbackBrand,
       surfaces: isValidSurfaceArray(parsed.surfaces) ? parsed.surfaces : fallbackSurfaces
@@ -3718,10 +4382,10 @@ function loadEffectiveConfig(projectRoot, configAbsPath, fallbackBrand, fallback
   }
 }
 function configuredBrandPath(projectRoot, configAbsPath) {
-  if (!existsSync13(configAbsPath)) return { path: null };
+  if (!existsSync15(configAbsPath)) return { path: null };
   let declared;
   try {
-    declared = JSON.parse(readFileSync18(configAbsPath, "utf8")).brand;
+    declared = JSON.parse(readFileSync22(configAbsPath, "utf8")).brand;
   } catch {
     return { path: null };
   }
@@ -3749,9 +4413,9 @@ function defaultTokenDir(detection) {
   return ["jig"];
 }
 function readConfiguredSurfaces(configAbsPath) {
-  if (!existsSync13(configAbsPath)) return null;
+  if (!existsSync15(configAbsPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync18(configAbsPath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(configAbsPath, "utf8"));
     return isValidSurfaceArray(parsed.surfaces) ? parsed.surfaces : null;
   } catch {
     return null;
@@ -3761,9 +4425,9 @@ function isCssModule(path) {
   return /\.module\.(css|scss)$/i.test(path);
 }
 function legacyBrandFile(projectRoot) {
-  const dir = join23(projectRoot, ".jig", "tokens");
-  if (!existsSync13(dir)) return void 0;
-  const found = readdirSync9(dir).find((f) => /^brand\.[\w.-]+\.css$/.test(f));
+  const dir = join27(projectRoot, ".jig", "tokens");
+  if (!existsSync15(dir)) return void 0;
+  const found = readdirSync10(dir).find((f) => /^brand\.[\w.-]+\.css$/.test(f));
   return found ? relKey(".jig", "tokens", found) : void 0;
 }
 function isTokenLayerFile(f) {
@@ -3775,7 +4439,7 @@ function findWireTarget(d) {
   if (candidates.length === 1) return candidates[0];
   return null;
 }
-var MODE_IMPORT_RE = new RegExp(`@import\\s+["']([^"']*/)?mode\\.(${MODES.join("|")})\\.css["'];?\\r?\\n?`);
+var MODE_IMPORT_RE = new RegExp(`@import\\s+["']([^"']*/)?mode\\.(${MODES2.join("|")})\\.css["'];?\\r?\\n?`);
 var CHARSET_RE = /^@charset\s+["'][^"']*["'];\r?\n?/;
 function insertAfterCharset(content, insertion) {
   const m = CHARSET_RE.exec(content);
@@ -3790,17 +4454,17 @@ function barrelBody(fileName, brandFile, mode, version2) {
 `;
 }
 var LEGACY_PAIR_RE = new RegExp(
-  `@import\\s+["'][^"']*brand\\.[\\w.-]+\\.css["'];?\\r?\\n?\\s*@import\\s+["'][^"']*mode\\.(?:${MODES.join("|")})\\.css["'];?\\r?\\n?`
+  `@import\\s+["'][^"']*brand\\.[\\w.-]+\\.css["'];?\\r?\\n?\\s*@import\\s+["'][^"']*mode\\.(?:${MODES2.join("|")})\\.css["'];?\\r?\\n?`
 );
 function wireBarrel(absPath, barrelImport) {
-  const content = existsSync13(absPath) ? readFileSync18(absPath, "utf8") : "";
+  const content = existsSync15(absPath) ? readFileSync22(absPath, "utf8") : "";
   const line = `@import "${barrelImport}";`;
   if (content.includes(line)) return { status: "already-present" };
   const legacy = LEGACY_PAIR_RE.exec(content);
   if (legacy) {
     const next2 = content.slice(0, legacy.index) + `${line}
 ` + content.slice(legacy.index + legacy[0].length);
-    writeFileSync4(absPath, next2, "utf8");
+    writeFileSync5(absPath, next2, "utf8");
     return { status: "rewired", detail: "replaced the separate brand and mode imports with the barrel" };
   }
   const tailwind = /@import\s+["']tailwindcss["'];?\r?\n?/.exec(content);
@@ -3809,8 +4473,8 @@ function wireBarrel(absPath, barrelImport) {
 
 ` : `${line}
 `);
-  mkdirSync5(dirname6(absPath), { recursive: true });
-  writeFileSync4(next === content ? absPath : absPath, next, "utf8");
+  mkdirSync6(dirname7(absPath), { recursive: true });
+  writeFileSync5(next === content ? absPath : absPath, next, "utf8");
   return { status: "wired" };
 }
 async function init(opts) {
@@ -3871,21 +4535,21 @@ async function init(opts) {
       for (const line of describeValidation(validation)) log(line);
     }
     const surfaceAnswer = await prompt(
-      `Surface \u2192 mode mapping. Enter to accept '/' \u2192 product, or 'match:mode,match:mode' (modes: ${MODES.join("/")}): `
+      `Surface \u2192 mode mapping. Enter to accept '/' \u2192 product, or 'match:mode,match:mode' (modes: ${MODES2.join("/")}): `
     );
     surfaces = parseSurfaces(surfaceAnswer, DEFAULT_SURFACES);
     if (surfaceAnswer.trim() && surfaces === DEFAULT_SURFACES) {
       log(
-        `  Could not parse '${surfaceAnswer}' as 'match:mode,match:mode' (modes: ${MODES.join("/")}) \u2014 using the default ('/' \u2192 product) instead.`
+        `  Could not parse '${surfaceAnswer}' as 'match:mode,match:mode' (modes: ${MODES2.join("/")}) \u2014 using the default ('/' \u2192 product) instead.`
       );
     }
   }
   if (opts.yes) {
-    const declared = readConfiguredSurfaces(join23(opts.projectRoot, "jig.config.json"));
+    const declared = readConfiguredSurfaces(join27(opts.projectRoot, "jig.config.json"));
     const inEffect = declared ?? surfaces;
     const map = inEffect.map((x) => `'${x.match}' \u2192 ${x.mode}`).join(", ");
     log(
-      declared ? `Surface \u2192 mode: ${map} \u2014 from jig.config.json. Mode sets density, type scale and control sizes, and it outranks an agent's own reading of the project.` : `Surface \u2192 mode: ${map} \u2014 the default, not inferred from this project. Mode sets density, type scale and control sizes, and it wins over an agent's own inference, so change it in jig.config.json if another mode fits (${MODES.join("/")}).`
+      declared ? `Surface \u2192 mode: ${map} \u2014 from jig.config.json. Mode sets density, type scale and control sizes, and it outranks an agent's own reading of the project.` : `Surface \u2192 mode: not declared. jig.config.json records no mapping, because --yes has nobody to ask and a guess written there cannot be told from a decision. Mode-gated rules stay silent until you declare one. Token files are written at ${inEffect[0]?.mode ?? "product"} as a baseline. Add "surfaces": [{"match": "/", "mode": "..."}] to jig.config.json and run jig init again \u2014 the config alone changes what agents read, not the token files the page imports \u2014 or run jig init without --yes (modes: ${MODES2.join("/")}).`
     );
   }
   if (!validation.passesContrast && validation.nearestPassingLightness !== void 0) {
@@ -3900,7 +4564,7 @@ Brand colour adjusted to clear the 4.5:1 contrast floor: l:${originalL}% \u2192
   const finalColor = { h: proposal.h, s: proposal.s, l: proposal.l };
   const projectSlug = deriveProjectSlug(opts.projectRoot);
   const configRelPath = "jig.config.json";
-  const configAbsPath = join23(opts.projectRoot, configRelPath);
+  const configAbsPath = join27(opts.projectRoot, configRelPath);
   const configuredBrand = configuredBrandPath(opts.projectRoot, configAbsPath);
   if (configuredBrand.refused) {
     log(
@@ -3934,7 +4598,7 @@ The token layer is at ${currentDir}/, and this project's layout suggests ${would
     }
   }
   const brandRelPath = relocateTo ?? configuredBrand.path ?? priorBrand ?? relKey(...defaultTokenDir(detection), brandFileName(projectSlug));
-  const brandAbsPath = join23(opts.projectRoot, ...brandRelPath.split("/"));
+  const brandAbsPath = join27(opts.projectRoot, ...brandRelPath.split("/"));
   const tokensRelDir = brandRelPath.split("/").slice(0, -1);
   log(
     `Token layer: ${tokensRelDir.join("/") || "."}/ \u2014 ` + (configuredBrand.path ? "from jig.config.json." : priorBrand ? "the layout this project already had. Set `brand` in jig.config.json to move it." : findWireTarget(detection) ? "beside the stylesheet being wired. Set `brand` in jig.config.json to put it elsewhere." : "no stylesheet found to follow, so the project root. Set `brand` in jig.config.json to move it.")
@@ -3967,18 +4631,18 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     if (configAction !== "written") log(`  ${configRelPath} exists and is not jig-tracked \u2014 leaving it alone (re-run without --yes to refresh).`);
   }
   if (brandAction === "written") {
-    const defaultCssRaw = readFileSync18(join23(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
+    const defaultCssRaw = readFileSync22(join27(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
     const content = renderBrandFile(defaultCssRaw, projectSlug, opts.version, proposal);
-    mkdirSync5(dirname6(brandAbsPath), { recursive: true });
-    writeFileSync4(brandAbsPath, content, "utf8");
+    mkdirSync6(dirname7(brandAbsPath), { recursive: true });
+    writeFileSync5(brandAbsPath, content, "utf8");
     files[brandRelPath] = checksum(content);
   }
   if (relocateTo && configAction !== "written") {
     try {
-      const existing = JSON.parse(readFileSync18(configAbsPath, "utf8"));
+      const existing = JSON.parse(readFileSync22(configAbsPath, "utf8"));
       const content = `${JSON.stringify({ ...existing, brand: brandRelPath }, null, 2)}
 `;
-      writeFileSync4(configAbsPath, content, "utf8");
+      writeFileSync5(configAbsPath, content, "utf8");
       files[configRelPath] = checksum(content);
       log(`  Updated ${configRelPath} to point at the new location.`);
     } catch {
@@ -3986,37 +4650,40 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     }
   }
   if (configAction === "written") {
-    const config = { brand: brandRelPath, surfaces };
+    const config = opts.yes ? { brand: brandRelPath } : { brand: brandRelPath, surfaces };
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    writeFileSync4(configAbsPath, content, "utf8");
+    writeFileSync5(configAbsPath, content, "utf8");
     files[configRelPath] = checksum(content);
   } else if (configAction === "merged") {
     let existing = {};
     try {
-      existing = JSON.parse(readFileSync18(configAbsPath, "utf8"));
+      existing = JSON.parse(readFileSync22(configAbsPath, "utf8"));
     } catch {
       existing = {};
     }
     const existingBrand = typeof existing.brand === "string" ? existing.brand : void 0;
-    const brandStillResolves = existingBrand ? existsSync13(join23(opts.projectRoot, ...existingBrand.split("/"))) : false;
+    const brandStillResolves = existingBrand ? existsSync15(join27(opts.projectRoot, ...existingBrand.split("/"))) : false;
+    const existingSurfaces = Array.isArray(existing.surfaces) && existing.surfaces.length > 0 ? existing.surfaces : void 0;
     const merged = {
       brand: brandStillResolves ? existingBrand : brandRelPath,
-      surfaces: Array.isArray(existing.surfaces) && existing.surfaces.length > 0 ? existing.surfaces : surfaces
+      // Same contract as the 'written' branch: never invent a mapping under
+      // `--yes`. An existing declaration is always kept.
+      ...existingSurfaces ? { surfaces: existingSurfaces } : opts.yes ? {} : { surfaces }
     };
     const content = `${JSON.stringify(merged, null, 2)}
 `;
-    writeFileSync4(configAbsPath, content, "utf8");
+    writeFileSync5(configAbsPath, content, "utf8");
     files[configRelPath] = checksum(content);
   }
   const effectiveConfig = loadEffectiveConfig(opts.projectRoot, configAbsPath, brandRelPath, surfaces);
   const primaryMode = effectiveConfig.surfaces[0]?.mode ?? "product";
-  const wiringBrandAbsPath = join23(opts.projectRoot, ...effectiveConfig.brand.split("/"));
+  const wiringBrandAbsPath = join27(opts.projectRoot, ...effectiveConfig.brand.split("/"));
   const declaredModes = [...new Set(effectiveConfig.surfaces.map((s) => s.mode))];
   const modeAbsPaths = {};
   for (const mode of declaredModes) {
     const modeFileName = `mode.${mode}.css`;
-    const modeAbsPath2 = join23(opts.projectRoot, ...tokensRelDir, modeFileName);
+    const modeAbsPath2 = join27(opts.projectRoot, ...tokensRelDir, modeFileName);
     modeAbsPaths[mode] = modeAbsPath2;
     const modeRelPath = relKey(...tokensRelDir, modeFileName);
     const modeState = fileState(opts.projectRoot, modeAbsPath2, modeRelPath, initManifest);
@@ -4024,10 +4691,10 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     if (modeState.existsOnDisk && !modeState.tracked) modeAction = "skipped-untracked";
     else if (modeState.modified) modeAction = "skipped-edited";
     if (modeAction === "written") {
-      const modeSourceRaw = readFileSync18(join23(opts.packageRoot, "tokens", modeFileName), "utf8");
+      const modeSourceRaw = readFileSync22(join27(opts.packageRoot, "tokens", modeFileName), "utf8");
       const content = vendorHeader(modeFileName, opts.version, "css", null) + modeSourceRaw;
-      mkdirSync5(dirname6(modeAbsPath2), { recursive: true });
-      writeFileSync4(modeAbsPath2, content, "utf8");
+      mkdirSync6(dirname7(modeAbsPath2), { recursive: true });
+      writeFileSync5(modeAbsPath2, content, "utf8");
       files[modeRelPath] = checksum(content);
     } else {
       log(`  ${modeRelPath} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone (re-run 'jig update' to refresh it).`);
@@ -4038,22 +4705,22 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   const barrelFor = (mode) => mode === primaryMode ? "theme.css" : `theme.${mode}.css`;
   for (const mode of declaredModes) {
     const rel = relKey(...tokensRelDir, barrelFor(mode));
-    const abs = join23(opts.projectRoot, ...tokensRelDir, barrelFor(mode));
+    const abs = join27(opts.projectRoot, ...tokensRelDir, barrelFor(mode));
     const state = fileState(opts.projectRoot, abs, rel, initManifest);
     if (state.existsOnDisk && (!state.tracked || state.modified)) {
       log(`  ${rel} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone.`);
       continue;
     }
     const content = barrelBody(barrelFor(mode), brandFileOnly, mode, opts.version);
-    mkdirSync5(dirname6(abs), { recursive: true });
-    writeFileSync4(abs, content, "utf8");
+    mkdirSync6(dirname7(abs), { recursive: true });
+    writeFileSync5(abs, content, "utf8");
     files[rel] = checksum(content);
   }
   if (detection.cssSystem === "tailwind-v4") {
     const declared = declaredTokenNames(
       [brandAbsPath, modeAbsPath].map((f) => {
         try {
-          return readFileSync18(f, "utf8");
+          return readFileSync22(f, "utf8");
         } catch {
           return "";
         }
@@ -4078,19 +4745,19 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
       log(`  This changes how components are written. Both styles are correct.`);
       const answer = (await prompt("  Generate it? [y/N]: ")).toLowerCase();
       if (answer === "y" || answer === "yes") {
-        const abs = join23(opts.projectRoot, ...tokensRelDir, "utilities.css");
+        const abs = join27(opts.projectRoot, ...tokensRelDir, "utilities.css");
         const state = fileState(opts.projectRoot, abs, rel, initManifest);
         if (state.existsOnDisk && (!state.tracked || state.modified)) {
           log(`  ${rel} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone.`);
         } else {
           const content = utilitiesBody(aliasable, opts.version);
-          mkdirSync5(dirname6(abs), { recursive: true });
-          writeFileSync4(abs, content, "utf8");
+          mkdirSync6(dirname7(abs), { recursive: true });
+          writeFileSync5(abs, content, "utf8");
           files[rel] = checksum(content);
           const target = findWireTarget(detection);
           const importPath = target ? relativeImportPath(
-            dirname6(join23(opts.projectRoot, target)),
-            join23(opts.projectRoot, ...tokensRelDir, "utilities.css")
+            dirname7(join27(opts.projectRoot, target)),
+            join27(opts.projectRoot, ...tokensRelDir, "utilities.css")
           ) : `./${rel}`;
           log(`  Wrote ${rel}. Import it in the stylesheet that imports Tailwind:`);
           log(`    @import "tailwindcss";`);
@@ -4108,11 +4775,11 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   writeInitManifest(opts.projectRoot, { version: opts.version, modes: declaredModes, files });
   if (relocateTo && currentBrand) {
     const oldDir = currentBrand.split("/").slice(0, -1);
-    const oldAbsDir = join23(opts.projectRoot, ...oldDir);
-    if (existsSync13(oldAbsDir)) {
-      for (const name of readdirSync9(oldAbsDir).filter((f) => f.endsWith(".css"))) {
+    const oldAbsDir = join27(opts.projectRoot, ...oldDir);
+    if (existsSync15(oldAbsDir)) {
+      for (const name of readdirSync10(oldAbsDir).filter((f) => f.endsWith(".css"))) {
         const rel = relKey(...oldDir, name);
-        const abs = join23(oldAbsDir, name);
+        const abs = join27(oldAbsDir, name);
         const state = fileState(opts.projectRoot, abs, rel, initManifest);
         if (!state.tracked || state.modified) {
           log(`  ${rel} was edited \u2014 left in place. Delete it yourself once you have moved anything you need.`);
@@ -4126,21 +4793,21 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   const wireTarget = findWireTarget(detection);
   let wiring;
   if (wireTarget) {
-    const targetAbsDir = dirname6(join23(opts.projectRoot, wireTarget));
+    const targetAbsDir = dirname7(join27(opts.projectRoot, wireTarget));
     const barrelImport = relativeImportPath(
       targetAbsDir,
-      join23(opts.projectRoot, ...tokensRelDir, "theme.css")
+      join27(opts.projectRoot, ...tokensRelDir, "theme.css")
     );
     const snippet = `@import "${barrelImport}";`;
     try {
       if (relocateTo && currentBrand) {
-        const abs = join23(opts.projectRoot, wireTarget);
+        const abs = join27(opts.projectRoot, wireTarget);
         const oldDirName = currentBrand.split("/").slice(0, -1).join("/");
-        const before = existsSync13(abs) ? readFileSync18(abs, "utf8") : "";
+        const before = existsSync15(abs) ? readFileSync22(abs, "utf8") : "";
         const after = before.split("\n").filter((l) => !(l.includes("@import") && l.includes(oldDirName))).join("\n");
-        if (after !== before) writeFileSync4(abs, after, "utf8");
+        if (after !== before) writeFileSync5(abs, after, "utf8");
       }
-      const outcome = wireBarrel(join23(opts.projectRoot, wireTarget), barrelImport);
+      const outcome = wireBarrel(join27(opts.projectRoot, wireTarget), barrelImport);
       wiring = { target: wireTarget, status: outcome.status, snippet };
       const verb = outcome.status === "wired" ? "Wired" : outcome.status === "rewired" ? "Rewired" : "Already present in";
       log(`
@@ -4157,7 +4824,7 @@ Could not write to ${wireTarget}: ${err.message}`);
   } else {
     const barrelImport = relativeImportPath(
       opts.projectRoot,
-      join23(opts.projectRoot, ...tokensRelDir, "theme.css")
+      join27(opts.projectRoot, ...tokensRelDir, "theme.css")
     );
     const snippet = `@import "${barrelImport}";`;
     wiring = { target: null, status: "print-only", snippet };
@@ -4166,7 +4833,7 @@ Could not write to ${wireTarget}: ${err.message}`);
     if (pasteTargets.length > 0) {
       log("Paste the block for whichever of these is your global stylesheet:");
       for (const target of pasteTargets) {
-        const dir = dirname6(join23(opts.projectRoot, target));
+        const dir = dirname7(join27(opts.projectRoot, target));
         const forTarget = `@import "${relativeImportPath(dir, wiringBrandAbsPath)}";
 @import "${relativeImportPath(dir, modeAbsPath)}";`;
         log(`
@@ -4180,9 +4847,16 @@ Could not write to ${wireTarget}: ${err.message}`);
       log(`  ${snippet.split("\n").join("\n  ")}`);
     }
   }
+  const tokenDirRel = tokensRelDir.join("/");
+  if (isIgnored(opts.projectRoot, tokenDirRel)) {
+    log(
+      `
+  WARNING: ${tokenDirRel}/ is gitignored, but it holds this project's tokens \u2014 the files your stylesheet @imports. Committed, teammates and CI get the same design system; ignored, their builds break on a missing import. Remove the ${tokenDirRel}/ rule from .gitignore, or commit the directory explicitly.`
+    );
+  }
   if (isIgnored(opts.projectRoot, ".jig")) {
     log(
-      "\n  WARNING: .jig/ is gitignored, but it holds this project's tokens \u2014 the files your stylesheet @imports. Committed, teammates and CI get the same design system; ignored, their builds break on a missing import. Remove the .jig/ rule from .gitignore, or commit the directory explicitly."
+      "\n  WARNING: .jig/ is gitignored. It holds state.json \u2014 which `update` reads to leave your edited files alone \u2014 and the specs, mockups and critique verdicts this project agreed. Ignored, update cannot tell your edits from its own writes, and every spec is invisible to the next agent. Commit it."
     );
   }
   const baselineResult = check({ projectRoot: opts.projectRoot, homeDir: opts.homeDir, version: opts.version, all: true, ci: false });
@@ -4205,9 +4879,565 @@ 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";
+
+// src/rules/citations.ts
+import { join as join28 } from "path";
+function citableIds(packageRoot2) {
+  const rulesDir = join28(packageRoot2, "rules");
+  const ids = [
+    ...loadRules(rulesDir, join28(packageRoot2, "rules.index.json")).map((r) => r.id),
+    ...loadSpecs(rulesDir).map((s) => s.id)
+  ];
+  return [...new Set(ids)].sort();
+}
+
+// src/probe/check.ts
+import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync24 } from "fs";
+import { join as join30 } from "path";
+
+// src/probe/save.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, 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";
+
+// src/probe/script.ts
+var PROBE_VERSION = 2;
+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'; };
+  const probe = document.createElement('div');
+  probe.style.all = 'initial';
+  document.body.appendChild(probe);
+  const defaultFont = getComputedStyle(probe).fontFamily;
+  probe.remove();
+  const text = document.body.innerText || '';
+  const junk = [...new Set(text.match(/\\$\\{|\\{\\{|\\bundefined\\b|\\bNaN\\b|\\[object Object\\]/g) || [])];
+  const unresolved = new Set();
+  for (const sheet of document.styleSheets) {
+    let rules; try { rules = sheet.cssRules; } catch (e) { continue; }
+    for (const rule of rules) {
+      for (const m of (rule.cssText || '').matchAll(/var\\(\\s*(--[\\w-]+)\\s*\\)/g)) {
+        if (!getComputedStyle(doc).getPropertyValue(m[1]).trim()) unresolved.add(m[1]);
+      }
+    }
+  }
+  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();
+  // The menu control: inside the header or navigation, or named as the menu.
+  // Not any disclosure \u2014 an FAQ <summary> is not a menu.
+  const inChrome = (b) => !!b.closest('header, nav, [role=navigation], [role=banner]');
+  const named = (b) => /\b(menu|navigation)\b/i.test((b.getAttribute('aria-label') || '') + ' ' + b.textContent);
+  const toggle = [...document.querySelectorAll('button, summary, [role=button]')].find((b) => vis(b) &&
+    (named(b) || (inChrome(b) && (b.tagName === 'SUMMARY' || b.hasAttribute('aria-expanded') || b.hasAttribute('aria-controls')))));
+  let menu = null;
+  if (toggle) {
+    const name = () => ((toggle.getAttribute('aria-label') || '') + ' ' + (toggle.textContent || '')).replace(/\\s+/g, ' ').trim();
+    // Opening is judged by what becomes visible anywhere: a menu panel is often
+    // a sibling of the header, not inside it (arm test 3, tw-1).
+    const allLinks = () => [...document.querySelectorAll('a')].filter(vis).length;
+    const controlled = () => { const id = toggle.getAttribute('aria-controls'); const el = id && document.getElementById(id); return el ? vis(el) : null; };
+    const before = { links: allLinks(), controlled: controlled(), expanded: toggle.getAttribute('aria-expanded'), name: name(), html: toggle.innerHTML };
+    toggle.click();
+    await new Promise((r) => setTimeout(r, 350));
+    const after = { links: allLinks(), controlled: controlled(), expanded: toggle.getAttribute('aria-expanded'), name: name(), htmlChanged: toggle.innerHTML !== before.html };
+    toggle.focus();
+    toggle.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    await new Promise((r) => setTimeout(r, 350));
+    menu = {
+      linksBefore: before.links, linksAfter: after.links,
+      expandedBefore: before.expanded, expandedAfter: after.expanded,
+      opened: after.links > before.links || (before.controlled === false && after.controlled === true),
+      labelChanged: after.name !== before.name || after.htmlChanged,
+      escapeCloses: toggle.getAttribute('aria-expanded') !== 'true' && allLinks() <= before.links,
+      focusReturned: document.activeElement === toggle,
+    };
+  }
+  return JSON.stringify({
+    jigProbe: ${PROBE_VERSION},
+    url: location.href,
+    width: innerWidth,
+    scrollWidth: doc.scrollWidth,
+    clientWidth: doc.clientWidth,
+    sidewaysScroll: doc.scrollWidth > doc.clientWidth,
+    bodyFont: getComputedStyle(document.body).fontFamily,
+    defaultFont: getComputedStyle(document.body).fontFamily === defaultFont,
+    unresolvedTokens: [...unresolved],
+    junkText: junk,
+    brokenImages: [...document.images].filter((i) => i.complete && i.naturalWidth === 0).length,
+    navLinksVisible: navAtRest,
+    menu,
+  });
+})()`;
+
+// src/probe/save.ts
+function saveProbe(opts) {
+  let probe;
+  try {
+    probe = JSON.parse(opts.json);
+  } catch (e) {
+    throw new Error(`That is not the probe's output: ${e.message}. Evaluate \`jig probe\` in the browser and pipe what it returns straight in.`);
+  }
+  if (probe.jigProbe !== PROBE_VERSION) {
+    throw new Error(`That JSON is not version ${PROBE_VERSION} probe output (jigProbe: ${JSON.stringify(probe.jigProbe)}). Re-read \`jig probe\` and evaluate it; do not write the file yourself.`);
+  }
+  const width = typeof probe.width === "number" ? probe.width : NaN;
+  if (!Number.isFinite(width)) throw new Error("The probe output has no width. Evaluate it in a browser, at the width you are judging.");
+  const url = typeof probe.url === "string" ? probe.url : "";
+  const page = pageFile(opts.projectRoot, url);
+  if (!page) {
+    throw new Error(`The probe ran at ${url || "no url"}, which is not a file in this project. Open the page you built \u2014 a file:// URL under the project \u2014 and probe that.`);
+  }
+  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);
+  mkdirSync7(dir, { recursive: true });
+  const path = join29(dir, `probe-${width}.json`);
+  writeFileSync6(path, JSON.stringify(probe), "utf8");
+  return { path: `.jig/critique/${opts.surface}/probe-${width}.json`, width, page: probe.pageFile };
+}
+function pageFile(projectRoot, url) {
+  if (!url.startsWith("file://")) return void 0;
+  let path;
+  try {
+    path = fileURLToPath2(url.split("#")[0].split("?")[0]);
+  } catch {
+    return void 0;
+  }
+  const abs = resolve3(path);
+  if (!abs.startsWith(resolve3(projectRoot))) return void 0;
+  return existsSync16(abs) ? abs : void 0;
+}
+
+// src/probe/check.ts
+function stampProblem(projectRoot, file, p) {
+  if (!p.pageChecksum || !p.pageFile) {
+    return `${file} was not written by \`jig probe --save\`, so nothing measured it. Evaluate \`jig probe\` in the browser and pipe its output into \`jig probe --save <surface>\`.`;
+  }
+  const page = pageFile(projectRoot, p.url ?? "");
+  if (!page) return `${file} names a page outside this project (${p.url ?? "no url"}).`;
+  let current;
+  try {
+    current = readFileSync24(page, "utf8");
+  } catch {
+    return `${file} was taken on ${p.pageFile}, which no longer exists.`;
+  }
+  if (checksum(current) !== p.pageChecksum) {
+    return `${file} was taken on an older ${p.pageFile} \u2014 the page changed after it. Render and probe again at that width.`;
+  }
+  return void 0;
+}
+function readProbes(projectRoot, dir, errors) {
+  if (!existsSync17(dir)) return [];
+  const probes = [];
+  for (const f of readdirSync11(dir).filter((n) => /^probe-\d+\.json$/.test(n)).sort()) {
+    try {
+      const p = JSON.parse(readFileSync24(join30(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;
+      }
+      const stale = stampProblem(projectRoot, f, p);
+      if (stale) {
+        errors.push(stale);
+        continue;
+      }
+      probes.push(p);
+    } catch (e) {
+      errors.push(`${f}: not valid JSON (${e.message}).`);
+    }
+  }
+  return probes;
+}
+function probeContradictions(probes, verdictOf) {
+  const errors = [];
+  const clean = (id) => ["ok", "n/a"].includes(verdictOf(id) ?? "");
+  const at = (p) => `probe-${p.width}.json`;
+  for (const p of probes) {
+    if (p.sidewaysScroll && clean("D-115")) {
+      errors.push(`D-115 is "${verdictOf("D-115")}", but ${at(p)} measured the page ${p.scrollWidth}px wide in a ${p.clientWidth}px viewport \u2014 it scrolls sideways.`);
+    }
+    if (p.defaultFont) {
+      errors.push(`${at(p)}: the page renders in the browser's default font (${p.bodyFont ?? "unknown"}) \u2014 its styles are not applying. No review of this page can pass until they do.`);
+    }
+    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).`);
+    }
+    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.`);
+    }
+  }
+  const navClean = clean("P-14") || clean("E-61");
+  const cite = [clean("P-14") && `P-14 is "${verdictOf("P-14")}"`, clean("E-61") && `E-61 is "${verdictOf("E-61")}"`].filter(Boolean).join(" and ");
+  for (const p of probes.filter((x) => x.width >= 768)) {
+    if (!navClean) continue;
+    const m = p.menu;
+    if (m && p.navLinksVisible > 0) {
+      errors.push(`${cite}, but at ${p.width}px ${at(p)} found a menu button beside navigation links that already show \u2014 ${m.opened ? "it opens a second copy of them" : "it opens nothing"}. At a width where the links show, there is no menu button.`);
+    } else if (m && m.opened && m.linksAfter - m.linksBefore <= 8) {
+      errors.push(`${cite}, but at ${p.width}px ${at(p)} found the navigation behind a menu \u2014 ${m.linksAfter - m.linksBefore} link(s) that fit on one row at this width. Show them.`);
+    } else if (p.navLinksVisible === 0 && !(m && m.opened)) {
+      errors.push(`${cite}, but at ${p.width}px ${at(p)} found no visible navigation links and no menu that opens.`);
+    }
+  }
+  const phone = probes.filter((p) => p.width <= 480).sort((a, b) => a.width - b.width)[0];
+  if (phone && clean("P-14")) {
+    const m = phone.menu;
+    if (!m && phone.navLinksVisible === 0) {
+      errors.push(`P-14 is "${verdictOf("P-14")}", but ${at(phone)} found no visible navigation links and no menu control.`);
+    } else if (m) {
+      const broken = [
+        !m.opened && `tapping it showed no more links (${m.linksBefore} \u2192 ${m.linksAfter})`,
+        m.expandedAfter !== "true" && `aria-expanded was ${JSON.stringify(m.expandedAfter)} after opening`,
+        !m.labelChanged && "its label and icon did not change to close",
+        !m.escapeCloses && "Escape did not close it"
+      ].filter(Boolean);
+      if (broken.length) errors.push(`P-14 is "${verdictOf("P-14")}", but ${at(phone)} operated the menu: ${broken.join("; ")}.`);
+    }
+  }
+  return errors;
+}
+
+// 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;
+  try {
+    return JSON.parse(readFileSync25(path, "utf8"));
+  } catch (e) {
+    errors.push(`${path}: not valid JSON (${e.message})`);
+    return {};
+  }
+}
+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 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;
+}
+function checkArm(name, file, required, otherPass, extraAllowed, extraRequired, errors) {
+  const total = required.length + extraRequired.length;
+  if (file === null) {
+    errors.push(`${name}.json is missing \u2014 the ${name} arm has not run, or did not write its verdicts.`);
+    return { state: "missing", judged: 0, total, findings: 0 };
+  }
+  const list = Array.isArray(file.verdicts) ? file.verdicts : [];
+  if (!Array.isArray(file.verdicts)) errors.push(`${name}.json has no "verdicts" array.`);
+  const seen = /* @__PURE__ */ new Set();
+  let findings = 0;
+  for (const v of list) {
+    const written = typeof v.id === "string" ? v.id.trim() : "";
+    const id = written.toUpperCase();
+    if (!id) {
+      errors.push(`${name}.json: a verdict has no id.`);
+      continue;
+    }
+    if (seen.has(id)) {
+      errors.push(`${name}.json: ${id} is judged more than once.`);
+      continue;
+    }
+    seen.add(id);
+    const pass = otherPass.get(id);
+    if (!required.includes(id) && !extraAllowed.has(id)) {
+      errors.push(pass === "mechanical" ? `${name}.json: ${id} is a mechanical rule \u2014 \`jig check\` decides it, so it has no verdict here. Remove it.` : pass ? `${name}.json: ${id} is a pass: ${pass} rule \u2014 it belongs to the other arm.` : `${name}.json: ${written} is not a rule or spec in this corpus. Run \`jig explain ${written}\`; an id that does not resolve is not a verdict.`);
+      continue;
+    }
+    if (typeof v.verdict !== "string" || !VERDICTS.includes(v.verdict)) {
+      errors.push(`${name}.json: ${id} 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(`${name}.json: ${id} has no reason.`);
+    else if (ABSENCE.test(reason)) errors.push(`${name}.json: ${id} \u2014 "${reason}" says the rule was not read. Read it with \`jig explain ${id}\` and judge it.`);
+    if (v.verdict === "finding") findings++;
+  }
+  const missing = [...required, ...extraRequired].filter((id) => !seen.has(id));
+  if (missing.length) {
+    errors.push(`${name}.json: ${missing.length} of ${total} ids have no verdict: ${missing.join(", ")}. Re-run the arm; never report a short pass.`);
+  }
+  const judged = total - missing.length;
+  return { state: missing.length ? "incomplete" : "ran", judged, total, findings };
+}
+function verifyVerdicts(opts) {
+  const root = opts.packageRoot ?? assetRoot();
+  const errors = [];
+  const index = JSON.parse(readFileSync25(join31(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);
+  const passOf = new Map([
+    ...index.filter((r) => r.bucket === "mechanical").map((r) => [r.id, "mechanical"]),
+    ...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 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)));
+    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;
+  }
+  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));
+    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;
+    }
+  }
+  const screenVerdicts = Array.isArray(screenFile?.verdicts) ? screenFile.verdicts : [];
+  const verdictOf = (id) => {
+    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));
+  if (screen.state === "ran" && !rendered) screen.state = "skipped";
+  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 };
+}
+
+// src/commands/gate.ts
+import { existsSync as existsSync20, mkdirSync as mkdirSync8, readdirSync as readdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync7 } from "fs";
+import { join as join33 } 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";
+function newestSpec(projectRoot) {
+  const dir = join32(projectRoot, ".jig", "specs");
+  if (!existsSync19(dir)) return void 0;
+  const files = readdirSync12(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") };
+}
+function specProblems(spec) {
+  const parts = spec.body.split(/^---\s*$/m);
+  const front = parts.length >= 3 ? parts[1] : "";
+  if (!front.trim()) {
+    return [`${spec.path} has no frontmatter. A spec is the frontmatter \u2014 feature, surface, mode, sizes (phone, tablet, desktop), states, decisions, later, mockup, confirmed \u2014 with the reasoning below it. Rewrite it in that shape.`];
+  }
+  const problems = [];
+  const has = (field) => new RegExp(`^\\s*${field}\\s*:`, "im").test(front);
+  for (const field of ["feature", "surface", "mode", "sizes", "confirmed", "mockup"]) {
+    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"]) {
+    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:\`.`);
+      continue;
+    }
+    if (line[1].trim()) {
+      problems.push(`${spec.path}: \`${size}:\` is a one-line description. A size is a composition \u2014 \`regions:\` in order, \`hierarchy:\`, \`nav:\` \u2014 each on its own line, or \`same-as:\` with a \`why:\`.`);
+      continue;
+    }
+    const block = sizeBlock(sizes, size);
+    if (/^\s*same-as\s*:/im.test(block)) {
+      if (!/^\s*why\s*:/im.test(block)) problems.push(`${spec.path}: \`${size}\` claims \`same-as:\` with no \`why:\`. The claim is checked on a render, so it says why it holds.`);
+      continue;
+    }
+    for (const field of ["regions", "nav"]) {
+      if (!new RegExp(`^\\s*${field}\\s*:`, "im").test(block)) {
+        problems.push(`${spec.path}: \`${size}\` has no \`${field}:\`. Every size names its regions in order and what its navigation is at that width (\`nav: none\` when the screen has none).`);
+      }
+    }
+  }
+  return problems;
+}
+function sizeBlock(sizes, size) {
+  const start = new RegExp(`^\\s+${size}\\s*:.*$`, "im").exec(sizes);
+  if (!start) return "";
+  const rest = sizes.slice(start.index + start[0].length);
+  const indent = /^\s*/.exec(start[0])[0].length;
+  const lines = [];
+  for (const line of rest.split("\n")) {
+    if (line.trim() && /^\s*/.exec(line)[0].length <= indent) break;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+var MENU_RE = /\b(menu|hamburger|drawer|burger)\b/i;
+var NONE_RE = /^\s*(none|no navigation|n\/a|-)\b/i;
+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"]) {
+    const block = sizeBlock(sizes, size);
+    const nav = /^\s*nav\s*:\s*(.+)$/im.exec(block)?.[1]?.trim();
+    if (!nav || NONE_RE.test(nav)) continue;
+    if (MENU_RE.test(nav) && !/\bopen\b|\bexpanded\b/i.test(nav)) {
+      problems.push(`${spec.path}: \`${size}\` has \`nav: ${nav}\`. Run P-14's table at that width \u2014 where every destination fits, the links show and there is no menu button. A decision about where the button sits is about position, not whether it exists.`);
+    }
+  }
+  return problems;
+}
+
+// src/commands/gate.ts
+var MAX_BLOCKS = 3;
+function lastJigCommand(transcriptPath) {
+  if (!transcriptPath || !existsSync20(transcriptPath)) return void 0;
+  let text;
+  try {
+    text = readFileSync27(transcriptPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  let found;
+  for (const line of text.split("\n")) {
+    if (!line.includes("/jig")) continue;
+    const name = /<command-name>\/?jig<\/command-name>[\s\S]{0,200}?<command-args>([^<]*)<\/command-args>/.exec(line);
+    const plain = /(?:^|["\s>])\/jig\s+([a-z]+)/.exec(line);
+    const arg = (name?.[1] ?? plain?.[1] ?? "").trim().split(/\s+/)[0];
+    if (arg) found = arg.toLowerCase();
+  }
+  return found;
+}
+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));
+    if (!file) problems.push("decide wrote no DECISIONS.md beside the token layer.");
+    else {
+      const body = readFileSync27(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.`");
+      }
+      if (/\[TODO\]/.test(body)) problems.push("DECISIONS.md still contains [TODO] markers.");
+    }
+  }
+  if (command === "spec" || command === "mockup" || command === "make" || command === "critique") {
+    if (!spec) problems.push(`${command} needs a spec: there is no file in .jig/specs/.`);
+    else {
+      problems.push(...specProblems(spec));
+      if (problems.length === 0) problems.push(...navProblems(spec));
+    }
+  }
+  if (command === "mockup" && spec) {
+    const front = spec.body.split(/^---\s*$/m)[1] ?? "";
+    const mockup = /^\s*mockup\s*:\s*(.+)$/im.exec(front)?.[1]?.trim() ?? "";
+    if (/^pending/i.test(mockup) || !mockup) problems.push(`${spec.path}: \`mockup:\` is still pending. It records the user's own word \u2014 approved, or skipped with their reason.`);
+    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) && !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"))) : [];
+    for (const surface of surfaces) {
+      const v = verifyVerdicts({ projectRoot: root, surface });
+      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.`);
+      }
+    }
+    if (surfaces.length === 0) {
+      problems.push("critique wrote no verdict files. Each reader arm writes .jig/critique/<surface>/screen.json or code.json, and `jig verdicts <surface>` \u2014 not your own count \u2014 decides whether the review is complete. A report without them is not a review.");
+    }
+  }
+  return problems;
+}
+function gate(opts) {
+  const root = opts.projectRoot;
+  if (!existsSync20(join33(root, "jig.config.json")) && !existsSync20(join33(root, ".jig"))) {
+    return { block: false, reason: "" };
+  }
+  const command = lastJigCommand(opts.input.transcript_path);
+  const problems = command ? commandProblems(root, command).map((p) => `/jig ${command}: ${p}`) : [];
+  const selection = selectFiles(root, false);
+  const changedStyles = selection.mode === "changed" && selection.files.some((f) => isStyleBearing(f));
+  if (changedStyles) {
+    const result = check({ projectRoot: root, homeDir: "", version: opts.version, all: false, ci: false });
+    const errors = result.findings.filter((f) => f.bucket === "mechanical" && f.severity === "error");
+    if (errors.length > 0) {
+      const shown = errors.slice(0, 8).map((f) => `  ${f.ruleId} ${f.file}:${f.line} ${f.message}`);
+      problems.push(
+        `jig check: ${errors.length} mechanical error(s) in the files you changed. Fix every one, then run \`jig check\` again.
+` + shown.join("\n") + (errors.length > shown.length ? `
+  \u2026 and ${errors.length - shown.length} more` : "")
+      );
+    }
+  }
+  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 v = verifyVerdicts({ projectRoot: root, surface });
+      if (!v.ok) {
+        const shown = v.errors.slice(0, 6).map((e) => `  ${e}`);
+        problems.push(
+          `jig verdicts ${surface}: the critique is not complete. Re-run the arm it names \u2014 do not edit the verdict files to pass.
+` + shown.join("\n") + (v.errors.length > shown.length ? `
+  \u2026 and ${v.errors.length - shown.length} more` : "")
+        );
+      }
+    }
+  }
+  const session = opts.input.session_id ?? "unknown";
+  const stateFile = join33(root, ".jig", "gate.json");
+  let state = {};
+  try {
+    state = JSON.parse(readFileSync27(stateFile, "utf8"));
+  } catch {
+  }
+  if (problems.length === 0) {
+    if (state[session]) {
+      delete state[session];
+      save(stateFile, state);
+    }
+    return { block: false, reason: "" };
+  }
+  const count = (state[session] ?? 0) + 1;
+  if (count > MAX_BLOCKS) {
+    return {
+      block: false,
+      reason: `jig gate: still failing after ${MAX_BLOCKS} attempts; letting you stop. Tell the user plainly that the work is not finished:
+${problems.join("\n\n")}`
+    };
+  }
+  state[session] = count;
+  save(stateFile, state);
+  return {
+    block: true,
+    reason: `Not finished \u2014 Jig's gate failed (attempt ${count} of ${MAX_BLOCKS}). Fix these before you stop, and do not report the work as done until they pass:
+
+${problems.join("\n\n")}`
+  };
+}
+function save(file, state) {
+  try {
+    mkdirSync8(join33(file, ".."), { recursive: true });
+    writeFileSync7(file, JSON.stringify(state), "utf8");
+  } catch {
+  }
+}
+
 // src/index.ts
 var packageRoot = getPackageRoot();
-var { version } = JSON.parse(readFileSync19(join24(packageRoot, "package.json"), "utf8"));
+var { version } = JSON.parse(readFileSync28(join34(packageRoot, "package.json"), "utf8"));
 function warnIfUnpublishedPin() {
   if (isPublishedBuild(packageRoot)) return;
   console.warn(
@@ -4216,12 +5446,28 @@ function warnIfUnpublishedPin() {
 }
 var program = new Command();
 program.name("jig").description("A design system for coding agents.").version(version);
-program.command("install").description("Install Jig rules and the agent skill file into a repository.").requiredOption("--agent <name>", `target agent (${adapterNames().join(", ")})`).option("--scope <scope>", "project or global", "project").action((opts) => {
+program.command("install").description("Install Jig rules and the agent skill file into a repository.").requiredOption("--agent <name>", `target agent (${adapterNames().join(", ")})`).option("--scope <scope>", "project or global", "project").option("--hook", "add the Stop hook that blocks finishing while check or a step fails (Claude Code, project scope)").option("--no-hook", "do not add the Stop hook, and do not ask for it").option("--yes", "non-interactive: ask nothing, and add no Stop hook unless --hook is given", false).action(async (opts) => {
   if (opts.scope !== "project" && opts.scope !== "global") {
     console.error(`Invalid scope '${opts.scope}'. Use 'project' or 'global'.`);
     process.exit(1);
   }
   const projectRoot = findProjectRoot(process.cwd());
+  let hook = opts.hook === true;
+  const unanswered = opts.hook === void 0;
+  if (unanswered && opts.agent === "claude" && opts.scope === "project" && !opts.yes && process.stdin.isTTY) {
+    const { createInterface } = await import("readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      console.log("\nClaude Code can run a Jig check when the agent tries to finish, and hold it there while");
+      console.log("the files it changed fail `check`, or the /jig step it just ran is unfinished. It adds one");
+      console.log("entry to .claude/settings.json, keeps everything else in that file, and lets go after three");
+      console.log("attempts. Weak models skip steps they are only asked to run; this is what catches that.");
+      const answer = (await rl.question("  Add it? [y/N]: ")).trim().toLowerCase();
+      hook = answer === "y" || answer === "yes";
+    } finally {
+      rl.close();
+    }
+  }
   try {
     const result = install({
       agent: opts.agent,
@@ -4229,7 +5475,8 @@ program.command("install").description("Install Jig rules and the agent skill fi
       projectRoot,
       packageRoot: assetRoot(),
       version,
-      homeDir: homedir()
+      homeDir: homedir(),
+      hook
     });
     if (result.warning) {
       console.warn(result.warning);
@@ -4239,14 +5486,19 @@ program.command("install").description("Install Jig rules and the agent skill fi
     warnIfUnpublishedPin();
     for (const f of result.written) console.log(`  + ${f}`);
     for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+    if (result.stopHook === true) console.log("  + .claude/settings.json (Stop hook: jig gate blocks finishing while check or a critique fails)");
+    if (result.stopHook === false) console.log("  ! .claude/settings.json is not valid JSON \u2014 the Stop hook was not added. Fix the file and run install again.");
+    if (result.stopHook === void 0 && opts.agent === "claude" && opts.scope === "project") {
+      console.log("  \xB7 No Stop hook. Add it any time with: npx jig-ui@" + version + " install --agent claude --hook");
+    }
   } catch (err) {
     console.error(err.message);
     process.exit(1);
   }
 });
-program.command("explain").description("Explain a rule, or find the rules you cannot name.").argument("[query]", "a rule id ('C-19'), a word to search for ('contrast'), or a section letter with --list").option("--list", "list every rule id and title, or one section with a section letter").action((query, options) => {
+program.command("explain").description("Explain a rule, or find the rules you cannot name.").argument("[query]", "a rule id ('C-19'), a word to search for ('contrast'), or a section letter with --list").option("--list", "list every rule id and title, or one section with a section letter").option("--layer", "name the six layers, or list one of them by name").action((query, options) => {
   try {
-    console.log(explain({ ruleId: query ?? "", version, list: options.list }));
+    console.log(explain({ ruleId: query ?? "", version, list: options.list, layer: options.layer }));
   } catch (err) {
     console.error(err.message);
     process.exit(1);
@@ -4275,6 +5527,19 @@ program.command("update").description("Update vendored Jig rules, skipping files
     process.exit(1);
   }
 });
+program.command("verdicts").description("Verify a critique's verdict files and compute its counts.").argument("<surface>", "the surface slug the critique wrote under .jig/critique/").action((surface) => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = verifyVerdicts({ projectRoot, surface });
+    for (const error of result.errors) console.error(`  \u2717 ${error}`);
+    if (result.ok) console.log(`  Every rule in both passes has a verdict.`);
+    console.log(`  ${result.line}`);
+    process.exit(result.ok ? 0 : 1);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
 program.command("check").description("Check the repo against Jig's mechanical + hybrid rules.").option(
   "--all",
   // Names the files, because the default scope surprised a user who read
@@ -4298,6 +5563,45 @@ 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) => {
+  if (!opts.save) {
+    console.log(PROBE_SCRIPT);
+    return;
+  }
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const json = process.stdin.isTTY ? "" : await new Promise((done, fail) => {
+      let text = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        text += chunk;
+      });
+      process.stdin.on("end", () => done(text));
+      process.stdin.on("error", fail);
+    });
+    const result = saveProbe({ projectRoot, surface: opts.save, json });
+    console.log(`  Recorded ${result.path} \u2014 ${result.page} at ${result.width}px.`);
+  } catch (err) {
+    console.error(`  \u2717 ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("gate").description("Run by the Claude Code Stop hook: block stopping while check or a critique fails.").action(() => {
+  let input = {};
+  try {
+    if (!process.stdin.isTTY) input = JSON.parse(readFileSync28(0, "utf8") || "{}");
+  } catch {
+  }
+  const cwd = input.cwd ?? process.cwd();
+  try {
+    const result = gate({ projectRoot: findProjectRoot(cwd), version, input });
+    if (result.block) console.log(JSON.stringify({ decision: "block", reason: result.reason }));
+    else if (result.reason) console.error(result.reason);
+  } catch (err) {
+    console.error(`jig gate: ${err.message}`);
+  }
+  process.exit(0);
+});
 program.command("init").description("Set the project up to use Jig: a brand file, jig.config.json, and a baseline check.").option("--yes", "non-interactive: derive everything, accept the proposal, ask nothing", false).action(async (opts) => {
   const projectRoot = findProjectRoot(process.cwd());
   try {