jig-ui 0.23.0 → 0.24.0

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync36 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join43 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync37 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join44 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -55,8 +55,8 @@ function cliInvocation(version2) {
 var JIG_GATE_HOOK = /(?:\bjig-ui@[^\s"]+|^jig) gate\b/;
 
 // src/commands/install.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } 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), make a small change to a built page (tweak), check the UI against the rules, or refresh the install.";
@@ -88,6 +88,236 @@ function agentsPointer(skillPath) {
   ].join("\n");
 }
 
+// src/install/agent-files.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join4 } from "path";
+
+// src/text.ts
+import { readFileSync } from "fs";
+function lf(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function readText(path) {
+  return lf(readFileSync(path, "utf8"));
+}
+
+// src/install/atomic.ts
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+function writeFileAtomic(path, content) {
+  const dir = dirname2(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join2(dir, `.${process.pid}-${Date.now()}.tmp`);
+  try {
+    writeFileSync(tmp, content, "utf8");
+    renameWithRetry(tmp, path);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function renameWithRetry(from, to) {
+  const retryable = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+  for (let waited = 0, delay = 10; ; waited += delay, delay = Math.min(delay * 2, 200)) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (err) {
+      const code = err.code ?? "";
+      if (process.platform !== "win32" || !retryable.has(code) || waited > 2e3) throw err;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+    }
+  }
+}
+
+// src/install/vendor.ts
+import { posix } from "path";
+var { join: join3 } = posix;
+var DELIMITERS = {
+  html: ["<!--", "-->"],
+  css: ["/*", "*/"]
+};
+function licencePathFor(relPath) {
+  const depth = relPath.split("/").length - 1;
+  return depth === 0 ? "." : Array(depth).fill("..").join("/");
+}
+function vendorHeader(file, version2, style = "html", licencePath = ".") {
+  const [open, close] = DELIMITERS[style];
+  const attribution = licencePath === null ? "     Licensed Apache-2.0. LICENSE and NOTICE ship beside the jig skill." : `     Licensed Apache-2.0. See ${join3(licencePath, "LICENSE")} and ${join3(licencePath, "NOTICE")}.`;
+  return [
+    `${open} ${file} \u2014 vendored from Jig v${version2}.`,
+    attribution,
+    `     Edit freely: \`jig update\` will not overwrite a file you have changed. ${close}`,
+    "",
+    ""
+  ].join("\n");
+}
+function findMarkerRegions(existing) {
+  const regions = [];
+  let searchFrom = 0;
+  let openStart = null;
+  while (true) {
+    const nextStart = existing.indexOf(BLOCK_START, searchFrom);
+    const nextEnd = existing.indexOf(BLOCK_END, searchFrom);
+    if (nextStart === -1 && nextEnd === -1) break;
+    const endIsNext = nextEnd !== -1 && (nextStart === -1 || nextEnd < nextStart);
+    if (endIsNext) {
+      if (openStart !== null) {
+        regions.push({ start: openStart, end: nextEnd + BLOCK_END.length });
+        openStart = null;
+      } else {
+        regions.push({ start: nextEnd, end: nextEnd + BLOCK_END.length });
+      }
+      searchFrom = nextEnd + BLOCK_END.length;
+    } else {
+      if (openStart !== null) {
+        regions.push({ start: openStart, end: openStart + BLOCK_START.length });
+      }
+      openStart = nextStart;
+      searchFrom = nextStart + BLOCK_START.length;
+    }
+  }
+  if (openStart !== null) {
+    regions.push({ start: openStart, end: existing.length });
+  }
+  regions.sort((a, b) => a.start - b.start);
+  return regions;
+}
+function stripMarkerRegions(existing) {
+  const regions = findMarkerRegions(existing);
+  if (regions.length === 0) {
+    return { text: existing, insertAt: existing.length, removed: false };
+  }
+  let text = "";
+  let cursor = 0;
+  let insertAt = -1;
+  regions.forEach((region, i) => {
+    let chunk = existing.slice(cursor, region.start);
+    if (i > 0) chunk = chunk.replace(/^\n/, "");
+    text += chunk;
+    if (insertAt === -1) insertAt = text.length;
+    cursor = region.end;
+  });
+  const tail = existing.slice(cursor).replace(/^\n/, "");
+  text += tail;
+  return { text, insertAt, removed: true };
+}
+function upsertBlock(existing, block) {
+  const { text, insertAt, removed } = stripMarkerRegions(existing);
+  if (!removed) {
+    const separator = text.length && !text.endsWith("\n") ? "\n\n" : text.length ? "\n" : "";
+    return `${text}${separator}${block}`;
+  }
+  return `${text.slice(0, insertAt)}${block}${text.slice(insertAt)}`;
+}
+
+// src/install/agent-files.ts
+var AGENTS_FILE = "AGENTS.md";
+var CLAUDE_FILE = "CLAUDE.md";
+function agentsGuide() {
+  return [
+    BLOCK_START,
+    "",
+    "# Jig: the design system for this project's UI",
+    "",
+    "Before building or reviewing any interface, load the Jig skill and follow it:",
+    "`.agents/skills/jig/SKILL.md`, or `skills/jig/SKILL.md` in your agent's own",
+    "folder (`.claude/skills/jig/SKILL.md` for Claude Code). It says which rule",
+    "files to load for the task.",
+    "",
+    "## How work goes",
+    "",
+    "- `/jig decide`, once: the project's design decisions, from the owner.",
+    "- For each page or feature: `/jig spec`, then `/jig mockup` (or skip it), then",
+    "  `/jig make`, then `/jig critique` (now, or left for `/jig ship`).",
+    "- A small change to a built page: `/jig tweak`.",
+    "- Before a release: `/jig ship`.",
+    "- After any change to UI files: `jig check`.",
+    "",
+    'With no slash commands, ask in plain words: "run jig spec for the pricing page".',
+    "",
+    "## The owner's word",
+    "",
+    "A spec confirmed, a drawing approved or skipped, a critique left for later, a",
+    "decision's reason: each is recorded in the owner's own words. Never infer one",
+    "from something else they said; ask.",
+    "",
+    "## Jig's files",
+    "",
+    "- `jig.config.json`: the mode each route uses, files `check` skips (`exempt`),",
+    "  and when pages are critiqued.",
+    "- The token folder: `brand.*.css` is the project's identity, edit it freely;",
+    "  `mode.*.css` is Jig's, refreshed by `jig update`; `theme.css` imports both.",
+    "- `DECISIONS.md`, beside the tokens: the project's decisions, written by",
+    "  `/jig decide` and `/jig tweak` only.",
+    "- `.jig/specs/`: what each page must be; `<name>.checked.json` is its check.",
+    "- `.jig/mockups/`: approved drawings.",
+    "- `.jig/critique/<page>/`: a critique's verdicts, its report and its lock.",
+    "- `.jig/state.json`: what Jig wrote, so `jig update` leaves your edits alone.",
+    "",
+    "Jig keeps this block current. Write your own instructions above or below it.",
+    "",
+    BLOCK_END,
+    ""
+  ].join("\n");
+}
+function claudeImport() {
+  return [
+    BLOCK_START,
+    "",
+    "Jig's instructions for this project are in AGENTS.md, imported here:",
+    "",
+    `@${AGENTS_FILE}`,
+    "",
+    BLOCK_END,
+    ""
+  ].join("\n");
+}
+function claudeInstalled(projectRoot, homeDir = homedir()) {
+  return existsSync2(join4(projectRoot, ".claude", "skills", "jig", "SKILL.md")) || existsSync2(join4(homeDir, ".claude", "skills", "jig", "SKILL.md"));
+}
+function blockIn(text) {
+  const t = lf(text);
+  const start = t.indexOf(BLOCK_START);
+  const end = t.indexOf(BLOCK_END, start);
+  return start >= 0 && end > start ? t.slice(start, end + BLOCK_END.length) : void 0;
+}
+var expected = (block) => block.trim();
+function ensureAgentFiles(projectRoot, opts) {
+  const wanted = [[AGENTS_FILE, agentsGuide()]];
+  if (opts.claude) wanted.push([CLAUDE_FILE, claudeImport()]);
+  const written = [];
+  for (const [file, block] of wanted) {
+    const path = join4(projectRoot, file);
+    const before = existsSync2(path) ? readFileSync2(path, "utf8") : "";
+    if (blockIn(before) === expected(block)) continue;
+    writeFileAtomic(path, upsertBlock(before, block));
+    written.push(file);
+  }
+  return written;
+}
+function agentFileProblems(projectRoot, homeDir = homedir()) {
+  if (!existsSync2(join4(projectRoot, ".jig", "state.json"))) return [];
+  const wanted = [[AGENTS_FILE, agentsGuide()]];
+  if (claudeInstalled(projectRoot, homeDir)) wanted.push([CLAUDE_FILE, claudeImport()]);
+  const problems = [];
+  for (const [file, block] of wanted) {
+    const path = join4(projectRoot, file);
+    if (!existsSync2(path)) {
+      problems.push(`${file} is missing, so an agent starts without Jig's instructions.`);
+      continue;
+    }
+    const found = blockIn(readFileSync2(path, "utf8"));
+    if (!found) problems.push(`${file} has no Jig block, so an agent starts without Jig's instructions.`);
+    else if (found !== expected(block)) problems.push(`${file}: Jig's block has been edited or is out of date.`);
+  }
+  return problems.map((p) => `${p} Run \`jig update\` to put it back; your own text in the file stays as it is.`);
+}
+
 // src/adapters/codex.ts
 var codex = {
   name: "codex",
@@ -96,7 +326,7 @@ var codex = {
     const skillPath = ".agents/skills/jig/SKILL.md";
     const files = [{ relPath: skillPath, content: ctx.skillBody }];
     const agentsPath = ctx.scope === "global" ? ".codex/AGENTS.md" : "AGENTS.md";
-    files.push({ relPath: agentsPath, content: agentsPointer(skillPath) });
+    files.push({ relPath: agentsPath, content: ctx.scope === "global" ? agentsPointer(skillPath) : agentsGuide() });
     if (ctx.commandBody && ctx.scope === "global") {
       files.push({ relPath: ".codex/prompts/jig.md", content: `${ctx.commandBody}
 ` });
@@ -258,22 +488,22 @@ function skillFilesFor(adapter, ctx) {
 }
 
 // src/install/references.ts
-import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
-import { join as join2, posix } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { join as join5, posix as posix2 } from "path";
 function referenceFiles(packageRoot2) {
-  const root = join2(packageRoot2, "references");
-  if (!existsSync2(root)) return [];
+  const root = join5(packageRoot2, "references");
+  if (!existsSync3(root)) return [];
   const found = [];
   const walk2 = (dir, prefix) => {
     for (const entry of readdirSync(dir, { withFileTypes: true }).sort(
       (a, b) => a.name.localeCompare(b.name)
     )) {
-      const child = join2(dir, entry.name);
-      const rel = prefix ? posix.join(prefix, entry.name) : entry.name;
+      const child = join5(dir, entry.name);
+      const rel = prefix ? posix2.join(prefix, entry.name) : entry.name;
       if (entry.isDirectory()) {
         walk2(child, rel);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        found.push({ relPath: rel, content: readFileSync(child, "utf8") });
+        found.push({ relPath: rel, content: readFileSync3(child, "utf8") });
       }
     }
   };
@@ -283,32 +513,11 @@ function referenceFiles(packageRoot2) {
 
 // src/install/manifest.ts
 import { createHash } from "crypto";
-import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, statSync, unlinkSync as unlinkSync2, writeSync } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-
-// src/install/atomic.ts
-import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-function writeFileAtomic(path, content) {
-  const dir = dirname2(path);
-  mkdirSync(dir, { recursive: true });
-  const tmp = join3(dir, `.${process.pid}-${Date.now()}.tmp`);
-  try {
-    writeFileSync(tmp, content, "utf8");
-    renameSync(tmp, path);
-  } catch (err) {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    throw err;
-  }
-}
-
-// src/install/manifest.ts
+import { closeSync, existsSync as existsSync4, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync4, statSync, unlinkSync as unlinkSync2, writeSync } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
 var REGENERATE_HINT = "Re-run 'jig install --agent <name>' to fix it.";
 function manifestPath(root, manifestDir) {
-  return join4(root, ...manifestDir.split("/"), "manifest.json");
+  return join6(root, ...manifestDir.split("/"), "manifest.json");
 }
 function checksum(content) {
   const normalized = content.replace(/\r\n/g, "\n");
@@ -346,10 +555,10 @@ function validateManifest(raw, path) {
 }
 function readManifest(root, manifestDir = ".jig") {
   const path = manifestPath(root, manifestDir);
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync2(path, "utf8"));
+    raw = JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     throw new Error(`Jig's manifest at ${path} is not valid JSON. ${REGENERATE_HINT}`);
   }
@@ -379,12 +588,9 @@ function withLock(lock, fn) {
       }
       break;
     } catch (err) {
-      if (err.code !== "EEXIST") throw err;
+      if (!BUSY.has(err.code ?? "")) throw err;
       if (lockIsStale(lock) || Date.now() > deadline) {
-        try {
-          unlinkSync2(lock);
-        } catch {
-        }
+        unlinkRetrying(lock);
         continue;
       }
       sleep(10 + Math.random() * 20);
@@ -393,15 +599,25 @@ function withLock(lock, fn) {
   try {
     fn();
   } finally {
+    unlinkRetrying(lock);
+  }
+}
+var BUSY = /* @__PURE__ */ new Set(["EEXIST", "EPERM", "EACCES", "EBUSY"]);
+function unlinkRetrying(lock) {
+  for (let attempt = 0; attempt < 20; attempt++) {
     try {
       unlinkSync2(lock);
-    } catch {
+      return;
+    } catch (err) {
+      const code = err.code ?? "";
+      if (code === "ENOENT" || !BUSY.has(code)) return;
+      sleep(5 + attempt * 5);
     }
   }
 }
 function lockIsStale(lock) {
   try {
-    const [pid, at] = readFileSync2(lock, "utf8").trim().split(/\s+/).map(Number);
+    const [pid, at] = readFileSync4(lock, "utf8").trim().split(/\s+/).map(Number);
     if (at && Date.now() - at > LOCK_STALE_MS) return true;
     if (pid && pid !== process.pid) {
       try {
@@ -421,7 +637,7 @@ function sleep(ms) {
 }
 function readManifestQuietly(path) {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (!isPlainObject(parsed) || !isPlainObject(parsed.files)) return null;
     return parsed;
   } catch {
@@ -431,9 +647,9 @@ function readManifestQuietly(path) {
 function isModified(projectRoot, relPath, m) {
   const recorded = m.files[relPath];
   if (!recorded) return false;
-  const abs = join4(projectRoot, relPath);
-  if (!existsSync3(abs)) return false;
-  return checksum(readFileSync2(abs, "utf8")) !== recorded;
+  const abs = join6(projectRoot, relPath);
+  if (!existsSync4(abs)) return false;
+  return checksum(readFileSync4(abs, "utf8")) !== recorded;
 }
 
 // src/template/render.ts
@@ -460,97 +676,16 @@ function renderCommandTable(metadata2) {
   return ["| Command | Description | Status |", "| --- | --- | --- |", ...rows].join("\n");
 }
 
-// src/install/vendor.ts
-import { posix as posix2 } from "path";
-var { join: join5 } = posix2;
-var DELIMITERS = {
-  html: ["<!--", "-->"],
-  css: ["/*", "*/"]
-};
-function licencePathFor(relPath) {
-  const depth = relPath.split("/").length - 1;
-  return depth === 0 ? "." : Array(depth).fill("..").join("/");
-}
-function vendorHeader(file, version2, style = "html", licencePath = ".") {
-  const [open, close] = DELIMITERS[style];
-  const attribution = licencePath === null ? "     Licensed Apache-2.0. LICENSE and NOTICE ship beside the jig skill." : `     Licensed Apache-2.0. See ${join5(licencePath, "LICENSE")} and ${join5(licencePath, "NOTICE")}.`;
-  return [
-    `${open} ${file} \u2014 vendored from Jig v${version2}.`,
-    attribution,
-    `     Edit freely: \`jig update\` will not overwrite a file you have changed. ${close}`,
-    "",
-    ""
-  ].join("\n");
-}
-function findMarkerRegions(existing) {
-  const regions = [];
-  let searchFrom = 0;
-  let openStart = null;
-  while (true) {
-    const nextStart = existing.indexOf(BLOCK_START, searchFrom);
-    const nextEnd = existing.indexOf(BLOCK_END, searchFrom);
-    if (nextStart === -1 && nextEnd === -1) break;
-    const endIsNext = nextEnd !== -1 && (nextStart === -1 || nextEnd < nextStart);
-    if (endIsNext) {
-      if (openStart !== null) {
-        regions.push({ start: openStart, end: nextEnd + BLOCK_END.length });
-        openStart = null;
-      } else {
-        regions.push({ start: nextEnd, end: nextEnd + BLOCK_END.length });
-      }
-      searchFrom = nextEnd + BLOCK_END.length;
-    } else {
-      if (openStart !== null) {
-        regions.push({ start: openStart, end: openStart + BLOCK_START.length });
-      }
-      openStart = nextStart;
-      searchFrom = nextStart + BLOCK_START.length;
-    }
-  }
-  if (openStart !== null) {
-    regions.push({ start: openStart, end: existing.length });
-  }
-  regions.sort((a, b) => a.start - b.start);
-  return regions;
-}
-function stripMarkerRegions(existing) {
-  const regions = findMarkerRegions(existing);
-  if (regions.length === 0) {
-    return { text: existing, insertAt: existing.length, removed: false };
-  }
-  let text = "";
-  let cursor = 0;
-  let insertAt = -1;
-  regions.forEach((region, i) => {
-    let chunk = existing.slice(cursor, region.start);
-    if (i > 0) chunk = chunk.replace(/^\n/, "");
-    text += chunk;
-    if (insertAt === -1) insertAt = text.length;
-    cursor = region.end;
-  });
-  const tail = existing.slice(cursor).replace(/^\n/, "");
-  text += tail;
-  return { text, insertAt, removed: true };
-}
-function upsertBlock(existing, block) {
-  const { text, insertAt, removed } = stripMarkerRegions(existing);
-  if (!removed) {
-    const separator = text.length && !text.endsWith("\n") ? "\n\n" : text.length ? "\n" : "";
-    return `${text}${separator}${block}`;
-  }
-  return `${text.slice(0, insertAt)}${block}${text.slice(insertAt)}`;
-}
-
 // src/install/writer.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
 
 // src/install/line-endings.ts
 function dominantEnding(existing) {
   const crlf = (existing.match(/\r\n/g) ?? []).length;
-  const lf = (existing.match(/(?<!\r)\n/g) ?? []).length;
-  if (crlf === 0 && lf === 0) return "\n";
-  return crlf >= lf ? "\r\n" : "\n";
+  const lf5 = (existing.match(/(?<!\r)\n/g) ?? []).length;
+  if (crlf === 0 && lf5 === 0) return "\n";
+  return crlf >= lf5 ? "\r\n" : "\n";
 }
 function matchLineEndings(content, existing) {
   const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -567,9 +702,9 @@ function createWriter(root, seed = {}) {
   return {
     files,
     write(key, content) {
-      const abs = join6(root, ...key.split("/"));
+      const abs = join7(root, ...key.split("/"));
       mkdirSync3(dirname4(abs), { recursive: true });
-      const existing = existsSync4(abs) ? readFileSync3(abs, "utf8") : void 0;
+      const existing = existsSync5(abs) ? readFileSync5(abs, "utf8") : void 0;
       const toWrite = matchLineEndings(content, existing);
       writeFileAtomic(abs, toWrite);
       files[key] = checksum(toWrite);
@@ -579,15 +714,15 @@ function createWriter(root, seed = {}) {
 }
 function bundleFiles(packageRoot2, dir) {
   const ext = dir === "rules" ? ".md" : ".css";
-  return readdirSync2(join6(packageRoot2, dir)).filter((f) => f.endsWith(ext)).sort();
+  return readdirSync2(join7(packageRoot2, dir)).filter((f) => f.endsWith(ext)).sort();
 }
 
 // src/commands/install.ts
 var ASK_INSTRUCTION = "Ask the user directly in chat, one question at a time, and wait for an answer before continuing.";
 function buildSkillBody(packageRoot2, rulesPath, version2) {
-  const template = readFileSync4(join7(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
+  const template = readFileSync6(join8(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
   const metadata2 = JSON.parse(
-    readFileSync4(join7(packageRoot2, "templates", "command-metadata.json"), "utf8")
+    readFileSync6(join8(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
   return render(template, {
     command_prefix: "/jig ",
@@ -604,12 +739,12 @@ function buildSkillBody(packageRoot2, rulesPath, version2) {
 }
 function buildCommandBody(packageRoot2, rulesPath, version2, argsPlaceholder) {
   const metadata2 = JSON.parse(
-    readFileSync4(join7(packageRoot2, "templates", "command-metadata.json"), "utf8")
+    readFileSync6(join8(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
   const subcommands = Object.entries(metadata2).filter(([, meta]) => meta.status === "available" || meta.status === "agent").map(([name]) => name).sort();
-  const templatePath = join7(packageRoot2, "templates", "COMMAND.md.tmpl");
-  if (!existsSync5(templatePath)) return { body: "", subcommands };
-  const template = readFileSync4(templatePath, "utf8");
+  const templatePath = join8(packageRoot2, "templates", "COMMAND.md.tmpl");
+  if (!existsSync6(templatePath)) return { body: "", subcommands };
+  const template = readFileSync6(templatePath, "utf8");
   const body = template.replace(/\{\{command_prefix\}\}/g, "/jig ").replace(/\{\{args_placeholder\}\}/g, argsPlaceholder).replace(/\{\{subcommand_list\}\}/g, subcommands.join(", ")).replace(/\{\{scripts_path\}\}/g, cliInvocation(version2)).replace(/\{\{update_path\}\}/g, "npx jig-ui@latest").replace(/\{\{rules_path\}\}/g, rulesPath).replace(/\{\{config_file\}\}/g, "jig.config.json");
   const unresolved = [...new Set(body.match(/\{\{[a-z_]+\}\}/g) ?? [])];
   if (unresolved.length > 0) {
@@ -637,6 +772,7 @@ function install(opts) {
         written: [],
         skipped: [],
         stopHook: installStopHook(opts.projectRoot, opts.version),
+        agentFiles: ensureAgentFiles(opts.projectRoot, { claude: true }),
         hookOnly: `Jig's skill is installed globally for 'claude' (${globalReferenceDir} under your home directory), so it stays there. Added only this project's Stop hook.`
       };
     }
@@ -657,9 +793,9 @@ function install(opts) {
     existingManifest = null;
   }
   const planned = [];
-  const rulesDir = join7(opts.packageRoot, "rules");
+  const rulesDir = join8(opts.packageRoot, "rules");
   for (const file of bundleFiles(opts.packageRoot, "rules")) {
-    const body = readFileSync4(join7(rulesDir, file), "utf8");
+    const body = readFileSync6(join8(rulesDir, file), "utf8");
     planned.push({
       key: relKey(referenceDir, "rules", file),
       content: vendorHeader(file, opts.version, "html", licencePathFor(`rules/${file}`)) + body,
@@ -675,13 +811,13 @@ function install(opts) {
   }
   planned.push({
     key: relKey(referenceDir, "rules.index.json"),
-    content: readFileSync4(join7(opts.packageRoot, "rules.index.json"), "utf8"),
+    content: readFileSync6(join8(opts.packageRoot, "rules.index.json"), "utf8"),
     checkable: true
   });
   for (const src of ["LICENSE", "NOTICE"]) {
     planned.push({
       key: relKey(referenceDir, src),
-      content: readFileSync4(join7(opts.packageRoot, src), "utf8"),
+      content: readFileSync6(join8(opts.packageRoot, src), "utf8"),
       checkable: false
     });
   }
@@ -703,9 +839,9 @@ function install(opts) {
   });
   for (const file of skillFiles) {
     const key = file.relPath;
-    const abs = join7(installRoot, ...key.split("/"));
+    const abs = join8(installRoot, ...key.split("/"));
     const isBlockFile = file.content.includes(BLOCK_START);
-    const content = isBlockFile && existsSync5(abs) ? upsertBlock(readFileSync4(abs, "utf8"), file.content) : file.content;
+    const content = isBlockFile && existsSync6(abs) ? upsertBlock(readFileSync6(abs, "utf8"), file.content) : file.content;
     planned.push({ key, content, checkable: !isBlockFile });
   }
   const writer = createWriter(installRoot);
@@ -732,11 +868,12 @@ function install(opts) {
   writeManifest(installRoot, manifest, referenceDir);
   written.push(relKey(referenceDir, "manifest.json"));
   const stopHook = opts.hook && opts.agent === "claude" && opts.scope === "project" ? installStopHook(installRoot, opts.version) : void 0;
-  return { written, skipped, stopHook };
+  const agentFiles = opts.scope === "project" ? ensureAgentFiles(opts.projectRoot, { claude: opts.agent === "claude" || claudeInstalled(opts.projectRoot, opts.homeDir) }) : [];
+  return { written, skipped, stopHook, agentFiles };
 }
 function hasStopHook(projectRoot) {
   try {
-    const settings = readFileSync4(join7(projectRoot, ".claude", "settings.json"), "utf8");
+    const settings = readFileSync6(join8(projectRoot, ".claude", "settings.json"), "utf8");
     const hooks = JSON.parse(settings).hooks?.Stop ?? [];
     return hooks.some((group) => (group.hooks ?? []).some((h) => JIG_GATE_HOOK.test(h.command ?? "")));
   } catch {
@@ -744,11 +881,11 @@ function hasStopHook(projectRoot) {
   }
 }
 function installStopHook(projectRoot, version2) {
-  const path = join7(projectRoot, ".claude", "settings.json");
+  const path = join8(projectRoot, ".claude", "settings.json");
   let settings = {};
-  if (existsSync5(path)) {
+  if (existsSync6(path)) {
     try {
-      settings = JSON.parse(readFileSync4(path, "utf8"));
+      settings = JSON.parse(readFileSync6(path, "utf8"));
     } catch {
       return false;
     }
@@ -759,14 +896,14 @@ function installStopHook(projectRoot, version2) {
   const stop = (hooks.Stop ?? []).map((group) => ({ ...group, hooks: group.hooks.filter((h) => !isJig(h)) })).filter((group) => group.hooks.length > 0);
   stop.push({ hooks: [{ type: "command", command }] });
   settings.hooks = { ...hooks, Stop: stop };
-  mkdirSync4(join7(projectRoot, ".claude"), { recursive: true });
+  mkdirSync4(join8(projectRoot, ".claude"), { recursive: true });
   writeFileSync2(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
   return true;
 }
 
 // src/commands/update.ts
-import { join as join10 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 
 // src/install/target.ts
 import { resolve } from "path";
@@ -809,14 +946,14 @@ function resolveAllInstalled(projectRoot, homeDir) {
 }
 
 // src/init/state.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
-var INIT_MANIFEST_REL = join8(".jig", "state.json");
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname5, join as join9 } from "path";
+var INIT_MANIFEST_REL = join9(".jig", "state.json");
 function readInitManifest(projectRoot) {
-  const path = join8(projectRoot, INIT_MANIFEST_REL);
-  if (!existsSync6(path)) return null;
+  const path = join9(projectRoot, INIT_MANIFEST_REL);
+  if (!existsSync7(path)) return null;
   try {
-    const raw = JSON.parse(readFileSync5(path, "utf8"));
+    const raw = JSON.parse(readFileSync7(path, "utf8"));
     if (typeof raw !== "object" || raw === null) return null;
     const { files, version: version2, modes } = raw;
     if (typeof files !== "object" || files === null) return null;
@@ -831,7 +968,7 @@ function readInitManifest(projectRoot) {
 }
 var MERGE_ATTEMPTS = 5;
 function writeInitManifest(projectRoot, m) {
-  const path = join8(projectRoot, INIT_MANIFEST_REL);
+  const path = join9(projectRoot, INIT_MANIFEST_REL);
   mkdirSync5(dirname5(path), { recursive: true });
   for (let attempt = 0; attempt < MERGE_ATTEMPTS; attempt++) {
     const onDisk = readInitManifest(projectRoot);
@@ -852,15 +989,15 @@ function isInitFileModified(projectRoot, relPath, m) {
 }
 
 // src/init/migrate.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync3, rmSync } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync8, readdirSync as readdirSync3, rmSync } from "fs";
+import { join as join10 } from "path";
 var LEGACY_RULE_RE = /^\d{2}-.*\.md$/;
 function isLegacyInstallArtifact(name) {
   return LEGACY_RULE_RE.test(name) || name === "rules.index.json" || name === "LICENSE" || name === "NOTICE" || name === "manifest.json";
 }
 function readLegacyManifest(dirAbs) {
   try {
-    const raw = JSON.parse(readFileSync6(join9(dirAbs, "manifest.json"), "utf8"));
+    const raw = JSON.parse(readFileSync8(join10(dirAbs, "manifest.json"), "utf8"));
     if (raw && typeof raw === "object" && typeof raw.files === "object") {
       return raw;
     }
@@ -872,8 +1009,8 @@ function classify(projectRoot, relPath, legacyManifest) {
   return legacyManifest && relPath in legacyManifest.files ? isModified(projectRoot, relPath, legacyManifest) : "unknown";
 }
 function detectLegacyRules(projectRoot) {
-  const jigDir = join9(projectRoot, ".jig");
-  if (!existsSync7(jigDir)) return { present: false, files: [] };
+  const jigDir = join10(projectRoot, ".jig");
+  if (!existsSync8(jigDir)) return { present: false, files: [] };
   const legacyManifest = readLegacyManifest(jigDir);
   let entries;
   try {
@@ -889,12 +1026,12 @@ function detectLegacyRules(projectRoot) {
 }
 function detectLegacyCursorRules(projectRoot) {
   const bundleDirRel = ".cursor/rules/jig";
-  const bundleDir = join9(projectRoot, ...bundleDirRel.split("/"));
+  const bundleDir = join10(projectRoot, ...bundleDirRel.split("/"));
   const mdcRel = ".cursor/rules/jig.mdc";
-  const mdcAbs = join9(projectRoot, ...mdcRel.split("/"));
+  const mdcAbs = join10(projectRoot, ...mdcRel.split("/"));
   const legacyManifest = readLegacyManifest(bundleDir);
   const files = [];
-  if (existsSync7(mdcAbs)) {
+  if (existsSync8(mdcAbs)) {
     files.push({ relPath: mdcRel, modified: classify(projectRoot, mdcRel, legacyManifest) });
   }
   let entries;
@@ -948,7 +1085,7 @@ function removableLegacyFiles(report2) {
 function removeLegacyFiles(projectRoot, relPaths) {
   for (const relPath of relPaths) {
     try {
-      rmSync(join9(projectRoot, ...relPath.split("/")), { force: true });
+      rmSync(join10(projectRoot, ...relPath.split("/")), { force: true });
     } catch {
     }
   }
@@ -991,6 +1128,9 @@ function update(opts) {
   const initResult = updateInitFiles(opts);
   updated.push(...initResult.updated);
   skipped.push(...initResult.skipped);
+  if (existsSync9(join11(opts.projectRoot, ".jig", "state.json"))) {
+    updated.push(...ensureAgentFiles(opts.projectRoot, { claude: claudeInstalled(opts.projectRoot, opts.homeDir) }));
+  }
   return {
     updated,
     skipped,
@@ -1013,14 +1153,14 @@ function updateTarget(opts, resolved) {
   const write = (key, content) => {
     updated.push(writer.write(key, content));
   };
-  const rulesDir = join10(opts.packageRoot, "rules");
+  const rulesDir = join11(opts.packageRoot, "rules");
   for (const file of bundleFiles(opts.packageRoot, "rules")) {
     const key = relKey(referenceDir, "rules", file);
     if (isModified(installRoot, key, existing)) {
       skipped.push(key);
       continue;
     }
-    write(key, vendorHeader(file, opts.version, "html", licencePathFor(`rules/${file}`)) + readFileSync7(join10(rulesDir, file), "utf8"));
+    write(key, vendorHeader(file, opts.version, "html", licencePathFor(`rules/${file}`)) + readFileSync9(join11(rulesDir, file), "utf8"));
   }
   for (const ref of referenceFiles(opts.packageRoot)) {
     const key = relKey(referenceDir, ...ref.relPath.split("/"));
@@ -1034,7 +1174,7 @@ function updateTarget(opts, resolved) {
   if (isModified(installRoot, indexKey, existing)) {
     skipped.push(indexKey);
   } else {
-    write(indexKey, readFileSync7(join10(opts.packageRoot, "rules.index.json"), "utf8"));
+    write(indexKey, readFileSync9(join11(opts.packageRoot, "rules.index.json"), "utf8"));
   }
   const rulesPath = rulesPathFor(referenceDir, discoveredScope);
   const skillBody = buildSkillBody(opts.packageRoot, rulesPath, opts.version);
@@ -1056,8 +1196,8 @@ function updateTarget(opts, resolved) {
     const key = file.relPath;
     const isBlockFile = file.content.includes(BLOCK_START);
     if (isBlockFile) {
-      const abs = join10(installRoot, ...key.split("/"));
-      const current = existsSync8(abs) ? readFileSync7(abs, "utf8") : "";
+      const abs = join11(installRoot, ...key.split("/"));
+      const current = existsSync9(abs) ? readFileSync9(abs, "utf8") : "";
       write(key, upsertBlock(current, file.content));
       continue;
     }
@@ -1068,7 +1208,7 @@ function updateTarget(opts, resolved) {
     write(key, file.content);
   }
   for (const src of ["LICENSE", "NOTICE"]) {
-    write(relKey(referenceDir, src), readFileSync7(join10(opts.packageRoot, src), "utf8"));
+    write(relKey(referenceDir, src), readFileSync9(join11(opts.packageRoot, src), "utf8"));
   }
   const manifest = {
     ...existing,
@@ -1084,7 +1224,7 @@ function updateInitFiles(opts) {
   const updated = [];
   const skipped = [];
   const tokens = [];
-  const tokensDir = join10(opts.packageRoot, "tokens");
+  const tokensDir = join11(opts.packageRoot, "tokens");
   const initManifest = readInitManifest(opts.projectRoot);
   if (initManifest) {
     const initFiles = { ...initManifest.files };
@@ -1096,10 +1236,10 @@ function updateInitFiles(opts) {
       for (const key of keys) {
         let before = "";
         try {
-          before = readFileSync7(join10(opts.projectRoot, ...key.split("/")), "utf8");
+          before = readFileSync9(join11(opts.projectRoot, ...key.split("/")), "utf8");
         } catch {
         }
-        const fresh = readFileSync7(join10(tokensDir, file), "utf8");
+        const fresh = readFileSync9(join11(tokensDir, file), "utf8");
         if (isInitFileModified(opts.projectRoot, key, initManifest)) {
           skipped.push(key);
           const change2 = tokenChange(key, before, fresh, true);
@@ -1120,12 +1260,12 @@ function updateInitFiles(opts) {
 }
 
 // src/commands/explain.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join16 } from "path";
 
 // src/rules/load.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync4 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync10, readdirSync as readdirSync4 } from "fs";
+import { join as join12 } from "path";
 
 // src/rules/parse.ts
 var HEADING = /^###\s+([A-Z])-(\d+)\s+(.+?)\s*$/;
@@ -1221,9 +1361,9 @@ function loadRules(rulesDir, indexPath) {
   const files = readdirSync4(rulesDir).filter((f) => f.endsWith(".md")).sort();
   const parsed = [];
   for (const file of files) {
-    parsed.push(...parseRules(readFileSync8(join11(rulesDir, file), "utf8"), file));
+    parsed.push(...parseRules(readFileSync10(join12(rulesDir, file), "utf8"), file));
   }
-  const entries = validateIndex(JSON.parse(readFileSync8(indexPath, "utf8")));
+  const entries = validateIndex(JSON.parse(readFileSync10(indexPath, "utf8")));
   const byId = new Map(entries.map((e) => [e.id, e]));
   const missing = parsed.filter((r) => !byId.has(r.id)).map((r) => r.id);
   if (missing.length) {
@@ -1245,8 +1385,8 @@ function loadRules(rulesDir, indexPath) {
 }
 
 // src/rules/specs.ts
-import { readFileSync as readFileSync9, readdirSync as readdirSync5 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
+import { join as join13 } from "path";
 var KINDS = {
   P: "pattern",
   M: "mode",
@@ -1305,14 +1445,14 @@ function parseSpecs(markdown, sourceFile) {
 function loadSpecs(rulesDir) {
   const specs = [];
   for (const file of readdirSync5(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
-    specs.push(...parseSpecs(readFileSync9(join12(rulesDir, file), "utf8"), file));
+    specs.push(...parseSpecs(readFileSync11(join13(rulesDir, file), "utf8"), file));
   }
   return specs;
 }
 
 // src/rules/sections.ts
-import { readFileSync as readFileSync10, readdirSync as readdirSync6 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync12, readdirSync as readdirSync6 } from "fs";
+import { join as join14 } from "path";
 var RULE_HEADING = /^###\s+[A-Z]-\d+\b/;
 var SPEC_HEADING = /^##\s+[PMLRT]-\d+\b/;
 var ANY_HEADING = /^(#{1,6})\s+(.*?)\s*$/;
@@ -1353,16 +1493,16 @@ function parseSections(markdown, file) {
 function loadSections(rulesDir) {
   const out = [];
   for (const file of readdirSync6(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
-    out.push(...parseSections(readFileSync10(join13(rulesDir, file), "utf8"), file));
+    out.push(...parseSections(readFileSync12(join14(rulesDir, file), "utf8"), file));
   }
   return out;
 }
 
 // src/rules/layers.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join15 } from "path";
 function loadLayers(packageRoot2) {
-  return JSON.parse(readFileSync11(join14(packageRoot2, "layers.json"), "utf8"));
+  return JSON.parse(readFileSync13(join15(packageRoot2, "layers.json"), "utf8"));
 }
 
 // src/commands/explain.ts
@@ -1444,8 +1584,8 @@ function renderSection(s) {
 function explain(opts) {
   const raw = opts.ruleId.trim().toUpperCase();
   const root = opts.packageRoot ?? assetRoot();
-  const rulesDir = join15(root, "rules");
-  const rules = loadRules(rulesDir, join15(root, "rules.index.json"));
+  const rulesDir = join16(root, "rules");
+  const rules = loadRules(rulesDir, join16(root, "rules.index.json"));
   const specs = loadSpecs(rulesDir);
   const sections = loadSections(rulesDir);
   const entries = searchEntries(rules, specs, sections);
@@ -1501,8 +1641,8 @@ function explain(opts) {
     const id = `${shape[1]}-${shape[2]}`;
     const rule = rules.find((r) => r.id === id);
     if (rule) {
-      const example = join15(root, "examples", `${id}.html`);
-      return existsSync9(example) ? `${renderRule(rule)}
+      const example = join16(root, "examples", `${id}.html`);
+      return existsSync10(example) ? `${renderRule(rule)}
 
 Example: ${example} (a dont and a do, each a self-contained HTML fragment)` : renderRule(rule);
     }
@@ -1559,13 +1699,13 @@ function sectionsOf(entries) {
 }
 
 // src/commands/check.ts
-import { existsSync as existsSync15, readFileSync as readFileSync19 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync21 } from "fs";
+import { join as join25 } from "path";
 
 // src/check/files.ts
 import { execFileSync } from "child_process";
 import { readdirSync as readdirSync7, realpathSync, statSync as statSync2 } from "fs";
-import { join as join16, relative, sep } from "path";
+import { join as join17, relative, sep } from "path";
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1640,7 +1780,7 @@ function walk(root, dir, out, seen) {
   }
   for (const entry of entries) {
     if (EXCLUDE_DIRS.has(entry.name)) continue;
-    const abs = join16(dir, entry.name);
+    const abs = join17(dir, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -1782,6 +1922,10 @@ function formatReport(findings, meta) {
       `  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.`
     );
   }
+  for (const problem of meta.agentFiles ?? []) lines.push(`  ${problem}`);
+  for (const { entry, why } of meta.exemptIgnored ?? []) {
+    lines.push(`  jig.config.json exempt: "${entry}" is ignored: ${why}`);
+  }
   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:`);
@@ -1789,6 +1933,9 @@ function formatReport(findings, meta) {
       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})`);
     }
+    for (const { pattern, suggest } of meta.exemptPatterns) {
+      if (suggest?.length) lines.push(`    ${pattern}: did you mean ${suggest.map((f) => `"${f}"`).join(" or ")}? Paths start at the project folder.`);
+    }
     if (n > 0) {
       lines.push(`    ${meta.exempt.slice(0, 8).join(", ")}${n > 8 ? `, and ${n - 8} more` : ""}`);
     }
@@ -1952,8 +2099,8 @@ function isReaderText(file) {
 }
 
 // src/check/run.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join19 } from "path";
 
 // src/check/css.ts
 function maskComments(source) {
@@ -3372,8 +3519,8 @@ var menuState = {
 };
 
 // src/check/declared-properties.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
+import { join as join18 } from "path";
 var DECLARATION_RE = /(?<![\w-])['"]?(--[A-Za-z_][\w-]*)['"]?\s*:/g;
 var AT_PROPERTY_RE = /@property\s+(--[\w-]+)/g;
 var SET_PROPERTY_RE = /setProperty\(\s*['"`](--[\w-]+)/g;
@@ -3385,16 +3532,16 @@ function addAll(names, text) {
   }
 }
 function readPackageImport(projectRoot, spec) {
-  const base = join17(projectRoot, "node_modules", spec);
+  const base = join18(projectRoot, "node_modules", spec);
   for (const candidate of [base, `${base}.css`]) {
     try {
-      if (existsSync10(candidate) && candidate.endsWith(".css")) return readFileSync12(candidate, "utf8");
+      if (existsSync11(candidate) && candidate.endsWith(".css")) return readFileSync14(candidate, "utf8");
     } catch {
     }
   }
   try {
-    const pkg = JSON.parse(readFileSync12(join17(base, "package.json"), "utf8"));
-    if (pkg.style) return readFileSync12(join17(base, pkg.style), "utf8");
+    const pkg = JSON.parse(readFileSync14(join18(base, "package.json"), "utf8"));
+    if (pkg.style) return readFileSync14(join18(base, pkg.style), "utf8");
   } catch {
   }
   return void 0;
@@ -3406,7 +3553,7 @@ function collectDeclaredProperties(projectRoot, files, tokenNames = []) {
   for (const file of files) {
     let raw;
     try {
-      raw = readFileSync12(join17(projectRoot, file), "utf8");
+      raw = readFileSync14(join18(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4256,7 +4403,7 @@ function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParti
     if (applicable.length === 0) continue;
     let raw;
     try {
-      raw = readFileSync13(join18(projectRoot, file), "utf8");
+      raw = readFileSync15(join19(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4270,8 +4417,8 @@ function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParti
 }
 
 // src/check/tokens.ts
-import { existsSync as existsSync11, readdirSync as readdirSync8, readFileSync as readFileSync14 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync8, readFileSync as readFileSync16 } from "fs";
+import { join as join20 } from "path";
 function rootDeclarations(source) {
   const out = {};
   for (const block of splitRuleBlocks(source)) {
@@ -4286,20 +4433,20 @@ function rootDeclarations(source) {
 }
 function loadTokenMap(projectRoot, consumerFiles = []) {
   const jig = {};
-  const tokensDir = join19(projectRoot, ".jig", "tokens");
-  if (existsSync11(tokensDir)) {
+  const tokensDir = join20(projectRoot, ".jig", "tokens");
+  if (existsSync12(tokensDir)) {
     for (const file of readdirSync8(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
-      Object.assign(jig, rootDeclarations(readFileSync14(join19(tokensDir, file), "utf8")));
+      Object.assign(jig, rootDeclarations(readFileSync16(join20(tokensDir, file), "utf8")));
     }
   }
   const consumer = {};
   const ambiguous = /* @__PURE__ */ new Set();
-  const vendored = join19(".jig", "tokens");
+  const vendored = join20(".jig", "tokens");
   for (const file of consumerFiles) {
     if (file.includes(vendored)) continue;
     let source;
     try {
-      source = readFileSync14(join19(projectRoot, file), "utf8");
+      source = readFileSync16(join20(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4318,8 +4465,8 @@ function loadTokenMap(projectRoot, consumerFiles = []) {
 }
 
 // src/check/exempt.ts
-import { existsSync as existsSync12, readFileSync as readFileSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
+import { join as join21 } from "path";
 function globToRegExp(glob) {
   let out = "";
   for (let i = 0; i < glob.length; i++) {
@@ -4338,18 +4485,37 @@ function globToRegExp(glob) {
   return new RegExp(`^${out}$`);
 }
 function readExemptions(projectRoot) {
-  const configPath = join20(projectRoot, "jig.config.json");
-  if (!existsSync12(configPath)) return [];
+  const none = { patterns: [], ignored: [] };
+  const configPath = join21(projectRoot, "jig.config.json");
+  if (!existsSync13(configPath)) return none;
   let declared;
   try {
-    declared = JSON.parse(readFileSync15(configPath, "utf8")).exempt;
+    declared = JSON.parse(readFileSync17(configPath, "utf8")).exempt;
   } catch {
-    return [];
+    return none;
+  }
+  if (!Array.isArray(declared)) return none;
+  const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const patterns = [];
+  const ignored = [];
+  for (const raw of declared) {
+    if (typeof raw !== "string" || !raw.trim()) continue;
+    let p = raw.trim().replace(/\\/g, "/");
+    if (p.startsWith(`${root}/`)) p = p.slice(root.length + 1);
+    p = p.replace(/^(\.\/)+/, "");
+    if (p.startsWith("/") || /^[A-Za-z]:\//.test(p)) {
+      ignored.push({ entry: raw, why: "an absolute path outside this project. Write it from the project folder, where jig.config.json is: `src/\u2026`" });
+    } else if (p.split("/").includes("..")) {
+      ignored.push({ entry: raw, why: "it leaves the project folder (`..`). Write it from the project folder, where jig.config.json is: `src/\u2026`" });
+    } else {
+      patterns.push(p);
+    }
   }
-  if (!Array.isArray(declared)) return [];
-  return declared.filter(
-    (p) => typeof p === "string" && p.trim() !== "" && !p.startsWith("/") && !p.split("/").includes("..")
-  );
+  return { patterns, ignored };
+}
+function suggestPaths(pattern, files) {
+  if (pattern.includes("/") || /[*?]/.test(pattern)) return [];
+  return files.filter((f) => f === pattern || f.endsWith(`/${pattern}`)).slice(0, 3);
 }
 var LIKELY_TOO_BROAD = 3;
 function applyExemptions(files, patterns) {
@@ -4374,8 +4540,8 @@ function applyExemptions(files, patterns) {
 }
 
 // src/check/waiver.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join22 } from "path";
 var WAIVER = /jig-allow\s+([A-Z]-\d+(?:\s*,\s*[A-Z]-\d+)*)\s*:(.*)$/;
 function readWaiver(line) {
   const m = WAIVER.exec(line);
@@ -4390,7 +4556,7 @@ function applyWaivers(root, findings) {
     let cached = lines.get(file);
     if (!cached) {
       try {
-        cached = readFileSync16(join21(root, file), "utf8").split("\n");
+        cached = readFileSync18(join22(root, file), "utf8").split("\n");
       } catch {
         cached = [];
       }
@@ -4455,8 +4621,8 @@ function hasMenuToggle(raw) {
 }
 
 // src/check/mode-wiring.ts
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
-import { dirname as dirname6, join as join22 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync19 } from "fs";
+import { dirname as dirname6, join as join23 } from "path";
 var MODES = ["editorial", "product", "operator"];
 function configProblems(config) {
   const problems = [];
@@ -4478,10 +4644,10 @@ function configProblems(config) {
 }
 function modeWiringProblems(projectRoot) {
   let config;
-  const path = join22(projectRoot, "jig.config.json");
-  if (!existsSync13(path)) return [];
+  const path = join23(projectRoot, "jig.config.json");
+  if (!existsSync14(path)) return [];
   try {
-    config = JSON.parse(readFileSync17(path, "utf8"));
+    config = JSON.parse(readFileSync19(path, "utf8"));
   } catch {
     return [{ mode: "", barrel: "jig.config.json", message: "jig.config.json is not valid JSON, so nothing in it applies" }];
   }
@@ -4494,10 +4660,10 @@ function modeWiringProblems(projectRoot) {
   const rel = (f) => dir === "." ? f : `${dir}/${f}`;
   const multi = modes.length > 1;
   const barrelOf = (mode) => multi ? `theme.${mode}.css` : "theme.css";
-  const anyBarrel = ["theme.css", ...modes.map((m) => `theme.${m}.css`)].some((f) => existsSync13(join22(projectRoot, rel(f))));
+  const anyBarrel = ["theme.css", ...modes.map((m) => `theme.${m}.css`)].some((f) => existsSync14(join23(projectRoot, rel(f))));
   if (!anyBarrel) return [];
   const problems = [];
-  if (multi && existsSync13(join22(projectRoot, rel("theme.css")))) {
+  if (multi && existsSync14(join23(projectRoot, rel("theme.css")))) {
     problems.push({
       mode: modes[0],
       barrel: rel("theme.css"),
@@ -4509,7 +4675,7 @@ function modeWiringProblems(projectRoot) {
     const modeFile = `mode.${mode}.css`;
     let body;
     try {
-      body = readFileSync17(join22(projectRoot, barrel), "utf8");
+      body = readFileSync19(join23(projectRoot, barrel), "utf8");
     } catch {
       problems.push({ mode, barrel, message: `jig.config.json declares ${mode}, but ${barrel} does not exist` });
       return;
@@ -4521,7 +4687,7 @@ function modeWiringProblems(projectRoot) {
         barrel,
         message: `jig.config.json declares ${mode}, but ${barrel} imports ${imported ? `mode.${imported}.css` : "no mode file"} \u2014 the page is styled at ${imported ?? "no"} density`
       });
-    } else if (!existsSync13(join22(projectRoot, rel(modeFile)))) {
+    } else if (!existsSync14(join23(projectRoot, rel(modeFile)))) {
       problems.push({ mode, barrel, message: `jig.config.json declares ${mode}, but ${rel(modeFile)} does not exist` });
     }
   });
@@ -4529,8 +4695,8 @@ function modeWiringProblems(projectRoot) {
 }
 
 // src/check/token-audit.ts
-import { existsSync as existsSync14, readdirSync as readdirSync9, readFileSync as readFileSync18 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync15, readdirSync as readdirSync9, readFileSync as readFileSync20 } from "fs";
+import { join as join24 } from "path";
 var TEXT_FLOOR = 4.5;
 var UI_FLOOR = 3;
 var FOREGROUNDS = [
@@ -4586,24 +4752,24 @@ function floorFor(token) {
 function tokenFiles(projectRoot) {
   const read = (rel) => {
     try {
-      return readFileSync18(join23(projectRoot, ...rel.split("/")), "utf8");
+      return readFileSync20(join24(projectRoot, ...rel.split("/")), "utf8");
     } catch {
       return null;
     }
   };
-  const statePath = join23(projectRoot, ".jig", "state.json");
-  if (existsSync14(statePath)) {
+  const statePath = join24(projectRoot, ".jig", "state.json");
+  if (existsSync15(statePath)) {
     try {
-      const state = JSON.parse(readFileSync18(statePath, "utf8"));
+      const state = JSON.parse(readFileSync20(statePath, "utf8"));
       const recorded = Object.keys(state.files ?? {}).filter((f) => f.endsWith(".css")).sort();
       const out = recorded.map((path) => ({ path, source: read(path) })).filter((f) => f.source !== null);
       if (out.length > 0) return out;
     } catch {
     }
   }
-  const legacy = join23(projectRoot, ".jig", "tokens");
-  if (!existsSync14(legacy)) return [];
-  return readdirSync9(legacy).filter((f) => f.endsWith(".css")).sort().map((f) => ({ path: `.jig/tokens/${f}`, source: readFileSync18(join23(legacy, f), "utf8") }));
+  const legacy = join24(projectRoot, ".jig", "tokens");
+  if (!existsSync15(legacy)) return [];
+  return readdirSync9(legacy).filter((f) => f.endsWith(".css")).sort().map((f) => ({ path: `.jig/tokens/${f}`, source: readFileSync20(join24(legacy, f), "utf8") }));
 }
 function auditTokenLayer(projectRoot) {
   const files = tokenFiles(projectRoot);
@@ -4671,15 +4837,15 @@ function auditTokenLayer(projectRoot) {
 }
 
 // src/commands/check.ts
-var LEGACY_INDEX_REL = join24(".jig", "rules.index.json");
+var LEGACY_INDEX_REL = join25(".jig", "rules.index.json");
 function resolveIndexPath(projectRoot) {
-  const legacy = join24(projectRoot, LEGACY_INDEX_REL);
-  if (existsSync15(legacy)) return legacy;
-  return join24(assetRoot(), "rules.index.json");
+  const legacy = join25(projectRoot, LEGACY_INDEX_REL);
+  if (existsSync16(legacy)) return legacy;
+  return join25(assetRoot(), "rules.index.json");
 }
 function resolveMode(projectRoot) {
   try {
-    const config = JSON.parse(readFileSync19(join24(projectRoot, "jig.config.json"), "utf8"));
+    const config = JSON.parse(readFileSync21(join25(projectRoot, "jig.config.json"), "utf8"));
     const modes = [...new Set((config.surfaces ?? []).map((s) => s.mode).filter(Boolean))];
     if (modes.length === 1) return modes[0];
     return modes.length > 1 ? "mixed" : "unknown";
@@ -4696,24 +4862,25 @@ function summariseUnscanned(files) {
 }
 function countSpecs() {
   try {
-    return loadSpecs(join24(assetRoot(), "rules")).length;
+    return loadSpecs(join25(assetRoot(), "rules")).length;
   } catch {
     return 0;
   }
 }
 function check(opts) {
   const indexPath = resolveIndexPath(opts.projectRoot);
-  const index = validateIndex(JSON.parse(readFileSync19(indexPath, "utf8")));
+  const index = validateIndex(JSON.parse(readFileSync21(indexPath, "utf8")));
   const selection = selectFiles(opts.projectRoot, opts.all);
-  const exemptions = readExemptions(opts.projectRoot);
-  const { scanned: files, exempt, byPattern } = applyExemptions(selection.files, exemptions);
+  const { patterns: exemptions, ignored: exemptIgnored } = readExemptions(opts.projectRoot);
+  const { scanned: files, exempt, byPattern: counted } = applyExemptions(selection.files, exemptions);
+  const byPattern = counted.map((p) => ({ ...p, suggest: p.count === 0 && selection.mode !== "changed" ? suggestPaths(p.pattern, selection.files) : [] }));
   const bucketFilter = opts.ci ? (b) => b === "mechanical" : void 0;
   const stylesheets = selection.mode === "all" ? files : selectFiles(opts.projectRoot, true).files;
   const tokens = loadTokenMap(opts.projectRoot, stylesheets);
   const projectParticipates = stylesheets.some((f) => {
     if (!hasExtension(f, CSS_EXTENSIONS)) return false;
     try {
-      return participatesInTokenLayer(readFileSync19(join24(opts.projectRoot, f), "utf8"), tokens);
+      return participatesInTokenLayer(readFileSync21(join25(opts.projectRoot, f), "utf8"), tokens);
     } catch {
       return false;
     }
@@ -4721,7 +4888,7 @@ function check(opts) {
   const projectResponsive = stylesheets.some((f) => {
     if (!isStyleBearing(f)) return false;
     try {
-      const raw = readFileSync19(join24(opts.projectRoot, f), "utf8");
+      const raw = readFileSync21(join25(opts.projectRoot, f), "utf8");
       return isResponsive(maskComments(maskNonStyleRegions(raw, f)), raw);
     } catch {
       return false;
@@ -4730,14 +4897,14 @@ function check(opts) {
   const viewportFitCover = stylesheets.some((f) => {
     if (!isStyleBearing(f)) return false;
     try {
-      return /viewport-fit\s*=\s*cover|viewportFit\s*:\s*['"]cover['"]/i.test(readFileSync19(join24(opts.projectRoot, f), "utf8"));
+      return /viewport-fit\s*=\s*cover|viewportFit\s*:\s*['"]cover['"]/i.test(readFileSync21(join25(opts.projectRoot, f), "utf8"));
     } catch {
       return false;
     }
   });
   const projectMenuToggle = stylesheets.some((f) => {
     try {
-      return hasMenuToggle(readFileSync19(join24(opts.projectRoot, f), "utf8"));
+      return hasMenuToggle(readFileSync21(join25(opts.projectRoot, f), "utf8"));
     } catch {
       return false;
     }
@@ -4745,7 +4912,7 @@ function check(opts) {
   const declaredProperties = collectDeclaredProperties(opts.projectRoot, stylesheets, Object.keys(tokens));
   const withStyles = files.filter((f) => {
     try {
-      const src = readFileSync19(join24(opts.projectRoot, f), "utf8");
+      const src = readFileSync21(join25(opts.projectRoot, f), "utf8");
       return hasExtension(f, CSS_EXTENSIONS) ? src.trim().length > 0 : maskNonStyleRegions(src, f).trim().length > 0;
     } catch {
       return false;
@@ -4778,7 +4945,7 @@ function check(opts) {
     // told to add a token @import it has nowhere to put.
     cssFiles.length > 0 && cssFiles.every((f) => {
       try {
-        return !participatesInTokenLayer(readFileSync19(join24(opts.projectRoot, f), "utf8"), tokens);
+        return !participatesInTokenLayer(readFileSync21(join25(opts.projectRoot, f), "utf8"), tokens);
       } catch {
         return true;
       }
@@ -4798,20 +4965,22 @@ function check(opts) {
     withStyles,
     exempt,
     exemptPatterns: byPattern,
+    exemptIgnored,
     scope: selection.mode,
     modeUnwired: modeWiringProblems(opts.projectRoot),
+    agentFiles: agentFileProblems(opts.projectRoot, opts.homeDir || void 0),
     waived
   });
   return { findings, report: report2, hasError, waived };
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readdirSync as readdirSync10, readFileSync as readFileSync23, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname7, isAbsolute, join as join28, resolve as resolve2, sep as sep3 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, readdirSync as readdirSync10, readFileSync as readFileSync25, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname7, isAbsolute, join as join29, resolve as resolve2, sep as sep3 } from "path";
 
 // src/init/detect.ts
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join26 } from "path";
 var TAILWIND_CONFIG_RE = /^tailwind\.config\.(js|ts|mjs|cjs)$/;
 var TAILWIND_V4_IMPORT_RE = /@import\s+["']tailwindcss["']/;
 var TAILWIND_V4_THEME_RE = /@theme\b/;
@@ -4828,7 +4997,7 @@ var FRAMEWORK_DEPS = [
 function detectFramework(projectRoot) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync20(join25(projectRoot, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync22(join26(projectRoot, "package.json"), "utf8"));
   } catch {
     return void 0;
   }
@@ -4846,7 +5015,7 @@ function detect(projectRoot) {
   for (const f of cssFiles) {
     let source;
     try {
-      source = readFileSync20(join25(projectRoot, f), "utf8");
+      source = readFileSync22(join26(projectRoot, f), "utf8");
     } catch {
       continue;
     }
@@ -4881,8 +5050,8 @@ function isIgnored(projectRoot, relPath) {
 }
 
 // src/init/derive.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join27 } from "path";
 var DEFAULT_PROPOSAL = {
   h: 264,
   s: 0,
@@ -4915,7 +5084,7 @@ function fromCssCustomProperties(projectRoot, cssFiles) {
   for (const file of cssFiles) {
     let source;
     try {
-      source = readFileSync21(join26(projectRoot, file), "utf8");
+      source = readFileSync23(join27(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -4964,7 +5133,7 @@ function balancedBraceBody(source, openIdx) {
 function fromTailwindConfig(projectRoot, tailwindConfigFile) {
   let source;
   try {
-    source = readFileSync21(join26(projectRoot, tailwindConfigFile), "utf8");
+    source = readFileSync23(join27(projectRoot, tailwindConfigFile), "utf8");
   } catch {
     return null;
   }
@@ -5020,7 +5189,7 @@ function fromLiteralFrequency(projectRoot, cssFiles) {
   for (const file of cssFiles) {
     let source;
     try {
-      source = readFileSync21(join26(projectRoot, file), "utf8");
+      source = readFileSync23(join27(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -5180,8 +5349,8 @@ function relativeImportPath(fromAbsDir, toAbsFile) {
 }
 
 // src/init/project-name.ts
-import { readFileSync as readFileSync22 } from "fs";
-import { basename, join as join27 } from "path";
+import { readFileSync as readFileSync24 } from "fs";
+import { basename, join as join28 } from "path";
 function slugify(name) {
   const withoutScope = name.replace(/^@[^/]+\//, "");
   const slug = withoutScope.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -5189,7 +5358,7 @@ function slugify(name) {
 }
 function deriveProjectSlug(projectRoot) {
   try {
-    const pkg = JSON.parse(readFileSync22(join27(projectRoot, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync24(join28(projectRoot, "package.json"), "utf8"));
     if (typeof pkg.name === "string" && pkg.name.trim()) return slugify(pkg.name);
   } catch {
   }
@@ -5330,7 +5499,7 @@ function parseSurfaces(answer, fallback) {
   return parsed.length > 0 ? parsed : fallback;
 }
 function fileState(projectRoot, absPath, relPath, initManifest) {
-  const existsOnDisk = existsSync16(absPath);
+  const existsOnDisk = existsSync17(absPath);
   const tracked = !!initManifest && relPath in initManifest.files;
   const modified = tracked && isInitFileModified(projectRoot, relPath, initManifest);
   return { existsOnDisk, tracked, modified };
@@ -5341,11 +5510,11 @@ function isValidSurfaceArray(v) {
   );
 }
 function loadEffectiveConfig(projectRoot, configAbsPath, fallbackBrand, fallbackSurfaces) {
-  if (!existsSync16(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
+  if (!existsSync17(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
   try {
-    const parsed = JSON.parse(readFileSync23(configAbsPath, "utf8"));
+    const parsed = JSON.parse(readFileSync25(configAbsPath, "utf8"));
     const brandCandidate = typeof parsed.brand === "string" && parsed.brand ? parsed.brand : void 0;
-    const brandResolves = brandCandidate ? existsSync16(join28(projectRoot, ...brandCandidate.split("/"))) : false;
+    const brandResolves = brandCandidate ? existsSync17(join29(projectRoot, ...brandCandidate.split("/"))) : false;
     return {
       brand: brandResolves ? brandCandidate : fallbackBrand,
       surfaces: isValidSurfaceArray(parsed.surfaces) ? parsed.surfaces : fallbackSurfaces
@@ -5355,10 +5524,10 @@ function loadEffectiveConfig(projectRoot, configAbsPath, fallbackBrand, fallback
   }
 }
 function configuredBrandPath(projectRoot, configAbsPath) {
-  if (!existsSync16(configAbsPath)) return { path: null };
+  if (!existsSync17(configAbsPath)) return { path: null };
   let declared;
   try {
-    declared = JSON.parse(readFileSync23(configAbsPath, "utf8")).brand;
+    declared = JSON.parse(readFileSync25(configAbsPath, "utf8")).brand;
   } catch {
     return { path: null };
   }
@@ -5386,9 +5555,9 @@ function defaultTokenDir(detection) {
   return ["jig"];
 }
 function readConfiguredSurfaces(configAbsPath) {
-  if (!existsSync16(configAbsPath)) return null;
+  if (!existsSync17(configAbsPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync23(configAbsPath, "utf8"));
+    const parsed = JSON.parse(readFileSync25(configAbsPath, "utf8"));
     return isValidSurfaceArray(parsed.surfaces) ? parsed.surfaces : null;
   } catch {
     return null;
@@ -5398,8 +5567,8 @@ function isCssModule(path) {
   return /\.module\.(css|scss)$/i.test(path);
 }
 function legacyBrandFile(projectRoot) {
-  const dir = join28(projectRoot, ".jig", "tokens");
-  if (!existsSync16(dir)) return void 0;
+  const dir = join29(projectRoot, ".jig", "tokens");
+  if (!existsSync17(dir)) return void 0;
   const found = readdirSync10(dir).find((f) => /^brand\.[\w.-]+\.css$/.test(f));
   return found ? relKey(".jig", "tokens", found) : void 0;
 }
@@ -5430,7 +5599,7 @@ var LEGACY_PAIR_RE = new RegExp(
   `@import\\s+["'][^"']*brand\\.[\\w.-]+\\.css["'];?\\r?\\n?\\s*@import\\s+["'][^"']*mode\\.(?:${MODES2.join("|")})\\.css["'];?\\r?\\n?`
 );
 function wireBarrel(absPath, barrelImport) {
-  const content = existsSync16(absPath) ? readFileSync23(absPath, "utf8") : "";
+  const content = existsSync17(absPath) ? readFileSync25(absPath, "utf8") : "";
   const line = `@import "${barrelImport}";`;
   if (content.includes(line)) return { status: "already-present" };
   const legacy = LEGACY_PAIR_RE.exec(content);
@@ -5525,7 +5694,7 @@ async function init(opts) {
     else if (critiqueAnswer) log(`  Could not read '${critiqueAnswer}' \u2014 leaving it page by page; each spec will ask.`);
   }
   if (opts.yes) {
-    const declared = readConfiguredSurfaces(join28(opts.projectRoot, "jig.config.json"));
+    const declared = readConfiguredSurfaces(join29(opts.projectRoot, "jig.config.json"));
     const inEffect = declared ?? surfaces;
     const map = inEffect.map((x) => `'${x.match}' \u2192 ${x.mode}`).join(", ");
     log(
@@ -5544,7 +5713,7 @@ Brand colour adjusted to clear the 4.5:1 contrast floor: l:${originalL}% \u2192
   const finalColor = { h: proposal.h, s: proposal.s, l: proposal.l };
   const projectSlug = deriveProjectSlug(opts.projectRoot);
   const configRelPath = "jig.config.json";
-  const configAbsPath = join28(opts.projectRoot, configRelPath);
+  const configAbsPath = join29(opts.projectRoot, configRelPath);
   const configuredBrand = configuredBrandPath(opts.projectRoot, configAbsPath);
   if (configuredBrand.refused) {
     log(
@@ -5578,7 +5747,7 @@ The token layer is at ${currentDir}/, and this project's layout suggests ${would
     }
   }
   const brandRelPath = relocateTo ?? configuredBrand.path ?? priorBrand ?? relKey(...defaultTokenDir(detection), brandFileName(projectSlug));
-  const brandAbsPath = join28(opts.projectRoot, ...brandRelPath.split("/"));
+  const brandAbsPath = join29(opts.projectRoot, ...brandRelPath.split("/"));
   const tokensRelDir = brandRelPath.split("/").slice(0, -1);
   log(
     `Token layer: ${tokensRelDir.join("/") || "."}/ \u2014 ` + (configuredBrand.path ? "from jig.config.json." : priorBrand ? "the layout this project already had. Set `brand` in jig.config.json to move it." : findWireTarget(detection) ? "beside the stylesheet being wired. Set `brand` in jig.config.json to put it elsewhere." : "no stylesheet found to follow, so the project root. Set `brand` in jig.config.json to move it.")
@@ -5611,7 +5780,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     if (configAction !== "written") log(`  ${configRelPath} exists and is not jig-tracked \u2014 leaving it alone (re-run without --yes to refresh).`);
   }
   if (brandAction === "written") {
-    const defaultCssRaw = readFileSync23(join28(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
+    const defaultCssRaw = readFileSync25(join29(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
     const content = renderBrandFile(defaultCssRaw, projectSlug, opts.version, proposal);
     mkdirSync6(dirname7(brandAbsPath), { recursive: true });
     writeFileSync4(brandAbsPath, content, "utf8");
@@ -5619,7 +5788,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   }
   if (relocateTo && configAction !== "written") {
     try {
-      const existing = JSON.parse(readFileSync23(configAbsPath, "utf8"));
+      const existing = JSON.parse(readFileSync25(configAbsPath, "utf8"));
       const content = `${JSON.stringify({ ...existing, brand: brandRelPath }, null, 2)}
 `;
       writeFileSync4(configAbsPath, content, "utf8");
@@ -5638,12 +5807,12 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   } else if (configAction === "merged") {
     let existing = {};
     try {
-      existing = JSON.parse(readFileSync23(configAbsPath, "utf8"));
+      existing = JSON.parse(readFileSync25(configAbsPath, "utf8"));
     } catch {
       existing = {};
     }
     const existingBrand = typeof existing.brand === "string" ? existing.brand : void 0;
-    const brandStillResolves = existingBrand ? existsSync16(join28(opts.projectRoot, ...existingBrand.split("/"))) : false;
+    const brandStillResolves = existingBrand ? existsSync17(join29(opts.projectRoot, ...existingBrand.split("/"))) : false;
     const existingSurfaces = Array.isArray(existing.surfaces) && existing.surfaces.length > 0 ? existing.surfaces : void 0;
     const merged = {
       ...existing,
@@ -5660,12 +5829,12 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   }
   const effectiveConfig = loadEffectiveConfig(opts.projectRoot, configAbsPath, brandRelPath, surfaces);
   const primaryMode = effectiveConfig.surfaces[0]?.mode ?? "product";
-  const wiringBrandAbsPath = join28(opts.projectRoot, ...effectiveConfig.brand.split("/"));
+  const wiringBrandAbsPath = join29(opts.projectRoot, ...effectiveConfig.brand.split("/"));
   const declaredModes = [...new Set(effectiveConfig.surfaces.map((s) => s.mode))];
   const modeAbsPaths = {};
   for (const mode of declaredModes) {
     const modeFileName = `mode.${mode}.css`;
-    const modeAbsPath2 = join28(opts.projectRoot, ...tokensRelDir, modeFileName);
+    const modeAbsPath2 = join29(opts.projectRoot, ...tokensRelDir, modeFileName);
     modeAbsPaths[mode] = modeAbsPath2;
     const modeRelPath = relKey(...tokensRelDir, modeFileName);
     const modeState = fileState(opts.projectRoot, modeAbsPath2, modeRelPath, initManifest);
@@ -5673,7 +5842,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     if (modeState.existsOnDisk && !modeState.tracked) modeAction = "skipped-untracked";
     else if (modeState.modified) modeAction = "skipped-edited";
     if (modeAction === "written") {
-      const modeSourceRaw = readFileSync23(join28(opts.packageRoot, "tokens", modeFileName), "utf8");
+      const modeSourceRaw = readFileSync25(join29(opts.packageRoot, "tokens", modeFileName), "utf8");
       const content = vendorHeader(modeFileName, opts.version, "css", null) + modeSourceRaw;
       mkdirSync6(dirname7(modeAbsPath2), { recursive: true });
       writeFileSync4(modeAbsPath2, content, "utf8");
@@ -5688,7 +5857,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   const barrelFor = (mode) => multiMode ? `theme.${mode}.css` : "theme.css";
   for (const mode of declaredModes) {
     const rel = relKey(...tokensRelDir, barrelFor(mode));
-    const abs = join28(opts.projectRoot, ...tokensRelDir, barrelFor(mode));
+    const abs = join29(opts.projectRoot, ...tokensRelDir, barrelFor(mode));
     const state = fileState(opts.projectRoot, abs, rel, initManifest);
     if (state.existsOnDisk && (!state.tracked || state.modified)) {
       log(`  ${rel} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone.`);
@@ -5701,8 +5870,8 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   }
   if (multiMode) {
     const rel = relKey(...tokensRelDir, "theme.css");
-    const abs = join28(opts.projectRoot, ...tokensRelDir, "theme.css");
-    if (existsSync16(abs)) {
+    const abs = join29(opts.projectRoot, ...tokensRelDir, "theme.css");
+    if (existsSync17(abs)) {
       const state = fileState(opts.projectRoot, abs, rel, initManifest);
       if (state.tracked && !state.modified) {
         rmSync2(abs);
@@ -5717,7 +5886,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
     const declared = declaredTokenNames(
       [brandAbsPath, modeAbsPath].map((f) => {
         try {
-          return readFileSync23(f, "utf8");
+          return readFileSync25(f, "utf8");
         } catch {
           return "";
         }
@@ -5742,7 +5911,7 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
       log(`  This changes how components are written. Both styles are correct.`);
       const answer = (await prompt("  Generate it? [y/N]: ")).toLowerCase();
       if (answer === "y" || answer === "yes") {
-        const abs = join28(opts.projectRoot, ...tokensRelDir, "utilities.css");
+        const abs = join29(opts.projectRoot, ...tokensRelDir, "utilities.css");
         const state = fileState(opts.projectRoot, abs, rel, initManifest);
         if (state.existsOnDisk && (!state.tracked || state.modified)) {
           log(`  ${rel} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone.`);
@@ -5753,8 +5922,8 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
           files[rel] = checksum(content);
           const target = findWireTarget(detection);
           const importPath = target ? relativeImportPath(
-            dirname7(join28(opts.projectRoot, target)),
-            join28(opts.projectRoot, ...tokensRelDir, "utilities.css")
+            dirname7(join29(opts.projectRoot, target)),
+            join29(opts.projectRoot, ...tokensRelDir, "utilities.css")
           ) : `./${rel}`;
           log(`  Wrote ${rel}. Import it in the stylesheet that imports Tailwind:`);
           log(`    @import "tailwindcss";`);
@@ -5773,11 +5942,11 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   writeInitManifest(opts.projectRoot, { version: opts.version, modes: declaredModes, files });
   if (relocateTo && currentBrand) {
     const oldDir = currentBrand.split("/").slice(0, -1);
-    const oldAbsDir = join28(opts.projectRoot, ...oldDir);
-    if (existsSync16(oldAbsDir)) {
+    const oldAbsDir = join29(opts.projectRoot, ...oldDir);
+    if (existsSync17(oldAbsDir)) {
       for (const name of readdirSync10(oldAbsDir).filter((f) => f.endsWith(".css"))) {
         const rel = relKey(...oldDir, name);
-        const abs = join28(oldAbsDir, name);
+        const abs = join29(oldAbsDir, name);
         const state = fileState(opts.projectRoot, abs, rel, initManifest);
         if (!state.tracked || state.modified) {
           log(`  ${rel} was edited \u2014 left in place. Delete it yourself once you have moved anything you need.`);
@@ -5791,11 +5960,11 @@ ${configRelPath} already exists and was not created by 'jig init' (or has been e
   const wireTarget = findWireTarget(detection);
   let wiring;
   if (multiMode) {
-    const bare2 = join28(opts.projectRoot, ...tokensRelDir, "theme.css");
+    const bare2 = join29(opts.projectRoot, ...tokensRelDir, "theme.css");
     for (const file of detection.cssFiles.filter((f) => !isTokenLayerFile(f))) {
-      const abs = join28(opts.projectRoot, file);
+      const abs = join29(opts.projectRoot, file);
       try {
-        const before = readFileSync23(abs, "utf8");
+        const before = readFileSync25(abs, "utf8");
         const after = before.split("\n").filter((l) => {
           const m = /^\s*@import\s+["']([^"']+)["'];?\s*$/.exec(l);
           return !(m && !/^[a-z]+:|^\//i.test(m[1]) && resolve2(dirname7(abs), m[1]) === bare2);
@@ -5817,21 +5986,21 @@ Could not edit ${file}: ${err.message}. Remove its import of ${relKey(...tokensR
       snippet: effectiveConfig.surfaces.map((s) => `${s.match} \u2192 ${relKey(...tokensRelDir, barrelFor(s.mode))}`).join("\n")
     };
   } else if (wireTarget) {
-    const targetAbsDir = dirname7(join28(opts.projectRoot, wireTarget));
+    const targetAbsDir = dirname7(join29(opts.projectRoot, wireTarget));
     const barrelImport = relativeImportPath(
       targetAbsDir,
-      join28(opts.projectRoot, ...tokensRelDir, "theme.css")
+      join29(opts.projectRoot, ...tokensRelDir, "theme.css")
     );
     const snippet = `@import "${barrelImport}";`;
     try {
       if (relocateTo && currentBrand) {
-        const abs = join28(opts.projectRoot, wireTarget);
+        const abs = join29(opts.projectRoot, wireTarget);
         const oldDirName = currentBrand.split("/").slice(0, -1).join("/");
-        const before = existsSync16(abs) ? readFileSync23(abs, "utf8") : "";
+        const before = existsSync17(abs) ? readFileSync25(abs, "utf8") : "";
         const after = before.split("\n").filter((l) => !(l.includes("@import") && l.includes(oldDirName))).join("\n");
         if (after !== before) writeFileSync4(abs, after, "utf8");
       }
-      const outcome = wireBarrel(join28(opts.projectRoot, wireTarget), barrelImport);
+      const outcome = wireBarrel(join29(opts.projectRoot, wireTarget), barrelImport);
       wiring = { target: wireTarget, status: outcome.status, snippet };
       const verb = outcome.status === "wired" ? "Wired" : outcome.status === "rewired" ? "Rewired" : "Already present in";
       log(`
@@ -5848,7 +6017,7 @@ Could not write to ${wireTarget}: ${err.message}`);
   } else {
     const barrelImport = relativeImportPath(
       opts.projectRoot,
-      join28(opts.projectRoot, ...tokensRelDir, "theme.css")
+      join29(opts.projectRoot, ...tokensRelDir, "theme.css")
     );
     const snippet = `@import "${barrelImport}";`;
     wiring = { target: null, status: "print-only", snippet };
@@ -5857,7 +6026,7 @@ Could not write to ${wireTarget}: ${err.message}`);
     if (pasteTargets.length > 0) {
       log("Paste the block for whichever of these is your global stylesheet:");
       for (const target of pasteTargets) {
-        const dir = dirname7(join28(opts.projectRoot, target));
+        const dir = dirname7(join29(opts.projectRoot, target));
         const forTarget = `@import "${relativeImportPath(dir, wiringBrandAbsPath)}";
 @import "${relativeImportPath(dir, modeAbsPath)}";`;
         log(`
@@ -5883,6 +6052,9 @@ Could not write to ${wireTarget}: ${err.message}`);
       "\n  WARNING: .jig/ is gitignored. It holds state.json \u2014 which `update` reads to leave your edited files alone \u2014 and the specs, mockups and critique verdicts this project agreed. Ignored, update cannot tell your edits from its own writes, and every spec is invisible to the next agent. Commit it."
     );
   }
+  const agentFiles = ensureAgentFiles(opts.projectRoot, { claude: claudeInstalled(opts.projectRoot, opts.homeDir) });
+  if (agentFiles.length) log(`
+  Wrote Jig's instructions for your agent into ${agentFiles.join(" and ")}; your own text in them is untouched.`);
   const baselineResult = check({ projectRoot: opts.projectRoot, homeDir: opts.homeDir, version: opts.version, all: true, ci: false });
   log("\nBaseline:");
   log(baselineResult.report);
@@ -5905,28 +6077,28 @@ Could not write to ${wireTarget}: ${err.message}`);
 
 // src/commands/verdicts.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync30 } from "fs";
-import { join as join37, relative as relative4, resolve as resolve5 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync32 } from "fs";
+import { join as join38, relative as relative4, resolve as resolve5, sep as sep6 } from "path";
 
 // src/rules/citations.ts
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function citableIds(packageRoot2) {
-  const rulesDir = join29(packageRoot2, "rules");
+  const rulesDir = join30(packageRoot2, "rules");
   const ids = [
-    ...loadRules(rulesDir, join29(packageRoot2, "rules.index.json")).map((r) => r.id),
+    ...loadRules(rulesDir, join30(packageRoot2, "rules.index.json")).map((r) => r.id),
     ...loadSpecs(rulesDir).map((s) => s.id)
   ];
   return [...new Set(ids)].sort();
 }
 
 // src/probe/check.ts
-import { existsSync as existsSync20, readdirSync as readdirSync13, readFileSync as readFileSync27 } from "fs";
-import { join as join34 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync13, readFileSync as readFileSync29 } from "fs";
+import { join as join35 } from "path";
 
 // src/probe/save.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync7, readdirSync as readdirSync12, readFileSync as readFileSync26, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync7, readdirSync as readdirSync12, readFileSync as readFileSync28, writeFileSync as writeFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join33, relative as relative3, resolve as resolve4, sep as sep5 } from "path";
+import { join as join34, relative as relative3, resolve as resolve4, sep as sep5 } from "path";
 
 // src/probe/script.ts
 var PROBE_VERSION = 9;
@@ -6158,24 +6330,28 @@ var PROBE_SCRIPT = `(async () => {
 
 // src/probe/browser.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync17, mkdtempSync, readdirSync as readdirSync11, rmSync as rmSync3 } from "fs";
-import { homedir, tmpdir } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync18, mkdtempSync, readdirSync as readdirSync11, rmSync as rmSync3 } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import { join as join31 } from "path";
 var CHROME_ENV = ["JIG_CHROME", "CHROME_PATH", "PUPPETEER_EXECUTABLE_PATH", "CHROMIUM_PATH"];
-var CHROME_COMMANDS = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"];
+var CHROME_COMMANDS = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser", "chrome", "msedge"];
 var CHROME_APPS = [
   "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
   "/Applications/Chromium.app/Contents/MacOS/Chromium",
   "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
   "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
-  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+  // Every Windows machine has Edge; Chrome is often installed per user.
+  "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+  "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+  ...process.env.LOCALAPPDATA ? [join31(process.env.LOCALAPPDATA, "Google", "Chrome", "Application", "chrome.exe")] : []
 ];
 function cachedBrowsers() {
   const roots = [
-    join30(homedir(), ".cache", "ms-playwright"),
-    join30(homedir(), "Library", "Caches", "ms-playwright"),
-    join30(homedir(), "AppData", "Local", "ms-playwright"),
-    join30(homedir(), ".cache", "puppeteer", "chrome")
+    join31(homedir2(), ".cache", "ms-playwright"),
+    join31(homedir2(), "Library", "Caches", "ms-playwright"),
+    join31(homedir2(), "AppData", "Local", "ms-playwright"),
+    join31(homedir2(), ".cache", "puppeteer", "chrome")
   ];
   const found = [];
   for (const root of roots) {
@@ -6195,8 +6371,8 @@ function cachedBrowsers() {
         ["chrome-win", "chrome.exe"],
         ["chrome-win64", "chrome.exe"]
       ]) {
-        const candidate = join30(root, entry, ...rel);
-        if (existsSync17(candidate)) found.push(candidate);
+        const candidate = join31(root, entry, ...rel);
+        if (existsSync18(candidate)) found.push(candidate);
       }
     }
   }
@@ -6205,21 +6381,25 @@ function cachedBrowsers() {
 function findChrome() {
   for (const key of CHROME_ENV) {
     const value = process.env[key];
-    if (value && existsSync17(value)) return value;
+    if (value && existsSync18(value)) return value;
   }
   for (const command of CHROME_COMMANDS) {
     const resolved = which(command);
     if (resolved) return resolved;
   }
-  for (const app of CHROME_APPS) if (existsSync17(app)) return app;
+  for (const app of CHROME_APPS) if (existsSync18(app)) return app;
   return cachedBrowsers()[0];
 }
 function which(command) {
-  const dirs = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+  const windows = process.platform === "win32";
+  const dirs = (process.env.PATH ?? "").split(windows ? ";" : ":");
+  const exts = windows ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean) : [""];
   for (const dir of dirs) {
     if (!dir) continue;
-    const candidate = join30(dir, command);
-    if (existsSync17(candidate)) return candidate;
+    for (const ext of exts) {
+      const candidate = join31(dir, command + ext);
+      if (existsSync18(candidate)) return candidate;
+    }
   }
   return void 0;
 }
@@ -6230,7 +6410,7 @@ async function runProbe(opts) {
       "No browser found to run the probe. Install one, or set JIG_CHROME to a Chrome, Chromium or Edge binary. A project with Playwright or Puppeteer already has one, and Jig will find it."
     );
   }
-  const profile = mkdtempSync(join30(tmpdir(), "jig-probe-"));
+  const profile = mkdtempSync(join31(tmpdir(), "jig-probe-"));
   const child = spawn(chrome, [
     "--headless=new",
     "--remote-debugging-port=0",
@@ -6274,6 +6454,9 @@ async function runProbe(opts) {
   }
 }
 async function evaluate(endpoint, url, width, height, timeoutMs, expression) {
+  if (typeof WebSocket === "undefined") {
+    throw new Error(`rendering a page needs Node 22 or later (this is Node ${process.versions.node}). Upgrade Node, then run it again.`);
+  }
   const socket = new WebSocket(endpoint);
   let nextId = 1;
   const pending = /* @__PURE__ */ new Map();
@@ -6331,8 +6514,8 @@ async function evaluate(endpoint, url, width, height, timeoutMs, expression) {
 
 // src/probe/serve.ts
 import { createServer } from "http";
-import { existsSync as existsSync18, readFileSync as readFileSync24, statSync as statSync3 } from "fs";
-import { extname, join as join31, resolve as resolve3, sep as sep4 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync26, statSync as statSync3 } from "fs";
+import { extname, join as join32, resolve as resolve3, sep as sep4 } from "path";
 var TYPES = {
   ".html": "text/html; charset=utf-8",
   ".htm": "text/html; charset=utf-8",
@@ -6359,19 +6542,19 @@ async function serveDirectory(dir) {
   const root = resolve3(dir);
   const server = createServer((req, res) => {
     let path = decodeURIComponent((req.url ?? "/").split("?")[0].split("#")[0]);
-    let file = resolve3(join31(root, path));
+    let file = resolve3(join32(root, path));
     if (file !== root && !file.startsWith(root + sep4)) {
       res.writeHead(403).end();
       return;
     }
-    if (existsSync18(file) && statSync3(file).isDirectory()) file = join31(file, "index.html");
-    else if (!existsSync18(file) && existsSync18(`${file}.html`)) file = `${file}.html`;
-    if (!existsSync18(file)) {
+    if (existsSync19(file) && statSync3(file).isDirectory()) file = join32(file, "index.html");
+    else if (!existsSync19(file) && existsSync19(`${file}.html`)) file = `${file}.html`;
+    if (!existsSync19(file)) {
       res.writeHead(404).end();
       return;
     }
     res.writeHead(200, { "content-type": TYPES[extname(file).toLowerCase()] ?? "application/octet-stream" });
-    res.end(readFileSync24(file));
+    res.end(readFileSync26(file));
   });
   await new Promise((done) => server.listen(0, "127.0.0.1", done));
   const address = server.address();
@@ -6383,8 +6566,8 @@ async function serveDirectory(dir) {
 }
 
 // src/probe/switches.ts
-import { readFileSync as readFileSync25 } from "fs";
-import { join as join32 } from "path";
+import { readFileSync as readFileSync27 } from "fs";
+import { join as join33 } from "path";
 var DECLARATION = /--breakpoint-([a-z0-9-]+)\s*:\s*(\d+(?:\.\d+)?)(px|rem)\b/g;
 function declaredSwitches(projectRoot) {
   const found = /* @__PURE__ */ new Map();
@@ -6392,7 +6575,7 @@ function declaredSwitches(projectRoot) {
     if (!/\.(css|scss|astro|vue|svelte|html)$/i.test(file)) continue;
     let text;
     try {
-      text = readFileSync25(join32(projectRoot, file), "utf8");
+      text = readFileSync27(join33(projectRoot, file), "utf8");
     } catch {
       continue;
     }
@@ -6427,18 +6610,18 @@ function saveProbe(opts) {
   }
   probe.pageFile = relative3(opts.projectRoot, page).split("\\").join("/");
   if (opts.serveRoot) probe.serveRoot = relative3(opts.projectRoot, resolve4(opts.projectRoot, opts.serveRoot)).split("\\").join("/") || ".";
-  probe.pageChecksum = checksum(readFileSync26(page, "utf8"));
+  probe.pageChecksum = checksum(readFileSync28(page, "utf8"));
   probe.recordedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dir = join33(opts.projectRoot, ".jig", "critique", opts.surface);
+  const dir = join34(opts.projectRoot, ".jig", "critique", opts.surface);
   mkdirSync7(dir, { recursive: true });
-  const path = join33(dir, `probe-${width}.json`);
+  const path = join34(dir, `probe-${width}.json`);
   writeFileSync5(path, JSON.stringify(probe), "utf8");
   return { path: `.jig/critique/${opts.surface}/probe-${width}.json`, width, page: probe.pageFile };
 }
 function projectFile(projectRoot, path) {
   const abs = resolve4(projectRoot, path);
   if (abs !== resolve4(projectRoot) && !abs.startsWith(resolve4(projectRoot) + sep5)) return void 0;
-  return existsSync19(abs) ? abs : void 0;
+  return existsSync20(abs) ? abs : void 0;
 }
 function pageFile(projectRoot, url) {
   if (!url.startsWith("file://")) return void 0;
@@ -6450,12 +6633,12 @@ function pageFile(projectRoot, url) {
   }
   const abs = resolve4(path);
   if (!abs.startsWith(resolve4(projectRoot))) return void 0;
-  return existsSync19(abs) ? abs : void 0;
+  return existsSync20(abs) ? abs : void 0;
 }
 var PROBE_WIDTHS = [360, 768, 1280, 1600];
 async function runAndSaveProbes(opts) {
   const abs = resolve4(opts.projectRoot, opts.page);
-  if (!existsSync19(abs)) throw new Error(`${opts.page} does not exist, so there is nothing to render.`);
+  if (!existsSync20(abs)) throw new Error(`${opts.page} does not exist, so there is nothing to render.`);
   const saved = [];
   const widths = opts.widths ?? probeWidths(PROBE_WIDTHS, declaredSwitches(opts.projectRoot));
   await withPageUrl(opts.projectRoot, abs, opts.serve, async (url) => {
@@ -6469,7 +6652,7 @@ async function runAndSaveProbes(opts) {
 async function withPageUrl(projectRoot, abs, serve, use) {
   if (!serve) return use(`file://${abs}`);
   const root = resolve4(projectRoot, serve);
-  if (!existsSync19(root)) throw new Error(`${serve} does not exist, so there is nothing to serve.`);
+  if (!existsSync20(root)) throw new Error(`${serve} does not exist, so there is nothing to serve.`);
   if (!abs.startsWith(root + sep5)) throw new Error(`The page is not inside ${serve}, so serving ${serve} cannot show it.`);
   const server = await serveDirectory(root);
   try {
@@ -6480,31 +6663,31 @@ async function withPageUrl(projectRoot, abs, serve, use) {
   }
 }
 function recordedPage(projectRoot, surface) {
-  const dir = join33(projectRoot, ".jig", "critique", surface);
-  if (!existsSync19(dir)) return void 0;
+  const dir = join34(projectRoot, ".jig", "critique", surface);
+  if (!existsSync20(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;
+      const probe = JSON.parse(readFileSync28(join34(dir, f), "utf8"));
+      if (probe.pageFile && existsSync20(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 dir = join34(opts.projectRoot, ".jig", "critique", opts.surface);
   const abs = resolve4(opts.projectRoot, opts.page);
   let current;
   try {
-    current = checksum(readFileSync26(abs, "utf8"));
+    current = checksum(readFileSync28(abs, "utf8"));
   } catch {
     return { recorded: [], reason: `${opts.page} could not be read` };
   }
-  const recorded = existsSync19(dir) ? readdirSync12(dir).map((f) => /^probe-(\d+)\.json$/.exec(f)?.[1]).filter((w) => !!w).map(Number) : [];
+  const recorded = existsSync20(dir) ? readdirSync12(dir).map((f) => /^probe-(\d+)\.json$/.exec(f)?.[1]).filter((w) => !!w).map(Number) : [];
   const widths = [.../* @__PURE__ */ new Set([...probeWidths(PROBE_WIDTHS, declaredSwitches(opts.projectRoot)), ...recorded])].sort((a, b) => a - b);
   const missing = widths.filter((width) => {
     try {
-      const probe = JSON.parse(readFileSync26(join33(dir, `probe-${width}.json`), "utf8"));
+      const probe = JSON.parse(readFileSync28(join34(dir, `probe-${width}.json`), "utf8"));
       return probe.jigProbe !== PROBE_VERSION || probe.pageChecksum !== current;
     } catch {
       return true;
@@ -6515,7 +6698,7 @@ async function ensureProbes(opts) {
   let serve;
   for (const width of widths) {
     try {
-      const probe = JSON.parse(readFileSync26(join33(dir, `probe-${width}.json`), "utf8"));
+      const probe = JSON.parse(readFileSync28(join34(dir, `probe-${width}.json`), "utf8"));
       if (probe.serveRoot) {
         serve = probe.serveRoot;
         break;
@@ -6531,9 +6714,9 @@ async function ensureProbes(opts) {
   return { recorded: missing };
 }
 function critiquedSurfaces(projectRoot) {
-  const root = join33(projectRoot, ".jig", "critique");
-  if (!existsSync19(root)) return [];
-  return readdirSync12(root).filter((surface) => !surface.startsWith("_") && (existsSync19(join33(root, surface, "screen.json")) || existsSync19(join33(root, surface, "code.json"))));
+  const root = join34(projectRoot, ".jig", "critique");
+  if (!existsSync20(root)) return [];
+  return readdirSync12(root).filter((surface) => !surface.startsWith("_") && (existsSync20(join34(root, surface, "screen.json")) || existsSync20(join34(root, surface, "code.json"))));
 }
 
 // src/probe/check.ts
@@ -6545,7 +6728,7 @@ function stampProblem(projectRoot, file, p) {
   if (!page) return `${file} names a page outside this project (${p.serveRoot ? p.pageFile : p.url ?? "no url"}).`;
   let current;
   try {
-    current = readFileSync27(page, "utf8");
+    current = readFileSync29(page, "utf8");
   } catch {
     return `${file} was taken on ${p.pageFile}, which no longer exists.`;
   }
@@ -6555,11 +6738,11 @@ function stampProblem(projectRoot, file, p) {
   return void 0;
 }
 function readProbes(projectRoot, dir, errors) {
-  if (!existsSync20(dir)) return [];
+  if (!existsSync21(dir)) return [];
   const probes = [];
   for (const f of readdirSync13(dir).filter((n) => /^probe-\d+\.json$/.test(n)).sort()) {
     try {
-      const p = JSON.parse(readFileSync27(join34(dir, f), "utf8"));
+      const p = JSON.parse(readFileSync29(join35(dir, f), "utf8"));
       if (typeof p.jigProbe === "number" && p.jigProbe < PROBE_VERSION && typeof p.width === "number") {
         errors.push(`${f} was taken by an older \`jig probe\` (version ${p.jigProbe}; this Jig reads version ${PROBE_VERSION}). Record it again with \`jig probe --run\`.`);
         continue;
@@ -6663,19 +6846,19 @@ function probeContradictions(probes, verdictOf, indexable = true) {
 }
 
 // src/check/decisions.ts
-import { existsSync as existsSync21, readFileSync as readFileSync28 } from "fs";
-import { join as join35, posix as posix3 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync30 } from "fs";
+import { join as join36, posix as posix3 } from "path";
 var HEADING4 = /^(#{2,3})\s+(.+?)\s*$/gm;
 var NOT_A_DECISION = /^(unresolved|open questions?|undecided|contents?|index)$/i;
 function decisionsFile(projectRoot) {
   const candidates = ["jig/DECISIONS.md", "DECISIONS.md", "src/jig/DECISIONS.md", "src/styles/jig/DECISIONS.md", ".jig/DECISIONS.md"];
   try {
-    const brand = JSON.parse(readFileSync28(join35(projectRoot, "jig.config.json"), "utf8")).brand;
+    const brand = JSON.parse(readFileSync30(join36(projectRoot, "jig.config.json"), "utf8")).brand;
     if (typeof brand === "string" && brand.includes("/")) candidates.unshift(`${posix3.dirname(brand.replace(/^\.\//, ""))}/DECISIONS.md`);
   } catch {
   }
   for (const candidate of candidates) {
-    if (existsSync21(join35(projectRoot, candidate))) return candidate;
+    if (existsSync22(join36(projectRoot, candidate))) return candidate;
   }
   return void 0;
 }
@@ -6688,7 +6871,7 @@ function decisionHeadings(projectRoot) {
   if (!path) return headings;
   let body;
   try {
-    body = readFileSync28(join35(projectRoot, path), "utf8");
+    body = readText(join36(projectRoot, path));
   } catch {
     return headings;
   }
@@ -6746,7 +6929,7 @@ function unsourcedReasons(current, before, opts = {}) {
   }
   return problems;
 }
-function quotesNotFrom(current, before, words) {
+function quotesNotFrom(current, before, words, source = "the owner's words in tweak.json (`change`)") {
   const problems = [];
   for (const [name, whys] of changedWhys(current, before, true)) {
     for (const why of whys) {
@@ -6754,7 +6937,7 @@ function quotesNotFrom(current, before, words) {
       if (/inferred/i.test(label)) continue;
       const missing = [...why.matchAll(/["“]([^"”]{3,})["”]/g)].map((m) => m[1]).filter((q) => !quoteHeld(q, words));
       if (missing.length) {
-        problems.push(`"${name}": its \`**${label}:**\` quotes "${missing[0]}", which the owner's words in tweak.json (\`change\`) do not say. Quote the owner as tweak.json records them, or put your reading under \`**Why (inferred):**\`.`);
+        problems.push(`"${name}": its \`**${label}:**\` quotes "${missing[0]}", which ${source} do not say. Quote the owner as they said it, or put your reading under \`**Why (inferred):**\`.`);
         break;
       }
     }
@@ -6768,25 +6951,25 @@ function quoteHeld(quote, words) {
 }
 
 // src/check/spec-shape.ts
-import { existsSync as existsSync22, readFileSync as readFileSync29, readdirSync as readdirSync14, statSync as statSync4 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync14, statSync as statSync4 } from "fs";
+import { join as join37 } from "path";
 function newestSpec(projectRoot) {
-  const dir = join36(projectRoot, ".jig", "specs");
-  if (!existsSync22(dir)) return void 0;
+  const dir = join37(projectRoot, ".jig", "specs");
+  if (!existsSync23(dir)) return void 0;
   const files = readdirSync14(dir).filter((f) => f.endsWith(".md"));
   if (files.length === 0) return void 0;
-  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") };
+  const newest = files.map((f) => ({ f, at: statSync4(join37(dir, f)).mtimeMs })).sort((a, b) => b.at - a.at)[0].f;
+  return { path: `.jig/specs/${newest}`, slug: newest.replace(/\.spec\.md$|\.md$/, ""), body: readText(join37(dir, newest)) };
 }
 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") };
+    const path = join37(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+    if (existsSync23(path)) return { path: `.jig/specs/${surface}.spec.md`, slug: surface, body: readText(path) };
   }
   return newestSpec(projectRoot);
 }
 function specProblems(spec) {
-  const parts = spec.body.split(/^---\s*$/m);
+  const parts = lf(spec.body).split(/^---\s*$/m);
   const front = parts.length >= 3 ? parts[1] : "";
   if (!front.trim()) {
     return [`${spec.path} has no frontmatter. A spec is the frontmatter \u2014 feature, surface, mode, sizes (phone, tablet, desktop), states, decisions, later, mockup, confirmed \u2014 with the reasoning below it. Rewrite it in that shape.`];
@@ -6804,7 +6987,7 @@ function specProblems(spec) {
   if (motion) {
     const inline = motion[1].replace(/\s+#.*$/, "").trim();
     const items = motion[2].split("\n").map((l) => l.replace(/^[ \t]+-\s*/, "").trim()).filter(Boolean);
-    if (!items.length && !/^none$/i.test(inline)) {
+    if (!items.length && !/^none\b(\s*$|\s*[—–:,;(-])/i.test(inline)) {
       problems.push(`${spec.path}: \`motion:\` is neither \`none\` nor a list. List each movement as \`- <what moves>: <how>, on <trigger>; tells <what the reader learns>\`, or write \`motion: none\`.`);
     }
     const unsaid = items.filter((i) => !/\bon\b/i.test(i) || !/\btells?\b/i.test(i));
@@ -6875,6 +7058,41 @@ function specIndexableField(front) {
   if (value === "false" || value === "no") return false;
   return "unreadable";
 }
+var SPEC_FIELDS = [
+  "feature",
+  "surface",
+  "route",
+  "mode",
+  "indexable",
+  "title",
+  "description",
+  "sizes",
+  "switches",
+  "states",
+  "motion",
+  "decisions",
+  "later",
+  "mockup",
+  "mockup_at",
+  "deviations",
+  "critique",
+  "superseded_by",
+  "confirmed"
+];
+var topLevelKeys = (body) => [...(body.split(/^---\s*$/m)[1] ?? "").matchAll(/^([A-Za-z_][\w-]*)\s*:/gm)].map((m) => m[1]);
+function newFieldProblems(spec, then) {
+  spec = { ...spec, body: lf(spec.body) };
+  then = lf(then);
+  const had = new Set(topLevelKeys(then));
+  const known = new Set(SPEC_FIELDS);
+  const added = [...new Set(topLevelKeys(spec.body))].filter((k) => !known.has(k) && !had.has(k));
+  if (!added.length) return [];
+  const near = (k) => SPEC_FIELDS.find((f) => k.includes(f) || f.startsWith(k.replace(/[-_].*$/, "")));
+  return added.map((k) => {
+    const hint = near(k);
+    return `${spec.path}: \`${k}:\` is not a field Jig reads, so nothing checks what it says. ` + (hint ? `If it is \`${hint}:\`, write it there. ` : "") + `Otherwise put it in the prose below the front matter. Jig's fields: ${SPEC_FIELDS.join(", ")}.`;
+  });
+}
 
 // src/commands/verdicts.ts
 var VERDICTS = ["ok", "finding", "n/a"];
@@ -6901,19 +7119,19 @@ function reasonProblems(file, judged, errors) {
   }
 }
 function readJson(path, errors) {
-  if (!existsSync23(path)) return null;
+  if (!existsSync24(path)) return null;
   try {
-    return JSON.parse(readFileSync30(path, "utf8"));
+    return JSON.parse(readFileSync32(path, "utf8"));
   } catch (e) {
     errors.push(`${path}: not valid JSON (${e.message})`);
     return {};
   }
 }
 function specIndexable(projectRoot, surface) {
-  const path = join37(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+  const path = join38(projectRoot, ".jig", "specs", `${surface}.spec.md`);
   let front = "";
   try {
-    front = readFileSync30(path, "utf8").split(/^---\s*$/m)[1] ?? "";
+    front = readText(path).split(/^---\s*$/m)[1] ?? "";
   } catch {
   }
   const declared = specIndexableField(front);
@@ -6922,13 +7140,17 @@ function specIndexable(projectRoot, surface) {
   return mode !== "product" && mode !== "operator";
 }
 function specNeedsNav(projectRoot, surface) {
-  const path = join37(projectRoot, ".jig", "specs", `${surface}.spec.md`);
-  if (!existsSync23(path)) return false;
-  const front = readFileSync30(path, "utf8").split(/^---\s*$/m)[1] ?? "";
+  const path = join38(projectRoot, ".jig", "specs", `${surface}.spec.md`);
+  if (!existsSync24(path)) return false;
+  const front = readText(path).split(/^---\s*$/m)[1] ?? "";
   const navField = [...front.matchAll(/^\s*nav:\s*(.+)$/gim)].some((m) => !/^\s*(none|n\/a|-)\b/i.test(m[1]));
   const navRegion = /^\s*-\s*(nav|navigation)\s*:/im.test(front);
   return navField || navRegion;
 }
+function unreadFields(label, file, known) {
+  if (!file || typeof file !== "object") return [];
+  return Object.entries(file).filter(([k, v]) => !known.includes(k) && v !== null && typeof v === "object" && Object.keys(v).length > 0).map(([k]) => `${label}: \`${k}\` is not a field Jig reads, so nothing counts what it holds. A rule's verdict goes in \`verdicts\`; what no rule names, in \`differences\`; a note, in the report.`);
+}
 function checkArm(name, file, required, otherPass, extraAllowed, extraRequired, errors, decisionList = []) {
   const total = required.length + extraRequired.length;
   if (file === null) {
@@ -6986,6 +7208,7 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
       } else findings++;
     }
   }
+  errors.push(...unreadFields(`${name}.json`, file, ["verdicts", "differences", "rendered", "artefacts"]));
   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.`);
@@ -6996,7 +7219,7 @@ function checkArm(name, file, required, otherPass, extraAllowed, extraRequired,
 function checkDecisions(projectRoot, dir, errors) {
   const required = decisionNames(projectRoot);
   if (required.length === 0) return { state: "ran", judged: 0, total: 0, findings: 0 };
-  const file = readJson(join37(dir, "decisions.json"), errors);
+  const file = readJson(join38(dir, "decisions.json"), errors);
   if (!file) {
     errors.push(
       `decisions.json is missing. Every decision in DECISIONS.md is judged against the built page, one verdict each: ${required.slice(0, 4).join(", ")}${required.length > 4 ? `, and ${required.length - 4} more` : ""}. A page can satisfy every rule and still break what this project decided.`
@@ -7005,6 +7228,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.');
+  errors.push(...unreadFields("decisions.json", file, ["verdicts"]));
   const seen = /* @__PURE__ */ new Set();
   const reasons = [];
   let findings = 0;
@@ -7050,7 +7274,7 @@ function decisionsSince(projectRoot, dir, unjudged) {
   if (!path) return [];
   const git = (args) => execFileSync3("git", args, { cwd: projectRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
   try {
-    const verdictFile = relative4(projectRoot, join37(dir, "decisions.json"));
+    const verdictFile = relative4(projectRoot, join38(dir, "decisions.json")).split(sep6).join("/");
     if (git(["status", "--porcelain", "--", verdictFile])) return [];
     const judgedIn = git(["log", "-1", "--format=%H", "--", verdictFile]);
     if (!judgedIn) return [];
@@ -7074,7 +7298,7 @@ function decisionsSince(projectRoot, dir, unjudged) {
 function verifyVerdicts(opts) {
   const root = opts.packageRoot ?? assetRoot();
   const errors = [];
-  const index = JSON.parse(readFileSync30(join37(root, "rules.index.json"), "utf8"));
+  const index = JSON.parse(readFileSync32(join38(root, "rules.index.json"), "utf8"));
   const judgment = index.filter((r) => r.bucket === "judgment" || r.bucket === "hybrid" && r.pass !== void 0);
   const screenIds = judgment.filter((r) => r.pass === "screen").map((r) => r.id);
   const codeIds = judgment.filter((r) => r.pass === "code").map((r) => r.id);
@@ -7083,9 +7307,9 @@ function verifyVerdicts(opts) {
     ...judgment.map((r) => [r.id, r.pass ?? ""])
   ]);
   const specIds = new Set(citableIds(root).filter((id) => /^[PMLRT]-\d+$/.test(id)));
-  const dir = join37(opts.projectRoot, ".jig", "critique", opts.surface);
-  const screenFile = readJson(join37(dir, "screen.json"), errors);
-  const codeFile = readJson(join37(dir, "code.json"), errors);
+  const dir = join38(opts.projectRoot, ".jig", "critique", opts.surface);
+  const screenFile = readJson(join38(dir, "screen.json"), errors);
+  const codeFile = readJson(join38(dir, "code.json"), errors);
   const screenExtraRequired = specNeedsNav(opts.projectRoot, opts.surface) ? ["P-14"] : [];
   const decisionList = decisionNames(opts.projectRoot);
   const screen = checkArm("screen", screenFile, screenIds, passOf, specIds, screenExtraRequired, errors, decisionList);
@@ -7093,7 +7317,7 @@ function verifyVerdicts(opts) {
   let rendered = false;
   if (screenFile && screenFile.rendered === true) {
     const artefacts = Array.isArray(screenFile.artefacts) ? screenFile.artefacts.filter((a) => typeof a === "string") : [];
-    const absent = artefacts.filter((a) => !existsSync23(resolve5(opts.projectRoot, a)));
+    const absent = artefacts.filter((a) => !existsSync24(resolve5(opts.projectRoot, a)));
     if (artefacts.length === 0) errors.push("screen.json says rendered: true but lists no artefacts. A render leaves a screenshot.");
     else if (absent.length) errors.push(`screen.json says rendered: true, but these artefacts do not exist: ${absent.join(", ")}.`);
     else rendered = true;
@@ -7114,7 +7338,7 @@ function verifyVerdicts(opts) {
   };
   let specFront = "";
   try {
-    specFront = readFileSync30(join37(opts.projectRoot, ".jig", "specs", `${opts.surface}.spec.md`), "utf8").split(/^---\s*$/m)[1] ?? "";
+    specFront = readText(join38(opts.projectRoot, ".jig", "specs", `${opts.surface}.spec.md`)).split(/^---\s*$/m)[1] ?? "";
   } catch {
   }
   if (specIndexableField(specFront) === "unreadable") {
@@ -7149,7 +7373,7 @@ function previousFindings(projectRoot, dir) {
     const out = /* @__PURE__ */ new Map();
     let text;
     try {
-      text = at ? git(["show", `${at}:./${rel}/${f}`]) : readFileSync30(join37(dir, f), "utf8");
+      text = at ? lf(git(["show", `${at}:./${rel}/${f}`])) : readText(join38(dir, f));
     } catch {
       return out;
     }
@@ -7231,18 +7455,17 @@ function sourceChanges(git, from, to) {
 }
 
 // src/commands/gate.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync8, readdirSync as readdirSync16, readFileSync as readFileSync35, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync8, readdirSync as readdirSync16, readFileSync as readFileSync36, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
 import { createHash as createHash3 } from "crypto";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 
 // src/check/mockup-drawing.ts
-import { readFileSync as readFileSync31 } from "fs";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 var FRAMES = [["phone", 360], ["tablet", 768], ["desktop", 1280], ["wide", 1600]];
 function mockupDrawingProblems(root, specBody, at) {
   let html;
   try {
-    html = readFileSync31(join38(root, at), "utf8");
+    html = readText(join39(root, at));
   } catch {
     return [];
   }
@@ -7303,7 +7526,7 @@ function frameRegionProblems(frames, specBody, at) {
 function approvedDrawingProblems(root, specBody, at) {
   let html;
   try {
-    html = readFileSync31(join38(root, at), "utf8");
+    html = readText(join39(root, at));
   } catch {
     return [];
   }
@@ -7409,12 +7632,12 @@ function sizeBlock2(sizes, size) {
 import { execFileSync as execFileSync4 } from "child_process";
 
 // src/commands/ship.ts
-import { existsSync as existsSync24, readdirSync as readdirSync15, readFileSync as readFileSync33 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync15, readFileSync as readFileSync34 } from "fs";
+import { join as join41 } from "path";
 
 // src/commands/seo.ts
-import { readFileSync as readFileSync32 } from "fs";
-import { join as join39 } from "path";
+import { readFileSync as readFileSync33 } from "fs";
+import { join as join40 } from "path";
 var SITEMAP_FILE = /(^|\/)sitemap(-index)?\.(xml|ts|js|mjs|tsx|jsx|rb|php|py)$/i;
 var ROBOTS_FILE = /(^|\/)robots\.(txt|ts|js|mjs|tsx|jsx)$/i;
 var ROUTE_IN_SITEMAP = /(?:<loc>\s*([^<\s]+)\s*<\/loc>)|(?:url\s*:\s*["'`]([^"'`]+)["'`])/gi;
@@ -7455,7 +7678,7 @@ function seo(opts) {
   for (const file of files) {
     let raw;
     try {
-      raw = readFileSync32(join39(root, file), "utf8");
+      raw = readFileSync33(join40(root, file), "utf8");
     } catch {
       continue;
     }
@@ -7520,7 +7743,7 @@ function critiqueAtShip(projectRoot, specBody) {
   const own = specCritique(specBody);
   if (own) return own === "at-ship";
   try {
-    return JSON.parse(readFileSync33(join40(projectRoot, "jig.config.json"), "utf8")).critique === "at-ship";
+    return JSON.parse(readFileSync34(join41(projectRoot, "jig.config.json"), "utf8")).critique === "at-ship";
   } catch {
     return false;
   }
@@ -7528,14 +7751,14 @@ function critiqueAtShip(projectRoot, specBody) {
 function tweakDeferred(dir) {
   let t;
   try {
-    t = JSON.parse(readFileSync33(join40(dir, "tweak.json"), "utf8"));
+    t = JSON.parse(readFileSync34(join41(dir, "tweak.json"), "utf8"));
   } catch {
     return false;
   }
   if (t.deferred === void 0 || t.deferred === false) return false;
   let judged;
   try {
-    judged = JSON.parse(readFileSync33(join40(dir, "verdicts.lock"), "utf8")).tweak;
+    judged = JSON.parse(readFileSync34(join41(dir, "verdicts.lock"), "utf8")).tweak;
   } catch {
   }
   return judged !== t.at;
@@ -7546,15 +7769,16 @@ function pageChecksum(html) {
 function changedSinceLock(projectRoot, dir) {
   let lock;
   try {
-    lock = JSON.parse(readFileSync33(join40(dir, "verdicts.lock"), "utf8"));
+    lock = JSON.parse(readFileSync34(join41(dir, "verdicts.lock"), "utf8"));
   } catch {
     return void 0;
   }
   const file = lock.page?.file;
   if (!file || !lock.page?.checksum) return void 0;
   try {
-    const html = readFileSync33(join40(projectRoot, file), "utf8");
-    return pageChecksum(html) !== lock.page.checksum && checksum(html) !== lock.page.checksum ? file : void 0;
+    const html = readFileSync34(join41(projectRoot, file), "utf8");
+    const seen = [pageChecksum(html), checksum(html)];
+    return seen.includes(lock.page.checksum) ? void 0 : file;
   } catch {
     return void 0;
   }
@@ -7564,7 +7788,7 @@ function supersededBy(front) {
   return named ? named : void 0;
 }
 function pageStatus(projectRoot, surface) {
-  const spec = readFileSync33(join40(projectRoot, ".jig", "specs", `${surface}.spec.md`), "utf8");
+  const spec = readText(join41(projectRoot, ".jig", "specs", `${surface}.spec.md`));
   const front = spec.split(/^---\s*$/m)[1] ?? "";
   if (!/^\s*confirmed\s*:\s*true\b/im.test(front)) {
     return { surface, state: "in-progress", detail: "its spec is not confirmed, so nothing of it is built to ship" };
@@ -7572,10 +7796,10 @@ function pageStatus(projectRoot, surface) {
   const successor = supersededBy(front);
   if (successor !== void 0) {
     const file = successor.replace(/(\.spec\.md)?$/, ".spec.md");
-    return existsSync24(join40(projectRoot, ".jig", "specs", file)) ? { surface, state: "superseded", detail: `superseded by ${file}, whose critique judges its page` } : { surface, state: "incomplete", detail: `\`superseded_by: ${successor}\` names a spec that does not exist in .jig/specs` };
+    return existsSync25(join41(projectRoot, ".jig", "specs", file)) ? { surface, state: "superseded", detail: `superseded by ${file}, whose critique judges its page` } : { surface, state: "incomplete", detail: `\`superseded_by: ${successor}\` names a spec that does not exist in .jig/specs` };
   }
-  const dir = join40(projectRoot, ".jig", "critique", surface);
-  if (!existsSync24(join40(dir, "screen.json")) && !existsSync24(join40(dir, "code.json"))) {
+  const dir = join41(projectRoot, ".jig", "critique", surface);
+  if (!existsSync25(join41(dir, "screen.json")) && !existsSync25(join41(dir, "code.json"))) {
     return { surface, state: "never", detail: "never critiqued" };
   }
   if (tweakDeferred(dir)) return { surface, state: "deferred", detail: "a tweak deferred its re-judge" };
@@ -7585,7 +7809,7 @@ function pageStatus(projectRoot, surface) {
   const stale = v.errors.find((e) => /was taken (on|by) an older/.test(e));
   let judgedPage = false;
   try {
-    judgedPage = !!JSON.parse(readFileSync33(join40(dir, "verdicts.lock"), "utf8")).page?.checksum;
+    judgedPage = !!JSON.parse(readFileSync34(join41(dir, "verdicts.lock"), "utf8")).page?.checksum;
   } catch {
   }
   if (stale && !judgedPage) return { surface, state: "changed", detail: "the page changed after its probes were taken" };
@@ -7601,17 +7825,19 @@ function ship(opts) {
   const mechanicalErrors = mechanical.findings.filter((f) => f.bucket === "mechanical" && f.severity === "error").length;
   const seoResult = seo({ projectRoot: root });
   const seoErrors = seoResult.findings.filter((f) => f.severity === "error").length;
-  const specsDir = join40(root, ".jig", "specs");
-  const surfaces = existsSync24(specsDir) ? readdirSync15(specsDir).filter((f) => f.endsWith(".spec.md") && !f.startsWith("_")).map((f) => f.replace(/\.spec\.md$/, "")).sort() : [];
+  const specsDir = join41(root, ".jig", "specs");
+  const surfaces = existsSync25(specsDir) ? readdirSync15(specsDir).filter((f) => f.endsWith(".spec.md") && !f.startsWith("_")).map((f) => f.replace(/\.spec\.md$/, "")).sort() : [];
   const pages = surfaces.map((s) => pageStatus(root, s));
   const owed = pages.filter((p) => p.state !== "judged" && p.state !== "in-progress" && p.state !== "superseded");
-  const ready = mechanicalErrors === 0 && seoErrors === 0 && owed.length === 0;
+  const agentFiles = agentFileProblems(root);
+  const ready = mechanicalErrors === 0 && seoErrors === 0 && owed.length === 0 && agentFiles.length === 0;
   const count = (state) => pages.filter((p) => p.state === state).length;
   const line = `JIG_SHIP: ready=${ready ? "yes" : "no"} mechanical=${mechanicalErrors} seo=${seoErrors} pages=${pages.length} judged=${count("judged")} owed=${owed.length} in-progress=${count("in-progress")} superseded=${count("superseded")}`;
   const mark = { judged: "\u2713", never: "\u2717", changed: "\u2717", reprobe: "\u2717", deferred: "\u2717", incomplete: "\u2717", findings: "\u2717", "in-progress": "\xB7", superseded: "\xB7" };
   const report2 = [
     `  ${mechanicalErrors === 0 ? "\u2713" : "\u2717"} check --all --ci: ${mechanicalErrors} mechanical error${mechanicalErrors === 1 ? "" : "s"}`,
     `  ${seoErrors === 0 ? "\u2713" : "\u2717"} seo: ${seoErrors} error${seoErrors === 1 ? "" : "s"}`,
+    ...agentFiles.map((p) => `  \u2717 ${p}`),
     ...pages.map((p) => `  ${mark[p.state]} ${p.surface}: ${p.detail}`),
     owed.length ? `  Critique each page marked \u2717 (\`/jig critique <page>\`); fix what it finds, or record the owner's ruling, and run \`jig ship\` again.` : "",
     `  Not checked by Jig, here or anywhere: ${NOT_COVERED}.`,
@@ -7621,11 +7847,37 @@ function ship(opts) {
 }
 
 // src/check/spec-checked.ts
-import { existsSync as existsSync25, readFileSync as readFileSync34 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync35 } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
+
+// src/check/owner-word.ts
+var SAYS = {
+  confirm: /\b(confirm(s|ed)?|yes|yep|approve[ds]?|looks (good|right|fine)|lgtm|go ahead|agreed|that['’]?s right|correct|ok(ay)?)\b|^\s*go\b/im,
+  approve: /\b(approve[ds]?|looks (good|right|fine)|lgtm|yes|go ahead|good to go|confirm(s|ed)?|agreed|build it|that['’]?s (it|right)|ok(ay)?)\b/i,
+  skip: /\bskip|\bno (mockup|drawing)|without (a )?(mockup|drawing)|(don['’]?t|do not|no need to) (draw|mock)|(mockup|drawing) (isn['’]?t|is not) needed/i,
+  defer: /\b(later|at ship|defer(red)?|wait|leave (it|the critique|the re-?judge)|(don['’]?t|do not) (re-?judge|critique)|no (re-?judge|critique)|skip the (re-?judge|critique))\b/i
+};
+function saysSo(word, text) {
+  return SAYS[word].test(text);
+}
+var WHAT = {
+  confirm: "confirm the spec",
+  approve: "approve the drawing",
+  skip: "skip the mockup",
+  defer: "leave the re-judge for later"
+};
+function ownerWordProblem(word, quoted, owner, where) {
+  const q = quoted.replace(/^["“]|["”]$/g, "").trim();
+  if (!q) return `${where} records the owner's word to ${WHAT[word]} without their words. Quote what they said.`;
+  if (!quoteHeld(q, owner)) return `${where} quotes "${q}", which the owner did not say in this session. Quote their reply as they wrote it; a word nobody gave is not one.`;
+  if (!saysSo(word, q)) return `${where} quotes "${q}", which does not ${WHAT[word]}. Words the owner said about something else are not their word on this: ask them, and quote the answer.`;
+  return void 0;
+}
+
+// src/check/spec-checked.ts
 function specChecksum(body) {
-  return createHash2("sha256").update(body.replace(/^\s*(confirmed|mockup)\s*:.*$/gim, "")).digest("hex");
+  return createHash2("sha256").update(body.replace(/\r\n/g, "\n").replace(/^\s*(confirmed|mockup)\s*:.*$/gim, "")).digest("hex");
 }
 var mockupLine = (body) => /^\s*mockup\s*:\s*(.*)$/im.exec(body.split(/^---\s*$/m)[1] ?? "")?.[1]?.trim() ?? "";
 function mockupWordProblems(spec, then, owner) {
@@ -7638,10 +7890,8 @@ function mockupWordProblems(spec, then, owner) {
   if (!quoted) {
     return [`${spec.path}: \`mockup: ${word}\` is recorded without the owner's words. Write \`mockup: ${word} \u2014 "<what they said>"\`, quoting the reply that ${word === "approved" ? "approved it" : "said to skip it"}.`];
   }
-  if (!quoteHeld(quoted, owner)) {
-    return [`${spec.path}: \`mockup: ${word}\` quotes "${quoted}", which the owner did not say in this session. Quote their reply as they wrote it; ${word === "approved" ? "an approval" : "a skip"} nobody gave is not one.`];
-  }
-  return [];
+  const problem = ownerWordProblem(word === "approved" ? "approve" : "skip", quoted, owner, `${spec.path}: \`mockup: ${word}\``);
+  return problem ? [problem] : [];
 }
 function mockupPending(body) {
   const now = mockupLine(body);
@@ -7676,7 +7926,7 @@ function specCheckProblems(root, spec, then, owner, decisions) {
   const recordPath = `.jig/specs/${spec.slug}.checked.json`;
   let record;
   try {
-    record = JSON.parse(readFileSync34(join41(root, recordPath), "utf8"));
+    record = JSON.parse(readFileSync35(join42(root, recordPath), "utf8"));
   } catch {
     problems.push(
       `${recordPath} is missing. Before the owner is asked to confirm, a reader who did not write the spec checks its quotations against the owner's words and its facts against their sources, and writes that record (step 3c). The owner checks the spec by the sheet it gives them.`
@@ -7705,16 +7955,16 @@ function specCheckProblems(root, spec, then, owner, decisions) {
   if (unsaid.length) problems.push(`${recordPath}: ${unsaid.length} unchecked ${unsaid.length === 1 ? "fact says" : "facts say"} nothing of why. Say in \`note\` why the source could not be opened; the owner opens it instead.`);
   const missing = facts.map((f) => typeof f?.source === "string" ? f.source.trim() : "").filter((s) => s && !/^[a-z][a-z0-9+.-]*:\/\//i.test(s)).filter((s) => {
     const [, file, line] = /^(.+?)(?::(\d+)(?:-\d+)?)?$/.exec(s) ?? [];
-    if (!file || !existsSync25(join41(root, file))) return true;
+    if (!file || !existsSync26(join42(root, file))) return true;
     if (!line) return false;
     try {
-      return Number(line) > readFileSync34(join41(root, file), "utf8").split("\n").length;
+      return Number(line) > readFileSync35(join42(root, file), "utf8").split("\n").length;
     } catch {
       return true;
     }
   });
   if (missing.length) {
-    problems.push(`${recordPath} cites ${missing.length === 1 ? "a source" : "sources"} the project does not have: ${missing.slice(0, 4).join(", ")}. A fact is checked at a source that exists; name it as a path from the project root, or a URL.`);
+    problems.push(`${recordPath} cites ${missing.length === 1 ? "a source" : "sources"} the project does not have: ${missing.slice(0, 4).join(", ")}. A fact is checked at a source that exists: \`source\` is a path from the project root, \`path:line\`, or a URL, and nothing else; what you found there goes in \`note\`.`);
   }
   return problems;
 }
@@ -7722,10 +7972,10 @@ function specCheckProblems(root, spec, then, owner, decisions) {
 // src/commands/gate.ts
 var MAX_BLOCKS = 3;
 function lastJigInvocation(transcriptPath) {
-  if (!transcriptPath || !existsSync26(transcriptPath)) return void 0;
+  if (!transcriptPath || !existsSync27(transcriptPath)) return void 0;
   let text;
   try {
-    text = readFileSync35(transcriptPath, "utf8");
+    text = readFileSync36(transcriptPath, "utf8");
   } catch {
     return void 0;
   }
@@ -7750,10 +8000,10 @@ function lastJigInvocation(transcriptPath) {
   return found;
 }
 function ownerWords(transcriptPath) {
-  if (!transcriptPath || !existsSync26(transcriptPath)) return "";
+  if (!transcriptPath || !existsSync27(transcriptPath)) return "";
   const said = [];
   try {
-    for (const line of readFileSync35(transcriptPath, "utf8").split("\n")) {
+    for (const line of readFileSync36(transcriptPath, "utf8").split("\n")) {
       if (!line.includes('"user"')) continue;
       let entry;
       try {
@@ -7773,11 +8023,46 @@ function ownerWords(transcriptPath) {
   }
   return said.join("\n");
 }
+function namedSpec(root, surface) {
+  if (!surface) return specFor(root, void 0);
+  return existsSync27(join43(root, ".jig", "specs", `${surface}.spec.md`)) ? specFor(root, surface) : void 0;
+}
+function isConfirmed(body) {
+  return /^\s*confirmed\s*:\s*true\b/im.test(body.split(/^---\s*$/m)[1] ?? "");
+}
+function ownerReplyAfter(transcriptPath, asked) {
+  if (!transcriptPath || !existsSync27(transcriptPath)) return void 0;
+  const turns = [];
+  try {
+    for (const line of readFileSync36(transcriptPath, "utf8").split("\n")) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "user" && entry.type !== "assistant" || 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 text of texts) turns.push({ who: entry.type === "user" ? "owner" : "agent", text });
+    }
+  } catch {
+    return void 0;
+  }
+  let answer;
+  turns.forEach((t, i) => {
+    if (t.who !== "agent" || !asked.test(t.text)) return;
+    const reply = [];
+    for (let j = i + 1; j < turns.length && turns[j].who === "owner"; j++) reply.push(turns[j].text);
+    if (reply.length) answer = reply.join("\n");
+  });
+  return answer;
+}
 function lastAssistantText(transcriptPath) {
-  if (!transcriptPath || !existsSync26(transcriptPath)) return void 0;
+  if (!transcriptPath || !existsSync27(transcriptPath)) return void 0;
   let found;
   try {
-    for (const line of readFileSync35(transcriptPath, "utf8").split("\n")) {
+    for (const line of readFileSync36(transcriptPath, "utf8").split("\n")) {
       if (!line.includes('"assistant"')) continue;
       let entry;
       try {
@@ -7801,9 +8086,9 @@ function asksOwner(text) {
 }
 var ASKS_THE_OWNER = /* @__PURE__ */ new Set(["decide", "spec", "mockup", "tweak"]);
 function sessionStart(transcriptPath) {
-  if (!transcriptPath || !existsSync26(transcriptPath)) return void 0;
+  if (!transcriptPath || !existsSync27(transcriptPath)) return void 0;
   try {
-    for (const line of readFileSync35(transcriptPath, "utf8").split("\n")) {
+    for (const line of readFileSync36(transcriptPath, "utf8").split("\n")) {
       const m = /"timestamp"\s*:\s*"([^"]+)"/.exec(line);
       if (m) {
         const t = Date.parse(m[1]);
@@ -7818,20 +8103,20 @@ function verdictsMtime(dir) {
   let newest = 0;
   for (const name of VERDICT_FILES) {
     try {
-      newest = Math.max(newest, statSync5(join42(dir, name)).mtimeMs);
+      newest = Math.max(newest, statSync5(join43(dir, name)).mtimeMs);
     } catch {
     }
   }
   return newest;
 }
 function surfacesInPlay(root, command, transcriptPath, surface) {
-  const critiqueDir = join42(root, ".jig", "critique");
-  if (!existsSync26(critiqueDir)) return [];
+  const critiqueDir = join43(root, ".jig", "critique");
+  if (!existsSync27(critiqueDir)) return [];
   const all = readdirSync16(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" || command === "tweak" ? specFor(root, surface)?.slug : void 0;
-  return all.filter((s) => s === current || verdictsMtime(join42(critiqueDir, s)) >= start - 1e3);
+  return all.filter((s) => s === current || verdictsMtime(join43(critiqueDir, s)) >= start - 1e3);
 }
 function surfacesToProbe(root, input) {
   const invocation = lastJigInvocation(input.transcript_path);
@@ -7839,9 +8124,13 @@ function surfacesToProbe(root, input) {
 }
 function fileAtSessionStart(root, path, start) {
   const git = (args) => execFileSync4("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  try {
+    if (start !== void 0 && statSync5(join43(root, path)).mtimeMs < start - 1e3) return readText(join43(root, path));
+  } catch {
+  }
   try {
     const base = start === void 0 ? "HEAD" : git(["rev-list", "-1", `--before=@${Math.floor(start / 1e3)}`, "HEAD"]).trim();
-    return base ? git(["show", `${base}:./${path}`]) : "";
+    return base ? lf(git(["show", `${base}:./${path}`])) : "";
   } catch {
     return "";
   }
@@ -7854,7 +8143,7 @@ function changedOutsideRecords(root, start) {
     const changed = git(["diff", "--name-only", base, "--", ".", ":(exclude).jig"]).split("\n").filter(Boolean);
     const created = git(["ls-files", "--others", "--exclude-standard", "--", ".", ":(exclude).jig"]).split("\n").filter(Boolean).filter((f) => {
       try {
-        return start === void 0 || statSync5(join42(root, f)).mtimeMs >= start - 1e3;
+        return start === void 0 || statSync5(join43(root, f)).mtimeMs >= start - 1e3;
       } catch {
         return false;
       }
@@ -7869,8 +8158,8 @@ function drawingChangedAfterApproval(root, specPath, at) {
   try {
     const approvedIn = git(["log", "-1", "--format=%H", "-G", "^mockup[[:space:]]*:[[:space:]]*approved", "--", specPath]).trim();
     if (!approvedIn) return void 0;
-    const then = git(["show", `${approvedIn}:./${at}`]);
-    return then !== readFileSync35(join42(root, at), "utf8") ? approvedIn.slice(0, 7) : void 0;
+    const then = lf(git(["show", `${approvedIn}:./${at}`]));
+    return then !== readText(join43(root, at)) ? approvedIn.slice(0, 7) : void 0;
   } catch {
     return void 0;
   }
@@ -7882,18 +8171,25 @@ function commandProblems(root, command, surface, start, owner = "") {
     const found = decisionsFile(root);
     if (!found) problems.push("decide wrote no DECISIONS.md beside the token layer.");
     else {
-      const body = readFileSync35(join42(root, found), "utf8");
+      const body = readText(join43(root, found));
       if (!/^##\s+Unresolved\s*$/im.test(body)) {
         problems.push("DECISIONS.md has no `## Unresolved` section. Round 3 asks by name what is still undecided; write what the owner named, or `None named by the owner.`");
       }
       if (/\[TODO\]/.test(body)) problems.push("DECISIONS.md still contains [TODO] markers.");
-      problems.push(...unsourcedReasons(body, fileAtSessionStart(root, found, start), { newWhysOnly: true }).map((p) => `DECISIONS.md: ${p}`));
+      const then = fileAtSessionStart(root, found, start);
+      problems.push(...unsourcedReasons(body, then, { newWhysOnly: true }).map((p) => `DECISIONS.md: ${p}`));
+      if (owner) problems.push(...quotesNotFrom(body, then, owner, "the owner's words in this session").map((p) => `DECISIONS.md: ${p}`));
     }
   }
+  if (command === "spec" && surface && !existsSync27(join43(root, ".jig", "specs", `${surface}.spec.md`))) {
+    problems.push(`spec wrote no .jig/specs/${surface}.spec.md. The spec is that file: a draft anywhere else is read by no later step and checked by nothing.`);
+    return problems;
+  }
   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));
+      problems.push(...newFieldProblems(spec, fileAtSessionStart(root, spec.path, start)));
       if (problems.length === 0) problems.push(...navProblems(spec));
     }
   }
@@ -7908,12 +8204,12 @@ function commandProblems(root, command, surface, start, owner = "") {
     const at = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
     if (/^approved/i.test(mockup)) {
       if (!at) problems.push(`${spec.path}: \`mockup_at:\` is empty. Record where the approved drawing is.`);
-      else if (!/^https?:/i.test(at) && !existsSync26(join42(root, at))) problems.push(`${spec.path}: \`mockup_at: ${at}\` does not exist.`);
+      else if (!/^https?:/i.test(at) && !existsSync27(join43(root, at))) problems.push(`${spec.path}: \`mockup_at: ${at}\` does not exist.`);
       else if (!/^https?:/i.test(at) && !at.startsWith(".jig/mockups/")) problems.push(`The drawing is at ${at}. A mockup lives in .jig/mockups/, outside what check scans and outside what ships.`);
     }
-    if (at && /\.html?$/i.test(at) && existsSync26(join42(root, at))) problems.push(...mockupDrawingProblems(root, spec.body, at));
+    if (at && /\.html?$/i.test(at) && existsSync27(join43(root, at))) problems.push(...mockupDrawingProblems(root, spec.body, at));
   }
-  if (command === "tweak" && spec) problems.push(...tweakProblems(root, spec, owner));
+  if (command === "tweak" && spec) problems.push(...tweakProblems(root, spec, owner, start));
   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] ?? "";
@@ -7939,7 +8235,7 @@ function commandProblems(root, command, surface, start, owner = "") {
     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) && at && !/^https?:/i.test(at) && existsSync26(join42(root, at))) {
+    if (/^approved/i.test(mockup) && at && !/^https?:/i.test(at) && existsSync27(join43(root, at))) {
       const changedAfter = drawingChangedAfterApproval(root, spec.path, at);
       if (changedAfter) {
         problems.push(`${at} has changed since the owner approved it (${changedAfter}). An approval is of the drawing as the owner saw it: set \`mockup: pending\` in ${spec.path} and ask again.`);
@@ -7951,7 +8247,7 @@ function commandProblems(root, command, surface, start, owner = "") {
     if (found) {
       let now = "";
       try {
-        now = readFileSync35(join42(root, found), "utf8");
+        now = readText(join43(root, found));
       } catch {
       }
       const then = fileAtSessionStart(root, found, start);
@@ -7965,13 +8261,13 @@ function commandProblems(root, command, surface, start, owner = "") {
     if (found) {
       let now = "";
       try {
-        now = readFileSync35(join42(root, found), "utf8");
+        now = readText(join43(root, found));
       } catch {
       }
       const then = fileAtSessionStart(root, found, start);
       if (now && now !== then) {
         problems.push(...unsourcedReasons(now, then, { newWhysOnly: true }).map((p) => `${found}: ${p}`));
-        const change = readTweak(join42(root, ".jig", "critique", spec.slug))?.change;
+        const change = readTweak(join43(root, ".jig", "critique", spec.slug))?.change;
         if (change) problems.push(...quotesNotFrom(now, then, change).map((p) => `${found}: ${p}`));
       }
     }
@@ -7980,7 +8276,7 @@ function commandProblems(root, command, surface, start, owner = "") {
     for (const file of modeFiles(root)) {
       let now = "";
       try {
-        now = readFileSync35(join42(root, file), "utf8");
+        now = readText(join43(root, file));
       } catch {
         continue;
       }
@@ -7991,8 +8287,8 @@ function commandProblems(root, command, surface, start, owner = "") {
     }
   }
   if (command === "critique") {
-    const dir = join42(root, ".jig", "critique");
-    const surfaces = existsSync26(dir) ? readdirSync16(dir).filter((s) => existsSync26(join42(dir, s, "screen.json")) || existsSync26(join42(dir, s, "code.json"))) : [];
+    const dir = join43(root, ".jig", "critique");
+    const surfaces = existsSync27(dir) ? readdirSync16(dir).filter((s) => existsSync27(join43(dir, s, "screen.json")) || existsSync27(join43(dir, s, "code.json"))) : [];
     for (const surface2 of surfaces) {
       const v = verifyVerdicts({ projectRoot: root, surface: surface2 });
       if (v.ok && v.decisions.state !== "ran" && v.decisions.total > 0) {
@@ -8003,7 +8299,7 @@ function commandProblems(root, command, surface, start, owner = "") {
       }
     }
     const own = specFor(root, surface)?.slug;
-    if (own && surfaces.includes(own)) problems.push(...reportOmissions(join42(dir, own), own));
+    if (own && surfaces.includes(own)) problems.push(...reportOmissions(join43(dir, own), own));
     if (surfaces.length === 0) {
       problems.push("critique wrote no verdict files. Each reader arm writes .jig/critique/<surface>/screen.json or code.json, and `jig verdicts <surface>` \u2014 not your own count \u2014 decides whether the review is complete. A report without them is not a review.");
     }
@@ -8016,7 +8312,7 @@ function drawingBeforeAsking(root, surface) {
   const front = spec.body.split(/^---\s*$/m)[1] ?? "";
   const named = /^\s*mockup_at\s*:\s*(.+)$/im.exec(front)?.[1]?.trim().replace(/^["']|["']$/g, "") ?? "";
   const at = named || `.jig/mockups/${spec.slug}.html`;
-  if (/^https?:/i.test(at) || !/\.html?$/i.test(at) || !existsSync26(join42(root, at))) return [];
+  if (/^https?:/i.test(at) || !/\.html?$/i.test(at) || !existsSync27(join43(root, at))) return [];
   const found = mockupDrawingProblems(root, spec.body, at);
   return found.length ? [`Fix the drawing before you put it to the owner; they approve what the spec lists, drawn. ${found.join(" ")}`] : [];
 }
@@ -8024,14 +8320,14 @@ function specChecked(root, spec, start, owner) {
   const found = decisionsFile(root);
   let decisions = "";
   try {
-    if (found) decisions = readFileSync35(join42(root, found), "utf8");
+    if (found) decisions = readText(join43(root, found));
   } catch {
   }
   return specCheckProblems(root, spec, fileAtSessionStart(root, spec.path, start), owner, decisions);
 }
 function modeFiles(root) {
   try {
-    const state = JSON.parse(readFileSync35(join42(root, ".jig", "state.json"), "utf8"));
+    const state = JSON.parse(readFileSync36(join43(root, ".jig", "state.json"), "utf8"));
     return Object.keys(state.files ?? {}).filter((f) => /(^|\/)mode\.[\w-]+\.css$/.test(f));
   } catch {
     return [];
@@ -8040,7 +8336,7 @@ function modeFiles(root) {
 function reportOmissions(dir, surface) {
   let report2;
   try {
-    report2 = readFileSync35(join42(dir, "REPORT.md"), "utf8").toLowerCase();
+    report2 = readText(join43(dir, "REPORT.md")).toLowerCase();
   } catch {
     return [];
   }
@@ -8048,7 +8344,7 @@ function reportOmissions(dir, surface) {
   for (const f of VERDICT_FILES) {
     let file;
     try {
-      file = JSON.parse(readFileSync35(join42(dir, f), "utf8"));
+      file = JSON.parse(readFileSync36(join43(dir, f), "utf8"));
     } catch {
       continue;
     }
@@ -8061,7 +8357,7 @@ function reportOmissions(dir, surface) {
   if (!missing.length) return [];
   return [`.jig/critique/${surface}/REPORT.md leaves out ${missing.length === 1 ? "a finding" : `${missing.length} findings`} the verdict files hold: ${missing.slice(0, 8).join(", ")}. The report is what the owner and \`make\` read; name every finding in it, by id (a decision by its name).`];
 }
-function tweakProblems(root, spec, owner = "") {
+function tweakProblems(root, spec, owner = "", start) {
   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\`.`);
@@ -8069,21 +8365,31 @@ function tweakProblems(root, spec, owner = "") {
   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(join42(root, ".jig", "critique", surface));
+  const record = readTweak(join43(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.`);
+    else if (owner && fileAtSessionStart(root, `.jig/critique/${surface}/tweak.json`, start) !== readText(join43(root, ".jig", "critique", surface, "tweak.json")) && !quoteHeld(record.change.replace(/^["“]|["”]$/g, ""), owner)) {
+      problems.push(`.jig/critique/${surface}/tweak.json: \`change\` is "${record.change.length > 90 ? `${record.change.slice(0, 90)}\u2026` : record.change}", which the owner did not say in this session. It is their words for the change, as they gave them; what you made of them goes in the spec's Tweak entry.`);
+    }
+    try {
+      const raw = JSON.parse(readFileSync36(join43(root, ".jig", "critique", surface, "tweak.json"), "utf8"));
+      const extra = Object.keys(raw).filter((k) => !["at", "change", "ids", "deferred"].includes(k));
+      if (extra.length) problems.push(`.jig/critique/${surface}/tweak.json: ${extra.map((k) => `\`${k}\``).join(", ")} ${extra.length === 1 ? "is not a field" : "are not fields"} Jig reads. tweak.json holds \`at\`, \`change\`, \`ids\` and \`deferred\`; what else you have to say goes in the spec's Tweak entry.`);
+    } catch {
+    }
     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.`);
     if (record.deferred !== void 0) {
-      if (typeof record.deferred === "string" ? !record.deferred.trim() || !quoteHeld(record.deferred.replace(/^["“]|["”]$/g, ""), owner) : !critiqueAtShip(root, spec.body)) {
+      const said = typeof record.deferred === "string" ? ownerWordProblem("defer", record.deferred, owner, `.jig/critique/${surface}/tweak.json: \`deferred\``) : void 0;
+      if (typeof record.deferred === "string" ? said !== void 0 : !critiqueAtShip(root, spec.body)) {
         problems.push(
-          `.jig/critique/${surface}/tweak.json defers its re-judge, and nobody said to. \`deferred\` quotes the owner telling you to leave it for later, or is \`true\` where the page's spec says \`critique: at-ship\` (or, the spec silent, jig.config.json says \`"critique": "at-ship"\`). Otherwise re-judge what it names.`
+          `.jig/critique/${surface}/tweak.json defers its re-judge, and nobody said to. \`deferred\` quotes the owner telling you to leave it for later, or is \`true\` where the page's spec says \`critique: at-ship\` (or, the spec silent, jig.config.json says \`"critique": "at-ship"\`). Otherwise re-judge what it names.` + (said ? ` ${said}` : "")
         );
       }
       return problems;
     }
-    const unjudged = unjudgedTweakIds(join42(root, ".jig", "critique", surface), record);
+    const unjudged = unjudgedTweakIds(join43(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.`
@@ -8110,7 +8416,7 @@ function structureSinceApproval(root, spec, front) {
   const problems = [];
   let thenBody = "";
   try {
-    thenBody = git(["show", `${baseline}:./${spec.path}`]);
+    thenBody = lf(git(["show", `${baseline}:./${spec.path}`]));
   } catch {
     return [];
   }
@@ -8119,9 +8425,9 @@ function structureSinceApproval(root, spec, front) {
     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) && existsSync26(join42(root, at))) {
+  if (at && !/^https?:/i.test(at) && existsSync27(join43(root, at))) {
     try {
-      if (git(["show", `${baseline}:./${at}`]) !== readFileSync35(join42(root, at), "utf8")) {
+      if (lf(git(["show", `${baseline}:./${at}`])) !== readText(join43(root, at))) {
         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 {
@@ -8131,7 +8437,7 @@ function structureSinceApproval(root, spec, front) {
 }
 function readTweak(dir) {
   try {
-    const raw = JSON.parse(readFileSync35(join42(dir, "tweak.json"), "utf8"));
+    const raw = JSON.parse(readFileSync36(join43(dir, "tweak.json"), "utf8"));
     const deferred = typeof raw.deferred === "string" || raw.deferred === true ? raw.deferred : void 0;
     return { at: String(raw.at ?? ""), change: String(raw.change ?? "").trim(), ids: Array.isArray(raw.ids) ? raw.ids.map(String) : [], ...deferred !== void 0 ? { deferred } : {} };
   } catch {
@@ -8144,20 +8450,20 @@ function surfacePage(projectRoot, surface) {
   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));
   for (const candidate of candidates) {
-    if (candidate && existsSync26(join42(projectRoot, candidate))) return candidate;
+    if (candidate && existsSync27(join43(projectRoot, candidate))) return candidate;
   }
   return void 0;
 }
 function gate(opts) {
   const root = opts.projectRoot;
-  if (!existsSync26(join42(root, "jig.config.json")) && !existsSync26(join42(root, ".jig"))) {
+  if (!existsSync27(join43(root, "jig.config.json")) && !existsSync27(join43(root, ".jig"))) {
     return { block: false, reason: "" };
   }
   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 start = sessionStart(opts.input.transcript_path);
-  const owner = command === "spec" || command === "mockup" || command === "make" || command === "tweak" ? ownerWords(opts.input.transcript_path) : "";
+  const owner = command === "decide" || command === "spec" || command === "mockup" || command === "make" || command === "tweak" ? ownerWords(opts.input.transcript_path) : "";
   const problems = command && !waiting ? commandProblems(root, command, invocation?.surface, start, owner).map((p) => `/jig ${command}: ${p}`) : [];
   if (waiting && command === "mockup") problems.push(...drawingBeforeAsking(root, invocation?.surface).map((p) => `/jig mockup: ${p}`));
   if (command === "ship" && !asksOwner(lastAssistantText(opts.input.transcript_path))) {
@@ -8171,9 +8477,24 @@ ${result.report}`);
       problems.push(`/jig make: ${spec.path} still says \`mockup: pending\`: nobody has said whether to draw it. Ask the owner, draw it with \`/jig mockup\` or skip it; if they skip it, write \`mockup: skipped \u2014 "<their words>"\` and build from the spec alone.`);
     }
   }
+  if (command === "spec" && !waiting) {
+    const spec = namedSpec(root, invocation?.surface);
+    if (spec && isConfirmed(spec.body) && !isConfirmed(fileAtSessionStart(root, spec.path, start))) {
+      const reply = ownerReplyAfter(opts.input.transcript_path, /\bconfirm/i);
+      const said = reply === void 0 ? void 0 : ownerWordProblem("confirm", reply.slice(0, 400), reply, `${spec.path}: \`confirmed: true\``);
+      if (reply === void 0) problems.push(`/jig spec: ${spec.path} is recorded as confirmed, and the owner was never asked to confirm it. Put it to them with its sheet and stop; record \`confirmed: true\` when they say yes.`);
+      else if (said) problems.push(`/jig spec: ${spec.path} is recorded as confirmed, but the owner's reply to being asked does not confirm it ("${reply.trim().slice(0, 120)}"). Record \`confirmed: true\` only on their yes.`);
+    }
+  }
   if (waiting && command === "spec") {
-    const spec = specFor(root, invocation?.surface);
+    const spec = namedSpec(root, invocation?.surface);
+    if (!spec && invocation?.surface && /\bconfirm/i.test(lastAssistantText(opts.input.transcript_path) ?? "")) {
+      problems.push(`/jig spec: you are asking the owner to confirm a spec that is not at .jig/specs/${invocation.surface}.spec.md. Write it there, with \`confirmed: false\`, have it checked (step 3c), and ask again: the checks the owner relies on read that file, and a draft kept anywhere else is checked by nothing.`);
+    }
     if (spec) problems.push(...specChecked(root, spec, start, owner).map((p) => `/jig spec: ${p}`));
+    if (spec && existsSync27(join43(root, ".jig", "specs", `${spec.slug}.checked.json`))) {
+      problems.push(...[...specProblems(spec), ...newFieldProblems(spec, fileAtSessionStart(root, spec.path, start))].map((p) => `/jig spec: ${p}`));
+    }
   }
   const selection = selectFiles(root, false);
   const changedUi = selection.mode === "changed" && selection.files.some((f) => isStyleBearing(f) || isReaderText(f));
@@ -8196,11 +8517,17 @@ ${result.report}`);
     }
   }
   problems.push(...verdictGuard(root, command, surfacesInPlay(root, command, opts.input.transcript_path, invocation?.surface)));
-  const critiqueDir = join42(root, ".jig", "critique");
-  if (existsSync26(critiqueDir)) {
+  problems.push(...probesLeftBehind(root, surfacesInPlay(root, command, opts.input.transcript_path, invocation?.surface)));
+  const touched = ["AGENTS.md", "CLAUDE.md"].some((f) => {
+    const now = existsSync27(join43(root, f)) ? readText(join43(root, f)) : "";
+    return fileAtSessionStart(root, f, start) !== now;
+  });
+  if (touched) problems.push(...agentFileProblems(root).map((p) => `Jig's agent instructions: ${p}`));
+  const critiqueDir = join43(root, ".jig", "critique");
+  if (existsSync27(critiqueDir)) {
     for (const surface of surfacesInPlay(root, command, opts.input.transcript_path, invocation?.surface)) {
-      const dir = join42(critiqueDir, surface);
-      if (!existsSync26(join42(dir, "screen.json")) && !existsSync26(join42(dir, "code.json"))) continue;
+      const dir = join43(critiqueDir, surface);
+      if (!existsSync27(join43(dir, "screen.json")) && !existsSync27(join43(dir, "code.json"))) continue;
       const v = verifyVerdicts({ projectRoot: root, surface });
       if (!v.ok) {
         const shown = v.errors.slice(0, 6).map((e) => `  ${e}`);
@@ -8223,10 +8550,10 @@ ${problems.join("\n\n")}`
   }
   const session = opts.input.session_id ?? "unknown";
   const key = `${session}:${createHash3("sha256").update(problems.join("\n")).digest("hex").slice(0, 12)}`;
-  const stateFile = join42(root, ".jig", "gate.json");
+  const stateFile = join43(root, ".jig", "gate.json");
   let state = {};
   try {
-    state = JSON.parse(readFileSync35(stateFile, "utf8"));
+    state = JSON.parse(readFileSync36(stateFile, "utf8"));
   } catch {
   }
   if (problems.length === 0) {
@@ -8261,7 +8588,7 @@ function verdictDigests(dir) {
   for (const f of VERDICT_FILES) {
     let file;
     try {
-      file = JSON.parse(readFileSync35(join42(dir, f), "utf8"));
+      file = JSON.parse(readFileSync36(join43(dir, f), "utf8"));
     } catch {
       continue;
     }
@@ -8276,7 +8603,7 @@ function writeLock(root, surface, lockPath, dir, now) {
   const pageFile2 = recordedPage(root, surface);
   let page;
   try {
-    if (pageFile2) page = { file: pageFile2, checksum: pageChecksum(readFileSync35(join42(root, pageFile2), "utf8")) };
+    if (pageFile2) page = { file: pageFile2, checksum: pageChecksum(readFileSync36(join43(root, pageFile2), "utf8")) };
   } catch {
   }
   const tweakAt = readTweak(dir)?.at;
@@ -8289,7 +8616,7 @@ function verdictChecksum(dir) {
   const parts = VERDICT_FILES.map((f) => {
     try {
       return `${f}
-${readFileSync35(join42(dir, f), "utf8")}`;
+${readFileSync36(join43(dir, f), "utf8")}`;
     } catch {
       return "";
     }
@@ -8297,15 +8624,15 @@ ${readFileSync35(join42(dir, f), "utf8")}`;
   return parts.some(Boolean) ? checksum(parts.join("\n")) : void 0;
 }
 function verdictGuard(root, command, inPlay) {
-  const critiqueDir = join42(root, ".jig", "critique");
-  if (!existsSync26(critiqueDir)) return [];
+  const critiqueDir = join43(root, ".jig", "critique");
+  if (!existsSync27(critiqueDir)) return [];
   const problems = [];
   for (const surface of readdirSync16(critiqueDir)) {
     if (surface.startsWith("_")) continue;
-    const dir = join42(critiqueDir, surface);
+    const dir = join43(critiqueDir, surface);
     const now = verdictChecksum(dir);
     if (!now) continue;
-    const lockPath = join42(dir, LOCK);
+    const lockPath = join43(dir, LOCK);
     if ((command === "critique" || command === "ship") && (!inPlay || inPlay.includes(surface))) {
       writeLock(root, surface, lockPath, dir, now);
       problems.push(...lockLeftBehind(root, surface));
@@ -8313,7 +8640,7 @@ function verdictGuard(root, command, inPlay) {
     }
     let lock = {};
     try {
-      lock = JSON.parse(readFileSync35(lockPath, "utf8"));
+      lock = JSON.parse(readFileSync36(lockPath, "utf8"));
     } catch {
       continue;
     }
@@ -8346,6 +8673,25 @@ function lockLeftBehind(root, surface) {
   }
   return [`${rel}/${LOCK} was written when you stopped, after the verdicts it records were committed. Commit it on its own (\`git add ${rel}/${LOCK} && git commit -m "chore: record ${surface}'s verdict lock"\`), and nothing else.`];
 }
+function probesLeftBehind(root, surfaces) {
+  if (!surfaces.length) return [];
+  let lines;
+  try {
+    lines = execFileSync4("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const path = (l) => l.slice(3).replace(/^"|"$/g, "");
+  const isProbe = (p) => /^\.jig\/critique\/[^/]+\/probe-[^/]+\.json$/.test(p);
+  const isLock = (p) => /^\.jig\/critique\/[^/]+\/verdicts\.lock$/.test(p);
+  if (lines.some((l) => !isProbe(path(l)) && !isLock(path(l)))) return [];
+  const left = lines.map(path).filter((p) => isProbe(p) && surfaces.some((s) => p.startsWith(`.jig/critique/${s}/`)));
+  if (!left.length) return [];
+  const bySurface = [...new Set(left.map((p) => p.split("/")[2]))];
+  return [
+    `The gate re-took ${left.length} probe file${left.length === 1 ? "" : "s"} of ${bySurface.join(", ")} when you stopped, after your last commit: the page changed since they were taken. Commit them on their own (\`git add ${bySurface.map((s) => `.jig/critique/${s}/probe-*.json`).join(" ")} && git commit -m "chore: re-take ${bySurface.join(", ")}'s probes"\`), and nothing else.`
+  ];
+}
 function tweakVerdictProblems(dir, surface, lockedVerdicts) {
   const record = readTweak(dir);
   if (!record) {
@@ -8370,7 +8716,7 @@ function unjudgedTweakIds(dir, record) {
   for (const f of VERDICT_FILES) {
     let file;
     try {
-      file = JSON.parse(readFileSync35(join42(dir, f), "utf8"));
+      file = JSON.parse(readFileSync36(join43(dir, f), "utf8"));
     } catch {
       continue;
     }
@@ -8382,7 +8728,7 @@ function unjudgedTweakIds(dir, record) {
 }
 function save(file, state) {
   try {
-    mkdirSync8(join42(file, ".."), { recursive: true });
+    mkdirSync8(join43(file, ".."), { recursive: true });
     writeFileSync6(file, JSON.stringify(state), "utf8");
   } catch {
   }
@@ -8390,7 +8736,7 @@ function save(file, state) {
 
 // src/index.ts
 var packageRoot = getPackageRoot();
-var { version } = JSON.parse(readFileSync36(join43(packageRoot, "package.json"), "utf8"));
+var { version } = JSON.parse(readFileSync37(join44(packageRoot, "package.json"), "utf8"));
 function warnIfUnpublishedPin() {
   if (isDevVersion(version)) {
     console.warn(
@@ -8434,7 +8780,7 @@ program.command("install").description("Install Jig rules and the agent skill fi
       projectRoot,
       packageRoot: assetRoot(),
       version,
-      homeDir: homedir2(),
+      homeDir: homedir3(),
       hook
     });
     if (result.warning) {
@@ -8443,6 +8789,7 @@ program.command("install").description("Install Jig rules and the agent skill fi
     }
     if (result.hookOnly) {
       console.log(result.hookOnly);
+      for (const f of result.agentFiles ?? []) console.log(`  + ${f} (Jig's block for your agent; your own text in it is untouched)`);
       if (result.stopHook === true) console.log("  + .claude/settings.json (Stop hook: jig gate blocks finishing while check or a critique fails)");
       if (result.stopHook === false) console.log("  ! .claude/settings.json is not valid JSON \u2014 the Stop hook was not added. Fix the file and run install again.");
       return;
@@ -8451,6 +8798,7 @@ program.command("install").description("Install Jig rules and the agent skill fi
     warnIfUnpublishedPin();
     for (const f of result.written) console.log(`  + ${f}`);
     for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+    for (const f of result.agentFiles ?? []) console.log(`  + ${f} (Jig's block for your agent; your own text in it is untouched)`);
     if (result.stopHook === true) console.log("  + .claude/settings.json (Stop hook: jig gate blocks finishing while check or a critique fails)");
     if (result.stopHook === false) console.log("  ! .claude/settings.json is not valid JSON \u2014 the Stop hook was not added. Fix the file and run install again.");
     if (result.stopHook === void 0 && opts.agent === "claude" && opts.scope === "project") {
@@ -8478,7 +8826,7 @@ program.command("update").description("Update vendored Jig rules, skipping files
       projectRoot,
       packageRoot: assetRoot(),
       version,
-      homeDir: homedir2()
+      homeDir: homedir3()
     });
     const label = result.targets.map((t) => `${t.agent} (${t.scope}, ${t.fromVersion})`).join(", ");
     warnIfUnpublishedPin();
@@ -8497,6 +8845,16 @@ program.command("update").description("Update vendored Jig rules, skipping files
     process.exit(1);
   }
 });
+program.command("checksum").description("Print a spec's checksum, the value its .checked.json records as `spec`.").argument("<spec>", "the spec by name (tokens-and-modes) or path (.jig/specs/tokens-and-modes.spec.md)").action((name) => {
+  const projectRoot = findProjectRoot(process.cwd());
+  const slug = name.replace(/^.*\//, "").replace(/\.spec\.md$/, "");
+  const path = join44(projectRoot, ".jig", "specs", `${slug}.spec.md`);
+  if (!existsSync28(path)) {
+    console.error(`  \u2717 no spec at .jig/specs/${slug}.spec.md`);
+    process.exit(1);
+  }
+  console.log(specChecksum(readFileSync37(path, "utf8")));
+});
 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 {
@@ -8541,7 +8899,7 @@ program.command("check").description("Check the repo against Jig's mechanical +
   try {
     const result = check({
       projectRoot,
-      homeDir: homedir2(),
+      homeDir: homedir3(),
       version,
       all: opts.all,
       ci: opts.ci
@@ -8624,13 +8982,14 @@ program.command("probe").description("Print the render probe. With --save, read
 program.command("gate").description("Run by the Claude Code Stop hook: block stopping while check or a critique fails.").action(async () => {
   let input = {};
   try {
-    if (!process.stdin.isTTY) input = JSON.parse(readFileSync36(0, "utf8") || "{}");
+    if (!process.stdin.isTTY) input = JSON.parse(readFileSync37(0, "utf8") || "{}");
   } catch {
   }
   const cwd = input.cwd ?? process.cwd();
   try {
     const projectRoot = findProjectRoot(cwd);
-    const critiqued = critiquedSurfaces(projectRoot);
+    const byHand = !input.transcript_path;
+    const critiqued = byHand ? [] : critiquedSurfaces(projectRoot);
     for (const surface of surfacesToProbe(projectRoot, input).filter((s) => critiqued.includes(s))) {
       const page = surfacePage(projectRoot, surface) ?? recordedPage(projectRoot, surface);
       if (!page) continue;
@@ -8653,7 +9012,7 @@ program.command("init").description("Set the project up to use Jig: a brand file
     await init({
       projectRoot,
       packageRoot: assetRoot(),
-      homeDir: homedir2(),
+      homeDir: homedir3(),
       version,
       yes: opts.yes
     });
@@ -8664,7 +9023,7 @@ program.command("init").description("Set the project up to use Jig: a brand file
 });
 function resolveSurfaceMode(projectRoot) {
   try {
-    const config = JSON.parse(readFileSync36(join43(projectRoot, "jig.config.json"), "utf8"));
+    const config = JSON.parse(readFileSync37(join44(projectRoot, "jig.config.json"), "utf8"));
     const modes = [...new Set((config.surfaces ?? []).map((s) => s.mode).filter(Boolean))];
     return modes.length === 1 ? modes[0] : void 0;
   } catch {