jig-ui 0.18.10 → 0.20.0

package/CHANGELOG.md

@@ -1,5 +1,96 @@
 # Changelog
 
+## 0.20.0 (2026-09-27)
+
+Critiques count owner rulings apart and say what the last round fixed; the gate
+keeps decisions the owner's, and tweak works on its first real pages.
+
+### Added
+
+- **A `ruled` verdict.** A finding the owner has already decided is judged
+  `ruled`, citing the decision's heading in `ruling`, and counted apart
+  (`ruled=`). On jig-site five of a header critique's 15 findings were the
+  owner's rulings, counted as findings and sent back to make.
+- **What happened to the last round's findings.** `jig verdicts` compares a
+  critique with the one before it in git and prints how many were fixed, are
+  still open, were ruled, and are new, with the ids. The report carries it.
+- **`jig verdicts --reprobe`** re-takes probes taken on an older page. The
+  gate and `--reprobe` now find the page from the probes themselves, so a spec
+  whose `surface:` is a sentence no longer leaves stale probes blocking.
+- **The probe names text drawn in a weight or style no loaded face covers**,
+  which the browser fakes from the nearest face. It is an error, like a page in
+  the default font. Probe version 8.
+- **`jig update` names the tokens** each refreshed mode file gained or lost,
+  and those an edited one did not get, since anything aliasing tokens (a
+  Tailwind `@theme`) needs the same change.
+
+### Changed
+
+- **`decide` keeps the owner's reasons apart from its own.** A `Why:` is the
+  owner's words in quotation marks or `not given`; anything the agent adds goes
+  under `**Why (inferred):**`. The gate checks each decision the session wrote
+  or changed.
+- **`make` does not edit DECISIONS.md.** The gate stops a make session that
+  changed it; decisions go through `decide` or `tweak`.
+- **A spec that no longer matches its approved drawing is not approved.** In
+  `spec` and `make`, each region the spec lists must be labelled in its size's
+  frame. Region names are read as the spec means them: a parenthetical
+  qualifies, "(… only)" is conditional, and a list names several regions.
+- **Critique's reader arms do not read the page's history**: no earlier
+  critiques, no git log. Which findings were fixed is the CLI's question.
+- **P-14 says how a menu in a fixed header behaves**: it lies over the page, a
+  tap outside closes it and does nothing else, controls in the header row work
+  on the first tap, and a long list scrolls inside itself.
+- **M-01's script budget is "none by default"**, not an absolute zero: a
+  feature may have script, named in a comment and as small as it allows.
+
+### Fixed
+
+- **`tweak`'s gate blocked both of its first real uses, on jig-site.** Three
+  causes, all in the gate:
+  - It took the session's command from any line that mentioned `/jig`, so the
+    command file Jig loads into the session, and tool results quoting it, read
+    as `/jig critique`. Only what the user sent counts now.
+  - It looked for the critique under the spec's `surface:` field, which on
+    jig-site is a sentence. A critique lives under the spec's file name, as
+    the command file says.
+  - It held the page to its structure at the commit that first approved the
+    mockup, before five confirmed, critiqued rounds. It now holds the page to
+    its structure at its last critique.
+
+  The gate also works on the spec the command names (`/jig tweak site-header`),
+  not whichever spec was written last.
+- **`jig verdicts` refuses reasons that judge nothing.** On jig-site a render
+  arm stopped with 33 of 34 verdicts reading "DRAFT, being refined", and the
+  review passed with full counts. A placeholder reason is now an error, and so
+  is one reason given word for word by four or more `ok` or `finding` verdicts
+  in a file. `n/a` verdicts may still share a reason, since one absence can
+  clear many rules.
+
+## 0.19.0 (2026-09-27)
+
+A new command, `tweak`, for a small change to a built page that its approved
+mockup does not show.
+
+### Added
+
+- **`/jig tweak`: a small change to a built page, in one pass.** On jig-site
+  half a day's rounds were changes the approved mockup does not show: a word
+  that wrapped, a mark's colour, how a version is written. Each went through
+  `decide`, `spec`, `make` and a full critique of every page it touched, or
+  would have been an edit by hand, which is the drift Jig exists to catch.
+  `tweak` records the decision if the change is one, brings the spec in line if
+  it disagrees, builds the change, and has a reader that did not make it
+  re-judge only the verdicts the change could affect. The gate bounds it: the
+  regions under the spec's `sizes:` must match the ones approved with the
+  mockup, the drawing must be unchanged since its approval, and the tweak may
+  change only the verdicts it names in `tweak.json`, each re-judged and stamped.
+  A change to structure is refused and routed through `spec` and `mockup`.
+- **A critique's lock records each verdict.** `verdicts.lock` now holds a digest
+  per verdict as well as the whole-file checksum, so the gate can tell which
+  verdicts a tweak changed. A lock written before this release is trusted once
+  by the first tweak and rewritten.
+
 ## 0.18.10 (2026-09-26)
 
 The rule against a stranded word holds in every browser, and the probe checks

package/README.md

@@ -250,7 +250,10 @@ Adopting Jig everywhere is not the price of using it anywhere. The rules apply
 to what you point them at:
 
 - **New work follows the loop** — decide, spec, mockup, make, critique — and the
-  Stop hook holds it to that, if you asked for the hook.
+  Stop hook holds it to that, if you asked for the hook. A small change to a
+  built page that its approved mockup does not show (a word, a colour, how text
+  wraps) goes through `tweak` instead: decided, specced, built and re-judged in
+  one pass, with the page's structure held as approved.
 - **Old pages sit where they are.** They are not rewritten, and the default
   `check` says nothing about a file nobody has touched.
 - **`jig.config.json` can exempt paths** you have no intention of revisiting, and

package/dist/index.js

@@ -46,7 +46,7 @@ import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as rea
 import { join as join7 } from "path";
 
 // src/adapters/types.ts
-var COMMAND_DESCRIPTION = "Run a Jig design-system command: set the project up, plan and build one feature at a time (decide, spec, mockup, make, critique), check the UI against the rules, or refresh the install.";
+var COMMAND_DESCRIPTION = "Run a Jig design-system command: set the project up, plan and build one feature at a time (decide, spec, mockup, make, critique), make a small change to a built page (tweak), check the UI against the rules, or refresh the install.";
 var SKILL_DESCRIPTION = "Design system rules for generating and reviewing UI. Load before building any interface.";
 function assertSafeRelPath(relPath, adapterName) {
   const isAbsolute2 = relPath.startsWith("/") || /^[A-Za-z]:/.test(relPath);
@@ -941,6 +941,16 @@ function removeLegacyFiles(projectRoot, relPaths) {
 }
 
 // src/commands/update.ts
+function declaredTokens(css) {
+  return new Set([...css.replace(/\/\*[\s\S]*?\*\//g, "").matchAll(/(--[\w-]+)\s*:/g)].map((m) => m[1]));
+}
+function tokenChange(file, before, after, skipped = false) {
+  const was = declaredTokens(before);
+  const now = declaredTokens(after);
+  const added = [...now].filter((t) => !was.has(t)).sort();
+  const removed = [...was].filter((t) => !now.has(t)).sort();
+  return added.length || removed.length ? { file, added, removed, ...skipped ? { skipped } : {} } : void 0;
+}
 function update(opts) {
   const resolved = resolveAllInstalled(opts.projectRoot, opts.homeDir);
   if (resolved.length === 0) {
@@ -972,7 +982,8 @@ function update(opts) {
     skipped,
     fromVersion: resolved[0].manifest.version,
     toVersion: opts.version,
-    targets
+    targets,
+    tokens: initResult.tokens
   };
 }
 function updateTarget(opts, resolved) {
@@ -1058,6 +1069,7 @@ function updateTarget(opts, resolved) {
 function updateInitFiles(opts) {
   const updated = [];
   const skipped = [];
+  const tokens = [];
   const tokensDir = join10(opts.packageRoot, "tokens");
   const initManifest = readInitManifest(opts.projectRoot);
   if (initManifest) {
@@ -1068,11 +1080,21 @@ function updateInitFiles(opts) {
       if (!file.startsWith("mode.")) continue;
       const keys = Object.keys(initManifest.files).filter((k) => k === file || k.endsWith(`/${file}`));
       for (const key of keys) {
+        let before = "";
+        try {
+          before = readFileSync7(join10(opts.projectRoot, ...key.split("/")), "utf8");
+        } catch {
+        }
+        const fresh = readFileSync7(join10(tokensDir, file), "utf8");
         if (isInitFileModified(opts.projectRoot, key, initManifest)) {
           skipped.push(key);
+          const change2 = tokenChange(key, before, fresh, true);
+          if (change2) tokens.push(change2);
           continue;
         }
-        const content = vendorHeader(file, opts.version, "css", null) + readFileSync7(join10(tokensDir, file), "utf8");
+        const change = tokenChange(key, before, fresh);
+        if (change) tokens.push(change);
+        const content = vendorHeader(file, opts.version, "css", null) + fresh;
         updated.push(writer.write(key, content));
         initChanged = true;
       }
@@ -1080,7 +1102,7 @@ function updateInitFiles(opts) {
     Object.assign(initFiles, writer.files);
     if (initChanged) writeInitManifest(opts.projectRoot, { ...initManifest, version: opts.version, files: initFiles });
   }
-  return { updated, skipped };
+  return { updated, skipped, tokens };
 }
 
 // src/commands/explain.ts
@@ -5749,7 +5771,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { join as join33, relative as relative3, resolve as resolve4, sep as sep5 } from "path";
 
 // src/probe/script.ts
-var PROBE_VERSION = 7;
+var PROBE_VERSION = 8;
 var PROBE_SCRIPT = `(async () => {
   const doc = document.documentElement;
   // checkVisibility also sees content a closed <details> hides: Chromium hides
@@ -5913,6 +5935,32 @@ var PROBE_SCRIPT = `(async () => {
       focusReturned: document.activeElement === toggle,
     };
   }
+  // A weight or style the page asks for that no loaded face covers: the
+  // browser draws it by thickening or slanting the nearest face it has. On
+  // jig-site a heading asked for a weight the site never loaded and every
+  // review passed it, since the page was styled and nothing was missing.
+  // Only web fonts are judged; a family with no @font-face is the system's.
+  if (document.fonts) await document.fonts.ready;
+  const faces = document.fonts ? [...document.fonts] : [];
+  const unquote = (f) => f.trim().replace(/^["']|["']$/g, '').toLowerCase();
+  const weightOf = (w) => (w === 'normal' ? 400 : w === 'bold' ? 700 : Number(w));
+  const covers = (face, w) => { const [lo, hi = lo] = String(face.weight).trim().split(/\\s+/).map(weightOf); return w >= lo && w <= hi; };
+  const fauxFaces = [];
+  const fauxSeen = new Set();
+  for (const el of [...document.body.querySelectorAll('*')].slice(0, 4000)) {
+    if (![...el.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim()) || !vis(el)) continue;
+    const cs = getComputedStyle(el);
+    const first = cs.fontFamily.split(',')[0];
+    const own = faces.filter((f) => unquote(f.family) === unquote(first));
+    if (!own.length) continue;
+    const weight = weightOf(cs.fontWeight);
+    const italic = cs.fontStyle !== 'normal';
+    if (own.some((f) => f.status === 'loaded' && covers(f, weight) && (f.style !== 'normal') === italic)) continue;
+    const key = unquote(first) + ' ' + weight + ' ' + italic;
+    if (fauxSeen.has(key)) continue;
+    fauxSeen.add(key);
+    fauxFaces.push({ family: first.trim().replace(/^["']|["']$/g, ''), weight, style: italic ? 'italic' : 'normal', text: (el.innerText || '').trim().slice(0, 40) });
+  }
   return JSON.stringify({
     jigProbe: ${PROBE_VERSION},
     url: location.href,
@@ -5929,6 +5977,7 @@ var PROBE_SCRIPT = `(async () => {
     navLinksVisible: navAtRest,
     strandedCount: stranded.length,
     strandedWords: stranded.slice(0, 6),
+    fauxFaces: fauxFaces.slice(0, 6),
     head: {
       title: (document.title || '').trim(),
       description: (document.querySelector('meta[name=description]') || {}).content || '',
@@ -6269,6 +6318,18 @@ async function withPageUrl(projectRoot, abs, serve, use) {
     await server.close();
   }
 }
+function recordedPage(projectRoot, surface) {
+  const dir = join33(projectRoot, ".jig", "critique", surface);
+  if (!existsSync19(dir)) return void 0;
+  for (const f of readdirSync12(dir).filter((name) => /^probe-\d+\.json$/.test(name)).sort()) {
+    try {
+      const probe = JSON.parse(readFileSync26(join33(dir, f), "utf8"));
+      if (probe.pageFile && existsSync19(resolve4(projectRoot, probe.pageFile))) return probe.pageFile;
+    } catch {
+    }
+  }
+  return void 0;
+}
 async function ensureProbes(opts) {
   const dir = join33(opts.projectRoot, ".jig", "critique", opts.surface);
   const abs = resolve4(opts.projectRoot, opts.page);
@@ -6371,6 +6432,10 @@ function probeContradictions(probes, verdictOf, indexable = true) {
     if (p.defaultFont) {
       errors.push(`${at(p)}: the page renders in the browser's default font (${p.bodyFont ?? "unknown"}) \u2014 its styles are not applying. No review of this page can pass until they do.`);
     }
+    if (p.fauxFaces?.length) {
+      const shown = p.fauxFaces.map((f) => `${f.family} ${f.weight}${f.style === "italic" ? " italic" : ""} ("${f.text}")`).join(", ");
+      errors.push(`${at(p)}: the page asks for ${shown}, and no loaded face covers ${p.fauxFaces.length === 1 ? "it" : "them"}, so the browser fakes the weight or slant from the nearest face it has. Load that weight, or use one the page already loads.`);
+    }
     if (p.unresolvedTokens.length) {
       errors.push(`${at(p)}: ${p.unresolvedTokens.length} token(s) have no value in the browser (${p.unresolvedTokens.slice(0, 6).join(", ")}) \u2014 every property using them is dropped (H-117).`);
     }
@@ -6473,6 +6538,43 @@ function decisionHeadings(projectRoot) {
   }
   return headings;
 }
+function decisionSections(body) {
+  const sections = /* @__PURE__ */ new Map();
+  const lines = body.split("\n");
+  let name;
+  let text = [];
+  const close = () => {
+    if (name && !NOT_A_DECISION.test(name) && !sections.has(name)) sections.set(name, text.join("\n").trim());
+  };
+  for (const line of lines) {
+    const heading = /^(#{1,3})\s+(.+?)\s*$/.exec(line);
+    if (heading) {
+      close();
+      name = heading[1].length >= 2 ? heading[2].replace(/[`*]/g, "").trim() : void 0;
+      text = [];
+    } else text.push(line);
+  }
+  close();
+  return sections;
+}
+function unsourcedReasons(current, before) {
+  const then = decisionSections(before);
+  const problems = [];
+  for (const [name, text] of decisionSections(current)) {
+    if (then.get(name) === text) continue;
+    const whys = text.split(/\n\s*\n/).filter((p) => /^\s*\*\*Why\b[^*]*:\*\*/.test(p));
+    for (const why of whys) {
+      const label = /^\s*\*\*(Why\b[^*]*):\*\*/.exec(why)[1];
+      const said = why.replace(/^\s*\*\*Why\b[^*]*:\*\*/, "").trim();
+      if (/inferred/i.test(label)) continue;
+      if (/^not given\b/i.test(said)) continue;
+      if (/["“][^"”]{3,}["”]/.test(said)) continue;
+      problems.push(`"${name}": its \`**${label}:**\` is not the owner's words in quotation marks. Quote what the owner said, write \`not given\`, or put what you added under \`**Why (inferred):**\`.`);
+      break;
+    }
+  }
+  return problems;
+}
 
 // src/check/spec-shape.ts
 import { existsSync as existsSync22, readFileSync as readFileSync29, readdirSync as readdirSync14, statSync as statSync4 } from "fs";
@@ -6485,6 +6587,13 @@ function newestSpec(projectRoot) {
   const newest = files.map((f) => ({ f, at: statSync4(join36(dir, f)).mtimeMs })).sort((a, b) => b.at - a.at)[0].f;
   return { path: `.jig/specs/${newest}`, slug: newest.replace(/\.spec\.md$|\.md$/, ""), body: readFileSync29(join36(dir, newest), "utf8") };
 }
+function specFor(projectRoot, surface) {
+  if (surface) {
+    const path = join36(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+    if (existsSync22(path)) return { path: `.jig/specs/${surface}.spec.md`, slug: surface, body: readFileSync29(path, "utf8") };
+  }
+  return newestSpec(projectRoot);
+}
 function specProblems(spec) {
   const parts = spec.body.split(/^---\s*$/m);
   const front = parts.length >= 3 ? parts[1] : "";
@@ -6562,7 +6671,28 @@ function specIndexableField(front) {
 
 // src/commands/verdicts.ts
 var VERDICTS = ["ok", "finding", "n/a"];
+var RULE_VERDICTS = [...VERDICTS, "ruled"];
 var ABSENCE = /\b(rule (not found|does not exist)|context unavailable|cannot (find|read|access) (the )?rule|not in (the )?(accessible )?corpus)\b/i;
+var PLACEHOLDER = /^\W*(draft|tbd|todo|placeholder|wip|fixme|xxx|lorem ipsum)\W*($|[,.;:(\u2014-])|\bbeing refined\b|\bto be (judged|written|refined|filled in|completed)\b|\bfill (this )?in later\b/i;
+var REPEAT_LIMIT = 4;
+function reasonProblems(file, judged, errors) {
+  const shared = /* @__PURE__ */ new Map();
+  for (const { label, verdict, reason } of judged) {
+    const bare2 = reason.replace(/^[A-Z]{1,2}-\d+[a-z0-9-]*\s*[:\u2014-]?\s*/i, "");
+    if (PLACEHOLDER.test(bare2)) {
+      errors.push(`${file}: ${label} \u2014 "${reason}" is a placeholder, not a judgment. Judge it against the page and write what you saw.`);
+      continue;
+    }
+    if (verdict === "n/a") continue;
+    const key = reason.toLowerCase().replace(/\s+/g, " ");
+    shared.set(key, [...shared.get(key) ?? [], label]);
+  }
+  for (const [, labels] of shared) {
+    if (labels.length < REPEAT_LIMIT) continue;
+    const reason = judged.find((j) => j.label === labels[0]).reason;
+    errors.push(`${file}: ${labels.length} verdicts give the same reason, "${reason}" (${labels.slice(0, 5).join(", ")}${labels.length > 5 ? ", \u2026" : ""}). A reason names what on this page holds or breaks that one rule; judge each of them.`);
+  }
+}
 function readJson(path, errors) {
   if (!existsSync23(path)) return null;
   try {
@@ -6592,7 +6722,7 @@ function specNeedsNav(projectRoot, surface) {
   const navRegion = /^\s*-\s*(nav|navigation)\s*:/im.test(front);
   return navField || navRegion;
 }
-function checkArm(name, file, required, otherPass, extraAllowed, extraRequired, errors) {
+function checkArm(name, file, required, otherPass, extraAllowed, extraRequired, errors, decisionList = []) {
   const total = required.length + extraRequired.length;
   if (file === null) {
     errors.push(`${name}.json is missing \u2014 the ${name} arm has not run, or did not write its verdicts.`);
@@ -6601,7 +6731,9 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
   const list = Array.isArray(file.verdicts) ? file.verdicts : [];
   if (!Array.isArray(file.verdicts)) errors.push(`${name}.json has no "verdicts" array.`);
   const seen = /* @__PURE__ */ new Set();
+  const reasons = [];
   let findings = 0;
+  let ruled = 0;
   for (const v of list) {
     const written = typeof v.id === "string" ? v.id.trim() : "";
     const id = written.toUpperCase();
@@ -6619,21 +6751,30 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
       errors.push(pass === "mechanical" ? `${name}.json: ${id} is a mechanical rule \u2014 \`jig check\` decides it, so it has no verdict here. Remove it.` : pass ? `${name}.json: ${id} is a pass: ${pass} rule \u2014 it belongs to the other arm.` : `${name}.json: ${written} is not a rule or spec in this corpus. Run \`jig explain ${written}\`; an id that does not resolve is not a verdict.`);
       continue;
     }
-    if (typeof v.verdict !== "string" || !VERDICTS.includes(v.verdict)) {
-      errors.push(`${name}.json: ${id} has verdict ${JSON.stringify(v.verdict)} \u2014 it must be ok, finding or n/a.`);
+    if (typeof v.verdict !== "string" || !RULE_VERDICTS.includes(v.verdict)) {
+      errors.push(`${name}.json: ${id} has verdict ${JSON.stringify(v.verdict)} \u2014 it must be ok, finding, ruled or n/a.`);
       continue;
     }
+    if (v.verdict === "ruled") {
+      const ruling = typeof v.ruling === "string" ? v.ruling.trim() : "";
+      const match = decisionList.find((d) => d.toLowerCase() === ruling.toLowerCase());
+      if (!ruling) errors.push(`${name}.json: ${id} is ruled, but names no \`ruling\`. A ruled verdict cites the DECISIONS.md heading that decided it; with none, it is a finding.`);
+      else if (!match) errors.push(`${name}.json: ${id} cites the ruling "${ruling}", which is not a heading in DECISIONS.md. Cite the decision as its heading reads, or judge it a finding.`);
+      else ruled++;
+    }
     const reason = typeof v.reason === "string" ? v.reason.trim() : "";
     if (!reason) errors.push(`${name}.json: ${id} has no reason.`);
     else if (ABSENCE.test(reason)) errors.push(`${name}.json: ${id} \u2014 "${reason}" says the rule was not read. Read it with \`jig explain ${id}\` and judge it.`);
+    else reasons.push({ label: id, verdict: v.verdict, reason });
     if (v.verdict === "finding") findings++;
   }
+  reasonProblems(`${name}.json`, reasons, errors);
   const missing = [...required, ...extraRequired].filter((id) => !seen.has(id));
   if (missing.length) {
     errors.push(`${name}.json: ${missing.length} of ${total} ids have no verdict: ${missing.join(", ")}. Re-run the arm; never report a short pass.`);
   }
   const judged = total - missing.length;
-  return { state: missing.length ? "incomplete" : "ran", judged, total, findings };
+  return { state: missing.length ? "incomplete" : "ran", judged, total, findings, ...ruled ? { ruled } : {} };
 }
 function checkDecisions(projectRoot, dir, errors) {
   const required = decisionNames(projectRoot);
@@ -6648,6 +6789,7 @@ function checkDecisions(projectRoot, dir, errors) {
   const list = Array.isArray(file.verdicts) ? file.verdicts : [];
   if (!Array.isArray(file.verdicts)) errors.push('decisions.json has no "verdicts" array.');
   const seen = /* @__PURE__ */ new Set();
+  const reasons = [];
   let findings = 0;
   for (const v of list) {
     const name = typeof v.decision === "string" ? v.decision.trim() : "";
@@ -6672,8 +6814,10 @@ function checkDecisions(projectRoot, dir, errors) {
     const reason = typeof v.reason === "string" ? v.reason.trim() : "";
     if (!reason) errors.push(`decisions.json: "${match}" has no reason. Name what on the page satisfies it, or what does not.`);
     else if (ABSENCE.test(reason)) errors.push(`decisions.json: "${match}" \u2014 "${reason}" says the decision was not read.`);
+    else reasons.push({ label: `"${match}"`, verdict: v.verdict, reason });
     if (v.verdict === "finding") findings++;
   }
+  reasonProblems("decisions.json", reasons, errors);
   const unjudged = required.filter((r) => !seen.has(r));
   const since = decisionsSince(projectRoot, dir, unjudged);
   const missing = unjudged.filter((r) => !since.includes(r));
@@ -6726,8 +6870,9 @@ function verifyVerdicts(opts) {
   const screenFile = readJson(join37(dir, "screen.json"), errors);
   const codeFile = readJson(join37(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);
+  const decisionList = decisionNames(opts.projectRoot);
+  const screen = checkArm("screen", screenFile, screenIds, passOf, specIds, screenExtraRequired, errors, decisionList);
+  const code = checkArm("code", codeFile, codeIds, passOf, specIds, [], errors, decisionList);
   let rendered = false;
   if (screenFile && screenFile.rendered === true) {
     const artefacts = Array.isArray(screenFile.artefacts) ? screenFile.artefacts.filter((a) => typeof a === "string") : [];
@@ -6763,8 +6908,60 @@ function verifyVerdicts(opts) {
   if (screen.state === "ran" && !rendered) screen.state = "skipped";
   const decisions = checkDecisions(opts.projectRoot, dir, errors);
   const field = (a) => a.state === "ran" ? `ran:${a.judged}` : `${a.state}:${a.judged}${a.state === "incomplete" ? `/${a.total}` : ""}`;
-  const line = `JIG_VERDICTS: surface=${opts.surface} screen=${field(screen)} code=${field(code)} decisions=${field(decisions)} rendered=${rendered ? "yes" : "no"} findings=${screen.findings + code.findings + decisions.findings}`;
-  return { ok: errors.length === 0, errors, screen, code, decisions, rendered, line };
+  const line = `JIG_VERDICTS: surface=${opts.surface} screen=${field(screen)} code=${field(code)} decisions=${field(decisions)} rendered=${rendered ? "yes" : "no"} findings=${screen.findings + code.findings + decisions.findings}${(screen.ruled ?? 0) + (code.ruled ?? 0) ? ` ruled=${(screen.ruled ?? 0) + (code.ruled ?? 0)}` : ""}`;
+  const previous = previousFindings(opts.projectRoot, dir);
+  return { ok: errors.length === 0, errors, screen, code, decisions, rendered, line, ...previous ? { previous } : {} };
+}
+function previousFindings(projectRoot, dir) {
+  const git = (args) => execFileSync3("git", args, { cwd: projectRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const rel = relative4(projectRoot, dir).split("\\").join("/");
+  const files = ["screen.json", "code.json", "decisions.json"];
+  const paths = files.map((f) => `${rel}/${f}`);
+  let commit;
+  try {
+    const dirty = git(["status", "--porcelain", "--", ...paths]).trim() !== "";
+    const touched = git(["log", "--format=%H", "-2", "--", ...paths]).split("\n").filter(Boolean);
+    commit = dirty ? touched[0] ?? "" : touched[1] ?? "";
+  } catch {
+    return void 0;
+  }
+  if (!commit) return void 0;
+  const read = (f, at) => {
+    const out = /* @__PURE__ */ new Map();
+    let text;
+    try {
+      text = at ? git(["show", `${at}:./${rel}/${f}`]) : readFileSync30(join37(dir, f), "utf8");
+    } catch {
+      return out;
+    }
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      return out;
+    }
+    for (const v of Array.isArray(body.verdicts) ? body.verdicts : []) {
+      const key = String(v.id ?? v.decision ?? "").trim();
+      if (key && typeof v.verdict === "string") out.set(f === "decisions.json" ? `"${key}"` : key.toUpperCase(), v.verdict);
+    }
+    return out;
+  };
+  const before = /* @__PURE__ */ new Map();
+  const now = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    for (const [k, v] of read(f, commit)) before.set(k, v);
+    for (const [k, v] of read(f)) now.set(k, v);
+  }
+  const result = { commit: commit.slice(0, 7), fixed: [], open: [], added: [], ruled: [] };
+  for (const [k, v] of before) {
+    if (v !== "finding") continue;
+    const after = now.get(k);
+    if (after === "finding") result.open.push(k);
+    else if (after === "ruled") result.ruled.push(k);
+    else if (after === "ok" || after === "n/a") result.fixed.push(k);
+  }
+  for (const [k, v] of now) if (v === "finding" && before.get(k) !== "finding") result.added.push(k);
+  return result;
 }
 
 // src/commands/gate.ts
@@ -6797,23 +6994,7 @@ function mockupDrawingProblems(root, specBody, at) {
       `${at} draws icons or images in its frames (${[...new Set(drawn)].slice(0, 4).join("; ")}). A mockup is structure only: an icon is its name in brackets, \`[search]\`, and an image is a labelled box saying what goes there.`
     );
   }
-  const regions = specRegions(specBody);
-  for (const [size] of FRAMES) {
-    const listed = regions[size];
-    const inFrame = frames.filter((f) => f.size === size).flatMap((f) => f.labels);
-    if (!listed || listed.length === 0 || !frames.some((f) => f.size === size)) continue;
-    const named = listed.filter((r) => r.name).map((r) => r.name);
-    const absent = named.filter((name) => !inFrame.some((label) => labelMatches(label, name)));
-    if (absent.length) {
-      problems.push(
-        `${at}: the ${size} frame has no labelled region for ${absent.map((n) => `"${n}"`).join(", ")}. Every region the spec lists for a size is drawn in that size's frame, with its name in a \`.name\` label.`
-      );
-    } else if (inFrame.length < listed.length) {
-      problems.push(
-        `${at}: the ${size} frame labels ${inFrame.length} region(s) and the spec lists ${listed.length} for ${size}. Draw each one in the frame, with its name in a \`.name\` label.`
-      );
-    }
-  }
+  problems.push(...frameRegionProblems(frames, specBody, at));
   const widths = new Set(frames.map((f) => f.width).filter((w) => w !== void 0));
   const crossed = specSwitches(specBody);
   const recorded = declaredSwitches(root);
@@ -6833,6 +7014,37 @@ function mockupDrawingProblems(root, specBody, at) {
   }
   return problems;
 }
+function frameRegionProblems(frames, specBody, at) {
+  const problems = [];
+  const regions = specRegions(specBody);
+  for (const [size] of FRAMES) {
+    const listed = regions[size];
+    const inFrame = frames.filter((f) => f.size === size).flatMap((f) => f.labels);
+    if (!listed || listed.length === 0 || !frames.some((f) => f.size === size)) continue;
+    const absent = listed.filter((r) => r.name && !r.optional && !regionDrawn(inFrame, r)).map((r) => r.name);
+    if (absent.length) {
+      problems.push(
+        `${at}: the ${size} frame has no labelled region for ${absent.map((n) => `"${n}"`).join(", ")}. Every region the spec lists for a size is drawn in that size's frame, with its name in a \`.name\` label.`
+      );
+    } else if (inFrame.length < listed.filter((r) => !r.optional).length) {
+      problems.push(
+        `${at}: the ${size} frame labels ${inFrame.length} region(s) and the spec lists ${listed.filter((r) => !r.optional).length} for ${size}. Draw each one in the frame, with its name in a \`.name\` label.`
+      );
+    }
+  }
+  return problems;
+}
+function approvedDrawingProblems(root, specBody, at) {
+  let html;
+  try {
+    html = readFileSync31(join38(root, at), "utf8");
+  } catch {
+    return [];
+  }
+  const frames = readFrames(html);
+  if (!frames.some((f) => f.size)) return [];
+  return frameRegionProblems(frames, specBody, at);
+}
 function specSwitches(specBody) {
   const front = specBody.split(/^---\s*$/m)[1] ?? "";
   const value = /^switches\s*:\s*(.+)$/im.exec(front)?.[1]?.replace(/#.*$/, "").trim();
@@ -6894,7 +7106,18 @@ function regionEntries(block) {
 function regionName(entry) {
   const text = entry.trim().replace(/^["']|["']$/g, "").replace(/\\"/g, '"');
   const head = normalise(text.split(":")[0]);
-  return head && head.split(" ").length <= 4 ? { name: head } : {};
+  const optional = /\([^)]*\bonly\b[^)]*\)/.test(head);
+  const bare2 = stripQualifiers(head);
+  if (!bare2 || bare2.split(" ").length > 4) return {};
+  const parts = bare2.split(/\s*,\s*(?:and\s+)?|\s+and\s+(?=[^,]*$)/).map((p) => p.trim()).filter(Boolean);
+  return { name: bare2, ...parts.length > 1 ? { parts } : {}, ...optional ? { optional } : {} };
+}
+function stripQualifiers(text) {
+  return text.replace(/\s*\([^)]*\)/g, "").replace(/\s+/g, " ").trim();
+}
+function regionDrawn(labels, region) {
+  const found = (name) => labels.some((label) => labelMatches(label, name) || labelMatches(stripQualifiers(label), name));
+  return found(region.name) || !!region.parts && region.parts.every(found);
 }
 function labelMatches(label, name) {
   return label === name || label.startsWith(`${name} `) || label.startsWith(`${name}:`) || new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(label);
@@ -6915,8 +7138,9 @@ function sizeBlock2(sizes, size) {
 }
 
 // src/commands/gate.ts
+import { execFileSync as execFileSync4 } from "child_process";
 var MAX_BLOCKS = 3;
-function lastJigCommand(transcriptPath) {
+function lastJigInvocation(transcriptPath) {
   if (!transcriptPath || !existsSync24(transcriptPath)) return void 0;
   let text;
   try {
@@ -6927,10 +7151,20 @@ function lastJigCommand(transcriptPath) {
   let found;
   for (const line of text.split("\n")) {
     if (!line.includes("/jig")) continue;
-    const name = /<command-name>\/?jig<\/command-name>[\s\S]{0,200}?<command-args>([^<]*)<\/command-args>/.exec(line);
-    const plain = /(?:^|["\s>])\/jig\s+([a-z]+)/.exec(line);
-    const arg = (name?.[1] ?? plain?.[1] ?? "").trim().split(/\s+/)[0];
-    if (arg) found = arg.toLowerCase();
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "user" || entry.isMeta) continue;
+    const content = entry.message?.content;
+    const texts = typeof content === "string" ? [content] : Array.isArray(content) ? content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text) : [];
+    for (const t of texts) {
+      const args = /<command-name>\/?jig<\/command-name>[\s\S]{0,200}?<command-args>([^<]*)<\/command-args>/.exec(t)?.[1] ?? /^\s*\/jig\s+([^\n]*)/.exec(t)?.[1];
+      const [command, surface] = (args ?? "").trim().split(/\s+/);
+      if (command && /^[a-z]+$/i.test(command)) found = { command: command.toLowerCase(), ...surface && /^[\w.-]+$/.test(surface) ? { surface } : {} };
+    }
   }
   return found;
 }
@@ -6960,7 +7194,7 @@ function asksOwner(text) {
   const prose = text.replace(/```[\s\S]*?```/g, "").replace(/`[^`\n]*`/g, "");
   return /\?(?=[\s)\]"'*_]|$)/.test(prose);
 }
-var ASKS_THE_OWNER = /* @__PURE__ */ new Set(["decide", "spec", "mockup"]);
+var ASKS_THE_OWNER = /* @__PURE__ */ new Set(["decide", "spec", "mockup", "tweak"]);
 function sessionStart(transcriptPath) {
   if (!transcriptPath || !existsSync24(transcriptPath)) return void 0;
   try {
@@ -6985,18 +7219,27 @@ function verdictsMtime(dir) {
   }
   return newest;
 }
-function surfacesInPlay(root, command, transcriptPath) {
+function surfacesInPlay(root, command, transcriptPath, surface) {
   const critiqueDir = join39(root, ".jig", "critique");
   if (!existsSync24(critiqueDir)) return [];
   const all = readdirSync15(critiqueDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("_") && !d.name.startsWith(".")).map((d) => d.name);
   const start = sessionStart(transcriptPath);
   if (start === void 0) return all;
-  const current = command === "critique" ? /^\s*surface\s*:\s*(.+)$/im.exec(newestSpec(root)?.body.split(/^---\s*$/m)[1] ?? "")?.[1]?.trim().replace(/^["']|["']$/g, "") : void 0;
+  const current = command === "critique" || command === "tweak" ? specFor(root, surface)?.slug : void 0;
   return all.filter((s) => s === current || verdictsMtime(join39(critiqueDir, s)) >= start - 1e3);
 }
-function commandProblems(root, command) {
+function fileAtSessionStart(root, path, start) {
+  const git = (args) => execFileSync4("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  try {
+    const base = start === void 0 ? "HEAD" : git(["rev-list", "-1", `--before=@${Math.floor(start / 1e3)}`, "HEAD"]).trim();
+    return base ? git(["show", `${base}:./${path}`]) : "";
+  } catch {
+    return "";
+  }
+}
+function commandProblems(root, command, surface, start) {
   const problems = [];
-  const spec = newestSpec(root);
+  const spec = specFor(root, surface);
   if (command === "decide") {
     const found = decisionsFile(root);
     if (!found) problems.push("decide wrote no DECISIONS.md beside the token layer.");
@@ -7006,9 +7249,10 @@ function commandProblems(root, command) {
         problems.push("DECISIONS.md has no `## Unresolved` section. Round 3 asks by name what is still undecided; write what the owner named, or `None named by the owner.`");
       }
       if (/\[TODO\]/.test(body)) problems.push("DECISIONS.md still contains [TODO] markers.");
+      problems.push(...unsourcedReasons(body, fileAtSessionStart(root, found, start)).map((p) => `DECISIONS.md: ${p}`));
     }
   }
-  if (command === "spec" || command === "mockup" || command === "make" || command === "critique") {
+  if (command === "spec" || command === "mockup" || command === "make" || command === "critique" || command === "tweak") {
     if (!spec) problems.push(`${command} needs a spec: there is no file in .jig/specs/.`);
     else {
       problems.push(...specProblems(spec));
@@ -7027,16 +7271,44 @@ function commandProblems(root, command) {
     }
     if (at && /\.html?$/i.test(at) && existsSync24(join39(root, at))) problems.push(...mockupDrawingProblems(root, spec.body, at));
   }
+  if (command === "tweak" && spec) problems.push(...tweakProblems(root, spec));
+  if ((command === "spec" || command === "make") && spec) {
+    const front = spec.body.split(/^---\s*$/m)[1] ?? "";
+    const mockup = /^\s*mockup\s*:\s*(\S+)/im.exec(front)?.[1] ?? "";
+    const at = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
+    if (/^approved/i.test(mockup) && /\.html?$/i.test(at) && !/^https?:/i.test(at)) {
+      const drift = approvedDrawingProblems(root, spec.body, at);
+      if (drift.length) {
+        problems.push(
+          `${spec.path} says \`mockup: approved\`, but the approved drawing no longer shows what the spec lists: ${drift.join(" ")} ` + (command === "spec" ? `The spec changed after the owner approved the drawing. Set \`mockup: pending\` in the spec; \`/jig mockup\` redraws it for the owner.` : `make builds from a drawing the owner approved of this spec, and this one is of an earlier spec. Stop, and ask for \`/jig mockup\`.`)
+        );
+      }
+    }
+  }
+  if (command === "make") {
+    const found = decisionsFile(root);
+    if (found) {
+      let now = "";
+      try {
+        now = readFileSync32(join39(root, found), "utf8");
+      } catch {
+      }
+      const then = fileAtSessionStart(root, found, start);
+      if (then && now !== then) {
+        problems.push(`${found} changed in a \`make\` session. make carries decisions out; it does not take them. Restore it (\`git checkout -- ${found}\`, or \`git show <commit>:${found}\` if the change is committed), and put what the owner must decide to them: \`/jig decide\`, or \`/jig tweak\` for a small change to a built page.`);
+      }
+    }
+  }
   if (command === "critique") {
     const dir = join39(root, ".jig", "critique");
     const surfaces = existsSync24(dir) ? readdirSync15(dir).filter((s) => existsSync24(join39(dir, s, "screen.json")) || existsSync24(join39(dir, s, "code.json"))) : [];
-    for (const surface of surfaces) {
-      const v = verifyVerdicts({ projectRoot: root, surface });
+    for (const surface2 of surfaces) {
+      const v = verifyVerdicts({ projectRoot: root, surface: surface2 });
       if (v.ok && v.decisions.state !== "ran" && v.decisions.total > 0) {
-        problems.push(`${surface}: ${v.decisions.total - v.decisions.judged} of ${v.decisions.total} decisions in DECISIONS.md have no verdict. A page can satisfy every rule and still break what this project decided.`);
+        problems.push(`${surface2}: ${v.decisions.total - v.decisions.judged} of ${v.decisions.total} decisions in DECISIONS.md have no verdict. A page can satisfy every rule and still break what this project decided.`);
       }
       if (v.ok && v.screen.state === "skipped") {
-        problems.push(`${surface}: the screen pass judged ${v.screen.judged} rules with rendered: false. Those rules are judged on a render \u2014 open the page at 360, 768 and 1280, run \`jig probe\` at each, and judge them there.`);
+        problems.push(`${surface2}: the screen pass judged ${v.screen.judged} rules with rendered: false. Those rules are judged on a render \u2014 open the page at 360, 768 and 1280, run \`jig probe\` at each, and judge them there.`);
       }
     }
     if (surfaces.length === 0) {
@@ -7045,8 +7317,76 @@ function commandProblems(root, command) {
   }
   return problems;
 }
+function tweakProblems(root, spec) {
+  const problems = [];
+  const front = spec.body.split(/^---\s*$/m)[1] ?? "";
+  if (!/^\s*confirmed\s*:\s*true\b/im.test(front)) problems.push(`${spec.path} is not confirmed. A tweak changes a page the owner has confirmed; an unconfirmed spec goes through \`spec\`.`);
+  const mockup = /^\s*mockup\s*:\s*(\S+)/im.exec(front)?.[1] ?? "";
+  if (!/^(approved|skipped)/i.test(mockup)) problems.push(`${spec.path}: \`mockup:\` is ${mockup || "empty"}. A tweak changes a page whose drawing the owner has approved (or skipped); take a new page through \`mockup\` and \`make\`.`);
+  else problems.push(...structureSinceApproval(root, spec, front));
+  const surface = spec.slug;
+  const record = readTweak(join39(root, ".jig", "critique", surface));
+  if (!record) {
+    problems.push(`.jig/critique/${surface}/tweak.json is missing. It names the change in the owner's words (\`change\`), when it was made (\`at\`) and the rule ids and decisions re-judged for it (\`ids\`).`);
+  } else {
+    if (!record.change) problems.push(`.jig/critique/${surface}/tweak.json has no \`change\`: the owner's words for what changed.`);
+    if (!record.ids.length) problems.push(`.jig/critique/${surface}/tweak.json names nothing to re-judge. A change that no rule and no decision could see needs no tweak; name the ones it can.`);
+    const unjudged = unjudgedTweakIds(join39(root, ".jig", "critique", surface), record);
+    if (unjudged.length) {
+      problems.push(
+        `.jig/critique/${surface}: tweak.json names ${unjudged.slice(0, 6).join(", ")}${unjudged.length > 6 ? " and more" : ""} but no verdict for ${unjudged.length === 1 ? "it" : "them"} carries \`"tweak": "${record.at}"\`. Each named verdict is re-judged on the changed page by a reader that did not make the change.`
+      );
+    }
+  }
+  return problems;
+}
+function structureSinceApproval(root, spec, front) {
+  const git = (args) => execFileSync4("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  let baseline;
+  let judged = true;
+  try {
+    baseline = git(["log", "-1", "--format=%H", "--", `.jig/critique/${spec.slug}/${LOCK}`]).trim();
+    if (!baseline) {
+      judged = false;
+      baseline = git(["log", "-1", "--format=%H", "-G", "^mockup[[:space:]]*:", "--", spec.path]).trim();
+    }
+  } catch {
+    return [];
+  }
+  if (!baseline) return [];
+  const when = judged ? `when the last critique judged it (${baseline.slice(0, 7)})` : `when the owner approved the mockup (${baseline.slice(0, 7)})`;
+  const problems = [];
+  let thenBody = "";
+  try {
+    thenBody = git(["show", `${baseline}:./${spec.path}`]);
+  } catch {
+    return [];
+  }
+  const shape = (body) => JSON.stringify(Object.entries(specRegions(body)).sort(([a], [b]) => a.localeCompare(b)).map(([size, regions]) => [size, regions.length, regions.map((r) => r.name ?? "")]));
+  if (shape(thenBody) !== shape(spec.body)) {
+    problems.push(`${spec.path}: the regions under \`sizes:\` differ from the ones the page had ${when}. A change to what the page holds is not a tweak: take it through \`spec\` and \`mockup\`.`);
+  }
+  const at = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "");
+  if (at && !/^https?:/i.test(at) && existsSync24(join39(root, at))) {
+    try {
+      if (git(["show", `${baseline}:./${at}`]) !== readFileSync32(join39(root, at), "utf8")) {
+        problems.push(`${at} has changed since ${when.replace(/^when /, "")}. A tweak leaves the drawing as approved; a change the drawing must show goes through \`mockup\`.`);
+      }
+    } catch {
+    }
+  }
+  return problems;
+}
+function readTweak(dir) {
+  try {
+    const raw = JSON.parse(readFileSync32(join39(dir, "tweak.json"), "utf8"));
+    return { at: String(raw.at ?? ""), change: String(raw.change ?? "").trim(), ids: Array.isArray(raw.ids) ? raw.ids.map(String) : [] };
+  } catch {
+    return void 0;
+  }
+}
 function surfacePage(projectRoot, surface) {
-  const spec = newestSpec(projectRoot);
+  const spec = specFor(projectRoot, surface);
   const front = spec?.body.split(/^---\s*$/m)[1] ?? "";
   const declared = /^\s*surface\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "");
   const candidates = [declared, `${surface}.html`, declared ? `${declared.replace(/^\//, "")}.html` : void 0].filter((c) => !!c && /\.\w+$/.test(c) === (c === declared ? /\.\w+$/.test(c) : true));
@@ -7060,9 +7400,10 @@ function gate(opts) {
   if (!existsSync24(join39(root, "jig.config.json")) && !existsSync24(join39(root, ".jig"))) {
     return { block: false, reason: "" };
   }
-  const command = lastJigCommand(opts.input.transcript_path);
+  const invocation = lastJigInvocation(opts.input.transcript_path);
+  const command = invocation?.command;
   const waiting = command !== void 0 && ASKS_THE_OWNER.has(command) && asksOwner(lastAssistantText(opts.input.transcript_path));
-  const problems = command && !waiting ? commandProblems(root, command).map((p) => `/jig ${command}: ${p}`) : [];
+  const problems = command && !waiting ? commandProblems(root, command, invocation?.surface, sessionStart(opts.input.transcript_path)).map((p) => `/jig ${command}: ${p}`) : [];
   const selection = selectFiles(root, false);
   const changedUi = selection.mode === "changed" && selection.files.some((f) => isStyleBearing(f) || isReaderText(f));
   if (changedUi) {
@@ -7083,10 +7424,10 @@ function gate(opts) {
       );
     }
   }
-  problems.push(...verdictGuard(root, command, surfacesInPlay(root, command, opts.input.transcript_path)));
+  problems.push(...verdictGuard(root, command, surfacesInPlay(root, command, opts.input.transcript_path, invocation?.surface)));
   const critiqueDir = join39(root, ".jig", "critique");
   if (existsSync24(critiqueDir)) {
-    for (const surface of surfacesInPlay(root, command, opts.input.transcript_path)) {
+    for (const surface of surfacesInPlay(root, command, opts.input.transcript_path, invocation?.surface)) {
       const dir = join39(critiqueDir, surface);
       if (!existsSync24(join39(dir, "screen.json")) && !existsSync24(join39(dir, "code.json"))) continue;
       const v = verifyVerdicts({ projectRoot: root, surface });
@@ -7135,6 +7476,28 @@ ${problems.join("\n\n")}`
 }
 var VERDICT_FILES = ["screen.json", "code.json", "decisions.json"];
 var LOCK = "verdicts.lock";
+function verdictDigests(dir) {
+  const out = {};
+  for (const f of VERDICT_FILES) {
+    let file;
+    try {
+      file = JSON.parse(readFileSync32(join39(dir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const v of Array.isArray(file.verdicts) ? file.verdicts : []) {
+      const key = String(v.id ?? v.decision ?? "").trim();
+      if (key) out[`${f}:${key}`] = checksum(JSON.stringify(v));
+    }
+  }
+  return out;
+}
+function writeLock(lockPath, dir, now) {
+  try {
+    writeFileSync6(lockPath, JSON.stringify({ checksum: now, verdicts: verdictDigests(dir) }) + "\n", "utf8");
+  } catch {
+  }
+}
 function verdictChecksum(dir) {
   const parts = VERDICT_FILES.map((f) => {
     try {
@@ -7157,18 +7520,22 @@ function verdictGuard(root, command, inPlay) {
     if (!now) continue;
     const lockPath = join39(dir, LOCK);
     if (command === "critique" && (!inPlay || inPlay.includes(surface))) {
-      try {
-        writeFileSync6(lockPath, JSON.stringify({ checksum: now }) + "\n", "utf8");
-      } catch {
-      }
+      writeLock(lockPath, dir, now);
       continue;
     }
-    let locked;
+    let lock = {};
     try {
-      locked = JSON.parse(readFileSync32(lockPath, "utf8")).checksum;
+      lock = JSON.parse(readFileSync32(lockPath, "utf8"));
     } catch {
       continue;
     }
+    const locked = lock.checksum;
+    if (command === "tweak" && (!inPlay || inPlay.includes(surface)) && locked !== now) {
+      const own = tweakVerdictProblems(dir, surface, lock.verdicts);
+      problems.push(...own);
+      if (own.length === 0) writeLock(lockPath, dir, now);
+      continue;
+    }
     if (locked && locked !== now) {
       problems.push(
         `.jig/critique/${surface}: the verdict files changed after \`/jig critique\` wrote them${command ? `, in a session that ran \`/jig ${command}\`` : ""}. Verdicts are the review's, not the builder's: restore them (\`git checkout -- .jig/critique/${surface}\`) and run \`/jig critique\` to judge the fix.`
@@ -7177,6 +7544,40 @@ function verdictGuard(root, command, inPlay) {
   }
   return problems;
 }
+function tweakVerdictProblems(dir, surface, lockedVerdicts) {
+  const record = readTweak(dir);
+  if (!record) {
+    return [`.jig/critique/${surface}: the verdict files changed in a \`/jig tweak\` session with no tweak.json naming what was re-judged.`];
+  }
+  const problems = [];
+  const named = new Set(record.ids.map((id) => id.toLowerCase()));
+  const nowVerdicts = verdictDigests(dir);
+  if (lockedVerdicts) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(lockedVerdicts), ...Object.keys(nowVerdicts)]);
+    const outside = [...keys].filter((k) => lockedVerdicts[k] !== nowVerdicts[k]).map((k) => k.slice(k.indexOf(":") + 1)).filter((id) => !named.has(id.toLowerCase()));
+    if (outside.length) {
+      problems.push(
+        `.jig/critique/${surface}: a tweak changed verdicts it did not name (${[...new Set(outside)].slice(0, 6).join(", ")}). A tweak re-judges only what its change could affect, listed in tweak.json's \`ids\`; restore the others (\`git checkout -- .jig/critique/${surface}\`).`
+      );
+    }
+  }
+  return problems;
+}
+function unjudgedTweakIds(dir, record) {
+  const stamped = /* @__PURE__ */ new Set();
+  for (const f of VERDICT_FILES) {
+    let file;
+    try {
+      file = JSON.parse(readFileSync32(join39(dir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const v of Array.isArray(file.verdicts) ? file.verdicts : []) {
+      if (record.at && v.tweak === record.at) stamped.add(String(v.id ?? v.decision ?? "").toLowerCase());
+    }
+  }
+  return record.ids.filter((id) => !stamped.has(id.toLowerCase()));
+}
 function save(file, state) {
   try {
     mkdirSync8(join39(file, ".."), { recursive: true });
@@ -7375,19 +7776,42 @@ program.command("update").description("Update vendored Jig rules, skipping files
     );
     for (const f of result.updated) console.log(`  ~ ${f}`);
     for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+    for (const t of result.tokens) {
+      const parts = [t.added.length ? `adds ${t.added.join(", ")}` : "", t.removed.length ? `removes ${t.removed.join(", ")}` : ""].filter(Boolean).join("; ");
+      console.log(t.skipped ? `  ! ${t.file}: this release ${parts}, and did not apply it, because the file is edited locally.` : `  + ${t.file}: ${parts}.`);
+    }
+    if (result.tokens.length) console.log("  Anything that aliases tokens (a Tailwind @theme, a generated utilities file) needs the same change.");
   } catch (err) {
     console.error(err.message);
     process.exit(1);
   }
 });
-program.command("verdicts").description("Verify a critique's verdict files and compute its counts.").argument("<surface>", "the surface slug the critique wrote under .jig/critique/").action((surface) => {
+program.command("verdicts").description("Verify a critique's verdict files and compute its counts.").argument("<surface>", "the surface slug the critique wrote under .jig/critique/").option("--reprobe", "re-take every probe that is missing or was taken on an older version of the page, first (needs a browser)").action(async (surface, opts) => {
   const projectRoot = findProjectRoot(process.cwd());
   try {
+    if (opts.reprobe) {
+      const page = surfacePage(projectRoot, surface) ?? recordedPage(projectRoot, surface);
+      if (!page) console.error(`  \u2717 --reprobe: no probe in .jig/critique/${surface}/ names a page that exists, so there is nothing to render. Run \`jig probe --run <page> --save ${surface}\`.`);
+      else {
+        const { recorded, reason } = await ensureProbes({ projectRoot, surface, page });
+        if (reason) console.error(`  \u2717 --reprobe: ${reason}.`);
+        else if (recorded.length) console.log(`  Re-probed ${page} at ${recorded.join(", ")}px.`);
+        else console.log(`  Every probe is current.`);
+      }
+    }
     const result = verifyVerdicts({ projectRoot, surface });
     for (const error of result.errors) console.error(`  \u2717 ${error}`);
+    if (!opts.reprobe && result.errors.some((e) => /was taken (on|by) an older/.test(e))) {
+      console.error(`  The page changed after these probes. \`jig verdicts ${surface} --reprobe\` re-takes them on the page as it is now.`);
+    }
     if (result.ok) console.log(`  Every rule in both passes has a verdict.`);
     const since = result.decisions.since ?? [];
     if (since.length) console.log(`  ${since.length} decision(s) recorded after this critique, for the next one to judge: ${since.join(", ")}.`);
+    const p = result.previous;
+    if (p) {
+      const list = (ids) => ids.length ? ` (${ids.slice(0, 8).join(", ")}${ids.length > 8 ? ", \u2026" : ""})` : "";
+      console.log(`  Since the critique before this one (${p.commit}): ${p.fixed.length} fixed${list(p.fixed)}, ${p.open.length} still open${list(p.open)}, ${p.ruled.length} ruled by the owner${list(p.ruled)}, ${p.added.length} new${list(p.added)}.`);
+    }
     console.log(`  ${result.line}`);
     process.exit(result.ok ? 0 : 1);
   } catch (err) {
@@ -7485,7 +7909,7 @@ program.command("gate").description("Run by the Claude Code Stop hook: block sto
   try {
     const projectRoot = findProjectRoot(cwd);
     for (const surface of critiquedSurfaces(projectRoot)) {
-      const page = surfacePage(projectRoot, surface);
+      const page = surfacePage(projectRoot, surface) ?? recordedPage(projectRoot, surface);
       if (!page) continue;
       try {
         await ensureProbes({ projectRoot, surface, page });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jig-ui",
-  "version": "0.18.10",
+  "version": "0.20.0",
   "description": "A design system for coding agents. 143 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/01-modes.md

@@ -86,7 +86,7 @@ Resolved values: `02-tokens.md` — the option sets for type, spacing, radius an
 - Every page states its subject above the fold in text, not only in an image.
 - Prose blocks are measure-capped even when the container is wide.
 - No horizontal scrolling regions on mobile. Reflow instead.
-- Total JS budget for a content page: **0 KB** unless a specific feature requires it. Interactivity is opt-in per component and must be justified in a comment. **Keyboard access a rule requires is not a feature and is not counted**: a few lines whose only job is behaviour a rule asks for and the browser does not give, such as `Escape` closing a `<details>` menu (`P-14`), are allowed in every mode, under 1 KB, with the rule named in a comment. Nothing else rides along in them.
+- JavaScript: **none by default.** A content page ships no script unless a feature on it needs some: a theme toggle, a search box, a filter. That is a default, not an absolute zero. Each script names, in a comment, the feature and the decision or rule that asks for it, and a review judges whether the feature needs it and whether it is as small as the feature allows, not whether it exists. What the budget forbids is script no feature asks for: a framework runtime to render static text, a library for one effect, tracking bundled into the page. **Behaviour a rule requires is not a feature and is not counted**: a few lines whose only job is something a rule asks for and the browser does not give, such as `Escape` closing a `<details>` menu, or a tap outside closing a menu in a fixed header (`P-14`), are allowed in every mode, under 1 KB, with the rule named in a comment. Nothing else rides along in them.
 
 ---
 

package/rules/03-patterns.md

@@ -476,11 +476,16 @@ Compose it for the phone first. Mobile navigation is a different control — not
   - Style the mark from that attribute — `[aria-current="page"]` in CSS — not from a separate `.active` or `.current` class. One source for both what is seen and what is announced means the two cannot drift apart; a class alone looks marked and tells a screen reader nothing.
   - The visible cue is not colour alone (`C-20`): weight, an underline or bar, or a filled state. Which one is the project's decision.
   - Inside an open menu, the current item is marked the same way. When the menu is closed nothing in the navigation is visible, so the page's `<h1>` is what tells the reader where they are — every page has one, and it names the page.
-- **It works with no JavaScript** (`F-41`). The links are ordinary links in the page and render visibly by default; script, if there is any, only adds the collapse. In `editorial`, where the script budget is zero (`M-01`), use `<details>` with `<summary>Menu</summary>` — a disclosure the browser provides with no script at all — and the few lines above for `Escape`.
+- **It works with no JavaScript** (`F-41`). The links are ordinary links in the page and render visibly by default; script, if there is any, only adds the collapse. In `editorial`, where a page has no script by default (`M-01`), use `<details>` with `<summary>Menu</summary>` — a disclosure the browser provides with no script at all — and the few lines above for `Escape`.
 - **Never let a row that does not fit scroll sideways.** Its last items go past the edge where nobody sees them (`E-62`), and `editorial` forbids horizontal scrolling on mobile outright. An open menu is a vertical list.
 - **Same destinations, same order, at every width.** The phone may show fewer at once. It never shows different ones, and never reorders them — `product` fixes navigation position across the app (`M-02`), and a reader who learned the order on one screen should not have to relearn it on another.
 - **Every item is at least `--size-touch-target` tall**, made with padding rather than a larger font. The target grows; the text does not.
 - **An open menu does not cover the page unless it has to.** If it does cover the page, it is a dialog and `P-07` applies: focus moves into it, `Escape` closes it, and focus returns to the button. A menu that opens inline needs none of that — but `Escape` still closes it and returns focus to the button.
+- **In a fixed or sticky header, the open menu lies over the page.** It cannot push the page down, so it covers what is under it, and it is still not a dialog: focus is not trapped and the page is not made inert. What it owes the reader instead:
+  - A tap outside the menu closes it, and that tap is spent closing it. It does not also follow the link or press the button that lay under it, so nothing on the page is activated by accident.
+  - A control in the header row itself — the theme toggle, a search button, the site name — works on the first tap: the menu closes and the control does its job. Only a tap on the page below is swallowed.
+  - When the list is taller than the screen below the header, the menu scrolls inside itself, so its last link is reachable without scrolling the page under it.
+  - These need a few lines of script where `<details>` alone is used; they are behaviour this rule requires, counted as `M-01` counts `Escape`.
 - **A sticky header at phone width is one row.** Two sticky rows permanently spend a sixth of a phone's height on chrome.
 - **The wide row appears where the labels fit, not at a device width.** Set the breakpoint from the content — the width at which every destination sits on one line at full touch size — so a longer label moves the breakpoint instead of breaking the row.
 - **`operator`:** the wide screen is the real case. At phone width, one **Menu** button for everything is enough, and keyboard operation of the open menu is mandatory (`M-03`).

package/templates/COMMAND.md.tmpl

@@ -12,7 +12,7 @@ then do the work below for that subcommand. Read the command's full output —
 findings are ordered by severity, not position, so `head`, `tail`, `grep` and
 `jq` drop the ones that matter.
 
-**Agent procedures** — `decide`, `spec`, `mockup`, `make`, `critique`. There is no binary. Do not try to run one:
+**Agent procedures** — `decide`, `spec`, `mockup`, `make`, `critique`, `tweak`. There is no binary. Do not try to run one:
 the section below **is** the command. A CLI can check what these produce; it
 cannot do their work, because the work is judgment and authorship.
 
@@ -26,6 +26,9 @@ spec       what exactly is being built: its smallest useful version, at every sc
 mockup     low-fidelity design of that spec, reviewed before any code
 make       high-fidelity: the actual page or feature, built from the spec & mockup
 critique   scrutinises what was built against the rules, its spec & mockup
+
+tweak      a small change the approved mockup does not show: decided if it is a
+           decision, specced, built, and re-judged where it could matter
 ```
 
 ## init
@@ -461,6 +464,14 @@ spec is not a weaker spec — it is not a spec, and `make` will refuse it.
 If the user changes something, revise and ask again. The run is incomplete until
 they confirm.
 
+**Revising a spec whose drawing was approved.** If the revision adds, removes or
+renames a region at any size, the approved drawing no longer shows the page: set
+`mockup: pending`, and `{{command_prefix}}mockup` redraws it for the owner. The gate
+checks it for a drawing in frames: while `mockup: approved`, each region the spec lists must be labelled in
+its size's frame of the drawing at `mockup_at:`. On jig-site the header spec went
+through five confirmed rounds after its drawing was approved, and still said
+`approved` over a drawing of none of them.
+
 ## mockup
 
 **Low-fidelity design.** Draw the confirmed spec in grayscale, at every size it
@@ -721,6 +732,16 @@ between them yourself.
 
 If `mockup: skipped`, build from the spec alone.
 
+**`make` does not edit `DECISIONS.md`.** The file records what the owner decided,
+and `make` is where decisions are carried out, not taken. When the build shows a
+decision is wrong, missing or in conflict with the spec, stop and say so: the owner
+changes it through `{{command_prefix}}decide`, or `{{command_prefix}}tweak` for a
+small change to a built page. A note that a decision has been carried out belongs in
+the spec, under `deviations:` or its as-built notes, not in the decision. On jig-site
+one make round added a decision and another rewrote one to match the tokens it had
+just switched to; the next critique judged the page against text the build had
+written. The gate stops a `make` session that changed `DECISIONS.md`.
+
 Build V1 only. Nothing in `later:`, however little extra it looks.
 
 Build the **phone** composition first, then add what `tablet` and `desktop`
@@ -874,16 +895,38 @@ A and C are kept apart for a narrower reason: an arm that has seen the render
 stops reading the source and starts confirming the picture. They answer to
 different evidence and must not share it.
 
+**Nor does either arm read the page's history.** Earlier critiques' verdict
+files, their reports, the folders set aside beside them, and the project's git
+log and commit messages all say what a reviewer found before, and an arm that
+has read "the header critique, 17 findings" judges the page it is shown against
+that list. Tell each arm so in its brief: it reads the page, the spec, the
+mockup, `DECISIONS.md` and the corpus, and runs no `git log`, `git show` or
+`git diff`, and opens nothing else under `.jig/critique/`. Which earlier findings
+were fixed is not the arms' question; `verdicts` answers it from git after both
+have written (step 4).
+
 ### 1a. Arms A and C walk the index. They do not search it.
 
 **This is not a style preference. It is the difference between covering the
 corpus and sampling it.**
 
 Load `rules.index.json`, filter to the pass the arm owns, and return a verdict
-for **every id in that list**: `ok`, `finding`, or `n/a` with one line of
-reason. A rule that does not apply is still answered — `n/a, this page has no
+for **every id in that list**: `ok`, `finding`, `ruled`, or `n/a` with one line
+of reason. A rule that does not apply is still answered — `n/a, this page has no
 form` is a verdict.
 
+**`ruled` is a finding the owner has already decided.** The page breaks the rule
+because a decision in `DECISIONS.md` says it should: an icon-only control the
+owner ruled icon-only, a menu the owner put at every phone width. The verdict
+names that decision in `ruling`, exactly as its heading reads, and `verdicts`
+refuses a `ruled` with no ruling or with one the file does not hold. A ruled
+verdict is reported, and counted apart (`ruled=`); it is not a finding, and it
+does not go back to `make`, which could only leave it as it is. On jig-site a
+header critique counted 15 findings, five of them rulings labelled "owner-ruled"
+in prose: every count was inflated, and the real findings were harder to see.
+A rule the page breaks with no decision behind it is a `finding`, however sure
+you are the owner would agree.
+
 Searching the corpus is how a *builder* works, and it is the right method there:
 it finds the rules you can already name. It cannot find the rule for the mistake
 you do not know you are making, which is the only kind of rule worth writing
@@ -945,7 +988,8 @@ Each reader arm writes its own file. The arm reports back only that it wrote it.
   "verdicts": [
     { "id": "D-115", "verdict": "ok", "reason": "no sideways scroll at 360, 768, 1280 or 1600" },
     { "id": "P-14", "verdict": "finding", "reason": "menu button at 360 does not open; aria-expanded never set" },
-    { "id": "A-60", "verdict": "n/a", "reason": "A-60 is about competing icons; this page has none" }
+    { "id": "A-60", "verdict": "n/a", "reason": "A-60 is about competing icons; this page has none" },
+    { "id": "E-51", "verdict": "ruled", "ruling": "The theme toggle is icon-only", "reason": "the toggle shows only a sun or a moon; the owner ruled it icon-only" }
   ]
 }
 ```
@@ -1022,7 +1066,9 @@ was not read, requires `P-14` when the spec has navigation, and refuses
 `rendered: true` without artefacts that exist. It ends with a `JIG_VERDICTS:` line.
 
 When it fails, **re-run the arm it names**. Do not edit the file to make it pass, and
-do not report an incomplete arm as having run. A live Haiku run of this command
+do not report an incomplete arm as having run. If it says the probes were taken
+on an older page, `{{scripts_path}} verdicts <surface> --reprobe` re-takes them
+on the page as it is now. A live Haiku run of this command
 before it existed produced invented rule ids, `screen=ran:1` filed as a review,
 `code=ran:97` against 67, `ran:100` against both, and arms that reported to the
 wrong agent entirely. Every one of those was forbidden here in prose. Prose did not
@@ -1111,6 +1157,17 @@ Say what is right as well as what is wrong — two or three things, and why they
 work. A review that only lists faults tells the reader nothing about what to
 preserve while fixing them.
 
+**Say what happened to the last round's findings.** `verdicts` compares this
+critique with the one before it in git and prints `Since the critique before
+this one: <n> fixed, <n> still open, <n> ruled by the owner, <n> new`, with the
+ids. Put that line in the report, as `verdicts` printed it, above the findings.
+The owner should not have to set two reports side by side to learn whether the
+make round worked. The comparison is made after both arms have written, so it
+tells the arms nothing.
+
+List `ruled` verdicts after the findings, under their own heading, each with the
+decision it cites. They are not findings, and they are not hidden either.
+
 Then the attestation:
 
 ```text
@@ -1166,6 +1223,87 @@ Only then suggest `{{command_prefix}}spec` for the next feature. Starting the ne
 with findings open means the second feature is built on top of the first one's
 problems, and nobody goes back for them.
 
+## tweak
+
+**A small change to a page that is built, reviewed and drawn,** one the owner's
+approved mockup does not show: a word or a sentence, a colour or its contrast, a
+weight, spacing inside a region, how text wraps, a focus ring. One pass does what
+the full loop would: record the decision if there is one, bring the spec in line,
+build it, and re-judge what the change could affect. There is no mockup step,
+because the drawing stays true, and no full critique, because nothing else moved.
+
+### Refuse rather than guess
+
+- **No confirmed spec for the page, or its `mockup:` is still pending** → this is
+  a page being made, not changed. Run `{{command_prefix}}spec`, `mockup` and
+  `make`.
+- **No critique record for the page yet** (`.jig/critique/<surface>/`) → nothing
+  has been judged, so nothing can be re-judged. Run `{{command_prefix}}critique`.
+- **The change adds, removes, reorders or regroups a region, changes the
+  navigation at any size, or would make the drawing wrong** → it is not a tweak.
+  Say so and name the route: `spec`, then `mockup`, then `make`. The gate checks
+  this whatever you decide: the regions under `sizes:` must match the ones the
+  page had at its last critique, and the drawing must be untouched since then.
+  `<surface>` is the spec's file name (`.jig/specs/<surface>.spec.md`), not its
+  `surface:` field.
+- **It is unclear what the owner wants** → ask one question and stop.
+
+### 1. Decide, if it is a decision
+
+If the change is a ruling of the owner's, or changes one already recorded (a
+colour for a mark, how versions are written), record it in `DECISIONS.md` the way
+`decide` does: the owner's words, dated, and what it changes. If the change
+applies a rule, or answers a finding the rules already settle (a word stranded on
+its own line, `B-106`), there is nothing to decide; do not invent a decision.
+
+### 2. Bring the spec in line, if it disagrees
+
+If the spec says something the change contradicts, or the page will no longer
+look as the spec describes, amend those lines and add a dated **Tweak** entry at
+the end quoting the owner. Their instruction is the confirmation; do not ask for
+it again. Leave `sizes:` regions and the mockup as they are.
+
+### 3. Build it
+
+As `make` builds: the project's tokens and components, inside the structure the
+page already has, and only what the change needs. Run `{{scripts_path}} check`,
+then render and record the page (`{{scripts_path}} probe --run`) at every width
+it records.
+
+### 4. Re-judge what the change could affect
+
+Write `.jig/critique/<surface>/tweak.json`:
+
+```json
+{
+  "at": "2026-09-26T14:02:00Z",
+  "change": "the owner's words for the change",
+  "ids": ["A-60", "C-19", "The GitHub link is GitHub's own mark"]
+}
+```
+
+`ids` names every rule and decision the change could move: the ones that judged
+the thing that changed, not the whole index. A colour change names the contrast
+and emphasis rules and the decision it applies; a reworded label names the copy
+rules for labels and the decision about naming.
+
+Then a reader that did not make the change re-judges exactly those. It is a
+subagent, run in the foreground, given the page, the ids and each rule's text,
+and not this conversation or your reasons for the change. For each id it replaces
+that verdict in `screen.json`, `code.json` or `decisions.json` with its own
+verdict and reason, adding `"tweak": "<at>"`. It changes nothing else. Then run
+`{{scripts_path}} verdicts <surface>`.
+
+The gate holds both ends: it refuses a tweak that changed a verdict it did not
+name, and one that named a verdict it did not re-judge.
+
+### Finish
+
+Report what changed, in the owner's words; the decision and spec lines you
+touched, if any; each re-judged verdict and what it says now; and the
+`JIG_CHECK` line. A re-judged verdict that is a finding goes to the owner: it is
+fixed by another tweak, or by `make` if it needs more.
+
 ## probe
 
 Run `{{scripts_path}} probe`. It prints one JavaScript expression — the render probe —
@@ -1391,9 +1529,10 @@ The accent appears as a whole field or not at all. A full-bleed section, a solid
 button, a filled active state — never a 2px underline, never a small icon tint,
 never a gradient stop. Its authority comes from arriving in quantity, rarely.
 
-**Why:** thinly spread, it reads as decoration and stops meaning anything. The
-audit test: if a coloured element is smaller than a section band, it is probably
-wrong.
+**Why:** "Thinly spread, it reads as decoration and stops meaning anything."
+
+**Why (inferred):** the audit test that follows from it: if a coloured element is
+smaller than a section band, it is probably wrong.
 ```
 
 A name gives the team something to cite in review. A reason lets a future agent
@@ -1408,23 +1547,30 @@ the same shape and judged against every page:
 A reader leaves knowing which plan fits them and which limit they would hit
 first. Nothing else on the page outranks that.
 
-**Why:** they arrive from the product page already interested; the job is to
-remove the last doubt, not to sell again.
+**Why:** "They arrive from the product page already interested. The job is to
+remove the last doubt, not to sell again."
 
 ### When two options conflict
 
 Comprehension wins over persuasion. If a clearer page converts worse, we ship
 the clearer page.
 
-**Why:** the reader is an engineer who has been sold to badly before, and the
-support cost of a wrong-plan signup outweighs the signup.
+**Why:** "Our reader is an engineer who has been sold to badly before, and a
+wrong-plan signup costs more in support than it brings in."
 ```
 
-**The reason is the owner's, or it is not written.** Write the `Why:` the user gave,
-in their words or close to them. If they gave none, ask for it. If they still give
-none, write `**Why:** not given` — never a reason you supplied. A live run invented
-reasons for two real reversals; an invented reason is worse than none, because the
-next agent weighs it as the team's and applies the rule where the team never would.
+**The reason is the owner's, in quotation marks, or it is not written as theirs.**
+`**Why:**` holds the words the user gave, quoted. If they gave none, ask for it. If
+they still give none, write `**Why:** not given`. A live run invented reasons for
+two real reversals; an invented reason is worse than none, because the next agent
+weighs it as the team's and applies the rule where the team never would.
+
+What you add to explain a reason, work out from it, or carry over from what the
+owner said elsewhere goes in its own paragraph, `**Why (inferred):**`, which says it
+is yours. On jig-site, reasons read "given directly by the owner", followed by
+sentences the agent had written; a later agent could not tell which half to weigh
+as the team's. The gate checks each decision this session wrote or changed: its
+`Why` is quoted, `not given`, or labelled inferred.
 
 **Record what is still open in its own section, at the end:**
 
@@ -1449,7 +1595,8 @@ round by round, and the section of the file it went to — a named decision, its
 `Why:`, or **Unresolved**. An answer that went nowhere is either added or shown to
 the user as left out on purpose, with the reason. Then go the other way: every
 `Why:` in the file must trace to something the user said; delete any that does not,
-and ask. Include this mapping in your message, below the file.
+and ask. A `Why (inferred):` traces to what it was inferred from; say what that was.
+Include this mapping in your message, below the file.
 
 Show it and ask the user to confirm it is right before you stop. Leave no
 `[TODO]` markers — the gate treats them as an unwritten file, correctly, because

package/templates/command-metadata.json

@@ -68,5 +68,10 @@
     "description": "Scrutinise what was built against the rules, its spec and its mockup: render it, judge what check cannot, and report by rule id. Needs DECISIONS.md. No CLI — the agent does this.",
     "argumentHint": "<page, feature or functionality, in your own words>",
     "status": "agent"
+  },
+  "tweak": {
+    "description": "A small change to a built page that its approved mockup does not show (wording, a colour, a weight, spacing inside a region, wrapping): records the decision if it is one, brings the spec in line, builds it, and re-judges only the verdicts the change could affect. Refuses a change that moves the page's structure. No CLI — the agent does this.",
+    "argumentHint": "<the change, in your own words>",
+    "status": "agent"
   }
 }