jig-ui 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 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

@@ -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.
-
-**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.
+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 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";
@@ -4847,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 });
@@ -4873,8 +4880,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 +4895,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 +4974,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 +5107,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 +5169,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 +5178,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 +5214,19 @@ 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 { 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);
@@ -5221,10 +5295,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 +5316,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 +5340,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 +5361,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 +5380,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,10 +5397,10 @@ function gate(opts) {
     }
   }
   const session = opts.input.session_id ?? "unknown";
-  const stateFile = join32(root, ".jig", "gate.json");
+  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) {
@@ -5355,15 +5429,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 +5563,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,6 +1,6 @@
 {
   "name": "jig-ui",
-  "version": "0.10.0",
+  "version": "0.11.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.",
   "license": "Apache-2.0",
   "type": "module",

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": {