jig-ui 0.11.0 → 0.12.0

package/CHANGELOG.md

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

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.
 

package/dist/index.js

@@ -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);
@@ -5215,6 +5269,7 @@ function verifyVerdicts(opts) {
 
 // src/commands/gate.ts
 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
@@ -5275,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] ?? "";
@@ -5397,6 +5452,7 @@ function gate(opts) {
     }
   }
   const session = opts.input.session_id ?? "unknown";
+  const key = `${session}:${createHash2("sha256").update(problems.join("\n")).digest("hex").slice(0, 12)}`;
   const stateFile = join33(root, ".jig", "gate.json");
   let state = {};
   try {
@@ -5404,13 +5460,14 @@ function gate(opts) {
   } 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,
@@ -5418,7 +5475,7 @@ function gate(opts) {
 ${problems.join("\n\n")}`
     };
   }
-  state[session] = count;
+  state[key] = count;
   save(stateFile, state);
   return {
     block: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jig-ui",
-  "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.",
+  "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"
   }
 ]