jig-ui 0.2.1 → 0.4.0

package/dist/index.js

@@ -2,9 +2,9 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join21 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -37,12 +37,16 @@ function assetRoot(startDir = getPackageRoot()) {
     current = dirname(current);
   }
 }
+function isPublishedBuild(packageRoot2) {
+  return packageRoot2.split(/[\\/]/).includes("node_modules");
+}
 
 // src/commands/install.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
 
 // src/adapters/types.ts
+var COMMAND_DESCRIPTION = "Run a Jig design-system command: set the project up, review the UI against the rules, or refresh the install.";
 var SKILL_DESCRIPTION = "Design system rules for generating and reviewing UI. Load before building any interface.";
 function assertSafeRelPath(relPath, adapterName) {
   const isAbsolute = relPath.startsWith("/") || /^[A-Za-z]:/.test(relPath);
@@ -56,92 +60,172 @@ function quoteYamlString(value) {
 }
 var BLOCK_START = "<!-- jig:start -->";
 var BLOCK_END = "<!-- jig:end -->";
-function agentsBlock(skillBody) {
-  return [BLOCK_START, "", "# Jig \u2014 UI rules", "", skillBody, "", BLOCK_END, ""].join("\n");
+function agentsPointer(skillPath) {
+  return [
+    BLOCK_START,
+    "",
+    "# Jig \u2014 UI rules",
+    "",
+    `This project uses Jig, a design system for generating and reviewing UI.`,
+    `Before building or reviewing any interface, read \`${skillPath}\` and follow it.`,
+    "It is short, and it tells you which rule files to load for the task at hand.",
+    "",
+    BLOCK_END,
+    ""
+  ].join("\n");
 }
 
-// src/adapters/claude.ts
-var claude = {
-  name: "claude",
-  displayName: "Claude Code",
-  supportsScope: () => true,
-  skillFiles(ctx) {
-    const content = [
-      "---",
-      "name: jig",
-      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
-      "user-invocable: true",
-      "---",
-      "",
-      ctx.skillBody,
-      ""
-    ].join("\n");
-    return [{ relPath: ".claude/skills/jig/SKILL.md", content }];
-  }
-};
-
 // src/adapters/codex.ts
 var codex = {
   name: "codex",
   displayName: "Codex",
-  supportsScope: () => true,
-  skillFiles(ctx) {
-    const relPath = ctx.scope === "global" ? ".codex/AGENTS.md" : "AGENTS.md";
-    return [{ relPath, content: agentsBlock(ctx.skillBody) }];
-  }
-};
-
-// src/adapters/cursor.ts
-var cursor = {
-  name: "cursor",
-  displayName: "Cursor",
-  supportsScope: (scope) => scope === "project",
-  skillFiles(ctx) {
-    const content = [
-      "---",
-      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
-      "alwaysApply: false",
-      "---",
-      "",
-      ctx.skillBody,
-      ""
-    ].join("\n");
-    return [{ relPath: ".cursor/rules/jig.mdc", content }];
-  }
-};
-
-// src/adapters/opencode.ts
-var opencode = {
-  name: "opencode",
-  displayName: "opencode",
-  supportsScope: () => true,
   skillFiles(ctx) {
-    const content = [
-      "---",
-      "name: jig",
-      `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
-      "---",
-      "",
-      ctx.skillBody,
-      ""
-    ].join("\n");
-    const relPath = ctx.scope === "global" ? ".config/opencode/skills/jig/SKILL.md" : ".opencode/skills/jig/SKILL.md";
-    return [{ relPath, content }];
-  }
+    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) });
+    if (ctx.commandBody && ctx.scope === "global") {
+      files.push({ relPath: ".codex/prompts/jig.md", content: `${ctx.commandBody}
+` });
+    }
+    return files;
+  },
+  /**
+   * codex has no skill directory: AGENTS.md is a plain file (project root, or
+   * `.codex/` for a global install). Reference material lives under `.codex/`
+   * at BOTH scopes.
+   *
+   * Project scope used to be a bare `.jig`, which put Jig's rules, index,
+   * licence and manifest into the one directory 0.4.0 reserves for the
+   * project's own material — the brand file, the mode copies, `state.json`.
+   * That cost more than tidiness:
+   *
+   * - `detectLegacyRules` scans `.jig/` for install artifacts and offers to
+   *   remove them. Under the old layout a *live* codex install looked exactly
+   *   like the legacy one, so the migration path could offer to delete the
+   *   install just made.
+   * - One directory holding two manifests is what let a stale
+   *   `.jig/manifest.json` hijack `update` and resurrect the vendored layout.
+   *
+   * Mirroring the global path keeps codex's own convention and leaves `.jig/`
+   * unambiguously the project's.
+   */
+  /**
+   * Beside the skill, like every other harness — the rules are what `SKILL.md`
+   * tells the agent to read, so they belong next to it. This used to be
+   * `.codex/.jig`, and before that a bare `.jig`, which put Jig's property in
+   * the one directory the project owns.
+   */
+  referenceDir: () => ".agents/skills/jig",
+  argsPlaceholder: "$ARGUMENTS"
 };
 
-// src/adapters/generic.ts
-var generic = {
-  name: "generic",
-  displayName: "Generic (AGENTS.md)",
-  supportsScope: (scope) => scope === "project",
-  skillFiles(ctx) {
-    return [{ relPath: "AGENTS.md", content: agentsBlock(ctx.skillBody) }];
+// src/adapters/skill-dir.ts
+var SKILL_DIR_HARNESSES = [
+  {
+    name: "claude",
+    dir: ".claude",
+    displayName: "Claude Code",
+    extraFrontmatter: ["user-invocable: true"],
+    // `commands/<name>.md`, YAML frontmatter, `$ARGUMENTS` in the body —
+    // verified against the shipped command files under
+    // ~/.claude/plugins/marketplaces/*/plugins/*/commands/.
+    commands: { dir: "commands", format: "md" }
+  },
+  { name: "cursor", dir: ".cursor", displayName: "Cursor", commands: { dir: "commands", format: "md" } },
+  {
+    name: "opencode",
+    dir: ".opencode",
+    globalDir: ".config/opencode",
+    displayName: "opencode",
+    // Singular `command/`, unlike everyone else's `commands/`.
+    commands: { dir: "command", format: "md" }
+  },
+  // No slash-command mechanism of its own — `.agents` is a skills convention
+  // rather than a harness, so there is nothing to write a command file for.
+  { name: "generic", dir: ".agents", displayName: "Generic (.agents/skills)" },
+  // Proves the table design: this row is the entire diff needed to support
+  // a sixth harness. Gemini CLI, Copilot CLI and others read `.agents/skills`
+  // too, but Gemini also has its own `.gemini` skill directory.
+  {
+    name: "gemini",
+    dir: ".gemini",
+    displayName: "Gemini CLI",
+    // Gemini reads TOML, with `{{args}}` where the others use `$ARGUMENTS`.
+    commands: { dir: "commands", format: "toml" }
   }
-};
+];
+function dirFor(h, scope) {
+  return scope === "global" && h.globalDir ? h.globalDir : h.dir;
+}
+function skillDirAdapter(h) {
+  return {
+    name: h.name,
+    displayName: h.displayName,
+    skillFiles(ctx) {
+      const content = [
+        "---",
+        "name: jig",
+        `description: ${quoteYamlString(SKILL_DESCRIPTION)}`,
+        ...h.extraFrontmatter ?? [],
+        "---",
+        "",
+        ctx.skillBody,
+        ""
+      ].join("\n");
+      const files = [
+        { relPath: `${dirFor(h, ctx.scope)}/skills/jig/SKILL.md`, content }
+      ];
+      if (h.commands && ctx.commandBody) {
+        files.push({
+          relPath: `${dirFor(h, ctx.scope)}/${h.commands.dir}/jig.${h.commands.format}`,
+          content: h.commands.format === "toml" ? tomlCommand(ctx.commandBody) : markdownCommand(ctx.commandBody, ctx.subcommands ?? [])
+        });
+      }
+      return files;
+    },
+    referenceDir(scope) {
+      return `${dirFor(h, scope)}/skills/jig`;
+    },
+    argsPlaceholder: h.commands?.format === "toml" ? "{{args}}" : "$ARGUMENTS"
+  };
+}
+function markdownCommand(body, subcommands) {
+  return [
+    "---",
+    `description: ${quoteYamlString(COMMAND_DESCRIPTION)}`,
+    `argument-hint: ${subcommands.join("|")} [flags]`,
+    "---",
+    "",
+    body,
+    ""
+  ].join("\n");
+}
+var TOML_DELIM = "'''";
+function tomlCommand(body) {
+  const safe = body.split(TOML_DELIM).join('"""');
+  return [
+    `description = ${JSON.stringify(COMMAND_DESCRIPTION)}`,
+    `prompt = ${TOML_DELIM}`,
+    safe,
+    TOML_DELIM,
+    ""
+  ].join("\n");
+}
+var SKILL_DIR_ADAPTERS = SKILL_DIR_HARNESSES.map(skillDirAdapter);
 
 // src/adapters/registry.ts
-var ADAPTERS = [claude, codex, cursor, opencode, generic];
+var ADAPTERS = [codex, ...SKILL_DIR_ADAPTERS];
+function referenceDirFor(adapter, scope) {
+  const dir = adapter.referenceDir(scope);
+  assertSafeRelPath(dir, adapter.name);
+  return dir;
+}
+for (const adapter of ADAPTERS) {
+  for (const scope of ["project", "global"]) {
+    assertSafeRelPath(adapter.referenceDir(scope), adapter.name);
+  }
+}
 function adapterNames() {
   return ADAPTERS.map((a) => a.name);
 }
@@ -160,12 +244,59 @@ function skillFilesFor(adapter, ctx) {
   return files;
 }
 
+// src/install/references.ts
+import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
+import { join as join2, posix } from "path";
+function referenceFiles(packageRoot2) {
+  const root = join2(packageRoot2, "references");
+  if (!existsSync2(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;
+      if (entry.isDirectory()) {
+        walk2(child, rel);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        found.push({ relPath: rel, content: readFileSync(child, "utf8") });
+      }
+    }
+  };
+  walk2(root, "");
+  return found;
+}
+
 // src/install/manifest.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-var MANIFEST_REL = join2(".jig", "manifest.json");
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } 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
 var REGENERATE_HINT = "Re-run 'jig install --agent <name>' to fix it.";
+function manifestPath(root, manifestDir) {
+  return join4(root, ...manifestDir.split("/"), "manifest.json");
+}
 function checksum(content) {
   const normalized = content.replace(/\r\n/g, "\n");
   return `sha256:${createHash("sha256").update(normalized, "utf8").digest("hex")}`;
@@ -200,29 +331,45 @@ function validateManifest(raw, path) {
     files
   };
 }
-function readManifest(projectRoot) {
-  const path = join2(projectRoot, MANIFEST_REL);
-  if (!existsSync2(path)) return null;
+function readManifest(root, manifestDir = ".jig") {
+  const path = manifestPath(root, manifestDir);
+  if (!existsSync3(path)) return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync(path, "utf8"));
+    raw = JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     throw new Error(`Jig's manifest at ${path} is not valid JSON. ${REGENERATE_HINT}`);
   }
   return validateManifest(raw, path);
 }
-function writeManifest(projectRoot, m) {
-  const path = join2(projectRoot, MANIFEST_REL);
-  mkdirSync(dirname2(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(m, null, 2)}
-`, "utf8");
+var MERGE_ATTEMPTS = 5;
+function writeManifest(root, m, manifestDir = ".jig") {
+  const path = manifestPath(root, manifestDir);
+  mkdirSync2(dirname3(path), { recursive: true });
+  for (let attempt = 0; attempt < MERGE_ATTEMPTS; attempt++) {
+    const onDisk = readManifestQuietly(path);
+    const merged = { ...m, files: { ...onDisk?.files ?? {}, ...m.files } };
+    writeFileAtomic(path, `${JSON.stringify(merged, null, 2)}
+`);
+    const after = readManifestQuietly(path);
+    if (after && Object.keys(merged.files).every((k) => k in after.files)) return;
+  }
+}
+function readManifestQuietly(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (!isPlainObject(parsed) || !isPlainObject(parsed.files)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
 }
 function isModified(projectRoot, relPath, m) {
   const recorded = m.files[relPath];
   if (!recorded) return false;
-  const abs = join2(projectRoot, relPath);
-  if (!existsSync2(abs)) return false;
-  return checksum(readFileSync(abs, "utf8")) !== recorded;
+  const abs = join4(projectRoot, relPath);
+  if (!existsSync3(abs)) return false;
+  return checksum(readFileSync2(abs, "utf8")) !== recorded;
 }
 
 // src/template/render.ts
@@ -250,15 +397,22 @@ function renderCommandTable(metadata) {
 }
 
 // src/install/vendor.ts
+import { posix as posix2 } from "path";
+var { join: join5 } = posix2;
 var DELIMITERS = {
   html: ["<!--", "-->"],
   css: ["/*", "*/"]
 };
-function vendorHeader(file, version2, style = "html") {
+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}.`,
-    "     Licensed Apache-2.0. See .jig/LICENSE and .jig/NOTICE.",
+    attribution,
     `     Edit freely: \`jig update\` will not overwrite a file you have changed. ${close}`,
     "",
     ""
@@ -301,16 +455,16 @@ function stripMarkerRegions(existing) {
     return { text: existing, insertAt: existing.length, removed: false };
   }
   let text = "";
-  let cursor2 = 0;
+  let cursor = 0;
   let insertAt = -1;
   regions.forEach((region, i) => {
-    let chunk = existing.slice(cursor2, region.start);
+    let chunk = existing.slice(cursor, region.start);
     if (i > 0) chunk = chunk.replace(/^\n/, "");
     text += chunk;
     if (insertAt === -1) insertAt = text.length;
-    cursor2 = region.end;
+    cursor = region.end;
   });
-  const tail = existing.slice(cursor2).replace(/^\n/, "");
+  const tail = existing.slice(cursor).replace(/^\n/, "");
   text += tail;
   return { text, insertAt, removed: true };
 }
@@ -323,82 +477,140 @@ function upsertBlock(existing, block) {
   return `${text.slice(0, insertAt)}${block}${text.slice(insertAt)}`;
 }
 
+// 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";
+}
+function matchLineEndings(content, existing) {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const target = existing === void 0 ? "\n" : dominantEnding(existing);
+  return target === "\n" ? normalized : normalized.replace(/\n/g, "\r\n");
+}
+
 // 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 relKey(...parts) {
   return parts.join("/");
 }
 function writeFile(root, key, content, files) {
-  const abs = join3(root, ...key.split("/"));
-  mkdirSync2(dirname3(abs), { recursive: true });
-  writeFileSync2(abs, content, "utf8");
-  files[key] = checksum(content);
+  const abs = join6(root, ...key.split("/"));
+  mkdirSync3(dirname4(abs), { recursive: true });
+  const existing = existsSync4(abs) ? readFileSync3(abs, "utf8") : void 0;
+  const toWrite = matchLineEndings(content, existing);
+  writeFileSync3(abs, toWrite, "utf8");
+  files[key] = checksum(toWrite);
 }
-function buildSkillBody(packageRoot2, scope) {
-  const template = readFileSync2(join3(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
+function buildSkillBody(packageRoot2, rulesPath, version2) {
+  const template = readFileSync3(join6(packageRoot2, "templates", "SKILL.md.tmpl"), "utf8");
   const metadata = JSON.parse(
-    readFileSync2(join3(packageRoot2, "templates", "command-metadata.json"), "utf8")
+    readFileSync3(join6(packageRoot2, "templates", "command-metadata.json"), "utf8")
   );
   return render(template, {
     command_prefix: "/jig ",
-    scripts_path: "npx jig-ui",
+    scripts_path: version2 ? `npx jig-ui@${version2}` : "npx jig-ui",
+    // `update` must NOT carry the pin. Pinned, it refreshes to the version
+    // already installed — reporting "Updated Jig → <same version>" for a no-op
+    // — so a reader following the skill could never upgrade.
+    update_path: "npx jig-ui@latest",
     ask_instruction: ASK_INSTRUCTION,
     available_commands: renderCommandTable(metadata),
     config_file: "jig.config.json",
-    rules_path: scope === "global" ? "~/.jig" : ".jig"
+    rules_path: rulesPath
   });
 }
+function buildCommandBody(packageRoot2, rulesPath, version2, argsPlaceholder) {
+  const metadata = JSON.parse(
+    readFileSync3(join6(packageRoot2, "templates", "command-metadata.json"), "utf8")
+  );
+  const subcommands = Object.entries(metadata).filter(([, meta]) => meta.status === "available").map(([name]) => name).sort();
+  const templatePath = join6(packageRoot2, "templates", "COMMAND.md.tmpl");
+  if (!existsSync4(templatePath)) return { body: "", subcommands };
+  const template = readFileSync3(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, `npx jig-ui@${version2}`).replace(/\{\{rules_path\}\}/g, rulesPath);
+  return { body, subcommands };
+}
+function rulesPathFor(referenceDir, scope) {
+  return scope === "global" ? `~/${referenceDir}/rules` : `${referenceDir}/rules`;
+}
 function install(opts) {
   const adapter = getAdapter(opts.agent);
-  if (!adapter.supportsScope(opts.scope)) {
-    throw new Error(`Adapter '${adapter.name}' does not support ${opts.scope} scope.`);
+  if (opts.scope === "project") {
+    const globalReferenceDir = referenceDirFor(adapter, "global");
+    let globalManifest;
+    try {
+      globalManifest = readManifest(opts.homeDir, globalReferenceDir);
+    } catch {
+      globalManifest = null;
+    }
+    if (globalManifest) {
+      return {
+        written: [],
+        skipped: [],
+        warning: `Jig is already installed globally for '${opts.agent}' (${globalReferenceDir} under your home directory). Installing again at project scope would leave two contradicting '${opts.agent}' skills. Run 'jig update' to refresh the global install instead, or choose a different --agent for this project.`
+      };
+    }
   }
   const installRoot = opts.scope === "global" ? opts.homeDir : opts.projectRoot;
+  const referenceDir = referenceDirFor(adapter, opts.scope);
   let existingManifest;
   try {
-    existingManifest = readManifest(installRoot);
+    existingManifest = readManifest(installRoot, referenceDir);
   } catch {
     existingManifest = null;
   }
   const planned = [];
-  const rulesDir = join3(opts.packageRoot, "rules");
-  for (const file of readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
-    const body = readFileSync2(join3(rulesDir, file), "utf8");
-    planned.push({ key: relKey(".jig", file), content: vendorHeader(file, opts.version) + body, checkable: true });
-  }
-  const tokensDir = join3(opts.packageRoot, "tokens");
-  for (const file of readdirSync(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
-    const body = readFileSync2(join3(tokensDir, file), "utf8");
+  const rulesDir = join6(opts.packageRoot, "rules");
+  for (const file of readdirSync2(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    const body = readFileSync3(join6(rulesDir, file), "utf8");
+    planned.push({
+      key: relKey(referenceDir, "rules", file),
+      content: vendorHeader(file, opts.version, "html", licencePathFor(`rules/${file}`)) + body,
+      checkable: true
+    });
+  }
+  for (const ref of referenceFiles(opts.packageRoot)) {
     planned.push({
-      key: relKey(".jig", "tokens", file),
-      content: vendorHeader(file, opts.version, "css") + body,
+      key: relKey(referenceDir, ...ref.relPath.split("/")),
+      content: vendorHeader(ref.relPath, opts.version, "html", licencePathFor(ref.relPath)) + ref.content,
       checkable: true
     });
   }
   planned.push({
-    key: relKey(".jig", "rules.index.json"),
-    content: readFileSync2(join3(opts.packageRoot, "rules.index.json"), "utf8"),
+    key: relKey(referenceDir, "rules.index.json"),
+    content: readFileSync3(join6(opts.packageRoot, "rules.index.json"), "utf8"),
     checkable: true
   });
   for (const src of ["LICENSE", "NOTICE"]) {
     planned.push({
-      key: relKey(".jig", src),
-      content: readFileSync2(join3(opts.packageRoot, src), "utf8"),
+      key: relKey(referenceDir, src),
+      content: readFileSync3(join6(opts.packageRoot, src), "utf8"),
       checkable: false
     });
   }
-  const skillBody = buildSkillBody(opts.packageRoot, opts.scope);
+  const rulesPath = rulesPathFor(referenceDir, opts.scope);
+  const skillBody = buildSkillBody(opts.packageRoot, rulesPath, opts.version);
+  const { body: commandBody, subcommands } = buildCommandBody(
+    opts.packageRoot,
+    rulesPath,
+    opts.version,
+    adapter.argsPlaceholder ?? "$ARGUMENTS"
+  );
+  const command = { commandBody, subcommands };
   const skillFiles = skillFilesFor(adapter, {
     version: opts.version,
     scope: opts.scope,
     skillBody,
-    commandPrefix: "/jig "
+    commandPrefix: "/jig ",
+    ...command
   });
   for (const file of skillFiles) {
     const key = file.relPath;
-    const abs = join3(installRoot, ...key.split("/"));
+    const abs = join6(installRoot, ...key.split("/"));
     const isBlockFile = file.content.includes(BLOCK_START);
-    const content = isBlockFile && existsSync3(abs) ? upsertBlock(readFileSync2(abs, "utf8"), file.content) : file.content;
+    const content = isBlockFile && existsSync4(abs) ? upsertBlock(readFileSync3(abs, "utf8"), file.content) : file.content;
     planned.push({ key, content, checkable: !isBlockFile });
   }
   const files = {};
@@ -421,79 +633,296 @@ function install(opts) {
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
     files
   };
-  writeManifest(installRoot, manifest);
-  written.push(relKey(".jig", "manifest.json"));
+  writeManifest(installRoot, manifest, referenceDir);
+  written.push(relKey(referenceDir, "manifest.json"));
   return { written, skipped };
 }
 
 // src/commands/update.ts
-import { basename, dirname as dirname4, join as join4, resolve } from "path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
-var ALWAYS_REPLACE = [relKey(".jig", "LICENSE"), relKey(".jig", "NOTICE")];
+import { dirname as dirname6, join as join9 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, readdirSync as readdirSync4, writeFileSync as writeFileSync5 } from "fs";
+
+// src/install/target.ts
+import { resolve } from "path";
+function resolveAllInstalled(projectRoot, homeDir) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sameRoot = resolve(projectRoot) === resolve(homeDir);
+  for (const adapter of ADAPTERS) {
+    const referenceDir = referenceDirFor(adapter, "project");
+    const manifest = readManifest(projectRoot, referenceDir);
+    if (manifest && manifest.agent !== adapter.name) {
+      getAdapter(manifest.agent);
+    }
+    if (manifest && manifest.agent === adapter.name) {
+      const collides = sameRoot && referenceDirFor(adapter, "global") === referenceDir;
+      const scope = collides ? manifest.scope : "project";
+      const installRoot = scope === "global" ? homeDir : projectRoot;
+      const key = `${resolve(installRoot)}\0${referenceDir}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        found.push({ installRoot, scope, manifest, referenceDir });
+      }
+    }
+  }
+  for (const adapter of ADAPTERS) {
+    const referenceDir = referenceDirFor(adapter, "global");
+    const manifest = readManifest(homeDir, referenceDir);
+    if (manifest && manifest.agent !== adapter.name) {
+      getAdapter(manifest.agent);
+    }
+    if (manifest && manifest.agent === adapter.name) {
+      const key = `${resolve(homeDir)}\0${referenceDir}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        found.push({ installRoot: homeDir, scope: "global", manifest, referenceDir });
+      }
+    }
+  }
+  return found;
+}
+
+// src/init/state.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
+var INIT_MANIFEST_REL = join7(".jig", "state.json");
+function readInitManifest(projectRoot) {
+  const path = join7(projectRoot, INIT_MANIFEST_REL);
+  if (!existsSync5(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync4(path, "utf8"));
+    if (typeof raw !== "object" || raw === null) return null;
+    const { files, version: version2, modes } = raw;
+    if (typeof files !== "object" || files === null) return null;
+    return {
+      files,
+      version: typeof version2 === "string" ? version2 : void 0,
+      modes: Array.isArray(modes) && modes.every((m) => typeof m === "string") ? modes : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+var MERGE_ATTEMPTS2 = 5;
+function writeInitManifest(projectRoot, m) {
+  const path = join7(projectRoot, INIT_MANIFEST_REL);
+  mkdirSync4(dirname5(path), { recursive: true });
+  for (let attempt = 0; attempt < MERGE_ATTEMPTS2; attempt++) {
+    const onDisk = readInitManifest(projectRoot);
+    const merged = {
+      ...m,
+      modes: [.../* @__PURE__ */ new Set([...onDisk?.modes ?? [], ...m.modes ?? []])],
+      files: { ...onDisk?.files ?? {}, ...m.files }
+    };
+    writeFileAtomic(path, `${JSON.stringify(merged, null, 2)}
+`);
+    const after = readInitManifest(projectRoot);
+    if (after && Object.keys(merged.files).every((k) => k in after.files)) return;
+  }
+}
+function isInitFileModified(projectRoot, relPath, m) {
+  const asManifest = { version: "", agent: "", scope: "project", installedAt: "", files: m.files };
+  return isModified(projectRoot, relPath, asManifest);
+}
+
+// src/init/migrate.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync3, rmSync } from "fs";
+import { join as join8 } 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(readFileSync5(join8(dirAbs, "manifest.json"), "utf8"));
+    if (raw && typeof raw === "object" && typeof raw.files === "object") {
+      return raw;
+    }
+  } catch {
+  }
+  return null;
+}
+function classify(projectRoot, relPath, legacyManifest) {
+  return legacyManifest && relPath in legacyManifest.files ? isModified(projectRoot, relPath, legacyManifest) : "unknown";
+}
+function detectLegacyRules(projectRoot) {
+  const jigDir = join8(projectRoot, ".jig");
+  if (!existsSync6(jigDir)) return { present: false, files: [] };
+  const legacyManifest = readLegacyManifest(jigDir);
+  let entries;
+  try {
+    entries = readdirSync3(jigDir);
+  } catch {
+    entries = [];
+  }
+  const files = entries.filter(isLegacyInstallArtifact).sort().map((name) => {
+    const relPath = `.jig/${name}`;
+    return { relPath, modified: classify(projectRoot, relPath, legacyManifest) };
+  });
+  return { present: files.length > 0, files };
+}
+function detectLegacyCursorRules(projectRoot) {
+  const bundleDirRel = ".cursor/rules/jig";
+  const bundleDir = join8(projectRoot, ...bundleDirRel.split("/"));
+  const mdcRel = ".cursor/rules/jig.mdc";
+  const mdcAbs = join8(projectRoot, ...mdcRel.split("/"));
+  const legacyManifest = readLegacyManifest(bundleDir);
+  const files = [];
+  if (existsSync6(mdcAbs)) {
+    files.push({ relPath: mdcRel, modified: classify(projectRoot, mdcRel, legacyManifest) });
+  }
+  let entries;
+  try {
+    entries = readdirSync3(bundleDir);
+  } catch {
+    entries = [];
+  }
+  for (const name of entries.filter(isLegacyInstallArtifact).sort()) {
+    const relPath = `${bundleDirRel}/${name}`;
+    files.push({ relPath, modified: classify(projectRoot, relPath, legacyManifest) });
+  }
+  return { present: files.length > 0, files };
+}
+function describeLegacyFiles(report, headerLine, subheaderLine) {
+  if (!report.present) return [];
+  const lines = [];
+  lines.push(`
+${headerLine}`);
+  lines.push(subheaderLine);
+  for (const f of report.files) lines.push(`    ${f.relPath}`);
+  const edited = report.files.filter((f) => f.modified === true).map((f) => f.relPath);
+  const unknown = report.files.filter((f) => f.modified === "unknown").map((f) => f.relPath);
+  if (edited.length) {
+    lines.push("  Edited since install \u2014 kept, never removed automatically:");
+    for (const relPath of edited) lines.push(`    ${relPath}`);
+  }
+  if (unknown.length) {
+    lines.push("  No install record to verify against \u2014 kept; remove manually if you are sure they are untouched:");
+    for (const relPath of unknown) lines.push(`    ${relPath}`);
+  }
+  return lines;
+}
+function describeLegacyReport(report) {
+  return describeLegacyFiles(
+    report,
+    `Found a pre-0.4.0 Jig install in .jig/ (${report.files.length} file(s)). These are no longer used \u2014`,
+    "  since 0.4.0 the skill and its rules live in your agent's skill directory, not the project:"
+  );
+}
+function describeLegacyCursorReport(report) {
+  return describeLegacyFiles(
+    report,
+    `Found a legacy Cursor install (${report.files.length} file(s)). Cursor's skill has moved \u2014`,
+    "  from .cursor/rules/jig.mdc to .cursor/skills/jig/SKILL.md; these are no longer read:"
+  );
+}
+function removableLegacyFiles(report) {
+  return report.files.filter((f) => f.modified === false).map((f) => f.relPath);
+}
+function removeLegacyFiles(projectRoot, relPaths) {
+  for (const relPath of relPaths) {
+    try {
+      rmSync(join8(projectRoot, ...relPath.split("/")), { force: true });
+    } catch {
+    }
+  }
+}
+
+// src/commands/update.ts
 function update(opts) {
-  const projectManifest = readManifest(opts.projectRoot);
-  const existing = projectManifest ?? readManifest(opts.homeDir);
-  if (!existing) {
+  const resolved = resolveAllInstalled(opts.projectRoot, opts.homeDir);
+  if (resolved.length === 0) {
+    const legacy = detectLegacyRules(opts.projectRoot);
+    const hint = legacy.present ? ` A pre-0.4.0 bundle is still in .jig/ (${legacy.files.length} file(s)); since 0.4.0 the skill and its rules live beside your agent's skill file instead, so that copy is no longer read. Re-run install, then 'jig init' will report the leftovers \u2014 it never removes a file you have edited.` : "";
     throw new Error(
-      `Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.`
+      `Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.${hint}`
     );
   }
-  const sameRoot = resolve(opts.projectRoot) === resolve(opts.homeDir);
-  const discoveredScope = !projectManifest ? "global" : sameRoot ? existing.scope : "project";
-  const installRoot = discoveredScope === "global" ? opts.homeDir : opts.projectRoot;
-  const adapter = getAdapter(existing.agent);
-  if (!adapter.supportsScope(discoveredScope)) {
-    throw new Error(
-      `Jig's manifest at ${installRoot} records agent '${existing.agent}', which does not support ${discoveredScope} scope. Re-run 'jig install --agent <name>' to fix it.`
-    );
+  const updated = [];
+  const skipped = [];
+  const targets = [];
+  for (const target of resolved) {
+    const one = updateTarget(opts, target);
+    updated.push(...one.updated);
+    skipped.push(...one.skipped);
+    targets.push({
+      agent: target.manifest.agent,
+      scope: target.scope,
+      referenceDir: target.referenceDir,
+      fromVersion: target.manifest.version
+    });
   }
+  const initResult = updateInitFiles(opts);
+  updated.push(...initResult.updated);
+  skipped.push(...initResult.skipped);
+  return {
+    updated,
+    skipped,
+    fromVersion: resolved[0].manifest.version,
+    toVersion: opts.version,
+    targets
+  };
+}
+function updateTarget(opts, resolved) {
+  const { installRoot, scope: discoveredScope, manifest: existing, referenceDir } = resolved;
+  const adapter = getAdapter(existing.agent);
   const updated = [];
   const skipped = [];
   const files = { ...existing.files };
   const write = (key, content) => {
-    const abs = join4(installRoot, ...key.split("/"));
-    mkdirSync3(dirname4(abs), { recursive: true });
-    writeFileSync3(abs, content, "utf8");
-    files[key] = checksum(content);
+    const abs = join9(installRoot, ...key.split("/"));
+    mkdirSync5(dirname6(abs), { recursive: true });
+    const existing2 = existsSync7(abs) ? readFileSync6(abs, "utf8") : void 0;
+    const toWrite = matchLineEndings(content, existing2);
+    writeFileSync5(abs, toWrite, "utf8");
+    files[key] = checksum(toWrite);
     updated.push(key);
   };
-  const rulesDir = join4(opts.packageRoot, "rules");
-  for (const file of readdirSync2(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
-    const key = relKey(".jig", file);
+  const rulesDir = join9(opts.packageRoot, "rules");
+  for (const file of readdirSync4(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    const key = relKey(referenceDir, "rules", file);
     if (isModified(installRoot, key, existing)) {
       skipped.push(key);
       continue;
     }
-    write(key, vendorHeader(file, opts.version) + readFileSync3(join4(rulesDir, file), "utf8"));
+    write(key, vendorHeader(file, opts.version, "html", licencePathFor(`rules/${file}`)) + readFileSync6(join9(rulesDir, file), "utf8"));
   }
-  const tokensDir = join4(opts.packageRoot, "tokens");
-  for (const file of readdirSync2(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
-    const key = relKey(".jig", "tokens", file);
+  for (const ref of referenceFiles(opts.packageRoot)) {
+    const key = relKey(referenceDir, ...ref.relPath.split("/"));
     if (isModified(installRoot, key, existing)) {
       skipped.push(key);
       continue;
     }
-    write(key, vendorHeader(file, opts.version, "css") + readFileSync3(join4(tokensDir, file), "utf8"));
+    write(key, vendorHeader(ref.relPath, opts.version, "html", licencePathFor(ref.relPath)) + ref.content);
   }
-  const indexKey = relKey(".jig", "rules.index.json");
+  const indexKey = relKey(referenceDir, "rules.index.json");
   if (isModified(installRoot, indexKey, existing)) {
     skipped.push(indexKey);
   } else {
-    write(indexKey, readFileSync3(join4(opts.packageRoot, "rules.index.json"), "utf8"));
+    write(indexKey, readFileSync6(join9(opts.packageRoot, "rules.index.json"), "utf8"));
   }
-  const skillBody = buildSkillBody(opts.packageRoot, discoveredScope);
+  const rulesPath = rulesPathFor(referenceDir, discoveredScope);
+  const skillBody = buildSkillBody(opts.packageRoot, rulesPath, opts.version);
+  const { body: commandBody, subcommands } = buildCommandBody(
+    opts.packageRoot,
+    rulesPath,
+    opts.version,
+    adapter.argsPlaceholder ?? "$ARGUMENTS"
+  );
+  const command = { commandBody, subcommands };
   const skillFiles = skillFilesFor(adapter, {
     version: opts.version,
     scope: discoveredScope,
     skillBody,
-    commandPrefix: "/jig "
+    commandPrefix: "/jig ",
+    ...command
   });
   for (const file of skillFiles) {
     const key = file.relPath;
     const isBlockFile = file.content.includes(BLOCK_START);
     if (isBlockFile) {
-      const abs = join4(installRoot, ...key.split("/"));
-      const current = existsSync4(abs) ? readFileSync3(abs, "utf8") : "";
+      const abs = join9(installRoot, ...key.split("/"));
+      const current = existsSync7(abs) ? readFileSync6(abs, "utf8") : "";
       write(key, upsertBlock(current, file.content));
       continue;
     }
@@ -503,8 +932,8 @@ function update(opts) {
     }
     write(key, file.content);
   }
-  for (const key of ALWAYS_REPLACE) {
-    write(key, readFileSync3(join4(opts.packageRoot, basename(key)), "utf8"));
+  for (const src of ["LICENSE", "NOTICE"]) {
+    write(relKey(referenceDir, src), readFileSync6(join9(opts.packageRoot, src), "utf8"));
   }
   const manifest = {
     ...existing,
@@ -513,42 +942,2510 @@ function update(opts) {
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
     files
   };
-  writeManifest(installRoot, manifest);
-  return { updated, skipped, fromVersion: existing.version, toVersion: opts.version };
+  writeManifest(installRoot, manifest, referenceDir);
+  return { updated, skipped };
+}
+function updateInitFiles(opts) {
+  const updated = [];
+  const skipped = [];
+  const tokensDir = join9(opts.packageRoot, "tokens");
+  const initManifest = readInitManifest(opts.projectRoot);
+  if (initManifest) {
+    const initFiles = { ...initManifest.files };
+    let initChanged = false;
+    for (const file of readdirSync4(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
+      const key = relKey(".jig", "tokens", file);
+      if (!(key in initManifest.files)) continue;
+      if (isInitFileModified(opts.projectRoot, key, initManifest)) {
+        skipped.push(key);
+        continue;
+      }
+      const content = vendorHeader(file, opts.version, "css", null) + readFileSync6(join9(tokensDir, file), "utf8");
+      const abs = join9(opts.projectRoot, ...key.split("/"));
+      mkdirSync5(dirname6(abs), { recursive: true });
+      writeFileSync5(abs, content, "utf8");
+      initFiles[key] = checksum(content);
+      initChanged = true;
+      updated.push(key);
+    }
+    if (initChanged) writeInitManifest(opts.projectRoot, { ...initManifest, version: opts.version, files: initFiles });
+  }
+  return { updated, skipped };
 }
 
-// src/index.ts
-var packageRoot = getPackageRoot();
-var { version } = JSON.parse(readFileSync4(join5(packageRoot, "package.json"), "utf8"));
-var program = new Command();
-program.name("jig").description("A design system for coding agents.").version(version);
-program.command("install").description("Install Jig rules and the agent skill file into a repository.").requiredOption("--agent <name>", `target agent (${adapterNames().join(", ")})`).option("--scope <scope>", "project or global", "project").action((opts) => {
-  if (opts.scope !== "project" && opts.scope !== "global") {
-    console.error(`Invalid scope '${opts.scope}'. Use 'project' or 'global'.`);
-    process.exit(1);
+// src/commands/explain.ts
+import { join as join12 } from "path";
+
+// src/rules/load.ts
+import { readFileSync as readFileSync7, readdirSync as readdirSync5 } from "fs";
+import { join as join10 } from "path";
+
+// src/rules/parse.ts
+var HEADING = /^###\s+([A-Z])-(\d+)\s+(.+?)\s*$/;
+function parseRules(markdown, sourceFile) {
+  const lines = markdown.split("\n");
+  const rules = [];
+  let current = null;
+  const push = () => {
+    if (current) rules.push(current);
+  };
+  for (const line of lines) {
+    const heading = HEADING.exec(line);
+    if (heading) {
+      push();
+      const [, section, num, title] = heading;
+      const id = `${section}-${num}`;
+      current = {
+        id,
+        section,
+        number: Number(num),
+        title,
+        wrong: "",
+        correction: "",
+        source: `${sourceFile}#${id.toLowerCase()}`
+      };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("\u274C") && !current.wrong) {
+      current.wrong = line.slice(1).trim();
+    } else if (line.startsWith("\u2705") && !current.correction) {
+      current.correction = line.slice(1).trim();
+    }
   }
-  const projectRoot = findProjectRoot(process.cwd());
+  push();
+  return rules;
+}
+
+// src/rules/schema.ts
+var BUCKETS = ["mechanical", "judgment", "hybrid"];
+var SEVERITIES = ["error", "warning", "note"];
+function validateIndex(entries) {
+  if (!Array.isArray(entries)) throw new Error("rules.index.json must be an array");
+  return entries.map((raw, i) => {
+    const e = raw;
+    const at = `rules.index.json[${i}]`;
+    if (typeof e.id !== "string" || !/^[A-Z]-\d+$/.test(e.id)) {
+      throw new Error(`${at}: missing or malformed id`);
+    }
+    if (!BUCKETS.includes(e.bucket)) {
+      throw new Error(`${at} (${e.id}): bucket must be one of ${BUCKETS.join(", ")}`);
+    }
+    if (!SEVERITIES.includes(e.severity)) {
+      throw new Error(`${at} (${e.id}): severity must be one of ${SEVERITIES.join(", ")}`);
+    }
+    if (typeof e.since !== "string") {
+      throw new Error(`${at} (${e.id}): since is required`);
+    }
+    return {
+      id: e.id,
+      bucket: e.bucket,
+      severity: e.severity,
+      detector: typeof e.detector === "string" ? e.detector : void 0,
+      fix: typeof e.fix === "string" ? e.fix : void 0,
+      since: e.since
+    };
+  });
+}
+
+// src/rules/load.ts
+function loadRules(rulesDir, indexPath) {
+  const files = readdirSync5(rulesDir).filter((f) => f.endsWith(".md")).sort();
+  const parsed = [];
+  for (const file of files) {
+    parsed.push(...parseRules(readFileSync7(join10(rulesDir, file), "utf8"), file));
+  }
+  const entries = validateIndex(JSON.parse(readFileSync7(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) {
+    throw new Error(
+      `Rules present in markdown but missing from rules.index.json: ${missing.join(", ")}`
+    );
+  }
+  const parsedIds = new Set(parsed.map((r) => r.id));
+  const orphans = entries.filter((e) => !parsedIds.has(e.id)).map((e) => e.id);
+  if (orphans.length) {
+    throw new Error(
+      `Entries in rules.index.json with no matching rule: ${orphans.join(", ")}`
+    );
+  }
+  return parsed.map((r) => {
+    const { id: _id, ...meta } = byId.get(r.id);
+    return { ...r, ...meta };
+  });
+}
+
+// src/rules/specs.ts
+import { readFileSync as readFileSync8, readdirSync as readdirSync6 } from "fs";
+import { join as join11 } from "path";
+var HEADING2 = /^##\s+([PM]-\d+)\s*(?:·\s*)?(.*?)\s*$/;
+function parseSpecs(markdown, sourceFile) {
+  const lines = markdown.split("\n");
+  const specs = [];
+  let current = null;
+  const body = [];
+  const push = () => {
+    if (!current) return;
+    specs.push({ ...current, body: body.join("\n").replace(/\n{3,}/g, "\n\n").trim() });
+    body.length = 0;
+  };
+  for (const line of lines) {
+    const heading = HEADING2.exec(line);
+    if (heading) {
+      push();
+      const [, id, title] = heading;
+      current = { id, title, body: "", source: `${sourceFile}#${id.toLowerCase()}` };
+      continue;
+    }
+    if (current && /^##\s/.test(line)) {
+      push();
+      current = null;
+      continue;
+    }
+    if (current) body.push(line);
+  }
+  push();
+  return specs;
+}
+function loadSpecs(rulesDir) {
+  const specs = [];
+  for (const file of readdirSync6(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
+    specs.push(...parseSpecs(readFileSync8(join11(rulesDir, file), "utf8"), file));
+  }
+  return specs;
+}
+
+// src/commands/explain.ts
+var ID_SHAPE = /^([A-Z])-(\d+)$/;
+function explain(opts) {
+  const raw = opts.ruleId.trim().toUpperCase();
+  const shape = ID_SHAPE.exec(raw);
+  if (!shape) {
+    throw new Error(
+      `'${opts.ruleId.trim()}' is not a rule id. Ids look like 'C-19' or 'P-02' \u2014 a section letter, a hyphen, and a number.`
+    );
+  }
+  const root = opts.packageRoot ?? assetRoot();
+  const rulesDir = join12(root, "rules");
+  const rules = loadRules(rulesDir, join12(root, "rules.index.json"));
+  const rule = rules.find((r) => r.id === raw);
+  if (rule) {
+    const lines = [
+      `${rule.id}  ${rule.title}`,
+      "",
+      `\u274C ${rule.wrong}`,
+      `\u2705 ${rule.correction}`,
+      "",
+      `   ${rule.bucket} \xB7 ${rule.severity}${rule.detector ? ` \xB7 detector: ${rule.detector}` : ""}`,
+      `   since ${rule.since} \xB7 ${rule.source}`
+    ];
+    return lines.join("\n");
+  }
+  const spec = loadSpecs(rulesDir).find((s) => s.id === raw);
+  if (spec) {
+    return [
+      `${spec.id}  ${spec.title}`,
+      "",
+      spec.body,
+      "",
+      `   specification \u2014 component anatomy and behaviour, not a single rule,`,
+      `   so it carries no \u274C/\u2705 pair and no detector.`,
+      `   ${spec.source}`
+    ].join("\n");
+  }
+  const section = shape[1];
+  const siblings = [
+    ...rules.filter((r) => r.id.startsWith(`${section}-`)).map((r) => r.id),
+    ...loadSpecs(rulesDir).filter((s) => s.id.startsWith(`${section}-`)).map((s) => s.id)
+  ].sort((a, b) => Number(a.split("-")[1]) - Number(b.split("-")[1]));
+  throw new Error(
+    siblings.length > 0 ? `No rule '${raw}'. Section ${section} has: ${siblings.join(", ")}.` : `No rule '${raw}', and no section '${section}' exists.`
+  );
+}
+
+// src/commands/check.ts
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
+import { join as join16 } from "path";
+
+// src/check/files.ts
+import { execFileSync } from "child_process";
+import { readdirSync as readdirSync7, realpathSync, statSync } from "fs";
+import { join as join13, relative, sep } from "path";
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".jig",
+  ".next",
+  "build",
+  "out",
+  "coverage",
+  ".svelte-kit",
+  "vendor"
+]);
+function isGitRepo(root) {
   try {
-    const result = install({
-      agent: opts.agent,
-      scope: opts.scope,
-      projectRoot,
-      packageRoot: assetRoot(),
-      version,
-      homeDir: homedir()
+    const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
-    console.log(`Installed Jig v${version} for ${opts.agent} (${opts.scope} scope)`);
-    for (const f of result.written) console.log(`  + ${f}`);
-    for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+    return out.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function gitChangedFiles(root) {
+  let diffOut;
+  try {
+    diffOut = execFileSync(
+      "git",
+      ["-c", "core.quotePath=false", "diff", "--name-only", "--relative", "-z", "HEAD"],
+      { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    diffOut = "";
+  }
+  let untrackedOut;
+  try {
+    untrackedOut = execFileSync(
+      "git",
+      ["-c", "core.quotePath=false", "ls-files", "--others", "--exclude-standard", "-z"],
+      { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    untrackedOut = "";
+  }
+  const files = /* @__PURE__ */ new Set();
+  for (const entry of [...diffOut.split("\0"), ...untrackedOut.split("\0")]) {
+    const f = entry.trim();
+    if (f) files.add(f);
+  }
+  return [...files];
+}
+function isExcluded(relPath) {
+  return relPath.split("/").some((segment) => EXCLUDE_DIRS.has(segment));
+}
+function walk(root, dir, out, seen) {
+  let entries;
+  try {
+    entries = readdirSync7(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (EXCLUDE_DIRS.has(entry.name)) continue;
+    const abs = join13(dir, entry.name);
+    let isDir = entry.isDirectory();
+    let isFile = entry.isFile();
+    if (entry.isSymbolicLink()) {
+      try {
+        const target = statSync(abs);
+        isDir = target.isDirectory();
+        isFile = target.isFile();
+      } catch {
+        continue;
+      }
+    }
+    if (isDir) {
+      let real;
+      try {
+        real = realpathSync(abs);
+      } catch {
+        continue;
+      }
+      if (seen.has(real)) continue;
+      seen.add(real);
+      walk(root, abs, out, seen);
+    } else if (isFile) {
+      out.push(relative(root, abs).split(sep).join("/"));
+    }
+  }
+}
+function filterGitIgnored(root, files) {
+  if (files.length === 0) return files;
+  const parseIgnored = (out) => new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
+  try {
+    const out = execFileSync("git", ["check-ignore", "--stdin"], {
+      cwd: root,
+      input: `${files.join("\n")}
+`,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const ignored = parseIgnored(out);
+    return files.filter((f) => !ignored.has(f));
   } catch (err) {
-    console.error(err.message);
-    process.exit(1);
+    const status = err.status;
+    if (status === 1) {
+      const stdout = err.stdout;
+      const out = typeof stdout === "string" ? stdout : stdout?.toString("utf8") ?? "";
+      const ignored = parseIgnored(out);
+      return files.filter((f) => !ignored.has(f));
+    }
+    return files;
   }
-});
-program.command("update").description("Update vendored Jig rules, skipping files you have edited.").action(() => {
-  const projectRoot = findProjectRoot(process.cwd());
+}
+function safeRealpath(p) {
   try {
-    const result = update({
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function wholeRepoFiles(root) {
+  const out = [];
+  walk(root, root, out, /* @__PURE__ */ new Set([safeRealpath(root)]));
+  return isGitRepo(root) ? filterGitIgnored(root, out) : out;
+}
+function selectFiles(root, all) {
+  if (all || !isGitRepo(root)) return { files: wholeRepoFiles(root), mode: "all" };
+  const changed = gitChangedFiles(root).filter((f) => !isExcluded(f));
+  if (changed.length === 0) return { files: wholeRepoFiles(root), mode: "all" };
+  return { files: changed, mode: "changed" };
+}
+
+// src/check/report.ts
+var MAX_ROWS_PER_RULE_PER_FILE = 3;
+var SEVERITY_SYMBOL = { error: "\u2717", warning: "\u26A0", note: "\xB7" };
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function formatReport(findings, meta) {
+  const lines = [];
+  const seenRule = /* @__PURE__ */ new Set();
+  const rows = findings.map((f) => {
+    const symbol = SEVERITY_SYMBOL[f.severity] ?? "\xB7";
+    const loc = `${f.file}:${f.line}`;
+    const firstOccurrence = !seenRule.has(f.ruleId);
+    seenRule.add(f.ruleId);
+    const hint = firstOccurrence ? `  (see rule ${f.ruleId} in your installed jig skill's rules/)` : "";
+    return { symbol, ruleId: f.ruleId, message: f.message, loc, fileOnly: f.file, bucket: f.bucket, hint };
+  });
+  if (rows.length > 0) {
+    const msgW = Math.max(0, ...rows.map((r) => r.message.length));
+    const locW = Math.max(0, ...rows.map((r) => r.loc.length));
+    const shown = /* @__PURE__ */ new Map();
+    const suppressed = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const key = `${r.ruleId}\0${r.fileOnly}`;
+      const n = (shown.get(key) ?? 0) + 1;
+      shown.set(key, n);
+      if (n <= MAX_ROWS_PER_RULE_PER_FILE) {
+        lines.push(
+          `  ${r.symbol} ${r.ruleId.padEnd(6)}${r.message.padEnd(msgW)}  ${r.loc.padEnd(locW)}   [${r.bucket}]${r.hint}`
+        );
+      } else {
+        suppressed.set(key, (suppressed.get(key) ?? 0) + 1);
+      }
+    }
+    for (const [key, n] of suppressed) {
+      const [ruleId, file] = key.split("\0");
+      lines.push(`          \u2026 ${n} more ${ruleId} in ${file}. Run with --json for all of them.`);
+    }
+    lines.push("");
+  } else {
+    lines.push("  No findings.");
+    lines.push("");
+    if (meta.noTokenLayer) {
+      lines.push("  No file references a Jig token, so H-47 (hard-coded values) was not run.");
+      lines.push("  Run 'jig init' to generate a brand file and wire it (with a mode file) into your CSS.");
+      lines.push("");
+    }
+  }
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const notes = findings.filter((f) => f.severity === "note").length;
+  const summaryParts = [plural(errors, "error")];
+  if (warnings > 0) summaryParts.push(plural(warnings, "warning"));
+  if (notes > 0) summaryParts.push(plural(notes, "note"));
+  const rulesFired = new Set(findings.map((f) => f.ruleId)).size;
+  const scope = meta.totalSpecs ? `${meta.totalRules} rules (+ ${meta.totalSpecs} pattern and mode specs)` : `${meta.totalRules} rules`;
+  lines.push(`  ${summaryParts.join(", ")} \xB7 ${scope}, ${rulesFired} fired`);
+  if (meta.unscanned && meta.unscanned.count > 0) {
+    const exts = meta.unscanned.extensions.join(", ");
+    lines.push("");
+    lines.push(
+      `  ${meta.unscanned.count} file(s) were not scanned (${exts}) \u2014 no style extraction exists for them, so any CSS they carry is invisible to this check and a clean result above does not cover it.`
+    );
+  }
+  const mechanicalErrors = findings.filter((f) => f.bucket === "mechanical" && f.severity === "error").length;
+  const mechStatus = `${mechanicalErrors > 0 ? "fail" : "pass"}:${mechanicalErrors}`;
+  lines.push(
+    `  JIG_CHECK: version=${meta.version} mode=${meta.mode ?? "unknown"} mechanical=${mechStatus} judgment=not-run`
+  );
+  return lines.join("\n");
+}
+
+// src/check/token-layer.ts
+var IMPORT_RE = /@import\s+(?:url\()?["']?[^"')]*\.jig\/tokens\/[^"')]+\.css["']?\)?/i;
+var VAR_RE = /var\(\s*--([\w-]+)/g;
+var THEME_DECL_RE = /@theme\b[^{]*\{([\s\S]*?)\}/gi;
+var CUSTOM_PROP_RE = /--([\w-]+)\s*:/g;
+function participatesInTokenLayer(source, tokens) {
+  if (IMPORT_RE.test(source)) return true;
+  VAR_RE.lastIndex = 0;
+  let m;
+  while (m = VAR_RE.exec(source)) {
+    if (Object.prototype.hasOwnProperty.call(tokens, m[1])) return true;
+  }
+  THEME_DECL_RE.lastIndex = 0;
+  let theme;
+  while (theme = THEME_DECL_RE.exec(source)) {
+    if (IMPORT_RE.test(theme[1])) return true;
+    CUSTOM_PROP_RE.lastIndex = 0;
+    let prop;
+    while (prop = CUSTOM_PROP_RE.exec(theme[1])) {
+      if (Object.prototype.hasOwnProperty.call(tokens, prop[1])) return true;
+    }
+  }
+  return false;
+}
+
+// src/check/ext.ts
+var CSS_EXTENSIONS = [".css", ".scss", ".less"];
+function hasExtension(file, exts) {
+  const lower = file.toLowerCase();
+  return exts.some((e) => lower.endsWith(e));
+}
+var STYLE_HOST_EXTENSIONS = [
+  ".html",
+  ".htm",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".jsx",
+  ".tsx",
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".php",
+  ".erb",
+  ".twig",
+  ".hbs",
+  ".mdx",
+  // Server-rendered markup. Every one of these is HTML with a template syntax
+  // threaded through it, so its `<style>` blocks and `style` attributes are the
+  // same constructs already handled — the template tags sit outside the style
+  // regions and are blanked with the rest of the markup.
+  ".asp",
+  ".aspx",
+  ".ascx",
+  ".master",
+  // Classic ASP, ASP.NET
+  ".cshtml",
+  ".vbhtml",
+  ".razor",
+  // Razor
+  ".jsp",
+  ".jspx",
+  // Java
+  ".eex",
+  ".heex",
+  ".leex",
+  // Phoenix
+  ".ejs",
+  ".njk",
+  ".liquid",
+  ".mustache",
+  // Node/Jinja-family engines
+  ".vm",
+  ".ftl",
+  // Velocity, FreeMarker
+  ".jinja",
+  ".jinja2",
+  ".j2",
+  // Jinja
+  // Indentation-delimited templates. These carry no HTML-shaped constructs at
+  // all — their style regions are found by their own block markers and
+  // attribute syntax instead. See `INDENTED_SYNTAXES` in styles.ts.
+  ".pug",
+  ".jade",
+  ".haml",
+  ".slim"
+];
+function isStyleBearing(file) {
+  return hasExtension(file, CSS_EXTENSIONS) || hasExtension(file, STYLE_HOST_EXTENSIONS);
+}
+
+// src/check/run.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join14 } from "path";
+
+// src/check/css.ts
+function maskComments(source) {
+  let out = "";
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      out += ch;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\" && i + 1 < source.length) {
+          out += source[i] + source[i + 1];
+          i += 2;
+          continue;
+        }
+        out += source[i];
+        if (source[i] === quote) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const end = source.indexOf("*/", i + 2);
+      const stop = end === -1 ? source.length : end + 2;
+      for (let j = i; j < stop; j++) out += source[j] === "\n" ? "\n" : " ";
+      i = stop;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function splitRuleBlocks(source) {
+  source = maskComments(source);
+  const blocks = [];
+  const stack = [];
+  let line = 1;
+  let lastBoundary = 0;
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "\n") line++;
+    if (ch === "{") {
+      stack.push({ selectorStart: lastBoundary, bodyStart: i + 1, bodyStartLine: line });
+      lastBoundary = i + 1;
+    } else if (ch === "}") {
+      const top = stack.pop();
+      if (top) {
+        blocks.push({
+          selector: cleanSelector(source.slice(top.selectorStart, top.bodyStart - 1)),
+          body: source.slice(top.bodyStart, i),
+          bodyStartLine: top.bodyStartLine
+        });
+      }
+      lastBoundary = i + 1;
+    }
+  }
+  return blocks;
+}
+function blankNested(body) {
+  const out = body.split("");
+  const blank2 = (from, to) => {
+    for (let j = from; j < to; j++) if (out[j] !== "\n") out[j] = " ";
+  };
+  let depth = 0;
+  let segmentStart = 0;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "{") {
+      if (depth === 0) blank2(segmentStart, i);
+      depth++;
+      out[i] = " ";
+    } else if (ch === "}") {
+      depth = Math.max(0, depth - 1);
+      out[i] = " ";
+      if (depth === 0) segmentStart = i + 1;
+    } else if (depth > 0) {
+      if (ch !== "\n") out[i] = " ";
+    } else if (ch === ";") {
+      segmentStart = i + 1;
+    }
+  }
+  return out.join("");
+}
+function cleanSelector(raw) {
+  const cut = Math.max(raw.lastIndexOf(";"), raw.lastIndexOf("}"));
+  return (cut === -1 ? raw : raw.slice(cut + 1)).trim();
+}
+function leafBlocks(source) {
+  return splitRuleBlocks(source).map((b) => b.body.includes("{") ? { ...b, body: blankNested(b.body) } : b).filter((b) => b.body.trim() !== "");
+}
+function lineOfOffset(block, offsetInBody) {
+  let n = 0;
+  const end = Math.min(offsetInBody, block.body.length);
+  for (let i = 0; i < end; i++) {
+    if (block.body[i] === "\n") n++;
+  }
+  return block.bodyStartLine + n;
+}
+function buildLineIndex(source) {
+  const starts = [0];
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") starts.push(i + 1);
+  }
+  return starts;
+}
+function lineForOffset(starts, offset) {
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo + 1;
+}
+function sourceLine(source, line) {
+  const lines = source.split("\n");
+  return (lines[line - 1] ?? "").trim();
+}
+
+// src/check/styles.ts
+function isStyleHost(file) {
+  return hasExtension(file, STYLE_HOST_EXTENSIONS);
+}
+function isMarkupHost(file) {
+  return hasExtension(file, MARKUP_HOSTS);
+}
+var MARKUP_HOSTS = [
+  ".html",
+  ".htm",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".php",
+  ".erb",
+  ".twig",
+  ".hbs",
+  ".mdx",
+  ".jsx",
+  ".tsx",
+  ".asp",
+  ".aspx",
+  ".ascx",
+  ".master",
+  ".cshtml",
+  ".vbhtml",
+  ".razor",
+  ".jsp",
+  ".jspx",
+  ".eex",
+  ".heex",
+  ".leex",
+  ".ejs",
+  ".njk",
+  ".liquid",
+  ".mustache",
+  ".vm",
+  ".ftl",
+  ".jinja",
+  ".jinja2",
+  ".j2"
+];
+var INDENTED_SYNTAXES = {
+  ".pug": { blockMarker: /^(\s*)style\.?\s*$/, attr: /\bstyle\s*=\s*(["'])([\s\S]*?)\1/g },
+  ".jade": { blockMarker: /^(\s*)style\.?\s*$/, attr: /\bstyle\s*=\s*(["'])([\s\S]*?)\1/g },
+  ".haml": {
+    blockMarker: /^(\s*)(?::css|%style)\s*$/,
+    attr: /(?::style\s*=>|\bstyle\s*:)\s*(["'])([\s\S]*?)\1/g
+  },
+  ".slim": {
+    blockMarker: /^(\s*)(?:css:|style:)\s*$/,
+    attr: /\bstyle\s*=\s*(["'])([\s\S]*?)\1/g
+  }
+};
+function indentedSyntaxFor(file) {
+  const lower = file.toLowerCase();
+  const ext = Object.keys(INDENTED_SYNTAXES).find((e) => lower.endsWith(e));
+  return ext ? INDENTED_SYNTAXES[ext] : void 0;
+}
+function indentedSpans(source, syntax) {
+  const spans = [];
+  const lines = source.split("\n");
+  const offsets = [];
+  let at = 0;
+  for (const line of lines) {
+    offsets.push(at);
+    at += line.length + 1;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const marker = syntax.blockMarker.exec(lines[i]);
+    if (!marker) continue;
+    const markerIndent = marker[1].length;
+    let end = i;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (lines[j].trim() === "") {
+        end = j;
+        continue;
+      }
+      const indent = lines[j].length - lines[j].trimStart().length;
+      if (indent <= markerIndent) break;
+      end = j;
+    }
+    if (end === i) continue;
+    const start = offsets[i + 1];
+    const last = offsets[end] + lines[end].length;
+    spans.push({ start, end: last });
+    i = end;
+  }
+  return spans;
+}
+var STYLE_BLOCK = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi;
+var STYLE_ATTR = /\bstyle\s*=\s*(["'])([\s\S]*?)\1/gi;
+var CSS_TAG = /\b(?:styled(?:\.\w+|\([^)]*\))(?:\s*\.\w+\([^)]*\))*|css|createGlobalStyle|keyframes|injectGlobal)\s*`/g;
+function readTemplate(source, openBacktick) {
+  let i = openBacktick + 1;
+  const start = i;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") return { start, end: i };
+    if (ch === "$" && source[i + 1] === "{") {
+      let depth = 1;
+      i += 2;
+      while (i < source.length && depth > 0) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === "{") depth++;
+        else if (source[i] === "}") depth--;
+        else if (source[i] === "`") {
+          const inner = readTemplate(source, i);
+          if (!inner) return null;
+          i = inner.end;
+        }
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return null;
+}
+var STYLE_OBJECT = /\bstyle\s*=\s*\{\{/g;
+function readObject(source, open) {
+  let depth = 0;
+  let i = open + 1;
+  const start = open + 2;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return { start, end: i };
+    }
+    i++;
+  }
+  return null;
+}
+function styleObjectToCss(body) {
+  let out = "";
+  for (const ch of body) {
+    if (ch === '"' || ch === "'" || ch === "`") out += " ";
+    else if (ch === ",") out += ";";
+    else out += ch;
+  }
+  return out;
+}
+function maskNonStyleRegions(source, file) {
+  if (hasExtension(file, CSS_EXTENSIONS)) return source;
+  if (!isStyleHost(file)) return blank(source);
+  const spans = [];
+  const indented = indentedSyntaxFor(file);
+  if (indented) {
+    spans.push(...indentedSpans(source, indented));
+    for (const m of source.matchAll(indented.attr)) {
+      const valueStart = m.index + m[0].indexOf(m[1]) + 1;
+      spans.push({ start: valueStart, end: valueStart + m[2].length, braced: true });
+    }
+    return applySpans(source, spans);
+  }
+  if (hasExtension(file, MARKUP_HOSTS)) {
+    for (const m of source.matchAll(STYLE_BLOCK)) {
+      const bodyStart = m.index + m[0].indexOf(">") + 1;
+      spans.push({ start: bodyStart, end: bodyStart + m[1].length });
+    }
+    for (const m of source.matchAll(STYLE_ATTR)) {
+      const valueStart = m.index + m[0].indexOf(m[1]) + 1;
+      spans.push({ start: valueStart, end: valueStart + m[2].length, braced: true });
+    }
+  }
+  for (const m of source.matchAll(CSS_TAG)) {
+    const backtick = m.index + m[0].length - 1;
+    const span = readTemplate(source, backtick);
+    if (span) spans.push({ ...span, braced: true });
+  }
+  for (const m of source.matchAll(STYLE_OBJECT)) {
+    const span = readObject(source, m.index + m[0].length - 2);
+    if (span) spans.push({ ...span, transform: styleObjectToCss, braced: true });
+  }
+  return applySpans(source, spans);
+}
+function applySpans(source, spans) {
+  if (spans.length === 0) return blank(source);
+  const out = blank(source).split("");
+  for (const span of spans) {
+    const text = source.slice(span.start, span.end);
+    const rendered = span.transform ? span.transform(text) : text;
+    for (let i = 0; i < rendered.length; i++) {
+      out[span.start + i] = rendered[i];
+    }
+    if (span.braced && span.start > 0 && span.end < out.length) {
+      out[span.start - 1] = "{";
+      out[span.end] = "}";
+    }
+  }
+  return out.join("");
+}
+function blank(source) {
+  let out = "";
+  for (const ch of source) out += ch === "\n" ? "\n" : " ";
+  return out;
+}
+
+// src/check/finding.ts
+function mkFinding(ctx, detector, file, line, message, excerpt) {
+  return {
+    ruleId: ctx.ruleId,
+    detector,
+    bucket: ctx.bucket,
+    severity: ctx.severity,
+    file,
+    line,
+    message,
+    excerpt
+  };
+}
+
+// src/check/detectors/gradient-text.ts
+var CLIP_RE = /(?:-webkit-)?background-clip\s*:\s*text\b/i;
+var GRADIENT_RE = /(?:background|background-image)\s*:[^;]*(?:linear|radial|conic)-gradient\s*\(/i;
+var gradientText = {
+  name: "gradient-text",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      const clipMatch = CLIP_RE.exec(block.body);
+      if (!clipMatch) continue;
+      if (!GRADIENT_RE.test(block.body)) continue;
+      const line = lineOfOffset(block, clipMatch.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "gradient-text",
+          file,
+          line,
+          "Gradient text via background-clip: text \u2014 use solid --color-text-strong instead",
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/color.ts
+var NAMED = {
+  white: { r: 255, g: 255, b: 255 },
+  black: { r: 0, g: 0, b: 0 }
+};
+function parseComponent(raw) {
+  const v = raw.trim();
+  if (v.endsWith("%")) return Math.round(parseFloat(v) / 100 * 255);
+  return Math.round(parseFloat(v));
+}
+function parseAlpha(raw) {
+  if (raw === void 0 || raw.trim() === "") return 1;
+  const v = raw.trim();
+  return v.endsWith("%") ? parseFloat(v) / 100 : parseFloat(v);
+}
+function splitFnArgs(inner) {
+  if (inner.includes(",")) {
+    const parts = inner.split(",").map((p) => p.trim());
+    const alphaStr2 = parts.length === 4 ? parts.pop() : void 0;
+    return { parts, alphaStr: alphaStr2 };
+  }
+  const [main, alphaStr] = inner.split("/").map((p) => p.trim());
+  return { parts: main.split(/\s+/).filter(Boolean), alphaStr };
+}
+function parseHex(value) {
+  const m = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.exec(value.trim());
+  if (!m) return null;
+  const hex = m[1];
+  let r, g, b, a = 255;
+  if (hex.length === 3 || hex.length === 4) {
+    r = parseInt(hex[0] + hex[0], 16);
+    g = parseInt(hex[1] + hex[1], 16);
+    b = parseInt(hex[2] + hex[2], 16);
+    if (hex.length === 4) a = parseInt(hex[3] + hex[3], 16);
+  } else {
+    r = parseInt(hex.slice(0, 2), 16);
+    g = parseInt(hex.slice(2, 4), 16);
+    b = parseInt(hex.slice(4, 6), 16);
+    if (hex.length === 8) a = parseInt(hex.slice(6, 8), 16);
+  }
+  return { r, g, b, a: a / 255 };
+}
+function parseRgbFn(value) {
+  const m = /^rgba?\(([^)]*)\)$/i.exec(value.trim());
+  if (!m) return null;
+  const { parts, alphaStr } = splitFnArgs(m[1].trim());
+  if (parts.length !== 3) return null;
+  const [r, g, b] = parts.map(parseComponent);
+  if ([r, g, b].some((n) => Number.isNaN(n))) return null;
+  return { r, g, b, a: parseAlpha(alphaStr) };
+}
+function parseHslFn(value) {
+  const m = /^hsla?\(([^)]*)\)$/i.exec(value.trim());
+  if (!m) return null;
+  const { parts, alphaStr } = splitFnArgs(m[1].trim());
+  if (parts.length !== 3) return null;
+  const h = parseFloat(parts[0]);
+  const s = parseFloat(parts[1]);
+  const l = parseFloat(parts[2]);
+  if ([h, s, l].some((n) => Number.isNaN(n))) return null;
+  return { h: (h % 360 + 360) % 360, s, l, a: parseAlpha(alphaStr) };
+}
+function hslToRgb(h, s, l) {
+  const sN = s / 100;
+  const lN = l / 100;
+  const c = (1 - Math.abs(2 * lN - 1)) * sN;
+  const hp = (h % 360 + 360) % 360 / 60;
+  const x = c * (1 - Math.abs(hp % 2 - 1));
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (hp < 1) [r1, g1, b1] = [c, x, 0];
+  else if (hp < 2) [r1, g1, b1] = [x, c, 0];
+  else if (hp < 3) [r1, g1, b1] = [0, c, x];
+  else if (hp < 4) [r1, g1, b1] = [0, x, c];
+  else if (hp < 5) [r1, g1, b1] = [x, 0, c];
+  else [r1, g1, b1] = [c, 0, x];
+  const m = lN - c / 2;
+  return { r: Math.round((r1 + m) * 255), g: Math.round((g1 + m) * 255), b: Math.round((b1 + m) * 255) };
+}
+function rgbToHsl(rgb) {
+  const r = rgb.r / 255, g = rgb.g / 255, b = rgb.b / 255;
+  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0, s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      default:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h *= 60;
+  }
+  return { h, s: s * 100, l: l * 100 };
+}
+function substituteVars(value, tokens, depth = 0) {
+  if (depth > 6) return value;
+  let changed = false;
+  const result = value.replace(/var\(\s*--([\w-]+)\s*(?:,\s*([^)]*))?\)/gi, (match, name, fallback) => {
+    if (Object.prototype.hasOwnProperty.call(tokens, name)) {
+      changed = true;
+      return tokens[name];
+    }
+    if (fallback !== void 0) {
+      changed = true;
+      return fallback;
+    }
+    return match;
+  });
+  return changed ? substituteVars(result, tokens, depth + 1) : result;
+}
+var OKLCH_RE = /^oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([-\d.]+)(?:deg)?\s*(?:\/\s*([\d.]+%?)\s*)?\)$/i;
+function gammaEncode(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function parseOklchFn(value) {
+  const m = OKLCH_RE.exec(value.trim());
+  if (!m) return null;
+  const num = (raw, pctBasis) => raw.endsWith("%") ? Number.parseFloat(raw) / 100 * pctBasis : Number.parseFloat(raw);
+  const L = num(m[1], 1);
+  const C = num(m[2], 0.4);
+  const H = Number.parseFloat(m[3]);
+  const a = m[4] === void 0 ? 1 : Math.min(1, Math.max(0, num(m[4], 1)));
+  if ([L, C, H].some((n) => !Number.isFinite(n))) return null;
+  const hRad = H * Math.PI / 180;
+  const oa = C * Math.cos(hRad);
+  const ob = C * Math.sin(hRad);
+  const l_ = L + 0.3963377774 * oa + 0.2158037573 * ob;
+  const m_ = L - 0.1055613458 * oa - 0.0638541728 * ob;
+  const s_ = L - 0.0894841775 * oa - 1.291485548 * ob;
+  const l = l_ ** 3;
+  const mm = m_ ** 3;
+  const ss = s_ ** 3;
+  const lr = 4.0767416621 * l - 3.3077115913 * mm + 0.2309699292 * ss;
+  const lg = -1.2684380046 * l + 2.6097574011 * mm - 0.3413193965 * ss;
+  const lb = -0.0041960863 * l - 0.7034186147 * mm + 1.707614701 * ss;
+  const to255 = (lin) => Math.round(Math.min(1, Math.max(0, gammaEncode(lin))) * 255);
+  return { r: to255(lr), g: to255(lg), b: to255(lb), a };
+}
+function extractColorComponents(value, tokens) {
+  const substituted = substituteVars(value, tokens).trim();
+  if (/var\(/i.test(substituted)) return null;
+  const named = NAMED[substituted.toLowerCase()];
+  if (named) return { rgb: named, hsl: rgbToHsl(named), alpha: 1 };
+  const hex = parseHex(substituted);
+  if (hex) {
+    const rgb = { r: hex.r, g: hex.g, b: hex.b };
+    return { rgb, hsl: rgbToHsl(rgb), alpha: hex.a };
+  }
+  const rgbFn = parseRgbFn(substituted);
+  if (rgbFn) {
+    const rgb = { r: rgbFn.r, g: rgbFn.g, b: rgbFn.b };
+    return { rgb, hsl: rgbToHsl(rgb), alpha: rgbFn.a };
+  }
+  const hslFn = parseHslFn(substituted);
+  if (hslFn) {
+    const rgb = hslToRgb(hslFn.h, hslFn.s, hslFn.l);
+    return { rgb, hsl: { h: hslFn.h, s: hslFn.s, l: hslFn.l }, alpha: hslFn.a };
+  }
+  const oklch = parseOklchFn(substituted);
+  if (oklch) {
+    const rgb = { r: oklch.r, g: oklch.g, b: oklch.b };
+    return { rgb, hsl: rgbToHsl(rgb), alpha: oklch.a };
+  }
+  return null;
+}
+var VAR_WITH_FALLBACK_RE = /var\(\s*--[\w-]+\s*,/i;
+function resolveOpaqueColor(value, tokens) {
+  if (VAR_WITH_FALLBACK_RE.test(value)) return null;
+  const c = extractColorComponents(value, tokens);
+  if (!c || c.alpha < 0.999) return null;
+  return c.rgb;
+}
+function relativeLuminance(rgb) {
+  const srgb = [rgb.r, rgb.g, rgb.b].map((v) => {
+    const c = v / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * srgb[0] + 0.7152 * srgb[1] + 0.0722 * srgb[2];
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a) + 0.05;
+  const lb = relativeLuminance(b) + 0.05;
+  return la > lb ? la / lb : lb / la;
+}
+
+// src/check/detectors/backdrop-blur.ts
+var BLUR_RE = /(?:-webkit-)?backdrop-filter\s*:[^;]*blur\s*\(/i;
+var BG_DECL_RE = /(?<![-\w])background(?:-color)?\s*:\s*([^;]+);?/gi;
+function hasTranslucentBackground(body, tokens) {
+  BG_DECL_RE.lastIndex = 0;
+  let m;
+  while (m = BG_DECL_RE.exec(body)) {
+    const c = extractColorComponents(m[1].trim(), tokens);
+    if (c && c.alpha < 0.999) return true;
+  }
+  return false;
+}
+var backdropBlur = {
+  name: "backdrop-blur",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      const blurMatch = BLUR_RE.exec(block.body);
+      if (!blurMatch) continue;
+      if (!hasTranslucentBackground(block.body, ctx.tokens)) continue;
+      const line = lineOfOffset(block, blurMatch.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "backdrop-blur",
+          file,
+          line,
+          "Glassmorphism \u2014 translucent fill + backdrop-filter: blur() fights legibility; use an opaque surface with a --color-stroke-weak edge",
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/pure-black-white.ts
+var COLOR_DECL_RE = /(?<![-\w])color\s*:\s*([^;]+)(?:;|$)/i;
+var BG_DECL_RE2 = /(?<![-\w])background(?:-color)?\s*:\s*([^;]+)(?:;|$)/gi;
+function isPure(rgb, target) {
+  return rgb.r === target && rgb.g === target && rgb.b === target;
+}
+var pureBlackWhite = {
+  name: "pure-black-white",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      const colorMatch = COLOR_DECL_RE.exec(block.body);
+      if (!colorMatch) continue;
+      const fg = extractColorComponents(colorMatch[1].trim(), ctx.tokens);
+      if (!fg || fg.alpha < 0.999 || !isPure(fg.rgb, 0)) continue;
+      BG_DECL_RE2.lastIndex = 0;
+      let hasWhiteBackground = false;
+      let m;
+      while (m = BG_DECL_RE2.exec(block.body)) {
+        const bg = extractColorComponents(m[1].trim(), ctx.tokens);
+        if (bg && bg.alpha >= 0.999 && isPure(bg.rgb, 255)) {
+          hasWhiteBackground = true;
+          break;
+        }
+      }
+      if (!hasWhiteBackground) continue;
+      const line = lineOfOffset(block, colorMatch.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "pure-black-white",
+          file,
+          line,
+          "Pure #000 on pure #fff \u2014 use near-black text on an off-white background instead",
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/tailwind.ts
+var CLASS_ATTR = /\b(?:class|className)\s*=\s*/g;
+function readBraced(source, open) {
+  let depth = 0;
+  for (let i = open; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return source.slice(open + 1, i);
+  }
+  return null;
+}
+function classAttributeValues(source) {
+  const out = [];
+  const lineAt = (offset) => source.slice(0, offset).split("\n").length;
+  for (const m of source.matchAll(CLASS_ATTR)) {
+    const at = m.index + m[0].length;
+    const opener = source[at];
+    if (opener === '"' || opener === "'") {
+      const end = source.indexOf(opener, at + 1);
+      if (end !== -1) out.push({ classes: source.slice(at + 1, end), line: lineAt(at) });
+      continue;
+    }
+    if (opener !== "{") continue;
+    const raw = readBraced(source, at);
+    if (raw === null) continue;
+    const literals = [...raw.matchAll(/(["'`])([\s\S]*?)\1/g)].map(
+      (q) => q[2].replace(/\$\{[\s\S]*?\}/g, " ")
+    );
+    if (literals.length > 0) out.push({ classes: literals.join(" ").trim(), line: lineAt(at) });
+  }
+  return out;
+}
+var ARBITRARY = /(?:^|\s)(?:[\w-]+:)*([a-z][\w-]*)-\[([^\]\s]+)\]/gi;
+var COLOUR = /^(?:#[0-9a-f]{3,8}|(?:rgba?|hsla?|oklch|oklab|lab|lch|color)\()/i;
+var LENGTH = /^-?\d*\.?\d+(?:px|rem|em|pt|vh|vw|vmin|vmax|ch|ex)$/i;
+function arbitraryValues(classes) {
+  const out = [];
+  for (const m of classes.matchAll(ARBITRARY)) {
+    const [, utility, rawValue] = m;
+    const value = rawValue.replace(/_/g, " ");
+    if (/var\(|--/.test(value)) continue;
+    if (COLOUR.test(value)) out.push({ utility, value, kind: "colour" });
+    else if (LENGTH.test(value)) out.push({ utility, value, kind: "length" });
+  }
+  return out;
+}
+var PALETTE = {
+  white: "#ffffff",
+  black: "#000000",
+  "gray-50": "#f9fafb",
+  "gray-100": "#f3f4f6",
+  "gray-200": "#e5e7eb",
+  "gray-300": "#d1d5db",
+  "gray-400": "#9ca3af",
+  "gray-500": "#6b7280",
+  "gray-600": "#4b5563",
+  "gray-700": "#374151",
+  "gray-800": "#1f2937",
+  "gray-900": "#111827",
+  "gray-950": "#030712",
+  "slate-50": "#f8fafc",
+  "slate-400": "#94a3b8",
+  "slate-500": "#64748b",
+  "slate-800": "#1e293b",
+  "slate-900": "#0f172a",
+  "slate-950": "#020617",
+  "zinc-400": "#a1a1aa",
+  "zinc-500": "#71717a",
+  "zinc-900": "#18181b",
+  "neutral-400": "#a3a3a3",
+  "neutral-500": "#737373",
+  "neutral-900": "#171717",
+  "stone-400": "#a8a29e",
+  "stone-500": "#78716c",
+  "stone-900": "#1c1917"
+};
+function palettePairs(classes) {
+  let background;
+  let foreground;
+  for (const token of classes.split(/\s+/)) {
+    const bare = token.replace(/^(?:[\w-]+:)*/, "");
+    const bg = /^bg-(.+)$/.exec(bare);
+    const fg = /^text-(.+)$/.exec(bare);
+    if (bg && PALETTE[bg[1]]) background = PALETTE[bg[1]];
+    if (fg && PALETTE[fg[1]]) foreground = PALETTE[fg[1]];
+  }
+  return background && foreground ? [{ background, foreground }] : [];
+}
+
+// src/check/detectors/contrast-floor.ts
+var FLOOR = 4.5;
+var LARGE_FLOOR = 3;
+var REM_TO_PX = 16;
+var FONT_SIZE_DECL_RE = /(?<![-\w])font-size\s*:\s*([^;]+?)(?:;|$)/i;
+var FONT_SIZE_PX_RE = /^(-?\d*\.?\d+)px$/i;
+var FONT_SIZE_REM_RE = /^(-?\d*\.?\d+)rem$/i;
+var BOLD_RE = /(?<![-\w])font-weight\s*:\s*(bold|[6-9]\d\d)/i;
+function resolveFloor(body) {
+  const m = FONT_SIZE_DECL_RE.exec(body);
+  if (!m) return FLOOR;
+  const raw = m[1].trim();
+  const pxMatch = FONT_SIZE_PX_RE.exec(raw);
+  const remMatch = FONT_SIZE_REM_RE.exec(raw);
+  let px;
+  if (pxMatch) px = parseFloat(pxMatch[1]);
+  else if (remMatch) px = parseFloat(remMatch[1]) * REM_TO_PX;
+  else return LARGE_FLOOR;
+  const large = BOLD_RE.test(body) ? px >= 18.66 : px >= 24;
+  return large ? LARGE_FLOOR : FLOOR;
+}
+var DECL_RE = /(?<![-\w])(color|background(?:-color)?)\s*:\s*([^;]+)(?:;|$)/gi;
+var contrastFloor = {
+  name: "contrast-floor",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      let fgValue = null;
+      let fgOffset = -1;
+      let bgValue = null;
+      DECL_RE.lastIndex = 0;
+      let m;
+      while (m = DECL_RE.exec(block.body)) {
+        const prop = m[1].toLowerCase();
+        if (prop === "color") {
+          fgValue = m[2].trim();
+          fgOffset = m.index;
+        } else {
+          bgValue = m[2].trim();
+        }
+      }
+      if (!fgValue || !bgValue) continue;
+      const fg = resolveOpaqueColor(fgValue, ctx.tokens);
+      const bg = resolveOpaqueColor(bgValue, ctx.tokens);
+      if (!fg || !bg) continue;
+      const floor = resolveFloor(block.body);
+      const ratio = contrastRatio(fg, bg);
+      if (ratio >= floor) continue;
+      const line = lineOfOffset(block, fgOffset);
+      findings.push(
+        mkFinding(
+          ctx,
+          "contrast-floor",
+          file,
+          line,
+          `Foreground/background contrast is ${ratio.toFixed(2)}:1, below the ${floor}:1 floor`,
+          sourceLine(source, line)
+        )
+      );
+    }
+    for (const attr of isMarkupHost(file) ? classAttributeValues(ctx.raw) : []) {
+      for (const pair of palettePairs(attr.classes)) {
+        const fg = resolveOpaqueColor(pair.foreground, ctx.tokens);
+        const bg = resolveOpaqueColor(pair.background, ctx.tokens);
+        if (!fg || !bg) continue;
+        const ratio = contrastRatio(fg, bg);
+        if (ratio >= 4.5) continue;
+        findings.push(
+          mkFinding(
+            ctx,
+            "contrast-floor",
+            file,
+            attr.line,
+            `Foreground/background contrast is ${ratio.toFixed(2)}:1, below the 4.5:1 floor (${pair.foreground} on ${pair.background})`,
+            sourceLine(ctx.raw, attr.line)
+          )
+        );
+      }
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/focus-removed.ts
+var OUTLINE_NONE_RE = /(?<![-\w])outline\s*:\s*(none|0(?:px)?)\s*(?:!important)?\s*(?:;|\}|$)/gi;
+var FOCUS_VISIBLE_RE = /:focus-visible\b/i;
+var focusRemoved = {
+  name: "focus-removed",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    if (FOCUS_VISIBLE_RE.test(source)) return [];
+    const findings = [];
+    const starts = buildLineIndex(source);
+    OUTLINE_NONE_RE.lastIndex = 0;
+    let m;
+    while (m = OUTLINE_NONE_RE.exec(source)) {
+      const line = lineForOffset(starts, m.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "focus-removed",
+          file,
+          line,
+          "outline removed with no :focus-visible replacement anywhere in this file",
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/hardcoded-value.ts
+var COLOR_PROPS = /* @__PURE__ */ new Set([
+  "color",
+  "background-color",
+  "background",
+  "border-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "fill",
+  "stroke",
+  "outline-color"
+]);
+var SPACING_PROPS = /* @__PURE__ */ new Set([
+  "font-size",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "gap",
+  "row-gap",
+  "column-gap"
+]);
+var DECL_RE2 = /(?<![-\w])([a-zA-Z-]+)\s*:\s*([^;]+)(?:;|$)/g;
+var COLOR_LITERAL_RE = /#[0-9a-fA-F]{3,8}\b|(?:rgb|hsl)a?\([^)]*\)/;
+var PX_RE = /(-?\d*\.?\d+)px/g;
+var EXCLUDED_PX = /* @__PURE__ */ new Set([0, 1, 2]);
+var KEYFRAME_STEP_RE = /^(from|to|\d+(\.\d+)?%)$/i;
+var hardcodedValue = {
+  name: "hardcoded-value",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const participates = isStyleHost(file) ? ctx.projectParticipates : participatesInTokenLayer(source, ctx.tokens);
+    if (!participates) return [];
+    const findings = [];
+    for (const block of leafBlocks(source)) {
+      if (KEYFRAME_STEP_RE.test(block.selector.trim())) continue;
+      DECL_RE2.lastIndex = 0;
+      let m;
+      while (m = DECL_RE2.exec(block.body)) {
+        const prop = m[1].toLowerCase();
+        const value = m[2].trim();
+        if (value.includes("var(")) continue;
+        if (COLOR_PROPS.has(prop) && COLOR_LITERAL_RE.test(value)) {
+          const line = lineOfOffset(block, m.index);
+          findings.push(
+            mkFinding(
+              ctx,
+              "hardcoded-value",
+              file,
+              line,
+              `Hard-coded colour \`${value}\` past the token layer`,
+              sourceLine(source, line)
+            )
+          );
+          continue;
+        }
+        if (SPACING_PROPS.has(prop)) {
+          PX_RE.lastIndex = 0;
+          let px;
+          let flagged = false;
+          while (px = PX_RE.exec(value)) {
+            if (!EXCLUDED_PX.has(Math.abs(parseFloat(px[1])))) {
+              flagged = true;
+              break;
+            }
+          }
+          if (flagged) {
+            const line = lineOfOffset(block, m.index);
+            findings.push(
+              mkFinding(
+                ctx,
+                "hardcoded-value",
+                file,
+                line,
+                `Hard-coded \`${value}\` past the token layer`,
+                sourceLine(source, line)
+              )
+            );
+          }
+        }
+      }
+    }
+    for (const attr of isMarkupHost(file) ? classAttributeValues(ctx.raw) : []) {
+      for (const found of arbitraryValues(attr.classes)) {
+        findings.push(
+          mkFinding(
+            ctx,
+            "hardcoded-value",
+            file,
+            attr.line,
+            found.kind === "colour" ? `Hard-coded colour \`${found.value}\` past the token layer (${found.utility}-[\u2026])` : `Hard-coded \`${found.value}\` past the token layer (${found.utility}-[\u2026])`,
+            attr.classes.length > 80 ? `${attr.classes.slice(0, 77)}\u2026` : attr.classes
+          )
+        );
+      }
+    }
+    return findings;
+  }
+};
+
+// src/check/detectors/violet-band-hue.ts
+var COLOR_TOKEN_RE = /#[0-9a-fA-F]{3,8}\b|(?:rgb|hsl)a?\([^)]*\)/g;
+var HUE_MIN = 235;
+var HUE_MAX = 290;
+var MIN_SATURATION = 15;
+var MIN_LIGHTNESS = 8;
+var MAX_LIGHTNESS = 92;
+var violetBandHue = {
+  name: "violet-band-hue",
+  appliesTo: (file) => isStyleBearing(file),
+  run(source, file, ctx) {
+    const findings = [];
+    const starts = buildLineIndex(source);
+    COLOR_TOKEN_RE.lastIndex = 0;
+    let m;
+    while (m = COLOR_TOKEN_RE.exec(source)) {
+      const c = extractColorComponents(m[0], ctx.tokens);
+      if (!c) continue;
+      const { h, s, l } = c.hsl;
+      if (s < MIN_SATURATION || l < MIN_LIGHTNESS || l > MAX_LIGHTNESS) continue;
+      if (h < HUE_MIN || h > HUE_MAX) continue;
+      const line = lineForOffset(starts, m.index);
+      findings.push(
+        mkFinding(
+          ctx,
+          "violet-band-hue",
+          file,
+          line,
+          `Violet/indigo hue (~${Math.round(h)}\xB0) \u2014 is this a deliberate brand choice, or the unspecified default?`,
+          sourceLine(source, line)
+        )
+      );
+    }
+    return findings;
+  }
+};
+
+// src/check/registry.ts
+var DETECTORS = [
+  gradientText,
+  backdropBlur,
+  pureBlackWhite,
+  contrastFloor,
+  focusRemoved,
+  hardcodedValue,
+  violetBandHue
+];
+function getDetector(name) {
+  return DETECTORS.find((d) => d.name === name);
+}
+
+// src/check/run.ts
+function runChecks(projectRoot, files, index, tokens, bucketFilter, projectParticipates = false) {
+  const findings = [];
+  const active = index.filter(
+    (e) => !!e.detector && !!getDetector(e.detector)
+  );
+  const relevant = bucketFilter ? active.filter((e) => bucketFilter(e.bucket)) : active;
+  if (relevant.length === 0) return findings;
+  for (const file of files) {
+    const applicable = relevant.map((entry) => ({ entry, detector: getDetector(entry.detector) })).filter(({ detector }) => detector.appliesTo(file));
+    if (applicable.length === 0) continue;
+    let raw;
+    try {
+      raw = readFileSync9(join14(projectRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    const source = maskComments(maskNonStyleRegions(raw, file));
+    for (const { entry, detector } of applicable) {
+      const ctx = { ruleId: entry.id, bucket: entry.bucket, severity: entry.severity, tokens, projectParticipates, raw };
+      findings.push(...detector.run(source, file, ctx));
+    }
+  }
+  return findings;
+}
+
+// src/check/tokens.ts
+import { existsSync as existsSync8, readdirSync as readdirSync8, readFileSync as readFileSync10 } from "fs";
+import { join as join15 } from "path";
+function loadTokenMap(projectRoot) {
+  const tokensDir = join15(projectRoot, ".jig", "tokens");
+  const tokens = {};
+  if (!existsSync8(tokensDir)) return tokens;
+  const files = readdirSync8(tokensDir).filter((f) => f.endsWith(".css")).sort();
+  for (const file of files) {
+    const source = readFileSync10(join15(tokensDir, file), "utf8");
+    for (const block of splitRuleBlocks(source)) {
+      if (block.body.includes("{")) continue;
+      if (block.selector.trim() !== ":root") continue;
+      const re = /--([\w-]+)\s*:\s*([^;]+);/g;
+      let m;
+      while (m = re.exec(block.body)) {
+        tokens[m[1]] = m[2].trim();
+      }
+    }
+  }
+  return tokens;
+}
+
+// src/commands/check.ts
+var LEGACY_INDEX_REL = join16(".jig", "rules.index.json");
+function resolveIndexPath(projectRoot) {
+  const legacy = join16(projectRoot, LEGACY_INDEX_REL);
+  if (existsSync9(legacy)) return legacy;
+  return join16(assetRoot(), "rules.index.json");
+}
+function resolveMode(projectRoot) {
+  try {
+    const config = JSON.parse(readFileSync11(join16(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";
+  } catch {
+    return "unknown";
+  }
+}
+var UNSUPPORTED_STYLE_HOSTS = [".elm", ".rs", ".templ", ".gohtml"];
+function summariseUnscanned(files) {
+  const hit = files.filter((f) => !isStyleBearing(f) && hasExtension(f, UNSUPPORTED_STYLE_HOSTS));
+  if (hit.length === 0) return void 0;
+  const extensions = [...new Set(hit.map((f) => f.slice(f.lastIndexOf(".")).toLowerCase()))].sort();
+  return { count: hit.length, extensions };
+}
+function countSpecs() {
+  try {
+    return loadSpecs(join16(assetRoot(), "rules")).length;
+  } catch {
+    return 0;
+  }
+}
+function check(opts) {
+  const indexPath = resolveIndexPath(opts.projectRoot);
+  const index = validateIndex(JSON.parse(readFileSync11(indexPath, "utf8")));
+  const tokens = loadTokenMap(opts.projectRoot);
+  const selection = selectFiles(opts.projectRoot, opts.all);
+  const { files } = selection;
+  const bucketFilter = opts.ci ? (b) => b === "mechanical" : void 0;
+  const stylesheets = selection.mode === "all" ? files : selectFiles(opts.projectRoot, true).files;
+  const projectParticipates = stylesheets.some((f) => {
+    if (!hasExtension(f, CSS_EXTENSIONS)) return false;
+    try {
+      return participatesInTokenLayer(readFileSync11(join16(opts.projectRoot, f), "utf8"), tokens);
+    } catch {
+      return false;
+    }
+  });
+  const findings = runChecks(opts.projectRoot, files, index, tokens, bucketFilter, projectParticipates);
+  const hasError = findings.some((f) => f.bucket === "mechanical" && f.severity === "error");
+  const cssFiles = files.filter((f) => /\.(css|scss|less)$/i.test(f));
+  const noTokenLayer = (
+    // `[].every()` is true, so without this guard a repo with no CSS at all is
+    // told to add a token @import it has nowhere to put.
+    cssFiles.length > 0 && cssFiles.every((f) => {
+      try {
+        return !participatesInTokenLayer(readFileSync11(join16(opts.projectRoot, f), "utf8"), tokens);
+      } catch {
+        return true;
+      }
+    })
+  );
+  const report = formatReport(findings, {
+    totalRules: index.length,
+    // From the CLI's own bundle, like `explain` — the spec count describes the
+    // system, not whatever a project happens to have vendored. A legacy project
+    // copy may have no `rules/` directory at all.
+    totalSpecs: countSpecs(),
+    version: opts.version,
+    noTokenLayer,
+    mode: resolveMode(opts.projectRoot),
+    unscanned: summariseUnscanned(files)
+  });
+  return { findings, report, hasError };
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join20 } from "path";
+
+// src/init/detect.ts
+import { readFileSync as readFileSync12 } from "fs";
+import { join as join17 } 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/;
+var FRAMEWORK_DEPS = [
+  ["next", "Next.js"],
+  ["nuxt", "Nuxt"],
+  ["@remix-run/react", "Remix"],
+  ["astro", "Astro"],
+  ["svelte", "Svelte"],
+  ["vue", "Vue"],
+  ["react", "React"],
+  ["solid-js", "Solid"]
+];
+function detectFramework(projectRoot) {
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync12(join17(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  for (const [dep, label] of FRAMEWORK_DEPS) {
+    if (deps[dep]) return label;
+  }
+  return void 0;
+}
+function detect(projectRoot) {
+  const allFiles = wholeRepoFiles(projectRoot);
+  const cssFiles = allFiles.filter((f) => hasExtension(f, CSS_EXTENSIONS));
+  const tailwindConfigFile = allFiles.find((f) => TAILWIND_CONFIG_RE.test(f.split("/").pop() ?? ""));
+  let tailwindV4EntryFile;
+  for (const f of cssFiles) {
+    let source;
+    try {
+      source = readFileSync12(join17(projectRoot, f), "utf8");
+    } catch {
+      continue;
+    }
+    if (TAILWIND_V4_IMPORT_RE.test(source) || TAILWIND_V4_THEME_RE.test(source)) {
+      tailwindV4EntryFile = f;
+      break;
+    }
+  }
+  let cssSystem;
+  if (tailwindV4EntryFile) cssSystem = "tailwind-v4";
+  else if (tailwindConfigFile) cssSystem = "tailwind-v3";
+  else if (cssFiles.length > 0) cssSystem = "plain-css";
+  else cssSystem = "unknown";
+  return { cssSystem, cssFiles, tailwindConfigFile, tailwindV4EntryFile, framework: detectFramework(projectRoot) };
+}
+
+// src/init/gitignore.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function isIgnored(projectRoot, relPath) {
+  const candidates = relPath.endsWith("/") ? [relPath] : [relPath, `${relPath}/`];
+  return candidates.some((path) => {
+    try {
+      execFileSync2("git", ["check-ignore", "-q", "--", path], {
+        cwd: projectRoot,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
+// src/init/derive.ts
+import { readFileSync as readFileSync13 } from "fs";
+import { join as join18 } from "path";
+var DEFAULT_PROPOSAL = {
+  h: 264,
+  s: 0,
+  l: 15,
+  source: "default",
+  detail: "no colour found in the project; using the unbranded default (near-black, matches tokens/brand.default.css)"
+};
+var NAME_PRIORITY_RE = /brand|primary|accent/i;
+var EXACT_NAMES = /* @__PURE__ */ new Set(["brand", "primary", "accent"]);
+var MIN_CHROMATIC_SATURATION = 15;
+function round(n) {
+  return Math.round(n * 10) / 10;
+}
+function toProposal(c, source, why) {
+  return { h: round(c.hsl.h), s: round(c.hsl.s), l: round(c.hsl.l), source, detail: why };
+}
+function mostFrequent(candidates) {
+  if (candidates.length === 0) return void 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const key = `${Math.round(c.hsl.h)}|${Math.round(c.hsl.s)}|${Math.round(c.hsl.l)}`;
+    const existing = counts.get(key);
+    if (existing) existing.count += 1;
+    else counts.set(key, { count: 1, candidate: c });
+  }
+  return [...counts.values()].sort((a, b) => b.count - a.count || b.candidate.hsl.s - a.candidate.hsl.s)[0].candidate;
+}
+function fromCssCustomProperties(projectRoot, cssFiles) {
+  const candidates = [];
+  for (const file of cssFiles) {
+    let source;
+    try {
+      source = readFileSync13(join18(projectRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const block of splitRuleBlocks(source)) {
+      if (block.body.includes("{")) continue;
+      const re = /--([\w-]+)\s*:\s*([^;]+);/g;
+      let m;
+      while (m = re.exec(block.body)) {
+        const [, name, rawValue] = m;
+        const value = rawValue.trim();
+        const comps = extractColorComponents(value, {});
+        if (!comps || comps.alpha < 0.999) continue;
+        candidates.push({ value, hsl: comps.hsl, name, file });
+      }
+    }
+  }
+  if (candidates.length === 0) return null;
+  const namedChromatic = candidates.filter(
+    (c) => c.name && NAME_PRIORITY_RE.test(c.name) && c.hsl.s >= MIN_CHROMATIC_SATURATION
+  );
+  if (namedChromatic.length > 0) {
+    const exact = namedChromatic.find((c) => EXACT_NAMES.has(c.name.toLowerCase()));
+    const named = exact ?? namedChromatic[0];
+    return toProposal(named, "css-custom-property", `--${named.name}: ${named.value} in ${named.file}`);
+  }
+  const chromatic = candidates.filter((c) => c.hsl.s >= MIN_CHROMATIC_SATURATION);
+  const pool = chromatic.length > 0 ? chromatic : candidates;
+  const chosen = mostFrequent(pool) ?? pool[0];
+  return toProposal(
+    chosen,
+    "css-custom-property",
+    `--${chosen.name}: ${chosen.value} in ${chosen.file} (most repeated custom-property colour)`
+  );
+}
+function balancedBraceBody(source, openIdx) {
+  let depth = 0;
+  for (let i = openIdx; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) return source.slice(openIdx + 1, i);
+    }
+  }
+  return null;
+}
+function fromTailwindConfig(projectRoot, tailwindConfigFile) {
+  let source;
+  try {
+    source = readFileSync13(join18(projectRoot, tailwindConfigFile), "utf8");
+  } catch {
+    return null;
+  }
+  const colorsBlock = (() => {
+    const extendIdx = source.search(/\bextend\s*:\s*\{/);
+    if (extendIdx !== -1) {
+      const extendBraceIdx = source.indexOf("{", extendIdx);
+      const extendBody = balancedBraceBody(source, extendBraceIdx);
+      if (extendBody) {
+        const colorsIdx2 = extendBody.search(/\bcolors\s*:\s*\{/);
+        if (colorsIdx2 !== -1) {
+          const braceIdx = extendBody.indexOf("{", colorsIdx2);
+          const body = balancedBraceBody(extendBody, braceIdx);
+          if (body) return body;
+        }
+      }
+    }
+    const colorsIdx = source.search(/\bcolors\s*:\s*\{/);
+    if (colorsIdx !== -1) {
+      const braceIdx = source.indexOf("{", colorsIdx);
+      return balancedBraceBody(source, braceIdx);
+    }
+    return null;
+  })();
+  if (!colorsBlock) return null;
+  const candidates = [];
+  const re = /['"]?([\w-]+)['"]?\s*:\s*['"]([^'"]+)['"]/g;
+  let m;
+  while (m = re.exec(colorsBlock)) {
+    const [, name, value] = m;
+    const comps = extractColorComponents(value, {});
+    if (!comps || comps.alpha < 0.999) continue;
+    candidates.push({ value, hsl: comps.hsl, name, file: tailwindConfigFile });
+  }
+  if (candidates.length === 0) return null;
+  const namedChromatic = candidates.filter(
+    (c) => NAME_PRIORITY_RE.test(c.name) && c.hsl.s >= MIN_CHROMATIC_SATURATION
+  );
+  const named = namedChromatic.length > 0 ? namedChromatic.find((c) => EXACT_NAMES.has(c.name.toLowerCase())) ?? namedChromatic[0] : void 0;
+  const chromatic = candidates.filter((c) => c.hsl.s >= MIN_CHROMATIC_SATURATION);
+  const pool = chromatic.length > 0 ? chromatic : candidates;
+  const chosen = named ?? mostFrequent(pool) ?? pool[0];
+  return toProposal(
+    chosen,
+    "tailwind-config",
+    `theme.extend.colors.${chosen.name}: '${chosen.value}' in ${tailwindConfigFile}`
+  );
+}
+var HEX_RE = /#[0-9a-fA-F]{3,8}\b/g;
+var RGB_HSL_RE = /(?:rgb|hsl)a?\([^)]*\)/g;
+function fromLiteralFrequency(projectRoot, cssFiles) {
+  const candidates = [];
+  for (const file of cssFiles) {
+    let source;
+    try {
+      source = readFileSync13(join18(projectRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const re of [HEX_RE, RGB_HSL_RE]) {
+      re.lastIndex = 0;
+      let m;
+      while (m = re.exec(source)) {
+        const comps = extractColorComponents(m[0], {});
+        if (!comps || comps.alpha < 0.999) continue;
+        if (comps.hsl.s < MIN_CHROMATIC_SATURATION) continue;
+        candidates.push({ value: m[0], hsl: comps.hsl, file });
+      }
+    }
+  }
+  if (candidates.length === 0) return null;
+  const chosen = mostFrequent(candidates) ?? candidates[0];
+  return toProposal(
+    chosen,
+    "literal-frequency",
+    `${chosen.value} \u2014 the most frequent literal chromatic colour across ${cssFiles.length} stylesheet(s), in ${chosen.file}`
+  );
+}
+function deriveBrandColor(projectRoot, cssFiles, tailwindConfigFile) {
+  return fromCssCustomProperties(projectRoot, cssFiles) ?? (tailwindConfigFile ? fromTailwindConfig(projectRoot, tailwindConfigFile) : null) ?? fromLiteralFrequency(projectRoot, cssFiles) ?? DEFAULT_PROPOSAL;
+}
+
+// src/init/validate.ts
+var BG_RAISED = { r: 255, g: 255, b: 255 };
+var BG_BASE_APPROX = { r: 250, g: 250, b: 248 };
+function compositeOver(fg, alpha, bg) {
+  return {
+    r: Math.round(fg.r * alpha + bg.r * (1 - alpha)),
+    g: Math.round(fg.g * alpha + bg.g * (1 - alpha)),
+    b: Math.round(fg.b * alpha + bg.b * (1 - alpha))
+  };
+}
+var FILL_COMPOSITED = compositeOver({ r: 0, g: 0, b: 0 }, 0.04, BG_BASE_APPROX);
+var CONTRAST_FLOOR = 4.5;
+function toRgb(h, s, l) {
+  const comps = extractColorComponents(`hsl(${h} ${s}% ${l}%)`, {});
+  if (!comps) throw new Error(`validate: could not resolve hsl(${h} ${s}% ${l}%) \u2014 this should never happen`);
+  return comps.rgb;
+}
+function worstRatio(h, s, l) {
+  const rgb = toRgb(h, s, l);
+  const vsRaised = contrastRatio(rgb, BG_RAISED);
+  const vsFill = contrastRatio(rgb, FILL_COMPOSITED);
+  return { vsRaised, vsFill, worst: Math.min(vsRaised, vsFill) };
+}
+var DARK_BRAND_L = 88;
+var DARK_SURFACE_S = 6;
+var DARK_RAISED_L = 15;
+var DARK_BASE_L = 10;
+var DARK_FILL_ALPHA = 0.06;
+function darkWorstRatio(h, s) {
+  const brand = toRgb(h, s, DARK_BRAND_L);
+  const raised = toRgb(h, DARK_SURFACE_S, DARK_RAISED_L);
+  const base = toRgb(h, DARK_SURFACE_S, DARK_BASE_L);
+  const fill = compositeOver({ r: 255, g: 255, b: 255 }, DARK_FILL_ALPHA, base);
+  const vsRaised = contrastRatio(brand, raised);
+  const vsFill = contrastRatio(brand, fill);
+  return { vsRaised, vsFill, worst: Math.min(vsRaised, vsFill) };
+}
+function nearestPassingLightness(h, s, l) {
+  if (worstRatio(h, s, l).worst >= CONTRAST_FLOOR) return l;
+  for (let delta = 1; delta <= 100; delta++) {
+    for (const candidate of [l - delta, l + delta]) {
+      if (candidate < 0 || candidate > 100) continue;
+      if (worstRatio(h, s, candidate).worst >= CONTRAST_FLOOR) return candidate;
+    }
+  }
+  return null;
+}
+var VIOLET_HUE_MIN = 235;
+var VIOLET_HUE_MAX = 290;
+var HUE_MIN_SATURATION = 15;
+var HUE_MIN_LIGHTNESS = 8;
+var HUE_MAX_LIGHTNESS = 92;
+function isHueVisible(s, l) {
+  return s >= HUE_MIN_SATURATION && l >= HUE_MIN_LIGHTNESS && l <= HUE_MAX_LIGHTNESS;
+}
+function isInVioletBand(h, s, l) {
+  return isHueVisible(s, l) && h >= VIOLET_HUE_MIN && h <= VIOLET_HUE_MAX;
+}
+function systemCollision(h, s, l) {
+  if (!isHueVisible(s, l)) return null;
+  if (h <= 20 || h >= 340) return "red";
+  if (h >= 25 && h <= 65) return "amber";
+  if (h >= 100 && h <= 170) return "green";
+  return null;
+}
+function validateBrandColor(h, s, l) {
+  const light = worstRatio(h, s, l);
+  const dark = darkWorstRatio(h, s);
+  const worst = Math.min(light.worst, dark.worst);
+  const passesContrast = worst >= CONTRAST_FLOOR;
+  return {
+    ratioVsRaised: light.vsRaised,
+    ratioVsFill: light.vsFill,
+    lightRatioVsRaised: light.vsRaised,
+    lightRatioVsFill: light.vsFill,
+    lightWorstRatio: light.worst,
+    darkRatioVsRaised: dark.vsRaised,
+    darkRatioVsFill: dark.vsFill,
+    darkWorstRatio: dark.worst,
+    worstRatio: worst,
+    passesContrast,
+    nearestPassingLightness: passesContrast ? void 0 : nearestPassingLightness(h, s, l) ?? void 0,
+    violetBand: isInVioletBand(h, s, l),
+    systemCollision: systemCollision(h, s, l)
+  };
+}
+
+// src/init/brand-file.ts
+var TOP_COMMENT_FIRST_LINE = "brand.default.css \u2014 unbranded default.";
+var TOP_COMMENT_LAST_LINE = "Copy to brand.<client>.css and override. Never edit this file per project.";
+function round2(n) {
+  return Math.round(n);
+}
+function renderBrandFile(defaultCssRaw, projectSlug, version2, proposal) {
+  const fileName = `brand.${projectSlug}.css`;
+  const header = vendorHeader(fileName, version2, "css", null);
+  if (!defaultCssRaw.includes(TOP_COMMENT_FIRST_LINE) || !defaultCssRaw.includes(TOP_COMMENT_LAST_LINE)) {
+    throw new Error(
+      `brand-file: tokens/brand.default.css does not match the expected shape \u2014 ${TOP_COMMENT_FIRST_LINE} / ${TOP_COMMENT_LAST_LINE} not found.`
+    );
+  }
+  let body = defaultCssRaw.replace(
+    TOP_COMMENT_FIRST_LINE,
+    `${fileName} \u2014 generated by \`jig init\`.`
+  );
+  body = body.replace(
+    TOP_COMMENT_LAST_LINE,
+    `Brand colour derived from: ${proposal.detail} (${proposal.source}). Edit --brand-h/-s/-l below directly \u2014 \`jig update\` will not touch this file.`
+  );
+  const substitute = (source, pattern, replacement, label) => {
+    if (!pattern.test(source)) {
+      throw new Error(`brand-file: tokens/brand.default.css does not match the expected shape \u2014 ${label} not found.`);
+    }
+    return source.replace(pattern, replacement);
+  };
+  body = substitute(body, /--brand-h:\s*[\d.]+;/, `--brand-h: ${round2(proposal.h)};`, "--brand-h");
+  body = substitute(body, /--brand-s:\s*[\d.]+%;/, `--brand-s: ${round2(proposal.s)}%;`, "--brand-s");
+  body = substitute(body, /--brand-l:\s*[\d.]+%;/, `--brand-l: ${round2(proposal.l)}%;`, "--brand-l");
+  return header + body;
+}
+function brandFileName(projectSlug) {
+  return `brand.${projectSlug}.css`;
+}
+
+// src/init/import-path.ts
+import { relative as relative2, sep as sep2 } from "path";
+function relativeImportPath(fromAbsDir, toAbsFile) {
+  let rel = relative2(fromAbsDir, toAbsFile).split(sep2).join("/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel;
+}
+
+// src/init/project-name.ts
+import { readFileSync as readFileSync14 } from "fs";
+import { basename, join as join19 } from "path";
+function slugify(name) {
+  const withoutScope = name.replace(/^@[^/]+\//, "");
+  const slug = withoutScope.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || "project";
+}
+function deriveProjectSlug(projectRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync14(join19(projectRoot, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.trim()) return slugify(pkg.name);
+  } catch {
+  }
+  return slugify(basename(projectRoot));
+}
+
+// src/commands/init.ts
+var MODES = ["editorial", "product", "operator"];
+var DEFAULT_SURFACES = [{ match: "/", mode: "product" }];
+async function defaultPrompt(question) {
+  const { createInterface } = await import("readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+function validateRounded(p) {
+  return validateBrandColor(Math.round(p.h), Math.round(p.s), Math.round(p.l));
+}
+function describeValidation(v) {
+  const lines = [];
+  const modes = `light ${v.lightWorstRatio.toFixed(2)}:1, dark ${v.darkWorstRatio.toFixed(2)}:1`;
+  if (v.passesContrast) {
+    lines.push(
+      `  contrast OK \u2014 ${modes} (floor 4.5:1; light is ${v.ratioVsRaised.toFixed(2)} vs --color-bg-raised and ${v.ratioVsFill.toFixed(2)} vs --color-fill)`
+    );
+  } else {
+    const failing = v.lightWorstRatio < v.darkWorstRatio ? "light" : "dark";
+    lines.push(
+      `  contrast FAILS in ${failing} mode \u2014 worst is ${v.worstRatio.toFixed(2)}:1 against the 4.5:1 floor (${modes})`
+    );
+    if (v.nearestPassingLightness !== void 0) {
+      lines.push(`  nearest passing lightness at the same hue/saturation: ${v.nearestPassingLightness}%`);
+    }
+  }
+  if (v.violetBand) {
+    lines.push(
+      "  A-01: this hue falls in the violet/indigo band \u2014 the unspecified-default hue. Confirm this was a deliberate choice."
+    );
+  }
+  if (v.systemCollision) {
+    lines.push(
+      `  E-64: this hue reads as ${v.systemCollision} \u2014 a system colour. Do not use it for interactive elements (links, buttons); keep it decorative.`
+    );
+  }
+  return lines;
+}
+function parseSurfaces(answer, fallback) {
+  const trimmed = answer.trim();
+  if (!trimmed) return fallback;
+  const parts = trimmed.split(",").map((p) => p.trim()).filter(Boolean);
+  const parsed = [];
+  for (const part of parts) {
+    const idx = part.lastIndexOf(":");
+    if (idx === -1) return fallback;
+    const match = part.slice(0, idx).trim();
+    const mode = part.slice(idx + 1).trim();
+    if (!match || !MODES.includes(mode)) return fallback;
+    parsed.push({ match, mode });
+  }
+  return parsed.length > 0 ? parsed : fallback;
+}
+function fileState(projectRoot, absPath, relPath, initManifest) {
+  const existsOnDisk = existsSync10(absPath);
+  const tracked = !!initManifest && relPath in initManifest.files;
+  const modified = tracked && isInitFileModified(projectRoot, relPath, initManifest);
+  return { existsOnDisk, tracked, modified };
+}
+function isValidSurfaceArray(v) {
+  return Array.isArray(v) && v.length > 0 && v.every(
+    (s) => typeof s === "object" && s !== null && typeof s.match === "string" && MODES.includes(s.mode)
+  );
+}
+function loadEffectiveConfig(projectRoot, configAbsPath, fallbackBrand, fallbackSurfaces) {
+  if (!existsSync10(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
+  try {
+    const parsed = JSON.parse(readFileSync15(configAbsPath, "utf8"));
+    const brandCandidate = typeof parsed.brand === "string" && parsed.brand ? parsed.brand : void 0;
+    const brandResolves = brandCandidate ? existsSync10(join20(projectRoot, ...brandCandidate.split("/"))) : false;
+    return {
+      brand: brandResolves ? brandCandidate : fallbackBrand,
+      surfaces: isValidSurfaceArray(parsed.surfaces) ? parsed.surfaces : fallbackSurfaces
+    };
+  } catch {
+    return { brand: fallbackBrand, surfaces: fallbackSurfaces };
+  }
+}
+function isCssModule(path) {
+  return /\.module\.(css|scss)$/i.test(path);
+}
+function findWireTarget(d) {
+  if (d.cssSystem === "tailwind-v4" && d.tailwindV4EntryFile) return d.tailwindV4EntryFile;
+  const candidates = d.cssFiles.filter((f) => !isCssModule(f));
+  if (candidates.length === 1) return candidates[0];
+  return null;
+}
+var MODE_IMPORT_RE = new RegExp(`@import\\s+["']([^"']*/)?mode\\.(${MODES.join("|")})\\.css["'];?\\r?\\n?`);
+var CHARSET_RE = /^@charset\s+["'][^"']*["'];\r?\n?/;
+function insertAfterCharset(content, insertion) {
+  const m = CHARSET_RE.exec(content);
+  const charsetLen = m ? m[0].length : 0;
+  return content.slice(0, charsetLen) + insertion + content.slice(charsetLen);
+}
+function wireImport(absPath, brandImport, modeImport, mode) {
+  const content = existsSync10(absPath) ? readFileSync15(absPath, "utf8") : "";
+  const brandImportLine = `@import "${brandImport}";`;
+  const modeImportLine = `@import "${modeImport}";`;
+  const brandPresent = content.includes(brandImportLine);
+  const existingModeMatch = MODE_IMPORT_RE.exec(content);
+  if (brandPresent) {
+    if (existingModeMatch && existingModeMatch[0].trim() === modeImportLine) {
+      return { status: "already-present" };
+    }
+    if (existingModeMatch) {
+      const previousMode = existingModeMatch[2];
+      const next3 = content.slice(0, existingModeMatch.index) + `${modeImportLine}
+` + content.slice(existingModeMatch.index + existingModeMatch[0].length);
+      writeFileSync6(absPath, next3, "utf8");
+      return { status: "rewired", detail: `rewired mode: ${previousMode} \u2192 ${mode}` };
+    }
+    const brandIdx = content.indexOf(brandImportLine);
+    let insertAt = brandIdx + brandImportLine.length;
+    if (content[insertAt] === "\r") insertAt++;
+    if (content[insertAt] === "\n") insertAt++;
+    const next2 = content.slice(0, insertAt) + modeImportLine + "\n" + content.slice(insertAt);
+    writeFileSync6(absPath, next2, "utf8");
+    return { status: "rewired", detail: `added missing mode import: ${mode}` };
+  }
+  const lines = `${brandImportLine}
+${modeImportLine}
+`;
+  const tailwindImportMatch = /@import\s+["']tailwindcss["'];?\r?\n?/.exec(content);
+  let next;
+  if (tailwindImportMatch) {
+    const idx = tailwindImportMatch.index + tailwindImportMatch[0].length;
+    next = content.slice(0, idx) + lines + content.slice(idx);
+  } else {
+    next = insertAfterCharset(content, content ? `${lines}
+` : lines);
+  }
+  mkdirSync6(dirname7(absPath), { recursive: true });
+  writeFileSync6(absPath, next, "utf8");
+  return { status: "wired" };
+}
+async function init(opts) {
+  const log = opts.log ?? ((line) => console.log(line));
+  const prompt = opts.prompt ?? defaultPrompt;
+  const migrateLegacy = async (report, describe) => {
+    if (!report.present) return;
+    for (const line of describe(report)) log(line);
+    const removable = removableLegacyFiles(report);
+    if (removable.length === 0) return;
+    if (opts.yes) {
+      log("  Re-run without --yes to be prompted for removal, or delete them yourself.");
+      return;
+    }
+    const answer = (await prompt(`  Remove these ${removable.length} unedited legacy file(s)? [y/N]: `)).toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      removeLegacyFiles(opts.projectRoot, removable);
+      log(`  Removed ${removable.length} file(s).`);
+    } else {
+      log("  Left them in place.");
+    }
+  };
+  await migrateLegacy(detectLegacyRules(opts.projectRoot), describeLegacyReport);
+  await migrateLegacy(detectLegacyCursorRules(opts.projectRoot), describeLegacyCursorReport);
+  const detection = detect(opts.projectRoot);
+  log(`Detected: ${detection.cssSystem}${detection.framework ? ` (${detection.framework})` : ""}`);
+  if (detection.cssFiles.length === 0) {
+    log("  No stylesheets found.");
+  } else {
+    log(`  ${detection.cssFiles.length} stylesheet(s) found.`);
+  }
+  let proposal = deriveBrandColor(opts.projectRoot, detection.cssFiles, detection.tailwindConfigFile);
+  let validation = validateRounded(proposal);
+  log(`Proposed brand colour: hsl(${proposal.h} ${proposal.s}% ${proposal.l}%) \u2014 ${proposal.detail}`);
+  for (const line of describeValidation(validation)) log(line);
+  let surfaces = DEFAULT_SURFACES;
+  if (!opts.yes) {
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const answer = await prompt(
+        `Use this brand colour? [Y/n, or paste a hex to override]: `
+      );
+      const normalized = answer.toLowerCase();
+      if (normalized === "" || normalized === "y" || normalized === "yes") break;
+      if (normalized === "n" || normalized === "no") break;
+      const comps = extractColorComponents(answer, {});
+      if (!comps) {
+        log(`  Could not parse '${answer}' as a colour \u2014 keeping the proposal.`);
+        break;
+      }
+      proposal = { h: comps.hsl.h, s: comps.hsl.s, l: comps.hsl.l, source: "default", detail: `user-provided: ${answer}` };
+      validation = validateRounded(proposal);
+      log(`Brand colour: hsl(${proposal.h} ${proposal.s}% ${proposal.l}%)`);
+      for (const line of describeValidation(validation)) log(line);
+    }
+    const surfaceAnswer = await prompt(
+      `Surface \u2192 mode mapping. Enter to accept '/' \u2192 product, or 'match:mode,match:mode' (modes: ${MODES.join("/")}): `
+    );
+    surfaces = parseSurfaces(surfaceAnswer, DEFAULT_SURFACES);
+    if (surfaceAnswer.trim() && surfaces === DEFAULT_SURFACES) {
+      log(
+        `  Could not parse '${surfaceAnswer}' as 'match:mode,match:mode' (modes: ${MODES.join("/")}) \u2014 using the default ('/' \u2192 product) instead.`
+      );
+    }
+  }
+  if (opts.yes) {
+    log(
+      `Surface \u2192 mode: ${surfaces.map((s) => `'${s.match}' \u2192 ${s.mode}`).join(", ")} \u2014 the default, not inferred from this project. Mode sets density, type scale and control sizes, and it wins over an agent's own inference, so change it in jig.config.json if another mode fits (${MODES.join("/")}).`
+    );
+  }
+  if (!validation.passesContrast && validation.nearestPassingLightness !== void 0) {
+    const originalL = proposal.l;
+    proposal = { ...proposal, l: validation.nearestPassingLightness };
+    validation = validateRounded(proposal);
+    log(
+      `
+Brand colour adjusted to clear the 4.5:1 contrast floor: l:${originalL}% \u2192 l:${proposal.l}% (hue/saturation unchanged).`
+    );
+  }
+  const finalColor = { h: proposal.h, s: proposal.s, l: proposal.l };
+  const projectSlug = deriveProjectSlug(opts.projectRoot);
+  const brandRelPath = relKey(".jig", "tokens", brandFileName(projectSlug));
+  const brandAbsPath = join20(opts.projectRoot, ".jig", "tokens", brandFileName(projectSlug));
+  const configRelPath = "jig.config.json";
+  const configAbsPath = join20(opts.projectRoot, configRelPath);
+  const initManifest = readInitManifest(opts.projectRoot);
+  const files = { ...initManifest?.files ?? {} };
+  const brandState = fileState(opts.projectRoot, brandAbsPath, brandRelPath, initManifest);
+  const configState = fileState(opts.projectRoot, configAbsPath, configRelPath, initManifest);
+  let brandAction = "written";
+  if (brandState.existsOnDisk && !brandState.tracked) brandAction = "skipped-untracked";
+  else if (brandState.modified) brandAction = "skipped-edited";
+  let configAction = "written";
+  if (configState.existsOnDisk && !configState.tracked) configAction = "skipped-untracked";
+  else if (configState.modified) configAction = "skipped-edited";
+  if (!opts.yes && (brandAction !== "written" || configAction !== "written")) {
+    if (brandAction !== "written") {
+      log(`
+${brandRelPath} already exists and was not created by 'jig init' (or has been edited).`);
+      const answer = (await prompt(`  [k]eep it, or [r]efresh it with the freshly derived colour? [k/r]: `)).toLowerCase();
+      brandAction = answer.startsWith("r") ? "written" : "kept";
+    }
+    if (configAction !== "written") {
+      log(`
+${configRelPath} already exists and was not created by 'jig init' (or has been edited).`);
+      const answer = (await prompt(`  [k]eep it, [r]efresh it, or [m]erge (keep your surfaces, only fix a missing brand path)? [k/r/m]: `)).toLowerCase();
+      configAction = answer.startsWith("r") ? "written" : answer.startsWith("m") ? "merged" : "kept";
+    }
+  } else {
+    if (brandAction !== "written") log(`  ${brandRelPath} exists and is not jig-tracked \u2014 leaving it alone (re-run without --yes to refresh).`);
+    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 = readFileSync15(join20(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
+    const content = renderBrandFile(defaultCssRaw, projectSlug, opts.version, proposal);
+    mkdirSync6(dirname7(brandAbsPath), { recursive: true });
+    writeFileSync6(brandAbsPath, content, "utf8");
+    files[brandRelPath] = checksum(content);
+  }
+  if (configAction === "written") {
+    const config = { brand: brandRelPath, surfaces };
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    writeFileSync6(configAbsPath, content, "utf8");
+    files[configRelPath] = checksum(content);
+  } else if (configAction === "merged") {
+    let existing = {};
+    try {
+      existing = JSON.parse(readFileSync15(configAbsPath, "utf8"));
+    } catch {
+      existing = {};
+    }
+    const existingBrand = typeof existing.brand === "string" ? existing.brand : void 0;
+    const brandStillResolves = existingBrand ? existsSync10(join20(opts.projectRoot, ...existingBrand.split("/"))) : false;
+    const merged = {
+      brand: brandStillResolves ? existingBrand : brandRelPath,
+      surfaces: Array.isArray(existing.surfaces) && existing.surfaces.length > 0 ? existing.surfaces : surfaces
+    };
+    const content = `${JSON.stringify(merged, null, 2)}
+`;
+    writeFileSync6(configAbsPath, content, "utf8");
+    files[configRelPath] = checksum(content);
+  }
+  const effectiveConfig = loadEffectiveConfig(opts.projectRoot, configAbsPath, brandRelPath, surfaces);
+  const primaryMode = effectiveConfig.surfaces[0]?.mode ?? "product";
+  const wiringBrandAbsPath = join20(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 = join20(opts.projectRoot, ".jig", "tokens", modeFileName);
+    modeAbsPaths[mode] = modeAbsPath2;
+    const modeRelPath = relKey(".jig", "tokens", modeFileName);
+    const modeState = fileState(opts.projectRoot, modeAbsPath2, modeRelPath, initManifest);
+    let modeAction = "written";
+    if (modeState.existsOnDisk && !modeState.tracked) modeAction = "skipped-untracked";
+    else if (modeState.modified) modeAction = "skipped-edited";
+    if (modeAction === "written") {
+      const modeSourceRaw = readFileSync15(join20(opts.packageRoot, "tokens", modeFileName), "utf8");
+      const content = vendorHeader(modeFileName, opts.version, "css", null) + modeSourceRaw;
+      mkdirSync6(dirname7(modeAbsPath2), { recursive: true });
+      writeFileSync6(modeAbsPath2, content, "utf8");
+      files[modeRelPath] = checksum(content);
+    } else {
+      log(`  ${modeRelPath} exists and is not jig-tracked (or has been edited) \u2014 leaving it alone (re-run 'jig update' to refresh it).`);
+    }
+  }
+  const modeAbsPath = modeAbsPaths[primaryMode];
+  writeInitManifest(opts.projectRoot, { version: opts.version, modes: declaredModes, files });
+  const wireTarget = findWireTarget(detection);
+  let wiring;
+  if (wireTarget) {
+    const targetAbsDir = dirname7(join20(opts.projectRoot, wireTarget));
+    const brandImport = relativeImportPath(targetAbsDir, wiringBrandAbsPath);
+    const modeImport = relativeImportPath(targetAbsDir, modeAbsPath);
+    const snippet = `@import "${brandImport}";
+@import "${modeImport}";`;
+    try {
+      const outcome = wireImport(join20(opts.projectRoot, wireTarget), brandImport, modeImport, primaryMode);
+      wiring = { target: wireTarget, status: outcome.status, snippet };
+      const verb = outcome.status === "wired" ? "Wired" : outcome.status === "rewired" ? "Rewired" : "Already present in";
+      log(`
+${verb} ${wireTarget}:`);
+      if (outcome.detail) log(`  ${outcome.detail}`);
+      log(`  ${snippet.split("\n").join("\n  ")}`);
+    } catch (err) {
+      wiring = { target: null, status: "print-only", snippet };
+      log(`
+Could not write to ${wireTarget}: ${err.message}`);
+      log("Add this near the top of your global stylesheet instead (adjust the path to wherever you paste it):");
+      log(`  ${snippet.split("\n").join("\n  ")}`);
+    }
+  } else {
+    const brandImport = relativeImportPath(opts.projectRoot, wiringBrandAbsPath);
+    const modeImport = relativeImportPath(opts.projectRoot, modeAbsPath);
+    const snippet = `@import "${brandImport}";
+@import "${modeImport}";`;
+    wiring = { target: null, status: "print-only", snippet };
+    log("\nCould not find a single unambiguous stylesheet to wire the import into.");
+    const pasteTargets = detection.cssFiles.filter((f) => !isCssModule(f));
+    if (pasteTargets.length > 0) {
+      log("Paste the block for whichever of these is your global stylesheet:");
+      for (const target of pasteTargets) {
+        const dir = dirname7(join20(opts.projectRoot, target));
+        const forTarget = `@import "${relativeImportPath(dir, wiringBrandAbsPath)}";
+@import "${relativeImportPath(dir, modeAbsPath)}";`;
+        log(`
+  ${target}:`);
+        log(`    ${forTarget.split("\n").join("\n    ")}`);
+      }
+    } else {
+      log(
+        "Add this near the top of your global stylesheet. A CSS @import resolves relative to the file it sits in, so these project-root paths need a ../ per directory of depth:"
+      );
+      log(`  ${snippet.split("\n").join("\n  ")}`);
+    }
+  }
+  if (isIgnored(opts.projectRoot, ".jig")) {
+    log(
+      "\n  WARNING: .jig/ is gitignored, but it holds this project's tokens \u2014 the files your stylesheet @imports. Committed, teammates and CI get the same design system; ignored, their builds break on a missing import. Remove the .jig/ rule from .gitignore, or commit the directory explicitly."
+    );
+  }
+  const baselineResult = check({ projectRoot: opts.projectRoot, homeDir: opts.homeDir, version: opts.version, all: true, ci: false });
+  log("\nBaseline:");
+  log(baselineResult.report);
+  return {
+    detection,
+    proposal,
+    validation,
+    finalColor,
+    // I2: report the surfaces that actually govern wiring (effectiveConfig),
+    // not the freshly-derived/prompted `surfaces` local — the two differ
+    // exactly when an existing config was kept, and this field should
+    // describe what happened, not what would have happened on a fresh write.
+    surfaces: effectiveConfig.surfaces,
+    brand: { relPath: brandRelPath, action: brandAction },
+    config: { relPath: configRelPath, action: configAction },
+    wiring,
+    baseline: { report: baselineResult.report, findingsCount: baselineResult.findings.length }
+  };
+}
+
+// src/index.ts
+var packageRoot = getPackageRoot();
+var { version } = JSON.parse(readFileSync16(join21(packageRoot, "package.json"), "utf8"));
+function warnIfUnpublishedPin() {
+  if (isPublishedBuild(packageRoot)) return;
+  console.warn(
+    `Note: this is a source build, so the skill pins 'npx jig-ui@${version}' \u2014 a version that may not be published. Agents reading it will not be able to run the CLI until it is. Re-run install or update from a published build to correct the pin.`
+  );
+}
+var program = new Command();
+program.name("jig").description("A design system for coding agents.").version(version);
+program.command("install").description("Install Jig rules and the agent skill file into a repository.").requiredOption("--agent <name>", `target agent (${adapterNames().join(", ")})`).option("--scope <scope>", "project or global", "project").action((opts) => {
+  if (opts.scope !== "project" && opts.scope !== "global") {
+    console.error(`Invalid scope '${opts.scope}'. Use 'project' or 'global'.`);
+    process.exit(1);
+  }
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = install({
+      agent: opts.agent,
+      scope: opts.scope,
+      projectRoot,
+      packageRoot: assetRoot(),
+      version,
+      homeDir: homedir()
+    });
+    if (result.warning) {
+      console.warn(result.warning);
+      return;
+    }
+    console.log(`Installed Jig v${version} for ${opts.agent} (${opts.scope} scope)`);
+    warnIfUnpublishedPin();
+    for (const f of result.written) console.log(`  + ${f}`);
+    for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.command("explain").description("Print a rule's full text, its correction, and the version it was introduced in.").argument("<rule-id>", "a rule id, e.g. 'C-19' or 'P-02'").action((ruleId) => {
+  try {
+    console.log(explain({ ruleId, version }));
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.command("update").description("Update vendored Jig rules, skipping files you have edited.").action(() => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = update({
       agent: "",
       scope: "project",
       projectRoot,
@@ -556,7 +3453,11 @@ program.command("update").description("Update vendored Jig rules, skipping files
       version,
       homeDir: homedir()
     });
-    console.log(`Updated Jig ${result.fromVersion} \u2192 ${result.toVersion}`);
+    const label = result.targets.map((t) => `${t.agent} (${t.scope}, ${t.fromVersion})`).join(", ");
+    warnIfUnpublishedPin();
+    console.log(
+      `Updated Jig \u2192 ${result.toVersion} in ${result.targets.length} harness${result.targets.length === 1 ? "" : "es"}: ${label}`
+    );
     for (const f of result.updated) console.log(`  ~ ${f}`);
     for (const f of result.skipped) console.log(`  \xB7 ${f} (edited locally, left alone)`);
   } catch (err) {
@@ -564,4 +3465,36 @@ program.command("update").description("Update vendored Jig rules, skipping files
     process.exit(1);
   }
 });
+program.command("check").description("Check the repo against Jig's mechanical + hybrid rules.").option("--all", "check the whole repo instead of just changed files", false).option("--ci", "mechanical bucket only; exits non-zero on any error, deterministic", false).option("--json", "emit findings as JSON", false).action((opts) => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    const result = check({
+      projectRoot,
+      homeDir: homedir(),
+      version,
+      all: opts.all,
+      ci: opts.ci
+    });
+    console.log(opts.json ? JSON.stringify(result.findings, null, 2) : result.report);
+    if (opts.ci && result.hasError) process.exit(1);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+program.command("init").description("Set the project up to use Jig: a brand file, jig.config.json, and a baseline check.").option("--yes", "non-interactive: derive everything, accept the proposal, ask nothing", false).action(async (opts) => {
+  const projectRoot = findProjectRoot(process.cwd());
+  try {
+    await init({
+      projectRoot,
+      packageRoot: assetRoot(),
+      homeDir: homedir(),
+      version,
+      yes: opts.yes
+    });
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
 program.parse();