jig-ui 0.2.0 → 0.3.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 readFileSync12 } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join14 } from "path";
 
 // src/paths.ts
 import { existsSync } from "fs";
@@ -427,20 +427,59 @@ function install(opts) {
 }
 
 // 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";
+import { basename, dirname as dirname5, join as join5 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
+
+// src/install/target.ts
+import { resolve } from "path";
+function resolveInstalled(projectRoot, homeDir) {
+  const projectManifest = readManifest(projectRoot);
+  const existing = projectManifest ?? readManifest(homeDir);
+  if (!existing) return null;
+  const sameRoot = resolve(projectRoot) === resolve(homeDir);
+  const scope = !projectManifest ? "global" : sameRoot ? existing.scope : "project";
+  const installRoot = scope === "global" ? homeDir : projectRoot;
+  return { installRoot, scope, manifest: existing };
+}
+
+// src/init/state.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+var INIT_MANIFEST_REL = join4(".jig", "init-manifest.json");
+function readInitManifest(projectRoot) {
+  const path = join4(projectRoot, INIT_MANIFEST_REL);
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync3(path, "utf8"));
+    if (typeof raw !== "object" || raw === null) return null;
+    const files = raw.files;
+    if (typeof files !== "object" || files === null) return null;
+    return { files };
+  } catch {
+    return null;
+  }
+}
+function writeInitManifest(projectRoot, m) {
+  const path = join4(projectRoot, INIT_MANIFEST_REL);
+  mkdirSync3(dirname4(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(m, null, 2)}
+`, "utf8");
+}
+function isInitFileModified(projectRoot, relPath, m) {
+  const asManifest = { version: "", agent: "", scope: "project", installedAt: "", files: m.files };
+  return isModified(projectRoot, relPath, asManifest);
+}
+
+// src/commands/update.ts
 var ALWAYS_REPLACE = [relKey(".jig", "LICENSE"), relKey(".jig", "NOTICE")];
 function update(opts) {
-  const projectManifest = readManifest(opts.projectRoot);
-  const existing = projectManifest ?? readManifest(opts.homeDir);
-  if (!existing) {
+  const resolved = resolveInstalled(opts.projectRoot, opts.homeDir);
+  if (!resolved) {
     throw new Error(
       `Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.`
     );
   }
-  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 { installRoot, scope: discoveredScope, manifest: existing } = resolved;
   const adapter = getAdapter(existing.agent);
   if (!adapter.supportsScope(discoveredScope)) {
     throw new Error(
@@ -451,35 +490,35 @@ function update(opts) {
   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");
+    const abs = join5(installRoot, ...key.split("/"));
+    mkdirSync4(dirname5(abs), { recursive: true });
+    writeFileSync4(abs, content, "utf8");
     files[key] = checksum(content);
     updated.push(key);
   };
-  const rulesDir = join4(opts.packageRoot, "rules");
+  const rulesDir = join5(opts.packageRoot, "rules");
   for (const file of readdirSync2(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
     const key = relKey(".jig", 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) + readFileSync4(join5(rulesDir, file), "utf8"));
   }
-  const tokensDir = join4(opts.packageRoot, "tokens");
+  const tokensDir = join5(opts.packageRoot, "tokens");
   for (const file of readdirSync2(tokensDir).filter((f) => f.endsWith(".css")).sort()) {
     const key = relKey(".jig", "tokens", file);
     if (isModified(installRoot, key, existing)) {
       skipped.push(key);
       continue;
     }
-    write(key, vendorHeader(file, opts.version, "css") + readFileSync3(join4(tokensDir, file), "utf8"));
+    write(key, vendorHeader(file, opts.version, "css") + readFileSync4(join5(tokensDir, file), "utf8"));
   }
   const indexKey = relKey(".jig", "rules.index.json");
   if (isModified(installRoot, indexKey, existing)) {
     skipped.push(indexKey);
   } else {
-    write(indexKey, readFileSync3(join4(opts.packageRoot, "rules.index.json"), "utf8"));
+    write(indexKey, readFileSync4(join5(opts.packageRoot, "rules.index.json"), "utf8"));
   }
   const skillBody = buildSkillBody(opts.packageRoot, discoveredScope);
   const skillFiles = skillFilesFor(adapter, {
@@ -492,8 +531,8 @@ function update(opts) {
     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 = join5(installRoot, ...key.split("/"));
+      const current = existsSync5(abs) ? readFileSync4(abs, "utf8") : "";
       write(key, upsertBlock(current, file.content));
       continue;
     }
@@ -504,7 +543,28 @@ function update(opts) {
     write(key, file.content);
   }
   for (const key of ALWAYS_REPLACE) {
-    write(key, readFileSync3(join4(opts.packageRoot, basename(key)), "utf8"));
+    write(key, readFileSync4(join5(opts.packageRoot, basename(key)), "utf8"));
+  }
+  const initManifest = readInitManifest(opts.projectRoot);
+  if (initManifest) {
+    const initFiles = { ...initManifest.files };
+    let initChanged = false;
+    for (const file of readdirSync2(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") + readFileSync4(join5(tokensDir, file), "utf8");
+      const abs = join5(opts.projectRoot, ...key.split("/"));
+      mkdirSync4(dirname5(abs), { recursive: true });
+      writeFileSync4(abs, content, "utf8");
+      initFiles[key] = checksum(content);
+      initChanged = true;
+      updated.push(key);
+    }
+    if (initChanged) writeInitManifest(opts.projectRoot, { files: initFiles });
   }
   const manifest = {
     ...existing,
@@ -517,9 +577,1689 @@ function update(opts) {
   return { updated, skipped, fromVersion: existing.version, toVersion: opts.version };
 }
 
+// src/commands/check.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join9 } from "path";
+
+// 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/check/files.ts
+import { execFileSync } from "child_process";
+import { readdirSync as readdirSync3 } from "fs";
+import { join as join6, 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 out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    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) {
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (EXCLUDE_DIRS.has(entry.name)) continue;
+    const abs = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(root, abs, out);
+    } else if (entry.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) {
+    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;
+  }
+}
+function wholeRepoFiles(root) {
+  const out = [];
+  walk(root, root, out);
+  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 .jig/00-anti-patterns.md#${f.ruleId.toLowerCase()})` : "";
+    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("  Import a brand and a mode file to bring your CSS under the token layer:");
+      lines.push('    @import ".jig/tokens/brand.default.css";');
+      lines.push('    @import ".jig/tokens/mode.product.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;
+  lines.push(`  ${summaryParts.join(", ")} \xB7 ${meta.totalRules} rules, ${rulesFired} fired`);
+  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} 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;
+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;
+  }
+  return false;
+}
+
+// src/check/run.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } 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 blank = (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) blank(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/ext.ts
+var CSS_EXTENSIONS = [".css", ".scss", ".less"];
+function hasExtension(file, exts) {
+  const lower = file.toLowerCase();
+  return exts.some((e) => lower.endsWith(e));
+}
+
+// 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) => hasExtension(file, CSS_EXTENSIONS),
+  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) => hasExtension(file, CSS_EXTENSIONS),
+  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) => hasExtension(file, CSS_EXTENSIONS),
+  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/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) => hasExtension(file, CSS_EXTENSIONS),
+  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)
+        )
+      );
+    }
+    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) => hasExtension(file, CSS_EXTENSIONS),
+  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) => hasExtension(file, CSS_EXTENSIONS),
+  run(source, file, ctx) {
+    if (!participatesInTokenLayer(source, ctx.tokens)) 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)
+              )
+            );
+          }
+        }
+      }
+    }
+    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) => hasExtension(file, CSS_EXTENSIONS),
+  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) {
+  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 = readFileSync5(join7(projectRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    const source = maskComments(raw);
+    for (const { entry, detector } of applicable) {
+      const ctx = { ruleId: entry.id, bucket: entry.bucket, severity: entry.severity, tokens };
+      findings.push(...detector.run(source, file, ctx));
+    }
+  }
+  return findings;
+}
+
+// src/check/tokens.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+function loadTokenMap(installRoot) {
+  const tokensDir = join8(installRoot, ".jig", "tokens");
+  const tokens = {};
+  if (!existsSync6(tokensDir)) return tokens;
+  const files = readdirSync4(tokensDir).filter((f) => f.endsWith(".css")).sort();
+  for (const file of files) {
+    const source = readFileSync6(join8(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
+function check(opts) {
+  const target = resolveInstalled(opts.projectRoot, opts.homeDir);
+  if (!target) {
+    throw new Error(`Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.`);
+  }
+  const indexPath = join9(target.installRoot, ".jig", "rules.index.json");
+  const index = validateIndex(JSON.parse(readFileSync7(indexPath, "utf8")));
+  const tokens = loadTokenMap(target.installRoot);
+  const { files } = selectFiles(opts.projectRoot, opts.all);
+  const bucketFilter = opts.ci ? (b) => b === "mechanical" : void 0;
+  const findings = runChecks(opts.projectRoot, files, index, tokens, bucketFilter);
+  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(readFileSync7(join9(opts.projectRoot, f), "utf8"), tokens);
+      } catch {
+        return true;
+      }
+    })
+  );
+  const report = formatReport(findings, {
+    totalRules: index.length,
+    version: opts.version,
+    noTokenLayer
+  });
+  return { findings, report, hasError };
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
+
+// src/init/detect.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join10 } 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(readFileSync8(join10(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 = readFileSync8(join10(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/derive.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join11 } 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 = readFileSync9(join11(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 = readFileSync9(join11(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 = readFileSync9(join11(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) };
+}
+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 { vsRaised, vsFill, worst } = worstRatio(h, s, l);
+  const passesContrast = worst >= CONTRAST_FLOOR;
+  return {
+    ratioVsRaised: vsRaised,
+    ratioVsFill: vsFill,
+    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");
+  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 readFileSync10 } from "fs";
+import { basename as basename2, join as join12 } 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(readFileSync10(join12(projectRoot, "package.json"), "utf8"));
+    if (typeof pkg.name === "string" && pkg.name.trim()) return slugify(pkg.name);
+  } catch {
+  }
+  return slugify(basename2(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 = [];
+  if (v.passesContrast) {
+    lines.push(
+      `  contrast OK \u2014 ${v.ratioVsRaised.toFixed(2)}:1 vs --color-bg-raised, ${v.ratioVsFill.toFixed(2)}:1 vs --color-fill (floor 4.5:1)`
+    );
+  } else {
+    lines.push(
+      `  contrast FAILS \u2014 worst is ${v.worstRatio.toFixed(2)}:1 against the 4.5:1 floor (${v.ratioVsRaised.toFixed(2)}:1 vs --color-bg-raised, ${v.ratioVsFill.toFixed(2)}:1 vs --color-fill)`
+    );
+    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 = existsSync7(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 (!existsSync7(configAbsPath)) return { brand: fallbackBrand, surfaces: fallbackSurfaces };
+  try {
+    const parsed = JSON.parse(readFileSync11(configAbsPath, "utf8"));
+    const brandCandidate = typeof parsed.brand === "string" && parsed.brand ? parsed.brand : void 0;
+    const brandResolves = brandCandidate ? existsSync7(join13(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 = existsSync7(absPath) ? readFileSync11(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);
+      writeFileSync5(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);
+    writeFileSync5(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);
+  }
+  mkdirSync5(dirname6(absPath), { recursive: true });
+  writeFileSync5(absPath, next, "utf8");
+  return { status: "wired" };
+}
+async function init(opts) {
+  const log = opts.log ?? ((line) => console.log(line));
+  const prompt = opts.prompt ?? defaultPrompt;
+  const resolved = resolveInstalled(opts.projectRoot, opts.homeDir);
+  if (!resolved) {
+    throw new Error(`Jig is not installed in ${opts.projectRoot}. Run 'jig install --agent <name>' first.`);
+  }
+  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 (!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 = join13(opts.projectRoot, ".jig", "tokens", brandFileName(projectSlug));
+  const configRelPath = "jig.config.json";
+  const configAbsPath = join13(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 = readFileSync11(join13(opts.packageRoot, "tokens", "brand.default.css"), "utf8");
+    const content = renderBrandFile(defaultCssRaw, projectSlug, opts.version, proposal);
+    mkdirSync5(dirname6(brandAbsPath), { recursive: true });
+    writeFileSync5(brandAbsPath, content, "utf8");
+    files[brandRelPath] = checksum(content);
+  }
+  if (configAction === "written") {
+    const config = { brand: brandRelPath, surfaces };
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    writeFileSync5(configAbsPath, content, "utf8");
+    files[configRelPath] = checksum(content);
+  } else if (configAction === "merged") {
+    let existing = {};
+    try {
+      existing = JSON.parse(readFileSync11(configAbsPath, "utf8"));
+    } catch {
+      existing = {};
+    }
+    const existingBrand = typeof existing.brand === "string" ? existing.brand : void 0;
+    const brandStillResolves = existingBrand ? existsSync7(join13(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)}
+`;
+    writeFileSync5(configAbsPath, content, "utf8");
+    files[configRelPath] = checksum(content);
+  }
+  const effectiveConfig = loadEffectiveConfig(opts.projectRoot, configAbsPath, brandRelPath, surfaces);
+  const primaryMode = effectiveConfig.surfaces[0]?.mode ?? "product";
+  const wiringBrandAbsPath = join13(opts.projectRoot, ...effectiveConfig.brand.split("/"));
+  const modeFileName = `mode.${primaryMode}.css`;
+  const modeAbsPath = join13(opts.projectRoot, ".jig", "tokens", modeFileName);
+  if (resolved.scope === "global") {
+    const modeRelPath = relKey(".jig", "tokens", modeFileName);
+    const modeState = fileState(opts.projectRoot, modeAbsPath, 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 = readFileSync11(join13(opts.packageRoot, "tokens", modeFileName), "utf8");
+      const content = vendorHeader(modeFileName, opts.version, "css") + modeSourceRaw;
+      mkdirSync5(dirname6(modeAbsPath), { recursive: true });
+      writeFileSync5(modeAbsPath, 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).`);
+    }
+  }
+  writeInitManifest(opts.projectRoot, { files });
+  const wireTarget = findWireTarget(detection);
+  let wiring;
+  if (wireTarget) {
+    const targetAbsDir = dirname6(join13(opts.projectRoot, wireTarget));
+    const brandImport = relativeImportPath(targetAbsDir, wiringBrandAbsPath);
+    const modeImport = relativeImportPath(targetAbsDir, modeAbsPath);
+    const snippet = `@import "${brandImport}";
+@import "${modeImport}";`;
+    try {
+      const outcome = wireImport(join13(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(
+      `
+Could not find a single unambiguous stylesheet to wire the import into. Add this near the top of your global stylesheet (paths shown relative to the project root \u2014 adjust to wherever you paste them):`
+    );
+    log(`  ${snippet.split("\n").join("\n  ")}`);
+  }
+  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(readFileSync4(join5(packageRoot, "package.json"), "utf8"));
+var { version } = JSON.parse(readFileSync12(join14(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) => {
@@ -564,4 +2304,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();