jig-ui 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 0.12.0
+
+### Added
+
+- **`I-118` Em dashes in interface text.** Use a full stop, a comma, a colon
+  or a second element. The mark is ambiguous on its own: it stands in for
+  four different ones, and the reader only learns which after reading past
+  it. It is also the clearest tell of machine-written copy, and copy that
+  reads as generated is copy the reader trusts less. The `em-dash` detector
+  reads element text and the attributes a reader hears or sees; scripts,
+  styles, comments, class names and documentation are not interface text.
+  The en dash keeps its one job, a range read as "to" (`2-10 seats`).
+
+## 0.11.1
+
+Two holes in the gate, both found by running the loop twice on 0.11.0 —
+once on Haiku, once on Sonnet.
+
+### Fixed
+
+- **The Stop hook's block budget is per failure, not per session.** A
+  headless session keeps one session id across every `/jig` step, so a run
+  that spent its three blocks on `init`, `spec` and `make` reached
+  `critique` with none left: it reported "complete and approved, zero
+  findings" having written no verdict files, and the gate that would have
+  caught it had already let go. Fixing a failure now returns its attempts,
+  a new failure starts fresh, and an agent that cannot fix a given failure
+  still gets out after three tries.
+- **`nav: horizontal bar (no menu)` is no longer read as a menu button**
+  at a width where the links fit. A false positive is how a gate gets
+  ignored.
+
+## 0.11.0
+
+One release, one lesson: a measurement an agent can type is not a
+measurement. Everything here came from two live runs at the capability
+floor the day 0.10.0 shipped.
+
+### Added
+
+- **`jig probe --save <surface>`.** The CLI writes the probe file now. It
+  reads what the probe returned on stdin, checks it is probe output for a
+  page inside the project, and stamps it with that page's checksum and the
+  time. A run had written its own probe file by hand — five links and an
+  Escape key that closed a menu with thirteen links and no Escape handler —
+  and its review passed on those numbers.
+- **`install --hook` / `--no-hook`.** The Stop hook is opt-in. An
+  interactive install offers it once and takes silence as no; `--yes` never
+  adds it, because that is the path an agent takes and nobody is there to
+  consent. `update` moves an existing hook and never adds one.
+
+### Changed
+
+- **Probe files are version 2.** `jig verdicts` rejects a probe with no
+  stamp — nothing measured it — and one whose page changed after it was
+  taken. Version 1 files no longer validate.
+- **README and `init` say which directory to commit, and why.** The tokens
+  live in `<css dir>/jig/`; `.jig/` holds `state.json`, specs, mockups and
+  critique verdicts. Both are warned about separately, each with what
+  ignoring it costs. Since 0.7.0 both had said `.jig/` holds the tokens.
+
 ## 0.10.0
 
 Mobile-first, and a design loop that a weak model cannot skip. Everything here

package/README.md

@@ -12,13 +12,13 @@ Installed as `npx jig-ui` — the bare name was taken on npm.
 Jig is **a skill your coding agent reads**, and **a CLI you can run yourself**.
 They are two halves of the same thing, and the split is not arbitrary:
 
-- Of the 113 rules, **16 can be decided by a machine** — a hard-coded colour, a
+- Of the 114 rules, **17 can be decided by a machine** — a hard-coded colour, a
   contrast ratio below the floor, a removed focus ring. The CLI decides those.
 - The other **97 are judgment** — whether an empty state says anything useful,
   whether a label reads as an instruction, whether motion earns its place. No
   regex settles those. An agent reads the rules and applies them.
 
-Running only the CLI gets you the 16. Running only the agent gets you the 97 with
+Running only the CLI gets you the 17. Running only the agent gets you the 97 with
 no verification. **A clean `jig check` is not a clean review**, and the skill
 says so to every agent that reads it.
 
@@ -149,13 +149,23 @@ Set `brand` in `jig.config.json` to put it somewhere else. Projects set up
 before 0.7.0 keep their `.jig/tokens/` layout; `update` does not move them, and
 `init` offers to.
 
-The mode file is the one thing genuinely copied: a stylesheet `@import` is an
-edge in a build graph and has to resolve locally, on every machine that builds.
+The mode file is the one token file copied verbatim from the package: a
+stylesheet `@import` is an edge in a build graph and has to resolve locally, on
+every machine that builds. The brand file and the barrel are generated for your
+project, not copied.
 
-**Commit `.jig/`.** It holds the token files your stylesheet imports, so a
-gitignored `.jig/` means the design system does not exist for anyone who did not
-run `init` themselves — their build breaks on a missing import, and CI's `jig
-check` sees no token layer at all. `init` warns if it finds `.jig/` ignored.
+**Commit the token directory** — `<css dir>/jig/`. It holds the files your
+stylesheet `@import`s, so ignoring it means the design system does not exist for
+anyone who did not run `init` themselves: their build breaks on a missing import,
+and CI's `jig check` sees no token layer at all.
+
+**Commit `.jig/` too.** It is not the tokens (it was, before 0.7.0). It holds
+`state.json`, which records the version and checksum of every file `init` wrote
+and is what `update` reads to know what it may refresh, plus the durable record of
+the design loop: your specs, approved mockups and critique verdicts. Ignored, a
+teammate's `update` cannot tell a file you edited from one it wrote, and every
+spec the project agreed is invisible to the next agent. `init` warns if it finds
+either directory ignored.
 
 Add `--yes` to accept every derived default non-interactively — the mode CI and
 agents run in. It states the mode it chose and where to change it, because
@@ -370,6 +380,8 @@ treatment.
 | `<css dir>/jig/brand.*.css` | Identity. One per project. |
 | `<css dir>/jig/mode.*.css` | Density, scale, rhythm, motion |
 | `<css dir>/jig/theme.css` | The barrel — brand + mode. This is what you import. |
+| `.jig/state.json` | What `init` wrote, with checksums. `update` reads it to leave your edits alone. |
+| `.jig/specs/`, `.jig/mockups/`, `.jig/critique/` | The design loop's record: what was agreed, what was drawn, what the review found. |
 
 `rules/*` and `rules.index.json` live beside your installed skill file, not
 in the project — see above.

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync28 } from "fs";
 import { homedir } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -3299,6 +3299,59 @@ var undeclaredToken = {
   }
 };
 
+// src/check/detectors/em-dash.ts
+var MARKUP = [".html", ".htm", ".vue", ".svelte", ".astro", ".jsx", ".tsx", ".php", ".erb", ".twig", ".hbs"];
+var TEXT_ATTRS = /\b(aria-label|aria-description|aria-placeholder|title|placeholder|alt|label|value|content)\s*=\s*("([^"]*)"|'([^']*)')/gi;
+var EM_DASH = /—/;
+function maskNonProse(source) {
+  const blank3 = (m) => " ".repeat(m.length);
+  return source.replace(/<script\b[\s\S]*?<\/script\s*>/gi, blank3).replace(/<style\b[\s\S]*?<\/style\s*>/gi, blank3).replace(/<!--[\s\S]*?-->/g, blank3).replace(/\/\*[\s\S]*?\*\//g, blank3).replace(/(^|[^:])\/\/[^\n]*/g, (m, p1) => p1 + " ".repeat(m.length - p1.length));
+}
+function proseSpans(masked) {
+  const spans = [];
+  let last = 0;
+  for (const tag of masked.matchAll(/<[^>]*>/g)) {
+    const between = masked.slice(last, tag.index);
+    if (between.trim()) spans.push({ index: last, text: between });
+    for (const attr of tag[0].matchAll(TEXT_ATTRS)) {
+      const value = attr[3] ?? attr[4] ?? "";
+      spans.push({ index: tag.index + attr.index + attr[0].indexOf(value), text: value });
+    }
+    last = tag.index + tag[0].length;
+  }
+  const tail = masked.slice(last);
+  if (tail.trim()) spans.push({ index: last, text: tail });
+  return spans;
+}
+var emDash = {
+  name: "em-dash",
+  appliesTo: (file) => hasExtension(file, MARKUP),
+  run(_source, file, ctx) {
+    const masked = maskNonProse(ctx.raw);
+    const starts = buildLineIndex(ctx.raw);
+    const findings = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const span of proseSpans(masked)) {
+      if (!EM_DASH.test(span.text)) continue;
+      const offset = span.index + span.text.indexOf("\u2014");
+      const line = lineForOffset(starts, offset);
+      if (seen.has(line)) continue;
+      seen.add(line);
+      findings.push(
+        mkFinding(
+          ctx,
+          "em-dash",
+          file,
+          line,
+          "an em dash in interface text: use a full stop, a comma, a colon, or a second element",
+          sourceLine(ctx.raw, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
 // src/check/registry.ts
 var DETECTORS = [
   gradientText,
@@ -3316,7 +3369,8 @@ var DETECTORS = [
   inputZoom,
   safeArea,
   menuState,
-  undeclaredToken
+  undeclaredToken,
+  emDash
 ];
 function getDetector(name) {
   return DETECTORS.find((d) => d.name === name);
@@ -4847,9 +4901,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 });
@@ -4873,8 +4934,8 @@ Could not write to ${wireTarget}: ${err.message}`);
 }
 
 // src/commands/verdicts.ts
-import { existsSync as existsSync17, readFileSync as readFileSync24 } from "fs";
-import { join as join30, resolve as resolve3 } from "path";
+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";
@@ -4888,11 +4949,16 @@ function citableIds(packageRoot2) {
 }
 
 // src/probe/check.ts
-import { existsSync as existsSync16, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "fs";
-import { join as join29 } from "path";
+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 = 1;
+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'; };
@@ -4962,17 +5028,79 @@ var PROBE_SCRIPT = `(async () => {
   });
 })()`;
 
+// 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 readProbes(dir, errors) {
-  if (!existsSync16(dir)) return [];
+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(readFileSync23(join29(dir, f), "utf8"));
+      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}).`);
@@ -5033,18 +5161,18 @@ function probeContradictions(probes, verdictOf) {
 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 (!existsSync17(path)) return null;
+  if (!existsSync18(path)) return null;
   try {
-    return JSON.parse(readFileSync24(path, "utf8"));
+    return JSON.parse(readFileSync25(path, "utf8"));
   } catch (e) {
     errors.push(`${path}: not valid JSON (${e.message})`);
     return {};
   }
 }
 function specNeedsNav(projectRoot, surface) {
-  const path = join30(projectRoot, ".jig", "specs", `${surface}.spec.md`);
-  if (!existsSync17(path)) return false;
-  const front = readFileSync24(path, "utf8").split(/^---\s*$/m)[1] ?? "";
+  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;
@@ -5095,7 +5223,7 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
 function verifyVerdicts(opts) {
   const root = opts.packageRoot ?? assetRoot();
   const errors = [];
-  const index = JSON.parse(readFileSync24(join30(root, "rules.index.json"), "utf8"));
+  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);
@@ -5104,21 +5232,21 @@ function verifyVerdicts(opts) {
     ...judgment.map((r) => [r.id, r.pass ?? ""])
   ]);
   const specIds = new Set(citableIds(root).filter((id) => /^[PMLRT]-\d+$/.test(id)));
-  const dir = join30(opts.projectRoot, ".jig", "critique", opts.surface);
-  const screenFile = readJson(join30(dir, "screen.json"), errors);
-  const codeFile = readJson(join30(dir, "code.json"), errors);
+  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) => !existsSync17(resolve3(opts.projectRoot, a)));
+    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(dir, errors);
+  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));
@@ -5140,19 +5268,20 @@ function verifyVerdicts(opts) {
 }
 
 // src/commands/gate.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync13, readFileSync as readFileSync26, writeFileSync as writeFileSync6 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync8, readdirSync as readdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync7 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { join as join33 } from "path";
 
 // src/check/spec-shape.ts
-import { existsSync as existsSync18, readFileSync as readFileSync25, readdirSync as readdirSync12, statSync as statSync2 } from "fs";
-import { join as join31 } from "path";
+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 = join31(projectRoot, ".jig", "specs");
-  if (!existsSync18(dir)) return void 0;
+  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(join31(dir, f)).mtimeMs })).sort((a, b) => b.at - a.at)[0].f;
-  return { path: `.jig/specs/${newest}`, slug: newest.replace(/\.spec\.md$|\.md$/, ""), body: readFileSync25(join31(dir, newest), "utf8") };
+  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);
@@ -5201,7 +5330,7 @@ function sizeBlock(sizes, size) {
   }
   return lines.join("\n");
 }
-var MENU_RE = /\b(menu|hamburger|drawer|burger)\b/i;
+var MENU_RE = /(?<!\b(?:no|not|without|never)\s)(?<!\bno\s\w{1,12}\s)\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] ?? "";
@@ -5221,10 +5350,10 @@ function navProblems(spec) {
 // src/commands/gate.ts
 var MAX_BLOCKS = 3;
 function lastJigCommand(transcriptPath) {
-  if (!transcriptPath || !existsSync19(transcriptPath)) return void 0;
+  if (!transcriptPath || !existsSync20(transcriptPath)) return void 0;
   let text;
   try {
-    text = readFileSync26(transcriptPath, "utf8");
+    text = readFileSync27(transcriptPath, "utf8");
   } catch {
     return void 0;
   }
@@ -5242,10 +5371,10 @@ function commandProblems(root, command) {
   const problems = [];
   const spec = newestSpec(root);
   if (command === "decide") {
-    const file = ["jig/DECISIONS.md", "DECISIONS.md", ".jig/DECISIONS.md"].map((p) => join32(root, p)).find((p) => existsSync19(p));
+    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 = readFileSync26(file, "utf8");
+      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.`");
       }
@@ -5266,13 +5395,13 @@ function commandProblems(root, command) {
     const at = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
     if (/^approved/i.test(mockup)) {
       if (!at) problems.push(`${spec.path}: \`mockup_at:\` is empty. Record where the approved drawing is.`);
-      else if (!/^https?:/i.test(at) && !existsSync19(join32(root, at))) problems.push(`${spec.path}: \`mockup_at: ${at}\` does not exist.`);
+      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 = join32(root, ".jig", "critique");
-    const surfaces = existsSync19(dir) ? readdirSync13(dir).filter((s) => existsSync19(join32(dir, s, "screen.json")) || existsSync19(join32(dir, s, "code.json"))) : [];
+    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") {
@@ -5287,7 +5416,7 @@ function commandProblems(root, command) {
 }
 function gate(opts) {
   const root = opts.projectRoot;
-  if (!existsSync19(join32(root, "jig.config.json")) && !existsSync19(join32(root, ".jig"))) {
+  if (!existsSync20(join33(root, "jig.config.json")) && !existsSync20(join33(root, ".jig"))) {
     return { block: false, reason: "" };
   }
   const command = lastJigCommand(opts.input.transcript_path);
@@ -5306,11 +5435,11 @@ function gate(opts) {
       );
     }
   }
-  const critiqueDir = join32(root, ".jig", "critique");
-  if (existsSync19(critiqueDir)) {
+  const critiqueDir = join33(root, ".jig", "critique");
+  if (existsSync20(critiqueDir)) {
     for (const surface of readdirSync13(critiqueDir)) {
-      const dir = join32(critiqueDir, surface);
-      if (!existsSync19(join32(dir, "screen.json")) && !existsSync19(join32(dir, "code.json"))) continue;
+      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}`);
@@ -5323,20 +5452,22 @@ function gate(opts) {
     }
   }
   const session = opts.input.session_id ?? "unknown";
-  const stateFile = join32(root, ".jig", "gate.json");
+  const key = `${session}:${createHash2("sha256").update(problems.join("\n")).digest("hex").slice(0, 12)}`;
+  const stateFile = join33(root, ".jig", "gate.json");
   let state = {};
   try {
-    state = JSON.parse(readFileSync26(stateFile, "utf8"));
+    state = JSON.parse(readFileSync27(stateFile, "utf8"));
   } catch {
   }
   if (problems.length === 0) {
-    if (state[session]) {
-      delete state[session];
+    const mine = Object.keys(state).filter((k) => k.startsWith(`${session}:`));
+    if (mine.length) {
+      for (const k of mine) delete state[k];
       save(stateFile, state);
     }
     return { block: false, reason: "" };
   }
-  const count = (state[session] ?? 0) + 1;
+  const count = (state[key] ?? 0) + 1;
   if (count > MAX_BLOCKS) {
     return {
       block: false,
@@ -5344,7 +5475,7 @@ function gate(opts) {
 ${problems.join("\n\n")}`
     };
   }
-  state[session] = count;
+  state[key] = count;
   save(stateFile, state);
   return {
     block: true,
@@ -5355,15 +5486,15 @@ ${problems.join("\n\n")}`
 }
 function save(file, state) {
   try {
-    mkdirSync7(join32(file, ".."), { recursive: true });
-    writeFileSync6(file, JSON.stringify(state), "utf8");
+    mkdirSync8(join33(file, ".."), { recursive: true });
+    writeFileSync7(file, JSON.stringify(state), "utf8");
   } catch {
   }
 }
 
 // src/index.ts
 var packageRoot = getPackageRoot();
-var { version } = JSON.parse(readFileSync27(join33(packageRoot, "package.json"), "utf8"));
+var { version } = JSON.parse(readFileSync28(join34(packageRoot, "package.json"), "utf8"));
 function warnIfUnpublishedPin() {
   if (isPublishedBuild(packageRoot)) return;
   console.warn(
@@ -5489,13 +5620,33 @@ program.command("check").description("Check the repo against Jig's mechanical +
     process.exit(1);
   }
 });
-program.command("probe").description("Print the render probe: run it in a browser at each width and save its output for `jig verdicts`.").action(() => {
-  console.log(PROBE_SCRIPT);
+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(readFileSync27(0, "utf8") || "{}");
+    if (!process.stdin.isTTY) input = JSON.parse(readFileSync28(0, "utf8") || "{}");
   } catch {
   }
   const cwd = input.cwd ?? process.cwd();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jig-ui",
-  "version": "0.10.0",
-  "description": "A design system for coding agents. 113 numbered UI rules, brand x mode design tokens, and an installer for Claude Code, Codex, Cursor and opencode.",
+  "version": "0.12.0",
+  "description": "A design system for coding agents. 114 numbered UI rules, brand x mode design tokens, and an installer for Claude Code, Codex, Cursor and opencode.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {

package/rules/05-copy.md

@@ -83,6 +83,14 @@ The one legitimate use is a **short label** distinguishing itself from nearby te
 ✅ Most interface text is too short to need them. Use a full stop only where the text is a complete sentence containing commas.
 Whichever you choose, be consistent across sibling elements — a list where three items end in a stop and two do not looks like a mistake, because it is one.
 
+### I-118 Em dashes in interface text
+❌ "Your plan — including every seat — renews monthly", "Free — forever", "Deleted — this cannot be undone"
+✅ A full stop, a comma, a colon or a new element. "Your plan renews monthly, including every seat." "Free forever." "Deleted. This cannot be undone."
+Interface text is read in fragments, at a glance, in a space someone else's content has to fit too. An em dash is a pause the reader has to interpret: it stands in for a comma, a colon, a bracket or a full stop, and which one it is only becomes clear after reading past it. The punctuation that says exactly one thing is faster.
+It is also the clearest tell of machine-written copy. Generated text reaches for the em dash far more often than a person does, and readers have learned to notice. Copy that reads as generated is copy the reader trusts less, whatever it says.
+This is about interface strings — labels, buttons, headings, errors, empty states, help text, and the prose a page ships. It is not a rule about your documentation, your commit messages or this file.
+The en dash keeps its one job: ranges, where it is read as "to" (`2–10 seats`, `Mon–Fri`). That is not a pause, and it is not affected.
+
 ### I-87 Inconsistent vocabulary
 ❌ "Add to cart" beside a "Bag" icon; "Sign up" on the page and "Register" in the nav
 ✅ One word per concept, everywhere. Keep a term list in the project and follow it.

package/rules.index.json

@@ -793,5 +793,12 @@
     "severity": "error",
     "since": "0.10.0",
     "detector": "undeclared-token"
+  },
+  {
+    "id": "I-118",
+    "bucket": "mechanical",
+    "severity": "warning",
+    "since": "0.12.0",
+    "detector": "em-dash"
   }
 ]

package/templates/COMMAND.md.tmpl

@@ -853,10 +853,18 @@ probe in the browser and save what it returns beside the verdicts:
 
 ```
 {{scripts_path}} probe > .jig/probe.js
-# at each width: set the viewport, open the page, evaluate .jig/probe.js, save the
-# JSON it returns as .jig/critique/<surface>/probe-<width>.json
+# at each width: set the viewport, open the page, evaluate .jig/probe.js, and pipe
+# exactly what it returned into:
+{{scripts_path}} probe --save <surface>
 ```
 
+**The CLI writes the probe file, you do not.** `--save` reads the probe's output,
+stamps it with the page's checksum, and stores it. That is what makes the file a
+measurement: `verdicts` recomputes the checksum, so a file written by hand, or one
+taken before the page's last edit, is rejected. A live run wrote a probe file itself
+— five links and Escape closing a menu that has thirteen links and no Escape handler
+— and its review passed on those numbers.
+
 The probe opens the phone menu, presses Escape, measures sideways scroll, and reads
 whether the styles and tokens actually applied. `verdicts` refuses `rendered: true`
 without a probe at each width, and refuses an `ok` the probe contradicts — a `P-14`

package/templates/command-metadata.json

@@ -30,8 +30,8 @@
     "status": "available"
   },
   "probe": {
-    "description": "Print the render probe: a script the critique runs in a browser at 360, 768 and 1280px. It opens the phone menu, presses Escape, measures sideways scroll and whether styles and tokens applied; `verdicts` refuses verdicts it contradicts.",
-    "argumentHint": "",
+    "description": "Print the render probe: a script the critique runs in a browser at 360, 768 and 1280px. With --save it records what the probe returned, stamped with the page's checksum, so `verdicts` can tell a measurement from a claim.",
+    "argumentHint": "[--save <surface>]",
     "status": "available"
   },
   "gate": {