jig-ui 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,129 @@
 # Changelog
 
+## 0.9.0
+
+One new rule and one amended correction, both from the same afternoon of
+dogfooding and both about the same blind spot: H-47's correction always pointed
+at a token, so an agent reading it literally always produced one.
+
+### Added
+
+- **`B-105` Monospace sized by a guessed ratio.** No rule in the corpus
+  mentioned monospace or inline `code` at all — `jig explain monospace` returned
+  nothing — while `brand.default.css` ships a `--font-mono` stack, so every Jig
+  project has the pairing and none had guidance on it.
+
+  Shrinking inline code by a ratio is right for faces drawn apart, where a mono
+  face often does sit larger at the same `font-size`. In a superfamily it is
+  wrong: IBM Plex Sans and IBM Plex Mono are both x-height 51.6 and cap-height
+  69.8 per 1000 units — identical — and mono is *narrower*. A `0.9em` there sets
+  code at x-height 46.8 inside text at 52, creating the mismatch it was meant to
+  remove. The rule asks for one measurement, once per project, when the brand
+  file is written.
+
+  It deliberately has no token. Inline `code` appears inside body text,
+  headings, table cells and captions; one multiplier has to be right for all
+  four, and a fixed token is worse — it collapses code in a heading to caption
+  size. Inheriting is correct in every host.
+
+### Changed
+
+- **`H-47`'s correction names a third branch.** It offered "reference the token"
+  or "a value that cannot be expressed as a token indicates a missing token".
+  Both end in a token. Twice in a row on Jig's own documentation site the right
+  answer was **deletion** — the `0.9em` above, and a `min-width` in `em` on a
+  table column that `max-content` measures for free. An agent following the text
+  as written invents `--text-code: 0.9em` and entrenches a value that should not
+  exist. The correction now says to check "should this value exist at all"
+  before minting a token.
+
+  `rules.index.json`'s `fix: token-substitute` on H-47 encoded the same
+  assumption and is now `token-substitute-or-remove`. Nothing consumes that
+  field yet, which is why it was worth correcting before something does.
+
+- **Rule count is 105.** The attestation line and the README's counts move with
+  it.
+
+
+## 0.8.2
+
+Every fix here was found by a consumer using Jig rather than by Jig checking
+itself: the documentation site was upgraded to 0.8.1 and then styled in
+Tailwind, which is the first time Jig's Tailwind guidance had been followed
+end to end by anything other than its own tests.
+
+Three of the four are the same shape — two places answering one question, and
+disagreeing without either knowing the other existed.
+
+### Fixed
+
+- **`H-47` read a value differently depending on how it was spelled.**
+  `00-anti-patterns.md:11` sets the scope of the whole rule file: "**Framework:**
+  agnostic. […] Where a utility-class framework is in use, translate — the rule
+  is about the resulting style, not the syntax." The detector was the exact
+  inverse, in both directions at once. Its CSS branch matched `px` alone and
+  excluded `0/1px/2px`; its Tailwind branch matched ten units and excluded
+  nothing. So `font-size: 0.9em` was silent while `text-[0.9em]` was an error,
+  and `p-[1px]` was an error while `padding: 1px` was not.
+
+  A project on plain CSS got a clean `check` for code a Tailwind project got
+  eight errors for. Found by converting a real stylesheet to utilities without
+  changing one computed value and watching the report go from `No findings` to
+  eight; the two declarations responsible had been in that file since it was
+  written and had never been flagged. Both branches now read one definition.
+
+  **This widens what `check` reports.** A stylesheet carrying `1rem` or `0.9em`
+  past the token layer was always an H-47 violation and is now reported as one,
+  so a repo that was clean under 0.8.1 can have findings here without its CSS
+  having moved.
+
+- **The naming contract named namespaces Tailwind does not have.**
+  `02-tokens.md` opened with "an alias block can expose **any of them** as
+  Tailwind utilities" over a table of thirteen. Three generate nothing in
+  Tailwind v4 — `--duration-*`, `--measure-*` and `--focus-ring-*` — and
+  `--duration-*` shared a row with `--ease-*`, so only half of that row worked.
+  Aliasing one is accepted, emits the custom property, and produces no rule, so
+  the class lands on the element and does nothing: the same silent failure the
+  file warns about 190 lines later, reached from the opposite direction. The
+  table now carries a **Utility** column, and the three say how to be read from
+  a class instead — `max-w-(--measure-prose)`, which keeps the semantic token
+  and satisfies `H-47` without going through `@theme`.
+
+  `init`'s own generator was wrong in both directions. It correctly filtered
+  `--measure-*` and `--focus-ring-*`, and it also filtered `--size-*` and
+  `--border-width-*`, which both generate working utilities — `size-control`
+  sets width and height, `border-hairline` sets a border width. Jig was
+  withholding correct aliases for its own tokens, and a test asserted that as
+  correct, which is how it survived.
+
+- **`check` did not say which files it had looked at.** It defaults to the
+  files changed since HEAD and falls back to the whole repo when that diff is
+  empty. Nothing in the output said so, so the same repo reported `files=31` on
+  a clean tree and `files=9` with nine files touched, minutes apart, with
+  nothing committed — and a consumer bisected it by reverting files one at a
+  time to find out why.
+
+  Worse, `mechanical=pass:0` on a dirty tree means "nothing in your diff
+  fired", not "the project is clean", and the skill tells an agent to run
+  `check` before finishing — exactly when the tree is dirty and the scope is
+  narrowest. The exempt line compounded it: `src/content/rules.ts (matches
+  nothing — check the path)` was printed for a path that exists, is tracked,
+  and had matched a file on the previous run. The glob was fine; it matched
+  nothing *within the narrowed set*, and "check the path" sends you to debug a
+  correct config.
+
+  The summary now names the scope, a narrowed run says a clean result is not a
+  clean project, the exempt note distinguishes "no such path" from "not in this
+  scan", and `--all`'s help says it widens the files rather than the rules —
+  which is how it had been read.
+
+- **A flag written across two lines vanished from the metadata guard.**
+  `registeredFlags` read `src/index.ts` line by line and required the flag
+  string to sit on the same line as `.option(`, so reformatting one option to
+  fit a longer description dropped `--all` from the parsed set and from every
+  guard built on it. Caught by its own canary the moment an option wrapped.
+
+
 ## 0.8.1
 
 Both fixes here are the same shape: 0.8.0 corrected the instance it was looking

package/README.md

@@ -12,7 +12,7 @@ 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 104 rules, **7 can be decided by a machine** — a hard-coded colour, a
+- Of the 105 rules, **7 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
@@ -181,7 +181,7 @@ on the result — the CLI reports, the agent applies the judgment half.
 | Slash command | Equivalent |
 | --- | --- |
 | `/jig init` | `jig init` — then states the mode it chose and what it wired |
-| `/jig check` | `jig check` — then applies the 94 judgment rules and reports both halves |
+| `/jig check` | `jig check` — then applies the 95 judgment rules and reports both halves |
 | `/jig explain C-19` | `jig explain C-19` — prints the rule as-is, without paraphrasing it |
 | `/jig explain contrast` | `jig explain contrast` — every rule matching a word, when you do not have an id |
 | `/jig install --agent cursor` | `jig install --agent cursor` |
@@ -262,7 +262,7 @@ In CI:
 code — nothing model-dependent, no network. As a pre-commit hook, plain `check`
 looks at changed files only.
 
-What you will not get from the CLI alone is the other 94 rules. `check` says so
+What you will not get from the CLI alone is the other 95 rules. `check` says so
 rather than letting a narrow pass read as a broad one.
 
 ## What `check` covers
@@ -330,7 +330,7 @@ treatment.
 
 | File | Contents |
 | --- | --- |
-| `rules/00-anti-patterns.md` | 87 universal rules with corrections |
+| `rules/00-anti-patterns.md` | 88 universal rules with corrections |
 | `rules/01-modes.md` | `editorial` / `product` / `operator` profiles |
 | `rules/02-tokens.md` | Token contract, naming, consumption |
 | `rules/03-patterns.md` | Component anatomy and behaviour |

package/dist/index.js

@@ -1448,7 +1448,7 @@ function formatReport(findings, meta) {
   if (notes > 0) summaryParts.push(plural(notes, "note"));
   const rulesFired = new Set(findings.map((f) => f.ruleId)).size;
   const scope = meta.totalSpecs ? `${meta.totalRules} rules (+ ${meta.totalSpecs} pattern and mode specs)` : `${meta.totalRules} rules`;
-  const examined = meta.scanned === void 0 ? "" : ` \xB7 ${plural(meta.scanned, "file")}, ${meta.withStyles ?? 0} with styles`;
+  const examined = meta.scanned === void 0 ? "" : ` \xB7 ${plural(meta.scanned, "file")}${meta.scope === "changed" ? " changed since HEAD" : ""}, ${meta.withStyles ?? 0} with styles`;
   lines.push(`  ${summaryParts.join(", ")} \xB7 ${scope}${examined}, ${rulesFired} fired`);
   if (meta.scanned !== void 0 && meta.withStyles === 0) {
     lines.push("");
@@ -1456,11 +1456,17 @@ function formatReport(findings, meta) {
       `  No file carried a style region, so the detectors examined nothing. This is not a pass \u2014 a project with no styling and a project with clean styling report the same findings, and only one of them has been checked.`
     );
   }
+  if (meta.scope === "changed") {
+    lines.push("");
+    lines.push(
+      `  Scope: files changed since HEAD, not the whole project \u2014 this is the inner-loop default. A clean result here means nothing in your diff fired, not that the project is clean. Run 'jig check --all' for that.`
+    );
+  }
   if (meta.exemptPatterns && meta.exemptPatterns.length > 0) {
     const n = meta.exempt?.length ?? 0;
     lines.push(`  ${n} file(s) exempt via jig.config.json and not scanned:`);
     for (const { pattern, count, tooBroad } of meta.exemptPatterns) {
-      const note = count === 0 ? "matches nothing \u2014 check the path" : tooBroad ? `${count} files \u2014 likely too broad, review it` : `${count} file${count > 1 ? "s" : ""}`;
+      const note = count === 0 ? meta.scope === "changed" ? "matches nothing among the changed files \u2014 not necessarily wrong" : "matches nothing \u2014 check the path" : tooBroad ? `${count} files \u2014 likely too broad, review it` : `${count} file${count > 1 ? "s" : ""}`;
       lines.push(`    ${pattern}  (${note})`);
     }
     if (n > 0) {
@@ -2361,6 +2367,35 @@ var pureBlackWhite = {
   }
 };
 
+// src/check/length.ts
+var LENGTH_UNITS = [
+  "px",
+  "rem",
+  "em",
+  "pt",
+  "vh",
+  "vw",
+  "vmin",
+  "vmax",
+  "ch",
+  "ex"
+];
+var UNITS = LENGTH_UNITS.join("|");
+var LENGTH_RE = new RegExp(`^-?\\d*\\.?\\d+(?:${UNITS})$`, "i");
+var LENGTH_SCAN_RE = new RegExp(`(-?\\d*\\.?\\d+)(${UNITS})`, "gi");
+function isExcludedLength(value, unit) {
+  if (value === 0) return true;
+  return unit.toLowerCase() === "px" && (Math.abs(value) === 1 || Math.abs(value) === 2);
+}
+function hasHardCodedLength(value) {
+  LENGTH_SCAN_RE.lastIndex = 0;
+  let m;
+  while (m = LENGTH_SCAN_RE.exec(value)) {
+    if (!isExcludedLength(parseFloat(m[1]), m[2])) return true;
+  }
+  return false;
+}
+
 // src/check/tailwind.ts
 var CLASS_ATTR = /\b(?:class|className)\s*=\s*/g;
 function readBraced(source, open) {
@@ -2404,15 +2439,21 @@ function classAttributeValues(source) {
 }
 var ARBITRARY = /(?:^|\s)(?:[\w-]+:)*([a-z][\w-]*)-\[([^\]\s]+)\]/gi;
 var COLOUR = /^(?:#[0-9a-f]{3,8}|(?:rgba?|hsla?|oklch|oklab|lab|lch|color)\()/i;
-var LENGTH = /^-?\d*\.?\d+(?:px|rem|em|pt|vh|vw|vmin|vmax|ch|ex)$/i;
+var LENGTH_PARTS = /^(-?\d*\.?\d+)([a-z]+)$/i;
 function arbitraryValues(classes) {
   const out = [];
   for (const m of classes.matchAll(ARBITRARY)) {
     const [, utility, rawValue] = m;
     const value = rawValue.replace(/_/g, " ");
     if (/var\(|--/.test(value)) continue;
-    if (COLOUR.test(value)) out.push({ utility, value, kind: "colour" });
-    else if (LENGTH.test(value)) out.push({ utility, value, kind: "length" });
+    if (COLOUR.test(value)) {
+      out.push({ utility, value, kind: "colour" });
+      continue;
+    }
+    if (!LENGTH_RE.test(value)) continue;
+    const parts = LENGTH_PARTS.exec(value);
+    if (isExcludedLength(parseFloat(parts[1]), parts[2])) continue;
+    out.push({ utility, value, kind: "length" });
   }
   return out;
 }
@@ -2604,8 +2645,6 @@ var SPACING_PROPS = /* @__PURE__ */ new Set([
 ]);
 var DECL_RE2 = /(?<![-\w])([a-zA-Z-]+)\s*:\s*([^;]+)(?:;|$)/g;
 var COLOR_LITERAL_RE = /#[0-9a-fA-F]{3,8}\b|(?:rgb|hsl)a?\([^)]*\)/;
-var PX_RE = /(-?\d*\.?\d+)px/g;
-var EXCLUDED_PX = /* @__PURE__ */ new Set([0, 1, 2]);
 var KEYFRAME_STEP_RE = /^(from|to|\d+(\.\d+)?%)$/i;
 var PRIMITIVE_RE = /var\(\s*(--(?:brand|error|warning|success|info)-(?:h|s|l|fill-a))\s*[,)]/g;
 var TOKEN_LAYER_RE = /(^|\/)(\.jig\/tokens|jig)\/[^/]+\.css$/;
@@ -2662,16 +2701,7 @@ var hardcodedValue = {
           continue;
         }
         if (SPACING_PROPS.has(prop)) {
-          PX_RE.lastIndex = 0;
-          let px;
-          let flagged = false;
-          while (px = PX_RE.exec(value)) {
-            if (!EXCLUDED_PX.has(Math.abs(parseFloat(px[1])))) {
-              flagged = true;
-              break;
-            }
-          }
-          if (flagged) {
+          if (hasHardCodedLength(value)) {
             const line = lineOfOffset(block, m.index);
             findings.push(
               mkFinding(
@@ -3132,7 +3162,8 @@ function check(opts) {
     scanned: files.length,
     withStyles,
     exempt,
-    exemptPatterns: byPattern
+    exemptPatterns: byPattern,
+    scope: selection.mode
   });
   return { findings, report, hasError };
 }
@@ -3547,7 +3578,9 @@ var TAILWIND_NAMESPACES = [
   "--perspective-",
   "--aspect-",
   "--ease-",
-  "--animate-"
+  "--animate-",
+  "--size-",
+  "--border-width-"
 ];
 function tailwindNamespaced(names) {
   const kept = names.filter((n) => TAILWIND_NAMESPACES.some((ns) => n.startsWith(ns)));
@@ -3587,8 +3620,10 @@ function utilitiesBody(names, version2) {
    order, so Jig's value always wins. Do not "fix" it \u2014 deleting the alias
    removes the utility, deleting Jig's removes the value.
 
-   Only tokens in a Tailwind namespace are listed. \`--size-*\`, \`--measure-*\`,
-   \`--focus-ring-*\` and \`--border-width-*\` have none, so they stay \`var()\`-only.
+   Only tokens in a Tailwind namespace are listed. \`--measure-*\`, \`--focus-ring-*\`
+   and \`--duration-*\` have none, so they stay \`var()\`-only \u2014 read them from a class
+   with Tailwind's custom-property form instead: \`max-w-(--measure-prose)\`,
+   \`duration-(--duration-fast)\`.
 
    Regenerate with \`jig init\` after the token layer changes; a token missing here
    is a class that renders and matches nothing. */
@@ -4240,7 +4275,13 @@ program.command("update").description("Update vendored Jig rules, skipping files
     process.exit(1);
   }
 });
-program.command("check").description("Check the repo against Jig's mechanical + hybrid rules.").option("--all", "check the whole repo instead of just changed files", false).option("--ci", "mechanical bucket only; exits non-zero on any error, deterministic", false).option("--json", "emit findings as JSON", false).action((opts) => {
+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
+  // this as widening the RULES and attested a clean diff as a clean project.
+  "scan every file in the repo, not just those changed since HEAD (same rules either way)",
+  false
+).option("--ci", "mechanical bucket only; exits non-zero on any error, deterministic", false).option("--json", "emit findings as JSON", false).action((opts) => {
   const projectRoot = findProjectRoot(process.cwd());
   try {
     const result = check({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jig-ui",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "A design system for coding agents. 104 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/rules/00-anti-patterns.md

@@ -144,6 +144,13 @@ Four workable treatments:
 4. **Solid background behind the text** — the caption approach; most reliable, least subtle.
 A text shadow may reinforce any of these but never substitutes for one. Verify against the worst image the slot will ever hold, not the one in the mockup.
 
+### B-105 Monospace sized by a guessed ratio
+❌ Inline `code` set to `0.9em` — or any fixed ratio — to stop it looking bigger than the text around it
+✅ Measure both faces before correcting either. If they share an x-height, the ratio is the mismatch. Let code inherit its host's size.
+The habit comes from pairings where it is true: a mono face drawn separately from the text face often does sit larger at the same `font-size`. In a superfamily it does not. IBM Plex Sans and IBM Plex Mono are both x-height 51.6 and cap-height 69.8 per 1000 units — identical — and mono is *narrower*, not larger. A `0.9em` there sets code at x-height 46.8 inside text at 52, creating the mismatch it was meant to remove.
+A ratio is also the wrong shape of answer. Inline `code` appears inside body text, headings, table cells and captions; one multiplier has to be right for all of them, and a fixed token is worse still — it collapses code in a heading to caption size. Inheriting is correct in every host, which is why this rule has no token.
+The measurement is one line in a browser: render `x` in both faces at the same size and compare the rendered heights, or read `sxHeight` from each font's `OS/2` table. Do it once per project when the brand file is written, not per component.
+
 ---
 
 ## C. Colour and contrast
@@ -485,7 +492,8 @@ Where people must *browse* to decide, split the list into two dependent fields
 
 ### H-47 Values hard-coded past the token layer
 ❌ A raw hex colour or pixel size written in component code
-✅ Reference the token. Consume the semantic role (`--color-text-strong`), not the primitive (`--color-neutral-900`). A value that cannot be expressed as a token indicates a missing token.
+✅ Reference the token. Consume the semantic role (`--color-text-strong`), not the primitive (`--color-neutral-900`). A value that cannot be expressed as a token is a missing token — or a value that should not exist at all. Check the second before minting the first.
+Deletion is a real answer and the easy one to miss, because the correction points at a token and an agent reading it literally invents one. Both times this rule fired on Jig's own documentation site the fix was removal: `font-size: 0.9em` on inline `code`, where the two faces share vertical metrics and inheriting is correct (`B-105`); and a `min-width` in `em` on a table column that `max-content` measures for free. A token minted to satisfy a detector entrenches the value it was invented for.
 
 ### H-48 JavaScript for something CSS does
 ❌ Scroll listeners for sticky positioning; scripted accordions and dialogs that have native equivalents

package/rules/02-tokens.md

@@ -281,23 +281,32 @@ Resist per-component tokens (`--button-bg`). They multiply fast and rarely earn
 
 ## Naming contract
 
-Names align to Tailwind v4's theme namespaces. This is free for other frameworks — they are ordinary custom properties — and means an alias block can expose any of them as Tailwind utilities without any framework taking a dependency on Tailwind.
+Names align to Tailwind v4's theme namespaces. This is free for other frameworks — they are ordinary custom properties — and means most of them can be exposed as Tailwind utilities through an alias block, without any framework taking a dependency on Tailwind.
 
-| Namespace | Holds | Layer |
-| --- | --- | --- |
-| `--color-*` | All colour | brand |
-| `--font-*` | Font families | brand |
-| `--text-*` | Font sizes | mode |
-| `--leading-*` | Line heights | mode |
-| `--tracking-*` | Letter spacing | mode |
-| `--spacing-*` | Spacing values | mode |
-| `--radius-*` | Corner radii | brand scale, mode selection |
-| `--border-width-*` | Stroke widths | brand options, mode selection |
-| `--focus-ring-*` | Focus indicator geometry | brand — an accessibility floor, so not mode-negotiable |
-| `--shadow-*` | Elevation | brand |
-| `--duration-*`, `--ease-*` | Motion | mode |
-| `--size-*` | Control and row heights | mode |
-| `--measure-*` | Line length caps | mode |
+**Most, not all.** Three of the namespaces below are Jig's own and have no utility behind them in Tailwind v4 — the **Utility** column says which. Aliasing one is accepted silently, emits the custom property, and generates no rule, so the class lands on the element and does nothing. That is the same silent failure this file warns about under [Optional: Tailwind utility classes](#optional-tailwind-utility-classes), reached from the other direction: there the alias is missing, here the alias is present and the utility does not exist.
+
+| Namespace | Holds | Layer | Utility |
+| --- | --- | --- | --- |
+| `--color-*` | All colour | brand | yes |
+| `--font-*` | Font families | brand | yes |
+| `--text-*` | Font sizes | mode | yes |
+| `--leading-*` | Line heights | mode | yes |
+| `--tracking-*` | Letter spacing | mode | yes |
+| `--spacing-*` | Spacing values | mode | yes |
+| `--radius-*` | Corner radii | brand scale, mode selection | yes |
+| `--border-width-*` | Stroke widths | brand options, mode selection | yes |
+| `--focus-ring-*` | Focus indicator geometry | brand — an accessibility floor, so not mode-negotiable | **no** |
+| `--shadow-*` | Elevation | brand | yes |
+| `--ease-*` | Motion easing | mode | yes |
+| `--duration-*` | Motion duration | mode | **no** |
+| `--size-*` | Control and row heights | mode | yes |
+| `--measure-*` | Line length caps | mode | **no** |
+
+`--duration-*` and `--ease-*` had one row between them and only one half of it works, which is why they are separated here.
+
+**Reading a `no` token from a class.** Use Tailwind's custom-property value form, which needs no alias and keeps the semantic name: `max-w-(--measure-prose)`, `duration-(--duration-fast)`, `outline-(--focus-ring-width)`. That satisfies `H-47` — the value is still the token — it simply does not route through `@theme`. The same form covers any token a mode file adds that has no namespace at all, such as the `--grid-*` values.
+
+Verified by compiling one alias per namespace against `tailwindcss@4.3.3` and reading the output. Probe each namespace with a *distinct* token name if you re-check this: `text-*`, `border-*`, `outline-*` and `max-w-*` each read more than one namespace, so a shared suffix makes a colour alias look like proof that four other namespaces work.
 
 **Rules**
 1. Semantic names only at the point of use. `--color-text-strong`, not `--color-neutral-900`, in component code. Primitives exist to build semantics, not to be consumed directly.

package/rules.index.json

@@ -49,7 +49,7 @@
     "bucket": "mechanical",
     "severity": "error",
     "detector": "hardcoded-value",
-    "fix": "token-substitute",
+    "fix": "token-substitute-or-remove",
     "since": "0.1.0"
   },
   {
@@ -187,6 +187,12 @@
     "severity": "note",
     "since": "0.1.0"
   },
+  {
+    "id": "B-105",
+    "bucket": "judgment",
+    "severity": "note",
+    "since": "0.9.0"
+  },
   {
     "id": "C-66",
     "bucket": "judgment",

package/templates/SKILL.md.tmpl

@@ -89,3 +89,13 @@ check that never inspected anything.
 
 A skipped check must say `skipped` and give the reason. Do not report `ran` for
 a check you did not perform.
+
+**`files=` and `styled=` describe a scope, and the scope is not fixed.**
+`jig check` defaults to the files changed since HEAD and falls back to the
+whole repo only when that diff is empty. So the same project reports a
+different `files=` before and after a commit with nothing else having moved,
+and two `JIG_CHECK:` lines are comparable only when both runs had the same
+scope. Run `jig check --all` for a number that describes the project rather
+than your diff — `--all` widens the files, not the rules. A narrowed run says
+so in its own output; attest from what it printed, not from what you assumed
+it looked at.