instrlint 0.1.0

package/dist/cli.js

@@ -0,0 +1,2916 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/run-command.ts
+import { execSync } from "child_process";
+import { basename as basename2 } from "path";
+import chalk4 from "chalk";
+
+// src/core/scanner.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function detectAll(projectRoot) {
+  const detections = [];
+  const claudeDir = join(projectRoot, ".claude");
+  if (existsSync(claudeDir)) {
+    const rootInDir = join(claudeDir, "CLAUDE.md");
+    const rootAtRoot = join(projectRoot, "CLAUDE.md");
+    detections.push({
+      tool: "claude-code",
+      rootFilePath: existsSync(rootInDir) ? rootInDir : existsSync(rootAtRoot) ? rootAtRoot : null,
+      configDir: claudeDir
+    });
+  }
+  const agentsDir = join(projectRoot, ".agents");
+  if (existsSync(agentsDir)) {
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    detections.push({
+      tool: "codex",
+      rootFilePath: existsSync(agentsMd) ? agentsMd : null,
+      configDir: agentsDir
+    });
+  }
+  const codexDir = join(projectRoot, ".codex");
+  if (existsSync(codexDir) && !detections.some((d) => d.tool === "codex")) {
+    const agentsMd = join(projectRoot, "AGENTS.md");
+    detections.push({
+      tool: "codex",
+      rootFilePath: existsSync(agentsMd) ? agentsMd : null,
+      configDir: codexDir
+    });
+  }
+  const cursorDir = join(projectRoot, ".cursor");
+  const cursorRules = join(projectRoot, ".cursorrules");
+  if (existsSync(cursorDir) || existsSync(cursorRules)) {
+    detections.push({
+      tool: "cursor",
+      rootFilePath: existsSync(cursorRules) ? cursorRules : null,
+      configDir: existsSync(cursorDir) ? cursorDir : null
+    });
+  }
+  return detections;
+}
+function detectByRootFile(projectRoot) {
+  const claudeMd = join(projectRoot, "CLAUDE.md");
+  if (existsSync(claudeMd)) {
+    return { tool: "claude-code", rootFilePath: claudeMd, configDir: null };
+  }
+  const agentsMd = join(projectRoot, "AGENTS.md");
+  if (existsSync(agentsMd)) {
+    return { tool: "codex", rootFilePath: agentsMd, configDir: null };
+  }
+  return null;
+}
+function scanProject(projectRoot, forceTool) {
+  if (!existsSync(projectRoot)) {
+    throw new Error(`Project root does not exist: ${projectRoot}`);
+  }
+  if (forceTool != null) {
+    const valid = ["claude-code", "codex", "cursor"];
+    if (!valid.includes(forceTool)) {
+      throw new Error(
+        `Invalid tool: "${forceTool}". Must be one of: ${valid.join(", ")}`
+      );
+    }
+    const tool = forceTool;
+    const detections2 = detectAll(projectRoot);
+    const match = detections2.find((d) => d.tool === tool);
+    return {
+      tool,
+      rootFilePath: match?.rootFilePath ?? null,
+      configDir: match?.configDir ?? null,
+      confidence: "high"
+    };
+  }
+  const detections = detectAll(projectRoot);
+  if (detections.length === 0) {
+    const byFile = detectByRootFile(projectRoot);
+    if (byFile != null) {
+      return { ...byFile, confidence: "low" };
+    }
+    return { tool: "unknown", rootFilePath: null, configDir: null, confidence: "low" };
+  }
+  if (detections.length === 1) {
+    const d = detections[0];
+    return { tool: d.tool, rootFilePath: d.rootFilePath, configDir: d.configDir, confidence: "high" };
+  }
+  const first = detections[0];
+  return {
+    tool: first.tool,
+    rootFilePath: first.rootFilePath,
+    configDir: first.configDir,
+    confidence: "ambiguous"
+  };
+}
+
+// src/adapters/claude-code.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { basename, dirname, join as join2, relative } from "path";
+
+// src/core/parser.ts
+import { readFileSync } from "fs";
+var KNOWN_KEYWORDS = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "eslint",
+  "prettier",
+  "biome",
+  "react",
+  "vue",
+  "svelte",
+  "angular",
+  "next",
+  "nextjs",
+  "nuxt",
+  "jest",
+  "vitest",
+  "mocha",
+  "jasmine",
+  "playwright",
+  "cypress",
+  "postgresql",
+  "postgres",
+  "mysql",
+  "sqlite",
+  "mongodb",
+  "redis",
+  "docker",
+  "kubernetes",
+  "k8s",
+  "terraform",
+  "git",
+  "github",
+  "gitlab",
+  "npm",
+  "pnpm",
+  "yarn",
+  "bun",
+  "node",
+  "nodejs",
+  "deno",
+  "webpack",
+  "vite",
+  "esbuild",
+  "tsup",
+  "rollup",
+  "zod",
+  "prisma",
+  "drizzle",
+  "openai",
+  "anthropic",
+  "claude",
+  "commitlint",
+  "husky",
+  "lint-staged"
+]);
+var KEYWORD_REGEX = new RegExp(
+  `\\b(${[...KNOWN_KEYWORDS].join("|")})\\b`,
+  "gi"
+);
+var PATH_REGEX = /(?<!\w)(?:\.{1,2}\/|(?:src|tests?|dist|lib|docs?|config|scripts?|packages?)\/)[^\s,;`'")\]>]+/g;
+var RULE_IMPERATIVE_WORDS = /\b(must|should|never|always|prefer|avoid|ensure|require|forbid|use|do not|don't)\b/i;
+var RULE_NEGATION_PATTERN = /\b(not|don't|do not)\s+\w+/i;
+var STRONG_IMPERATIVE = /\b(must|shall|always|never)\b/i;
+function parseYamlFrontmatter(content) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/m.exec(content);
+  if (match == null) {
+    return { body: content };
+  }
+  const yaml = match[1] ?? "";
+  const body = match[2] ?? "";
+  const paths = extractYamlStringArray(yaml, "paths");
+  const globs = extractYamlStringArray(yaml, "globs");
+  return {
+    ...paths != null ? { paths } : {},
+    ...globs != null ? { globs } : {},
+    body
+  };
+}
+function extractYamlStringArray(yaml, key) {
+  const blockMatch = new RegExp(
+    `^${key}:\\s*\\n((?:\\s+-\\s+.+\\n?)*)`,
+    "m"
+  ).exec(yaml);
+  if (blockMatch != null) {
+    return (blockMatch[1] ?? "").split("\n").map(
+      (l) => l.replace(/^\s+-\s+/, "").replace(/["']/g, "").trim()
+    ).filter((l) => l.length > 0);
+  }
+  const inlineMatch = new RegExp(`^${key}:\\s*\\[(.+)\\]`, "m").exec(yaml);
+  if (inlineMatch != null) {
+    return (inlineMatch[1] ?? "").split(",").map((s) => s.replace(/["']/g, "").trim()).filter((s) => s.length > 0);
+  }
+  return void 0;
+}
+function classifyLine(text, inCodeBlock, inHtmlComment) {
+  if (inCodeBlock) return "code";
+  if (inHtmlComment) return "comment";
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return "blank";
+  if (/^#{1,6}\s/.test(trimmed)) return "heading";
+  if (trimmed.startsWith("```")) return "code";
+  if (/^<!--[\s\S]*-->$/.test(trimmed)) return "comment";
+  if (trimmed.startsWith("<!--")) return "comment";
+  if (isRule(trimmed)) return "rule";
+  return "other";
+}
+function isRule(text) {
+  const isList = text.startsWith("- ");
+  const body = isList ? text.slice(2) : text;
+  if (isList) {
+    if (RULE_IMPERATIVE_WORDS.test(body)) return true;
+    if (RULE_NEGATION_PATTERN.test(body)) return true;
+  } else {
+    if (STRONG_IMPERATIVE.test(body) && /^[A-Z]/.test(body)) return true;
+    if (RULE_IMPERATIVE_WORDS.test(body) && /^[A-Z][a-z]/.test(body))
+      return true;
+  }
+  return false;
+}
+function extractKeywords(text) {
+  const matches = text.matchAll(KEYWORD_REGEX);
+  const found = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    found.add(m[0].toLowerCase());
+  }
+  return [...found];
+}
+function extractPaths(text) {
+  const matches = text.matchAll(PATH_REGEX);
+  const found = [];
+  for (const m of matches) {
+    const cleaned = m[0].replace(/[.,;)>\]'"]+$/, "");
+    if (cleaned.length > 1) found.push(cleaned);
+  }
+  return [...new Set(found)];
+}
+function parseInstructionFile(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const rawLines = raw.split(/\r?\n/);
+  if (rawLines.length > 0 && rawLines[rawLines.length - 1] === "") {
+    rawLines.pop();
+  }
+  let inCodeBlock = false;
+  let inHtmlComment = false;
+  const lines = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    const text = rawLines[i] ?? "";
+    const trimmed = text.trim();
+    const type = classifyLine(text, inCodeBlock, inHtmlComment);
+    if (!inHtmlComment && trimmed.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+    }
+    if (!inCodeBlock) {
+      if (inHtmlComment) {
+        if (trimmed.includes("-->")) inHtmlComment = false;
+      } else if (trimmed.startsWith("<!--") && !trimmed.includes("-->")) {
+        inHtmlComment = true;
+      }
+    }
+    lines.push({
+      lineNumber: i + 1,
+      text,
+      type,
+      keywords: extractKeywords(text),
+      referencedPaths: extractPaths(text)
+    });
+  }
+  return {
+    path: filePath,
+    lines,
+    lineCount: lines.length,
+    // tokenCount and tokenMethod will be filled by the adapter/estimator
+    tokenCount: 0,
+    tokenMethod: "estimated"
+  };
+}
+
+// src/detectors/token-estimator.ts
+var encoder = null;
+var initPromise = (async () => {
+  try {
+    const { getEncoding } = await import("js-tiktoken");
+    encoder = getEncoding("cl100k_base");
+  } catch {
+    process.stderr.write(
+      "[instrlint] Warning: js-tiktoken failed to load \u2014 falling back to character estimation\n"
+    );
+    encoder = null;
+  }
+})();
+async function ensureInitialized() {
+  await initPromise;
+}
+var CJK_REGEX = /[\u3000-\u9fff\uac00-\ud7af\uf900-\ufaff]/g;
+function cjkRatio(text) {
+  if (text.length === 0) return 0;
+  const matches = text.match(CJK_REGEX);
+  return (matches?.length ?? 0) / text.length;
+}
+function countTokens(text) {
+  if (text.length === 0) return { count: 0, method: "measured" };
+  if (encoder != null) {
+    try {
+      return { count: encoder.encode(text).length, method: "measured" };
+    } catch {
+    }
+  }
+  return estimateFallback(text);
+}
+function estimateFallback(text) {
+  const ratio = cjkRatio(text);
+  const charsPerToken = 4 * (1 - ratio) + 2 * ratio;
+  return {
+    count: Math.ceil(text.length / charsPerToken),
+    method: "estimated"
+  };
+}
+function estimateMcpTokens(config) {
+  if (config.toolCount != null) {
+    return { count: config.toolCount * 400, method: "estimated" };
+  }
+  return { count: 2500, method: "estimated" };
+}
+
+// src/adapters/claude-code.ts
+function withTokens(file) {
+  const raw = (() => {
+    try {
+      return readFileSync2(file.path, "utf8");
+    } catch {
+      return "";
+    }
+  })();
+  const { count, method } = countTokens(raw);
+  return { ...file, tokenCount: count, tokenMethod: method };
+}
+function safeParseFile(filePath) {
+  try {
+    const file = parseInstructionFile(filePath);
+    return withTokens(file);
+  } catch {
+    process.stderr.write(
+      `[instrlint] Warning: could not read ${filePath}, skipping
+`
+    );
+    return null;
+  }
+}
+function findRootFile(projectRoot) {
+  const candidates = [
+    join2(projectRoot, "CLAUDE.md"),
+    join2(projectRoot, ".claude", "CLAUDE.md")
+  ];
+  return candidates.find(existsSync2) ?? null;
+}
+function loadRules(projectRoot) {
+  const rulesDir = join2(projectRoot, ".claude", "rules");
+  if (!existsSync2(rulesDir)) return [];
+  const rules = [];
+  let entries = [];
+  try {
+    entries = readdirSync(rulesDir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  for (const filename of entries) {
+    const filePath = join2(rulesDir, filename);
+    try {
+      const raw = readFileSync2(filePath, "utf8");
+      const { paths, globs, body } = parseYamlFrontmatter(raw);
+      const baseFile = parseInstructionFile(filePath);
+      const { count, method } = countTokens(body);
+      rules.push({
+        ...baseFile,
+        tokenCount: count,
+        tokenMethod: method,
+        ...paths != null ? { paths } : {},
+        ...globs != null ? { globs } : {}
+      });
+    } catch {
+      process.stderr.write(
+        `[instrlint] Warning: could not parse rule ${filePath}, skipping
+`
+      );
+    }
+  }
+  return rules;
+}
+function loadSkills(projectRoot) {
+  const skillsDir = join2(projectRoot, ".claude", "skills");
+  if (!existsSync2(skillsDir)) return [];
+  const skills = [];
+  let entries = [];
+  try {
+    entries = readdirSync(skillsDir);
+  } catch {
+    return [];
+  }
+  for (const skillName of entries) {
+    const skillFile = join2(skillsDir, skillName, "SKILL.md");
+    if (!existsSync2(skillFile)) continue;
+    const parsed = safeParseFile(skillFile);
+    if (parsed != null) {
+      skills.push({ ...parsed, skillName });
+    }
+  }
+  return skills;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".claude",
+  ".turbo",
+  "coverage"
+]);
+function findSubClaudeFiles(dir, projectRoot, depth = 0) {
+  if (depth > 10) return [];
+  const results = [];
+  let entries = [];
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = join2(dir, entry);
+    try {
+      const stat = statSync(full);
+      if (stat.isDirectory()) {
+        results.push(...findSubClaudeFiles(full, projectRoot, depth + 1));
+      } else if (entry === "CLAUDE.md") {
+        if (relative(projectRoot, full) === "CLAUDE.md") continue;
+        const parsed = safeParseFile(full);
+        if (parsed != null) results.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function parseMcpServers(projectRoot) {
+  const candidates = [
+    join2(projectRoot, ".claude", "settings.json"),
+    join2(projectRoot, ".claude", "settings.local.json")
+  ];
+  const servers = [];
+  for (const settingsPath of candidates) {
+    if (!existsSync2(settingsPath)) continue;
+    try {
+      const raw = readFileSync2(settingsPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed == null || typeof parsed !== "object" || !("mcpServers" in parsed)) {
+        continue;
+      }
+      const mcpServers = parsed.mcpServers;
+      for (const [name, entry] of Object.entries(mcpServers)) {
+        const toolCount = Array.isArray(entry.tools) ? entry.tools.length : void 0;
+        const config = {
+          name,
+          estimatedTokens: 0,
+          ...toolCount !== void 0 ? { toolCount } : {}
+        };
+        const { count } = estimateMcpTokens(config);
+        servers.push({ ...config, estimatedTokens: count });
+      }
+    } catch {
+      process.stderr.write(
+        `[instrlint] Warning: could not parse MCP config in ${settingsPath}, skipping
+`
+      );
+    }
+  }
+  return servers;
+}
+function loadClaudeCodeProject(projectRoot) {
+  const rootFilePath = findRootFile(projectRoot);
+  const rootFile = rootFilePath != null ? safeParseFile(rootFilePath) ?? emptyFile(rootFilePath) : emptyFile(join2(projectRoot, "CLAUDE.md"));
+  const rules = loadRules(projectRoot);
+  const skills = loadSkills(projectRoot);
+  const subFiles = findSubClaudeFiles(projectRoot, projectRoot);
+  const mcpServers = parseMcpServers(projectRoot);
+  return {
+    tool: "claude-code",
+    rootFile,
+    rules,
+    skills,
+    subFiles,
+    mcpServers
+  };
+}
+function emptyFile(path) {
+  return {
+    path,
+    lines: [],
+    lineCount: 0,
+    tokenCount: 0,
+    tokenMethod: "estimated"
+  };
+}
+
+// src/adapters/codex.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+function safeParseFile2(filePath) {
+  try {
+    const raw = readFileSync3(filePath, "utf8");
+    const file = parseInstructionFile(filePath);
+    const { count, method } = countTokens(raw);
+    return { ...file, tokenCount: count, tokenMethod: method };
+  } catch {
+    process.stderr.write(
+      `[instrlint] Warning: could not read ${filePath}, skipping
+`
+    );
+    return null;
+  }
+}
+function emptyFile2(path) {
+  return {
+    path,
+    lines: [],
+    lineCount: 0,
+    tokenCount: 0,
+    tokenMethod: "estimated"
+  };
+}
+function loadSkills2(projectRoot) {
+  const skillsDir = join3(projectRoot, ".agents", "skills");
+  if (!existsSync3(skillsDir)) return [];
+  const skills = [];
+  let entries = [];
+  try {
+    entries = readdirSync2(skillsDir);
+  } catch {
+    return [];
+  }
+  for (const skillName of entries) {
+    const skillFile = join3(skillsDir, skillName, "SKILL.md");
+    if (!existsSync3(skillFile)) continue;
+    const parsed = safeParseFile2(skillFile);
+    if (parsed != null) {
+      skills.push({ ...parsed, skillName });
+    }
+  }
+  return skills;
+}
+function parseMcpFromToml(toml) {
+  const servers = [];
+  const sectionRe = /^\[mcp_servers\.([^\]]+)\]/;
+  const keyValueRe = /^(\w+)\s*=\s*(.+)$/;
+  let currentName = null;
+  let currentTools;
+  const flush = () => {
+    if (currentName != null) {
+      const config = {
+        name: currentName,
+        estimatedTokens: 0,
+        ...currentTools !== void 0 ? { toolCount: currentTools.length } : {}
+      };
+      const { count } = estimateMcpTokens(config);
+      servers.push({ ...config, estimatedTokens: count });
+    }
+    currentName = null;
+    currentTools = void 0;
+  };
+  for (const line of toml.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") continue;
+    const sectionMatch = sectionRe.exec(trimmed);
+    if (sectionMatch != null) {
+      flush();
+      currentName = sectionMatch[1];
+      continue;
+    }
+    if (currentName == null) continue;
+    const kvMatch = keyValueRe.exec(trimmed);
+    if (kvMatch == null) continue;
+    const key = kvMatch[1];
+    const raw = kvMatch[2].trim();
+    if (key === "tools") {
+      const items = raw.match(/"([^"]+)"/g);
+      currentTools = items != null ? items.map((s) => s.slice(1, -1)) : [];
+    }
+  }
+  flush();
+  return servers;
+}
+function loadMcpServers(projectRoot) {
+  const tomlPath = join3(projectRoot, ".codex", "config.toml");
+  if (!existsSync3(tomlPath)) return [];
+  try {
+    const raw = readFileSync3(tomlPath, "utf8");
+    return parseMcpFromToml(raw);
+  } catch {
+    process.stderr.write(
+      `[instrlint] Warning: could not parse MCP config in ${tomlPath}, skipping
+`
+    );
+    return [];
+  }
+}
+function loadCodexProject(projectRoot) {
+  const rootFilePath = join3(projectRoot, "AGENTS.md");
+  const rootFile = existsSync3(rootFilePath) ? safeParseFile2(rootFilePath) ?? emptyFile2(rootFilePath) : emptyFile2(rootFilePath);
+  const skills = loadSkills2(projectRoot);
+  const mcpServers = loadMcpServers(projectRoot);
+  return {
+    tool: "codex",
+    rootFile,
+    rules: [],
+    skills,
+    subFiles: [],
+    mcpServers
+  };
+}
+
+// src/adapters/cursor.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+function safeParseFile3(filePath) {
+  try {
+    const raw = readFileSync4(filePath, "utf8");
+    const file = parseInstructionFile(filePath);
+    const { count, method } = countTokens(raw);
+    return { ...file, tokenCount: count, tokenMethod: method };
+  } catch {
+    process.stderr.write(
+      `[instrlint] Warning: could not read ${filePath}, skipping
+`
+    );
+    return null;
+  }
+}
+function emptyFile3(path) {
+  return {
+    path,
+    lines: [],
+    lineCount: 0,
+    tokenCount: 0,
+    tokenMethod: "estimated"
+  };
+}
+function findRootFile2(projectRoot) {
+  const cursorRules = join4(projectRoot, ".cursorrules");
+  if (existsSync4(cursorRules)) return cursorRules;
+  return null;
+}
+function loadRules2(projectRoot) {
+  const rulesDir = join4(projectRoot, ".cursor", "rules");
+  if (!existsSync4(rulesDir)) return [];
+  const rules = [];
+  let entries = [];
+  try {
+    entries = readdirSync3(rulesDir).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  for (const filename of entries) {
+    const filePath = join4(rulesDir, filename);
+    try {
+      const raw = readFileSync4(filePath, "utf8");
+      const { globs, body } = parseYamlFrontmatter(raw);
+      const baseFile = parseInstructionFile(filePath);
+      const { count, method } = countTokens(body);
+      rules.push({
+        ...baseFile,
+        tokenCount: count,
+        tokenMethod: method,
+        ...globs != null ? { globs } : {}
+      });
+    } catch {
+      process.stderr.write(
+        `[instrlint] Warning: could not parse rule ${filePath}, skipping
+`
+      );
+    }
+  }
+  return rules;
+}
+function loadMcpServers2(projectRoot) {
+  const mcpPath = join4(projectRoot, ".cursor", "mcp.json");
+  if (!existsSync4(mcpPath)) return [];
+  try {
+    const raw = readFileSync4(mcpPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed == null || typeof parsed !== "object" || !("mcpServers" in parsed)) {
+      return [];
+    }
+    const mcpServers = parsed.mcpServers;
+    return Object.entries(mcpServers).map(([name, entry]) => {
+      const toolCount = Array.isArray(entry.tools) ? entry.tools.length : void 0;
+      const config = {
+        name,
+        estimatedTokens: 0,
+        ...toolCount !== void 0 ? { toolCount } : {}
+      };
+      const { count } = estimateMcpTokens(config);
+      return { ...config, estimatedTokens: count };
+    });
+  } catch {
+    process.stderr.write(
+      `[instrlint] Warning: could not parse MCP config in ${mcpPath}, skipping
+`
+    );
+    return [];
+  }
+}
+function loadCursorProject(projectRoot) {
+  const rootFilePath = findRootFile2(projectRoot);
+  const rootFile = rootFilePath != null ? safeParseFile3(rootFilePath) ?? emptyFile3(rootFilePath) : emptyFile3(join4(projectRoot, ".cursorrules"));
+  const rules = loadRules2(projectRoot);
+  const mcpServers = loadMcpServers2(projectRoot);
+  return {
+    tool: "cursor",
+    rootFile,
+    rules,
+    skills: [],
+    subFiles: [],
+    mcpServers
+  };
+}
+
+// src/adapters/dispatch.ts
+function loadProject(projectRoot, tool) {
+  switch (tool) {
+    case "claude-code":
+      return loadClaudeCodeProject(projectRoot);
+    case "codex":
+      return loadCodexProject(projectRoot);
+    case "cursor":
+      return loadCursorProject(projectRoot);
+    default:
+      return loadClaudeCodeProject(projectRoot);
+  }
+}
+
+// src/analyzers/budget.ts
+var CONTEXT_WINDOW = 2e5;
+var SYSTEM_PROMPT_TOKENS = 12e3;
+var WARN_LINE_THRESHOLD = 200;
+var CRITICAL_LINE_THRESHOLD = 400;
+var WARN_BASELINE_PCT = 0.25;
+var MCP_INFO_THRESHOLD = 1e4;
+function sumTokens(items) {
+  if (items.length === 0) return { tokens: 0, method: "measured" };
+  const tokens = items.reduce((acc, f) => acc + f.tokenCount, 0);
+  const method = items.every((f) => f.tokenMethod === "measured") ? "measured" : "estimated";
+  return { tokens, method };
+}
+function analyzeBudget(instructions) {
+  const findings = [];
+  const rootFileTokens = instructions.rootFile.tokenCount;
+  const rootFileMethod = instructions.rootFile.tokenMethod;
+  const rootLines = instructions.rootFile.lineCount;
+  if (rootLines > CRITICAL_LINE_THRESHOLD) {
+    findings.push({
+      severity: "critical",
+      category: "budget",
+      file: instructions.rootFile.path,
+      messageKey: "budget.rootFileCritical",
+      messageParams: { lines: String(rootLines) },
+      suggestion: `Root instruction file is ${rootLines} lines \u2014 agent compliance drops significantly above 200 lines`,
+      autoFixable: false
+    });
+  } else if (rootLines > WARN_LINE_THRESHOLD) {
+    findings.push({
+      severity: "warning",
+      category: "budget",
+      file: instructions.rootFile.path,
+      messageKey: "budget.rootFileWarning",
+      messageParams: { lines: String(rootLines) },
+      suggestion: `Root instruction file is ${rootLines} lines (recommended: < 200)`,
+      autoFixable: false
+    });
+  }
+  const { tokens: rulesTokens, method: rulesMethod } = sumTokens(instructions.rules);
+  const { tokens: skillsTokens, method: skillsMethod } = sumTokens(instructions.skills);
+  const { tokens: subFilesTokens, method: subFilesMethod } = sumTokens(
+    instructions.subFiles
+  );
+  const mcpTokens = instructions.mcpServers.reduce(
+    (acc, s) => acc + s.estimatedTokens,
+    0
+  );
+  for (const server of instructions.mcpServers) {
+    if (server.estimatedTokens > MCP_INFO_THRESHOLD) {
+      findings.push({
+        severity: "info",
+        category: "budget",
+        file: ".claude/settings.json",
+        messageKey: "budget.mcpLargeServer",
+        messageParams: {
+          name: server.name,
+          tokens: server.estimatedTokens.toLocaleString("en")
+        },
+        suggestion: `MCP server '${server.name}' consumes ~${server.estimatedTokens.toLocaleString("en")} tokens`,
+        autoFixable: false
+      });
+    }
+  }
+  const totalBaseline = SYSTEM_PROMPT_TOKENS + rootFileTokens + rulesTokens + skillsTokens + subFilesTokens + mcpTokens;
+  const availableTokens = CONTEXT_WINDOW - totalBaseline;
+  const pct2 = totalBaseline / CONTEXT_WINDOW;
+  if (pct2 > WARN_BASELINE_PCT) {
+    findings.push({
+      severity: "warning",
+      category: "budget",
+      file: instructions.rootFile.path,
+      messageKey: "budget.baselineHigh",
+      messageParams: { pct: Math.round(pct2 * 100).toString() },
+      suggestion: `Baseline context consumption is ${Math.round(pct2 * 100)}% of window`,
+      autoFixable: false
+    });
+  }
+  const tokenMethod = [rootFileMethod, rulesMethod, skillsMethod, subFilesMethod].every(
+    (m) => m === "measured"
+  ) ? "measured" : "estimated";
+  const fileBreakdown = [
+    { path: instructions.rootFile.path, tokenCount: rootFileTokens, tokenMethod: rootFileMethod },
+    ...instructions.rules.map((r) => ({
+      path: r.path,
+      tokenCount: r.tokenCount,
+      tokenMethod: r.tokenMethod
+    })),
+    ...instructions.skills.map((s) => ({
+      path: s.path,
+      tokenCount: s.tokenCount,
+      tokenMethod: s.tokenMethod
+    })),
+    ...instructions.subFiles.map((f) => ({
+      path: f.path,
+      tokenCount: f.tokenCount,
+      tokenMethod: f.tokenMethod
+    }))
+  ];
+  const summary = {
+    systemPromptTokens: SYSTEM_PROMPT_TOKENS,
+    rootFileTokens,
+    rootFileMethod,
+    rulesTokens,
+    rulesMethod,
+    skillsTokens,
+    skillsMethod,
+    subFilesTokens,
+    subFilesMethod,
+    mcpTokens,
+    totalBaseline,
+    availableTokens,
+    fileBreakdown,
+    tokenMethod
+  };
+  return { findings, summary };
+}
+
+// src/detectors/config-overlap.ts
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function readJsonFile(projectRoot, filename) {
+  try {
+    const content = readFileSync5(join5(projectRoot, filename), "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function readTextFile(projectRoot, filename) {
+  try {
+    return readFileSync5(join5(projectRoot, filename), "utf8");
+  } catch {
+    return null;
+  }
+}
+function checkEditorConfig(projectRoot, key) {
+  const content = readTextFile(projectRoot, ".editorconfig");
+  if (!content) return false;
+  return new RegExp(`^${key}\\s*=\\s*.+`, "m").test(content);
+}
+function checkPrettierConfig(projectRoot, field) {
+  for (const filename of [".prettierrc", ".prettierrc.json"]) {
+    const parsed = readJsonFile(projectRoot, filename);
+    if (parsed !== null && typeof parsed === "object" && parsed !== null) {
+      if (field in parsed) return true;
+    }
+  }
+  return false;
+}
+function getPrettierField(projectRoot, field) {
+  for (const filename of [".prettierrc", ".prettierrc.json"]) {
+    const parsed = readJsonFile(projectRoot, filename);
+    if (parsed !== null && typeof parsed === "object") {
+      const obj = parsed;
+      if (field in obj) return obj[field];
+    }
+  }
+  return void 0;
+}
+function checkEslintRule(projectRoot, ruleName) {
+  const parsed = readJsonFile(projectRoot, ".eslintrc.json");
+  if (!parsed || typeof parsed !== "object") return false;
+  const rules = parsed["rules"];
+  if (!rules || typeof rules !== "object") return false;
+  const val = rules[ruleName];
+  if (val === void 0) return false;
+  if (val === "off" || val === 0) return false;
+  if (Array.isArray(val) && (val[0] === "off" || val[0] === 0)) return false;
+  return true;
+}
+var PATTERNS = [
+  {
+    id: "ts-strict",
+    rulePattern: /\b(typescript|ts)\b.*\bstrict\b|\bstrict\s*(mode|typing)/i,
+    configCheck: (root) => {
+      const tsconfig = readJsonFile(root, "tsconfig.json");
+      if (!tsconfig || typeof tsconfig !== "object") return false;
+      const opts = tsconfig["compilerOptions"];
+      if (!opts || typeof opts !== "object") return false;
+      return opts["strict"] === true;
+    },
+    configName: "tsconfig.json (compilerOptions.strict: true)"
+  },
+  {
+    id: "indent-spaces",
+    rulePattern: /\b(2|two|4|four)\s*(-?\s*)space\s*indent/i,
+    configCheck: (root) => checkEditorConfig(root, "indent_size") || checkPrettierConfig(root, "tabWidth"),
+    configName: ".editorconfig / .prettierrc (indentation)"
+  },
+  {
+    id: "import-order",
+    rulePattern: /import\s*(order|sort)|sort\s*import/i,
+    configCheck: (root) => {
+      const pkg = readJsonFile(root, "package.json");
+      if (!pkg || typeof pkg !== "object") return false;
+      const devDeps = pkg["devDependencies"];
+      const hasPlugin = devDeps && typeof devDeps === "object" && "eslint-plugin-import" in devDeps;
+      return hasPlugin === true && checkEslintRule(root, "import/order");
+    },
+    configName: "eslint-plugin-import (import/order)"
+  },
+  {
+    id: "conventional-commit",
+    rulePattern: /conventional\s*commit/i,
+    configCheck: (root) => {
+      const pkg = readJsonFile(root, "package.json");
+      if (pkg && typeof pkg === "object" && "commitlint" in pkg)
+        return true;
+      const configFiles = [
+        "commitlint.config.js",
+        "commitlint.config.cjs",
+        "commitlint.config.ts",
+        ".commitlintrc",
+        ".commitlintrc.json",
+        ".commitlintrc.yaml",
+        ".commitlintrc.yml"
+      ];
+      return configFiles.some((f) => existsSync5(join5(root, f)));
+    },
+    configName: "commitlint config"
+  },
+  {
+    id: "semicolons",
+    rulePattern: /\b(semicolons?|always\s*use\s*;|semi\s*colon)/i,
+    configCheck: (root) => checkPrettierConfig(root, "semi"),
+    configName: ".prettierrc (semi)"
+  },
+  {
+    id: "single-quote",
+    rulePattern: /single\s*quotes?|prefer\s*'|use\s*'/i,
+    configCheck: (root) => getPrettierField(root, "singleQuote") === true,
+    configName: ".prettierrc (singleQuote: true)"
+  },
+  {
+    id: "trailing-comma",
+    rulePattern: /trailing\s*comma/i,
+    configCheck: (root) => checkPrettierConfig(root, "trailingComma"),
+    configName: ".prettierrc (trailingComma)"
+  },
+  {
+    id: "max-line-length",
+    rulePattern: /\b(max|maximum)\s*(line\s*)?(length|width|chars?)\b|\bprint\s*width\b/i,
+    configCheck: (root) => checkPrettierConfig(root, "printWidth"),
+    configName: ".prettierrc (printWidth)"
+  },
+  {
+    id: "no-console",
+    rulePattern: /\b(no|avoid|remove)\b.*\bconsole\.(log|warn|error)/i,
+    configCheck: (root) => checkEslintRule(root, "no-console"),
+    configName: "eslint (no-console)"
+  },
+  {
+    id: "no-unused-vars",
+    rulePattern: /\b(no|remove|avoid)\s*(unused|dead)\s*(var|variable|import)/i,
+    configCheck: (root) => {
+      const tsconfig = readJsonFile(root, "tsconfig.json");
+      if (tsconfig && typeof tsconfig === "object") {
+        const opts = tsconfig["compilerOptions"];
+        if (opts && typeof opts === "object") {
+          const o = opts;
+          if (o["noUnusedLocals"] === true || o["noUnusedParameters"] === true)
+            return true;
+        }
+      }
+      return checkEslintRule(root, "no-unused-vars") || checkEslintRule(root, "@typescript-eslint/no-unused-vars");
+    },
+    configName: "tsconfig / eslint (no-unused-vars)"
+  },
+  {
+    id: "test-framework",
+    rulePattern: /\b(use|prefer)\s*(jest|vitest|mocha|jasmine)\b/i,
+    configCheck: (root) => {
+      const configs = [
+        "vitest.config.ts",
+        "vitest.config.js",
+        "jest.config.ts",
+        "jest.config.js",
+        "jest.config.cjs",
+        ".mocharc.js",
+        ".mocharc.json",
+        ".mocharc.yaml"
+      ];
+      if (configs.some((f) => existsSync5(join5(root, f)))) return true;
+      const pkg = readJsonFile(root, "package.json");
+      if (!pkg || typeof pkg !== "object") return false;
+      const devDeps = pkg["devDependencies"] ?? {};
+      return ["jest", "vitest", "mocha", "jasmine"].some(
+        (fw) => typeof devDeps === "object" && fw in devDeps
+      );
+    },
+    configName: "test framework config file"
+  },
+  {
+    id: "formatter",
+    rulePattern: /\b(format|prettier|biome)\s*(code|files|on\s*save)/i,
+    configCheck: (root) => {
+      const prettierFiles = [
+        ".prettierrc",
+        ".prettierrc.json",
+        ".prettierrc.yaml",
+        ".prettierrc.yml"
+      ];
+      if (prettierFiles.some((f) => existsSync5(join5(root, f)))) return true;
+      return existsSync5(join5(root, "biome.json"));
+    },
+    configName: "prettier / biome config file"
+  },
+  {
+    id: "end-of-line",
+    rulePattern: /\b(line\s*ending|eol|crlf|lf)\b/i,
+    configCheck: (root) => checkEditorConfig(root, "end_of_line") || checkPrettierConfig(root, "endOfLine"),
+    configName: ".editorconfig / .prettierrc (endOfLine)"
+  },
+  {
+    id: "tab-width",
+    rulePattern: /\btab\s*(width|size)\b/i,
+    configCheck: (root) => checkEditorConfig(root, "tab_width") || checkEditorConfig(root, "indent_size") || checkPrettierConfig(root, "tabWidth"),
+    configName: ".editorconfig / .prettierrc (tabWidth)"
+  },
+  {
+    id: "no-default-export",
+    rulePattern: /\b(no|avoid|prefer\s*named)\s*(default\s*export)/i,
+    configCheck: (root) => checkEslintRule(root, "import/no-default-export") || checkEslintRule(root, "no-restricted-exports"),
+    configName: "eslint-plugin-import (no-default-export)"
+  }
+];
+function collectRuleLines(instructions) {
+  const result = [];
+  for (const l of instructions.rootFile.lines) {
+    if (l.type === "rule")
+      result.push({ line: l, file: instructions.rootFile.path });
+  }
+  for (const sub of instructions.subFiles) {
+    for (const l of sub.lines) {
+      if (l.type === "rule") result.push({ line: l, file: sub.path });
+    }
+  }
+  for (const rule of instructions.rules) {
+    for (const l of rule.lines) {
+      if (l.type === "rule") result.push({ line: l, file: rule.path });
+    }
+  }
+  return result;
+}
+function detectConfigOverlaps(instructions, projectRoot) {
+  const findings = [];
+  const ruleLines = collectRuleLines(instructions);
+  for (const { line, file } of ruleLines) {
+    for (const pattern of PATTERNS) {
+      if (pattern.rulePattern.test(line.text) && pattern.configCheck(projectRoot)) {
+        const ruleText = line.text.trim();
+        const short = ruleText.length > 60 ? ruleText.slice(0, 60) + "\u2026" : ruleText;
+        findings.push({
+          severity: "warning",
+          category: "dead-rule",
+          file,
+          line: line.lineNumber,
+          messageKey: "deadRule.configOverlap",
+          messageParams: {
+            rule: ruleText.slice(0, 80),
+            config: pattern.configName
+          },
+          suggestion: `Rule "${short}" is already enforced by ${pattern.configName}`,
+          autoFixable: true
+        });
+        break;
+      }
+    }
+  }
+  return findings;
+}
+
+// src/utils/text.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "to",
+  "for",
+  "and",
+  "or",
+  "in",
+  "of",
+  "with",
+  "that",
+  "this"
+]);
+function tokenizeWords(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1);
+}
+function removeStopWords(words) {
+  return words.filter((w) => !STOP_WORDS.has(w));
+}
+function jaccardSimilarity(setA, setB) {
+  if (setA.length === 0 && setB.length === 0) return 0;
+  const a = new Set(setA);
+  const b = new Set(setB);
+  let intersection = 0;
+  for (const word of a) {
+    if (b.has(word)) intersection++;
+  }
+  const union = (/* @__PURE__ */ new Set([...a, ...b])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+// src/detectors/duplicate.ts
+var SIMILARITY_THRESHOLD = 0.7;
+var MIN_WORDS_AFTER_STOP = 4;
+function collectRuleLines2(instructions) {
+  const result = [];
+  const add = (lines, file) => {
+    for (const l of lines) {
+      if (l.type !== "rule") continue;
+      const words = removeStopWords(tokenizeWords(l.text));
+      if (words.length < MIN_WORDS_AFTER_STOP) continue;
+      result.push({ line: l, file, words });
+    }
+  };
+  add(instructions.rootFile.lines, instructions.rootFile.path);
+  for (const sub of instructions.subFiles) add(sub.lines, sub.path);
+  for (const rule of instructions.rules) add(rule.lines, rule.path);
+  return result;
+}
+function detectDuplicates(instructions) {
+  const findings = [];
+  const ruleLines = collectRuleLines2(instructions);
+  const reported = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ruleLines.length; i++) {
+    for (let j = i + 1; j < ruleLines.length; j++) {
+      const a = ruleLines[i];
+      const b = ruleLines[j];
+      const pairKey = `${a.file}:${a.line.lineNumber}|${b.file}:${b.line.lineNumber}`;
+      if (reported.has(pairKey)) continue;
+      const sim = jaccardSimilarity(a.words, b.words);
+      if (sim < SIMILARITY_THRESHOLD) continue;
+      reported.add(pairKey);
+      const isExact = sim >= 1;
+      const simPct = `${Math.round(sim * 100)}`;
+      findings.push({
+        severity: isExact ? "warning" : "info",
+        category: "duplicate",
+        file: b.file,
+        line: b.line.lineNumber,
+        messageKey: isExact ? "deadRule.exactDuplicate" : "deadRule.nearDuplicate",
+        messageParams: {
+          otherFile: a.file,
+          otherLine: String(a.line.lineNumber),
+          similarity: simPct
+        },
+        suggestion: isExact ? `Exact duplicate of line ${a.line.lineNumber} in ${a.file}` : `Very similar to line ${a.line.lineNumber} in ${a.file} (${simPct}% similar)`,
+        autoFixable: isExact
+      });
+    }
+  }
+  return findings;
+}
+
+// src/analyzers/dead-rules.ts
+function analyzeDeadRules(instructions, projectRoot) {
+  return {
+    findings: [
+      ...detectConfigOverlaps(instructions, projectRoot),
+      ...detectDuplicates(instructions)
+    ]
+  };
+}
+
+// src/detectors/contradiction.ts
+var NEGATION_WORDS = ["never", "don't", "avoid", "forbid"];
+function isNegated(text, word) {
+  const sentences = text.split(/[.!?]+\s+/);
+  const escapedWord = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const wordPresent = new RegExp(`\\b${escapedWord}\\b`, "i");
+  for (const sentence of sentences) {
+    if (!wordPresent.test(sentence)) continue;
+    const lower = sentence.toLowerCase();
+    for (const neg of NEGATION_WORDS) {
+      const pattern = new RegExp(
+        `\\b${neg}\\b(?:\\s+\\w+){0,1}\\s+\\b${escapedWord}\\b`,
+        "i"
+      );
+      if (pattern.test(lower)) return true;
+    }
+    const notPattern = new RegExp(
+      `\\b(?:do\\s+)?not\\b(?:\\s+\\w+){0,1}\\s+\\b${escapedWord}\\b`,
+      "i"
+    );
+    if (notPattern.test(lower)) return true;
+  }
+  return false;
+}
+var POLARITY_STOP_WORDS = /* @__PURE__ */ new Set([
+  // Polarity / negation markers (meta-level, not domain content)
+  "never",
+  "always",
+  "avoid",
+  "not",
+  // Generic imperative verbs (describe HOW to comply, not WHAT topic)
+  "use",
+  "ensure",
+  "require",
+  "prefer",
+  "follow",
+  "keep",
+  // Common modals and auxiliaries
+  "must",
+  "should",
+  "can",
+  "will",
+  "may",
+  // Generic quantifiers
+  "all",
+  "every",
+  "each",
+  "any"
+]);
+function collectRuleLines3(instructions) {
+  const sources = [
+    instructions.rootFile,
+    ...instructions.subFiles,
+    ...instructions.rules
+  ];
+  const annotated = [];
+  for (const file of sources) {
+    for (const line of file.lines) {
+      if (line.type !== "rule") continue;
+      const words = removeStopWords(tokenizeWords(line.text)).filter(
+        (w) => !POLARITY_STOP_WORDS.has(w)
+      );
+      if (words.length < 3) continue;
+      annotated.push({ line, words, file: file.path });
+    }
+  }
+  return annotated;
+}
+function detectContradictions(instructions) {
+  const lines = collectRuleLines3(instructions);
+  const findings = [];
+  const reportedPairs = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    for (let j = i + 1; j < lines.length; j++) {
+      const a = lines[i];
+      const b = lines[j];
+      const setA = new Set(a.words);
+      const setB = new Set(b.words);
+      const shared = [...setB].filter((w) => setA.has(w));
+      if (shared.length < 3) continue;
+      const hasContradiction = shared.some(
+        (word) => isNegated(a.line.text, word) !== isNegated(b.line.text, word)
+      );
+      if (!hasContradiction) continue;
+      const pairKey = `${a.file}:${a.line.lineNumber}|${b.file}:${b.line.lineNumber}`;
+      if (reportedPairs.has(pairKey)) continue;
+      reportedPairs.add(pairKey);
+      const snippet = a.line.text.length > 60 ? `${a.line.text.slice(0, 60)}...` : a.line.text;
+      findings.push({
+        severity: "critical",
+        category: "contradiction",
+        file: b.file,
+        line: b.line.lineNumber,
+        messageKey: "structure.contradiction",
+        messageParams: {
+          snippet,
+          lineA: String(a.line.lineNumber),
+          lineB: String(b.line.lineNumber),
+          fileA: a.file
+        },
+        suggestion: `Contradicting rules: "${snippet}" (${a.file} line ${a.line.lineNumber}) conflicts with line ${b.line.lineNumber}.`,
+        autoFixable: false
+      });
+    }
+  }
+  return findings;
+}
+
+// src/detectors/stale-refs.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+function collectLines(instructions) {
+  const sources = [
+    instructions.rootFile,
+    ...instructions.subFiles,
+    ...instructions.rules
+  ];
+  const result = [];
+  for (const file of sources) {
+    for (const line of file.lines) {
+      if (line.type === "blank" || line.type === "code") continue;
+      if (line.referencedPaths.length === 0) continue;
+      result.push({ line, file: file.path });
+    }
+  }
+  return result;
+}
+function detectStaleRefs(instructions, projectRoot) {
+  const findings = [];
+  for (const { line, file } of collectLines(instructions)) {
+    for (const refPath of line.referencedPaths) {
+      if (refPath.endsWith("/") || refPath.includes("*")) continue;
+      const absolutePath = join6(projectRoot, refPath);
+      if (!existsSync6(absolutePath)) {
+        findings.push({
+          severity: "warning",
+          category: "stale-ref",
+          file,
+          line: line.lineNumber,
+          messageKey: "structure.staleRef",
+          messageParams: { path: refPath },
+          suggestion: `Stale reference: "${refPath}" does not exist.`,
+          autoFixable: true
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+// src/detectors/scope-classifier.ts
+var PATH_REF_PATTERN = /\b(?:src|tests?|lib|dist)\//i;
+var HOOK_PATTERN = /\b(?:never|don't|do\s+not|forbid)\b.*\b(?:commit|push|merge|build|run)\b/i;
+function classifyScope(instructions) {
+  const findings = [];
+  const rootFile = instructions.rootFile;
+  for (const line of rootFile.lines) {
+    if (line.type !== "rule") continue;
+    if (HOOK_PATTERN.test(line.text)) {
+      const snippet = line.text.length > 60 ? `${line.text.slice(0, 60)}...` : line.text;
+      findings.push({
+        severity: "info",
+        category: "structure",
+        file: rootFile.path,
+        line: line.lineNumber,
+        messageKey: "structure.scopeHook",
+        messageParams: { line: String(line.lineNumber), snippet },
+        suggestion: `Rule at line ${line.lineNumber} could be a git hook: "${snippet}"`,
+        autoFixable: false
+      });
+      continue;
+    }
+    if (PATH_REF_PATTERN.test(line.text)) {
+      const snippet = line.text.length > 60 ? `${line.text.slice(0, 60)}...` : line.text;
+      findings.push({
+        severity: "info",
+        category: "structure",
+        file: rootFile.path,
+        line: line.lineNumber,
+        messageKey: "structure.scopePathScoped",
+        messageParams: { line: String(line.lineNumber), snippet },
+        suggestion: `Rule at line ${line.lineNumber} references a specific path \u2014 consider a path-scoped rule file: "${snippet}"`,
+        autoFixable: false
+      });
+    }
+  }
+  return findings;
+}
+
+// src/analyzers/structure.ts
+function analyzeStructure(instructions, projectRoot) {
+  return {
+    findings: [
+      ...detectContradictions(instructions),
+      ...detectStaleRefs(instructions, projectRoot),
+      ...classifyScope(instructions)
+    ]
+  };
+}
+
+// src/core/scorer.ts
+var CONTEXT_WINDOW2 = 2e5;
+var CRITICAL_DEDUCTION = 10;
+var WARNING_DEDUCTION = 5;
+var INFO_DEDUCTION = 1;
+var MAX_CRITICAL_DEDUCTION = 40;
+var MAX_WARNING_DEDUCTION = 30;
+var MAX_INFO_DEDUCTION = 10;
+function gradeFromScore(score) {
+  if (score >= 90) return "A";
+  if (score >= 80) return "B";
+  if (score >= 70) return "C";
+  if (score >= 60) return "D";
+  return "F";
+}
+function calculateScore(findings, budget) {
+  const criticals = findings.filter((f) => f.severity === "critical").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  const criticalDeduction = Math.min(criticals * CRITICAL_DEDUCTION, MAX_CRITICAL_DEDUCTION);
+  const warningDeduction = Math.min(warnings * WARNING_DEDUCTION, MAX_WARNING_DEDUCTION);
+  const infoDeduction = Math.min(infos * INFO_DEDUCTION, MAX_INFO_DEDUCTION);
+  const baselinePct = budget.totalBaseline / CONTEXT_WINDOW2;
+  let budgetDeduction = 0;
+  if (baselinePct > 0.5) budgetDeduction = 15;
+  else if (baselinePct > 0.25) budgetDeduction = 5;
+  const score = Math.max(
+    0,
+    100 - criticalDeduction - warningDeduction - infoDeduction - budgetDeduction
+  );
+  return { score, grade: gradeFromScore(score) };
+}
+function buildActionPlan(findings) {
+  const priorityOf = (f) => {
+    if (f.severity === "critical") return 1;
+    if (f.severity === "warning") return 2;
+    return 3;
+  };
+  const seen = /* @__PURE__ */ new Set();
+  return findings.filter((f) => {
+    if (seen.has(f.suggestion)) return false;
+    seen.add(f.suggestion);
+    return true;
+  }).map((f) => ({
+    priority: priorityOf(f),
+    description: f.suggestion,
+    category: f.category
+  })).sort((a, b) => a.priority - b.priority);
+}
+
+// src/core/reporter.ts
+import chalk2 from "chalk";
+
+// src/commands/budget-command.ts
+import chalk from "chalk";
+
+// src/i18n/en.json
+var en_default = {
+  "label.tokenBudget": "TOKEN BUDGET",
+  "label.deadRules": "DEAD RULES",
+  "label.structure": "STRUCTURE",
+  "label.actionPlan": "ACTION PLAN",
+  "label.fixSummary": "FIX SUMMARY",
+  "label.systemPrompt": "System prompt",
+  "label.rootFile": "Root file",
+  "label.ruleFiles": "Rule files",
+  "label.skillFiles": "Skill files",
+  "label.subDirFiles": "Sub-dir files",
+  "label.mcpServers": "MCP servers",
+  "label.baselineTotal": "Baseline total",
+  "label.available": "Available",
+  "label.redundantByConfig": "Redundant (enforced by config)",
+  "label.duplicates": "Duplicates",
+  "label.contradictions": "Contradictions",
+  "label.staleReferences": "Stale References",
+  "label.refactoringOpportunities": "Refactoring Opportunities",
+  "label.tool": "Tool:",
+  "label.score": "Score:",
+  "status.noBudgetIssues": "\u2713 No budget issues found",
+  "status.noDeadRules": "\u2713 No dead rules found",
+  "status.noStructuralIssues": "\u2713 No structural issues found",
+  "status.noAutoFixable": "\u2713 No auto-fixable issues found",
+  "status.perfectScore": "\u2713 Perfect score \u2014 no issues found",
+  "status.fixedIssues": "\u2713 Fixed {{count}} issue{{s}} \u2014 run `git diff` to review changes",
+  "error.unknownTool": "No agent instruction files found. Run this command in a project that uses Claude Code, Codex, or Cursor.",
+  "error.missingRootFile": "Found {{tool}} configuration but no root instruction file.",
+  "error.dirtyWorkingTree": "Working tree is dirty. Commit or stash your changes before running --fix, or use --force to skip this check.",
+  "fix.removedDeadRules": "Removed {{count}} redundant rule{{s}}",
+  "fix.removedStaleRefs": "Removed {{count}} stale reference{{s}}",
+  "fix.removedDuplicates": "Removed {{count}} exact duplicate{{s}}",
+  "summary.redundantRules": "{{count}} redundant rule{{s}}",
+  "summary.duplicates": "{{count}} duplicate{{s}}",
+  "summary.contradictions": "{{count}} contradiction{{s}}",
+  "summary.staleRefs": "{{count}} stale ref{{s}}",
+  "summary.refactoringSuggestions": "{{count}} refactoring suggestion{{s}}",
+  "summary.found": "{{parts}} found",
+  "tokens.measured": "{{count}} tokens",
+  "tokens.estimated": "~{{count}} tokens (estimated)",
+  "actionPlan.andMore": "\u2026 and {{count}} more",
+  "severity.critical": "{{count}} critical",
+  "severity.warnings": "{{count}} warning{{s}}",
+  "severity.suggestions": "{{count}} suggestion{{s}}",
+  "budget.rootFileCritical": "Root instruction file is {{lines}} lines \u2014 agent compliance drops significantly above 200 lines",
+  "budget.rootFileWarning": "Root instruction file is {{lines}} lines (recommended: < 200)",
+  "budget.mcpLargeServer": "MCP server '{{name}}' consumes ~{{tokens}} tokens",
+  "budget.baselineHigh": "Baseline context consumption is {{pct}}% of window",
+  "deadRule.configOverlap": 'Rule "{{rule}}" is already enforced by {{config}}',
+  "deadRule.exactDuplicate": "Exact duplicate of line {{otherLine}} in {{otherFile}}",
+  "deadRule.nearDuplicate": "Very similar to line {{otherLine}} in {{otherFile}} ({{similarity}}% similar)",
+  "structure.contradiction": 'Contradicting rules: "{{snippet}}" ({{fileA}} line {{lineA}}) conflicts with line {{lineB}}.',
+  "structure.staleRef": 'Stale reference: "{{path}}" does not exist.',
+  "structure.scopeHook": 'Rule at line {{line}} could be a git hook: "{{snippet}}"',
+  "structure.scopePathScoped": 'Rule at line {{line}} references a specific path \u2014 consider a path-scoped rule file: "{{snippet}}"',
+  "label.budget": "BUDGET",
+  "label.findings": "FINDINGS",
+  "label.topIssues": "TOP ISSUES",
+  "label.category": "Category",
+  "compact.budgetLine": "{{used}} / {{window}} tokens ({{pct}}%)",
+  "compact.andMore": "\u2026 and {{count}} more (run instrlint <command> for details)",
+  "compact.budget": "Budget",
+  "compact.deadRules": "Dead rules",
+  "compact.duplicates": "Duplicates",
+  "compact.contradictions": "Contradictions",
+  "compact.staleRefs": "Stale refs",
+  "compact.structure": "Structure",
+  "markdown.title": "instrlint Health Report \u2014 {{project}}",
+  "markdown.scoreLine": "**Score: {{score}}/100 ({{grade}})** \xB7 Tool: `{{tool}}`",
+  "markdown.summary": "## Summary",
+  "markdown.severity": "Severity",
+  "markdown.count": "Count",
+  "markdown.critical": "\u{1F534} Critical",
+  "markdown.warning": "\u{1F7E1} Warning",
+  "markdown.info": "\u2139\uFE0F Info",
+  "markdown.contradictions": "Contradictions",
+  "markdown.staleReferences": "Stale References",
+  "markdown.deadRules": "Dead Rules",
+  "markdown.duplicateRules": "Duplicates",
+  "markdown.budgetIssues": "Budget Issues",
+  "markdown.refactoringOpportunities": "Refactoring Opportunities",
+  "markdown.lineRef": "(line {{line}})",
+  "markdown.actionPlan": "## Action Plan",
+  "markdown.attribution": "*Generated by [instrlint](https://github.com/jed1978/instrlint)*",
+  "ci.passed": "\u2713 instrlint passed  score={{score}} grade={{grade}}",
+  "ci.failed": "\u2716 instrlint failed  score={{score}} grade={{grade}}",
+  "ci.writtenTo": "\u2192 written to {{file}}",
+  "initCi.created": "\u2713 Created {{path}}",
+  "initCi.alreadyExists": "{{path}} already exists. Use --force to overwrite.",
+  "install.installed": "\u2713 Installed to {{path}}",
+  "install.alreadyExists": "{{path}} already exists. Use --force to overwrite.",
+  "install.unknownTarget": "Specify --claude-code or --codex",
+  "fix.manualActions": "MANUAL ACTIONS NEEDED",
+  "fix.hookCreate": "Add to .claude/settings.json:",
+  "fix.hookWarning": "\u26A0 Hook executes shell commands \u2014 review carefully before adding",
+  "fix.pathScopedCreate": "Create {{path}}:",
+  "fix.thenRemoveLine": "Then remove line {{line}} from {{file}}"
+};
+
+// src/i18n/zh-TW.json
+var zh_TW_default = {
+  "label.tokenBudget": "TOKEN \u9810\u7B97",
+  "label.deadRules": "\u5197\u9918\u898F\u5247",
+  "label.structure": "\u7D50\u69CB\u5206\u6790",
+  "label.actionPlan": "\u884C\u52D5\u8A08\u756B",
+  "label.fixSummary": "\u4FEE\u5FA9\u6458\u8981",
+  "label.systemPrompt": "\u7CFB\u7D71\u63D0\u793A",
+  "label.rootFile": "\u6839\u6307\u4EE4\u6A94",
+  "label.ruleFiles": "\u898F\u5247\u6A94",
+  "label.skillFiles": "\u6280\u80FD\u6A94",
+  "label.subDirFiles": "\u5B50\u76EE\u9304\u6A94",
+  "label.mcpServers": "MCP \u4F3A\u670D\u5668",
+  "label.baselineTotal": "\u521D\u59CB\u7E3D\u91CF",
+  "label.available": "\u53EF\u7528",
+  "label.redundantByConfig": "\u5197\u9918\uFF08\u5DF2\u7531\u914D\u7F6E\u5F37\u5236\u57F7\u884C\uFF09",
+  "label.duplicates": "\u91CD\u8907\u9805\u76EE",
+  "label.contradictions": "\u898F\u5247\u77DB\u76FE",
+  "label.staleReferences": "\u904E\u6642\u53C3\u7167",
+  "label.refactoringOpportunities": "\u91CD\u69CB\u5EFA\u8B70",
+  "label.tool": "\u5DE5\u5177\uFF1A",
+  "label.score": "\u5206\u6578\uFF1A",
+  "status.noBudgetIssues": "\u2713 \u7121 Token \u9810\u7B97\u554F\u984C",
+  "status.noDeadRules": "\u2713 \u7121\u5197\u9918\u898F\u5247",
+  "status.noStructuralIssues": "\u2713 \u7121\u7D50\u69CB\u6027\u554F\u984C",
+  "status.noAutoFixable": "\u2713 \u7121\u53EF\u81EA\u52D5\u4FEE\u5FA9\u7684\u554F\u984C",
+  "status.perfectScore": "\u2713 \u6EFF\u5206 \u2014 \u7121\u4EFB\u4F55\u554F\u984C",
+  "status.fixedIssues": "\u2713 \u5DF2\u4FEE\u5FA9 {{count}} \u500B\u554F\u984C \u2014 \u57F7\u884C `git diff` \u67E5\u770B\u8B8A\u66F4",
+  "error.unknownTool": "\u627E\u4E0D\u5230\u4EE3\u7406\u6307\u4EE4\u6A94\u3002\u8ACB\u5728\u4F7F\u7528 Claude Code\u3001Codex \u6216 Cursor \u7684\u5C08\u6848\u4E2D\u57F7\u884C\u6B64\u6307\u4EE4\u3002",
+  "error.missingRootFile": "\u627E\u5230 {{tool}} \u914D\u7F6E\uFF0C\u4F46\u627E\u4E0D\u5230\u6839\u6307\u4EE4\u6A94\u3002",
+  "error.dirtyWorkingTree": "\u5DE5\u4F5C\u76EE\u9304\u6709\u672A\u63D0\u4EA4\u7684\u8B8A\u66F4\u3002\u8ACB\u5148\u63D0\u4EA4\u6216\u5132\u85CF\u8B8A\u66F4\u518D\u57F7\u884C --fix\uFF0C\u6216\u4F7F\u7528 --force \u8DF3\u904E\u6B64\u6AA2\u67E5\u3002",
+  "fix.removedDeadRules": "\u5DF2\u79FB\u9664 {{count}} \u500B\u5197\u9918\u898F\u5247",
+  "fix.removedStaleRefs": "\u5DF2\u79FB\u9664 {{count}} \u500B\u904E\u6642\u53C3\u7167",
+  "fix.removedDuplicates": "\u5DF2\u79FB\u9664 {{count}} \u500B\u91CD\u8907\u9805\u76EE",
+  "summary.redundantRules": "{{count}} \u500B\u5197\u9918\u898F\u5247",
+  "summary.duplicates": "{{count}} \u500B\u91CD\u8907\u9805\u76EE",
+  "summary.contradictions": "{{count}} \u500B\u898F\u5247\u77DB\u76FE",
+  "summary.staleRefs": "{{count}} \u500B\u904E\u6642\u53C3\u7167",
+  "summary.refactoringSuggestions": "{{count}} \u500B\u91CD\u69CB\u5EFA\u8B70",
+  "summary.found": "\u767C\u73FE {{parts}}",
+  "tokens.measured": "{{count}} tokens",
+  "tokens.estimated": "~{{count}} tokens\uFF08\u4F30\u8A08\u503C\uFF09",
+  "actionPlan.andMore": "\u2026 \u9084\u6709 {{count}} \u500B",
+  "severity.critical": "{{count}} \u500B\u56B4\u91CD\u554F\u984C",
+  "severity.warnings": "{{count}} \u500B\u8B66\u544A",
+  "severity.suggestions": "{{count}} \u500B\u5EFA\u8B70",
+  "budget.rootFileCritical": "\u6839\u6307\u4EE4\u6A94\u6709 {{lines}} \u884C \u2014 \u8D85\u904E 200 \u884C\u5F8C\u4EE3\u7406\u9075\u5FAA\u7387\u986F\u8457\u4E0B\u964D",
+  "budget.rootFileWarning": "\u6839\u6307\u4EE4\u6A94\u6709 {{lines}} \u884C\uFF08\u5EFA\u8B70\uFF1A< 200 \u884C\uFF09",
+  "budget.mcpLargeServer": "MCP \u4F3A\u670D\u5668\u300C{{name}}\u300D\u6D88\u8017\u7D04 {{tokens}} tokens",
+  "budget.baselineHigh": "\u57FA\u7DDA\u60C5\u5883\u6D88\u8017\u4F54\u8996\u7A97 {{pct}}%",
+  "deadRule.configOverlap": "\u898F\u5247\u300C{{rule}}\u300D\u5DF2\u7531 {{config}} \u5F37\u5236\u57F7\u884C",
+  "deadRule.exactDuplicate": "\u8207 {{otherFile}} \u7B2C {{otherLine}} \u884C\u5B8C\u5168\u91CD\u8907",
+  "deadRule.nearDuplicate": "\u8207 {{otherFile}} \u7B2C {{otherLine}} \u884C\u9AD8\u5EA6\u76F8\u4F3C\uFF08{{similarity}}% \u76F8\u4F3C\u5EA6\uFF09",
+  "structure.contradiction": "\u898F\u5247\u77DB\u76FE\uFF1A\u300C{{snippet}}\u300D\uFF08{{fileA}} \u7B2C {{lineA}} \u884C\uFF09\u8207\u7B2C {{lineB}} \u884C\u885D\u7A81\u3002",
+  "structure.staleRef": "\u904E\u6642\u53C3\u7167\uFF1A\u300C{{path}}\u300D\u4E0D\u5B58\u5728\u3002",
+  "structure.scopeHook": "\u7B2C {{line}} \u884C\u7684\u898F\u5247\u9069\u5408\u505A\u6210 git hook\uFF1A\u300C{{snippet}}\u300D",
+  "structure.scopePathScoped": "\u7B2C {{line}} \u884C\u7684\u898F\u5247\u53C3\u7167\u4E86\u7279\u5B9A\u8DEF\u5F91 \u2014 \u5EFA\u8B70\u5EFA\u7ACB\u8DEF\u5F91\u7BC4\u570D\u7684\u898F\u5247\u6A94\uFF1A\u300C{{snippet}}\u300D",
+  "label.budget": "\u9810\u7B97",
+  "label.findings": "\u554F\u984C\u7E3D\u89BD",
+  "label.topIssues": "\u9996\u8981\u554F\u984C",
+  "label.category": "Category",
+  "compact.budgetLine": "{{used}} / {{window}} tokens ({{pct}}%)",
+  "compact.andMore": "\u2026 \u9084\u6709 {{count}} \u500B\uFF08\u57F7\u884C instrlint <command> \u67E5\u770B\u8A73\u60C5\uFF09",
+  "compact.budget": "Budget",
+  "compact.deadRules": "Dead rules",
+  "compact.duplicates": "Duplicates",
+  "compact.contradictions": "Contradictions",
+  "compact.staleRefs": "Stale refs",
+  "compact.structure": "Structure",
+  "markdown.title": "instrlint \u5065\u5EB7\u5831\u544A \u2014 {{project}}",
+  "markdown.scoreLine": "**\u5206\u6578\uFF1A{{score}}/100 ({{grade}})** \xB7 \u5DE5\u5177\uFF1A`{{tool}}`",
+  "markdown.summary": "## \u6458\u8981",
+  "markdown.severity": "\u56B4\u91CD\u7A0B\u5EA6",
+  "markdown.count": "\u6578\u91CF",
+  "markdown.critical": "\u{1F534} \u56B4\u91CD",
+  "markdown.warning": "\u{1F7E1} \u8B66\u544A",
+  "markdown.info": "\u2139\uFE0F \u8CC7\u8A0A",
+  "markdown.contradictions": "\u898F\u5247\u77DB\u76FE",
+  "markdown.staleReferences": "\u904E\u6642\u53C3\u7167",
+  "markdown.deadRules": "\u5197\u9918\u898F\u5247",
+  "markdown.duplicateRules": "\u91CD\u8907\u9805\u76EE",
+  "markdown.budgetIssues": "Token \u9810\u7B97\u554F\u984C",
+  "markdown.refactoringOpportunities": "\u91CD\u69CB\u5EFA\u8B70",
+  "markdown.lineRef": "\uFF08\u7B2C {{line}} \u884C\uFF09",
+  "markdown.actionPlan": "## \u884C\u52D5\u8A08\u756B",
+  "markdown.attribution": "*\u7531 [instrlint](https://github.com/jed1978/instrlint) \u751F\u6210*",
+  "ci.passed": "\u2713 instrlint \u901A\u904E  \u5206\u6578={{score}} \u7B49\u7D1A={{grade}}",
+  "ci.failed": "\u2716 instrlint \u672A\u901A\u904E  \u5206\u6578={{score}} \u7B49\u7D1A={{grade}}",
+  "ci.writtenTo": "\u2192 \u5DF2\u5BEB\u5165 {{file}}",
+  "initCi.created": "\u2713 \u5DF2\u5EFA\u7ACB {{path}}",
+  "initCi.alreadyExists": "{{path}} \u5DF2\u5B58\u5728\u3002\u4F7F\u7528 --force \u8986\u84CB\u3002",
+  "install.installed": "\u2713 \u5DF2\u5B89\u88DD\u81F3 {{path}}",
+  "install.alreadyExists": "{{path}} \u5DF2\u5B58\u5728\u3002\u4F7F\u7528 --force \u8986\u84CB\u3002",
+  "install.unknownTarget": "\u8ACB\u6307\u5B9A --claude-code \u6216 --codex",
+  "fix.manualActions": "\u9700\u8981\u624B\u52D5\u64CD\u4F5C",
+  "fix.hookCreate": "\u52A0\u5165 .claude/settings.json\uFF1A",
+  "fix.hookWarning": "\u26A0 Hook \u6703\u57F7\u884C shell command\uFF0C\u8ACB\u4ED4\u7D30\u78BA\u8A8D\u5F8C\u518D\u52A0\u5165",
+  "fix.pathScopedCreate": "\u5EFA\u7ACB {{path}}\uFF1A",
+  "fix.thenRemoveLine": "\u642C\u79FB\u5F8C\u8ACB\u5F9E {{file}} \u7B2C {{line}} \u884C\u522A\u9664\u539F\u898F\u5247"
+};
+
+// src/i18n/index.ts
+var LOCALE_MAP = {
+  en: en_default,
+  "zh-TW": zh_TW_default
+};
+var _locale = "en";
+var _messages = LOCALE_MAP["en"];
+function detectLocale() {
+  const env = process.env["INSTRLINT_LANG"];
+  if (env === "zh-TW" || env === "en") return env;
+  try {
+    const sys = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (sys.startsWith("zh")) return "zh-TW";
+  } catch {
+  }
+  return "en";
+}
+function initLocale(lang) {
+  const valid = ["en", "zh-TW"];
+  const resolved = valid.includes(lang) ? lang : detectLocale();
+  _locale = resolved;
+  _messages = LOCALE_MAP[resolved];
+}
+function getLocale() {
+  return _locale;
+}
+function t(key, params) {
+  const template = _messages[key] ?? key;
+  if (!params) return template;
+  return template.replace(
+    /\{\{(\w+)\}\}/g,
+    (_, k) => params[k] ?? `{{${k}}}`
+  );
+}
+function plural(count) {
+  return count === 1 ? "" : "s";
+}
+
+// src/commands/budget-command.ts
+function getFmt() {
+  return new Intl.NumberFormat(getLocale());
+}
+function formatTokens(count, method) {
+  const formatted = getFmt().format(count);
+  if (method === "measured") return t("tokens.measured", { count: formatted });
+  return t("tokens.estimated", { count: formatted });
+}
+function bar(fraction, width = 24) {
+  const filled = Math.round(Math.min(1, Math.max(0, fraction)) * width);
+  const empty = width - filled;
+  return chalk.cyan("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
+}
+function pct(fraction) {
+  return `${Math.round(fraction * 100)}%`;
+}
+function printBudgetTerminal(summary, findings, output = console) {
+  const total = summary.totalBaseline;
+  const window = total + summary.availableTokens;
+  output.log("");
+  output.log(chalk.bold.white(`  ${t("label.tokenBudget")}`));
+  output.log(chalk.gray("  \u2500".repeat(30)));
+  const rows = [
+    {
+      labelKey: "label.systemPrompt",
+      tokens: summary.systemPromptTokens,
+      method: "estimated"
+    },
+    {
+      labelKey: "label.rootFile",
+      tokens: summary.rootFileTokens,
+      method: summary.rootFileMethod
+    },
+    {
+      labelKey: "label.ruleFiles",
+      tokens: summary.rulesTokens,
+      method: summary.rulesMethod
+    },
+    {
+      labelKey: "label.skillFiles",
+      tokens: summary.skillsTokens,
+      method: summary.skillsMethod
+    },
+    {
+      labelKey: "label.subDirFiles",
+      tokens: summary.subFilesTokens,
+      method: summary.subFilesMethod
+    },
+    {
+      labelKey: "label.mcpServers",
+      tokens: summary.mcpTokens,
+      method: "estimated"
+    }
+  ];
+  for (const row of rows) {
+    if (row.tokens === 0) continue;
+    const fraction = row.tokens / window;
+    const label = t(row.labelKey).padEnd(14);
+    const tokenStr = formatTokens(row.tokens, row.method).padStart(28);
+    output.log(
+      `  ${chalk.white(label)} ${bar(fraction)}  ${chalk.yellow(tokenStr)}`
+    );
+  }
+  output.log(chalk.gray("  \u2500".repeat(30)));
+  const baselineFraction = total / window;
+  const baselineStr = formatTokens(total, summary.tokenMethod).padStart(28);
+  output.log(
+    `  ${t("label.baselineTotal").padEnd(14)} ${bar(baselineFraction)}  ${chalk.bold.yellow(baselineStr)}  ${chalk.gray(pct(baselineFraction))}`
+  );
+  const availStr = formatTokens(summary.availableTokens, "estimated").padStart(
+    28
+  );
+  output.log(
+    `  ${t("label.available").padEnd(14)} ${"".padEnd(26)}  ${chalk.green(availStr)}`
+  );
+  output.log("");
+  if (findings.length === 0) {
+    output.log(chalk.green(`  ${t("status.noBudgetIssues")}`));
+  } else {
+    for (const f of findings) {
+      const icon = f.severity === "critical" ? chalk.red("  \u2716") : f.severity === "warning" ? chalk.yellow("  \u26A0") : chalk.blue("  \u2139");
+      output.log(`${icon}  ${t(f.messageKey, f.messageParams)}`);
+    }
+  }
+  output.log("");
+}
+async function runBudget(opts, output = console) {
+  initLocale(opts.lang);
+  await ensureInitialized();
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const scan = scanProject(projectRoot, opts.tool);
+  if (scan.tool === "unknown") {
+    output.error(t("error.unknownTool"));
+    return { exitCode: 1, errorMessage: "unknown tool" };
+  }
+  if (scan.rootFilePath === null) {
+    output.error(t("error.missingRootFile", { tool: scan.tool }));
+    return { exitCode: 1, errorMessage: "missing root file" };
+  }
+  const instructions = loadProject(projectRoot, scan.tool);
+  const { findings, summary } = analyzeBudget(instructions);
+  if (opts.format === "json") {
+    output.log(JSON.stringify({ findings, summary }, null, 2));
+    return { exitCode: 0 };
+  }
+  printBudgetTerminal(summary, findings, output);
+  return { exitCode: 0 };
+}
+
+// src/core/reporter.ts
+var BOX_W = 50;
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function visLen(s) {
+  return s.replace(ANSI_RE, "").length;
+}
+function padR(s, w) {
+  return s + " ".repeat(Math.max(0, w - visLen(s)));
+}
+function gradeColor(grade) {
+  if (grade === "A") return chalk2.green;
+  if (grade === "B") return chalk2.cyan;
+  if (grade === "C") return chalk2.yellow;
+  if (grade === "D") return chalk2.magenta;
+  return chalk2.red;
+}
+function gradeBadge(grade) {
+  if (grade === "A") return chalk2.bgGreen(chalk2.bold.black(` ${grade} `));
+  if (grade === "B") return chalk2.bgCyan(chalk2.bold.black(` ${grade} `));
+  if (grade === "C") return chalk2.bgYellow(chalk2.bold.black(` ${grade} `));
+  if (grade === "D") return chalk2.bgMagenta(chalk2.bold.white(` ${grade} `));
+  return chalk2.bgRed(chalk2.bold.white(` ${grade} `));
+}
+function scoreBar(score, grade, width = 30) {
+  const filled = Math.round(score / 100 * width);
+  const empty = width - filled;
+  return gradeColor(grade)("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(empty));
+}
+function sectionHeader(title, width = BOX_W) {
+  const inner = ` ${title} `;
+  const remaining = Math.max(0, width - 2 - inner.length);
+  return chalk2.gray(`  \u2500\u2500${chalk2.bold.white(inner)}${"\u2500".repeat(remaining)}\u2500\u2500`);
+}
+function printCompactBudget(summary, output) {
+  const total = summary.totalBaseline;
+  const window = total + summary.availableTokens;
+  const fraction = total / window;
+  const fmt = new Intl.NumberFormat(getLocale());
+  const usedPrefix = summary.tokenMethod === "estimated" ? "~" : "";
+  const budgetLine = t("compact.budgetLine", {
+    used: `${usedPrefix}${fmt.format(total)}`,
+    window: fmt.format(window),
+    pct: String(Math.round(fraction * 100))
+  });
+  output.log(`  ${chalk2.yellow(budgetLine)}  ${bar(fraction, 14)}`);
+}
+var SEVERITY_ORDER = {
+  critical: 0,
+  warning: 1,
+  info: 2
+};
+function printFindingsTable(findings, output) {
+  const categories = [
+    { key: "contradiction", label: t("compact.contradictions") },
+    { key: "budget", label: t("compact.budget") },
+    { key: "dead-rule", label: t("compact.deadRules") },
+    { key: "duplicate", label: t("compact.duplicates") },
+    { key: "stale-ref", label: t("compact.staleRefs") },
+    { key: "structure", label: t("compact.structure") }
+  ];
+  const rows = categories.map(({ key, label }) => {
+    const group = findings.filter((f) => f.category === key);
+    return {
+      label,
+      critical: group.filter((f) => f.severity === "critical").length,
+      warning: group.filter((f) => f.severity === "warning").length,
+      info: group.filter((f) => f.severity === "info").length
+    };
+  }).filter((r) => r.critical + r.warning + r.info > 0);
+  if (rows.length === 0) return;
+  output.log(sectionHeader(t("label.findings")));
+  for (const row of rows) {
+    const parts = [];
+    if (row.critical > 0) parts.push(chalk2.red(`\u2716 ${row.critical}`));
+    if (row.warning > 0) parts.push(chalk2.yellow(`\u26A0 ${row.warning}`));
+    if (row.info > 0) parts.push(chalk2.blue(`\u2139 ${row.info}`));
+    output.log(
+      `  ${chalk2.whiteBright(row.label.padEnd(18))}${parts.join("  ")}`
+    );
+  }
+}
+function printTopIssues(findings, output) {
+  if (findings.length === 0) return;
+  const sorted = [...findings].sort(
+    (a, b) => (SEVERITY_ORDER[a.severity] ?? 3) - (SEVERITY_ORDER[b.severity] ?? 3)
+  );
+  const top = sorted.slice(0, 5);
+  output.log("");
+  output.log(sectionHeader(t("label.topIssues")));
+  for (let i = 0; i < top.length; i++) {
+    const f = top[i];
+    const icon = f.severity === "critical" ? chalk2.red("\u2716") : f.severity === "warning" ? chalk2.yellow("\u26A0") : chalk2.blue("\u2139");
+    const msg = t(f.messageKey, f.messageParams);
+    const truncated = msg.length > 68 ? `${msg.slice(0, 68)}\u2026` : msg;
+    output.log(`  ${chalk2.white(`${i + 1}.`)} ${icon}  ${truncated}`);
+  }
+  if (sorted.length > 5) {
+    output.log(
+      chalk2.white(
+        `     ${t("compact.andMore", { count: String(sorted.length - 5) })}`
+      )
+    );
+  }
+}
+function printCombinedTerminal(report, output = console) {
+  const { project, tool, score, grade, tokenMethod } = report;
+  const border = "\u2500".repeat(BOX_W);
+  output.log("");
+  const B = chalk2.green;
+  output.log(B(`  \u256D${border}\u256E`));
+  const line1 = `  ${chalk2.bold.white("instrlint")}  ${B("\u2500")}  ${chalk2.cyan(project)}`;
+  output.log(`  ${B("\u2502")}${padR(line1, BOX_W)}${B("\u2502")}`);
+  const line2 = `  ${chalk2.white(tool)}  ${B("\xB7")}  ${chalk2.white(tokenMethod)}`;
+  output.log(`  ${B("\u2502")}${padR(line2, BOX_W)}${B("\u2502")}`);
+  output.log(B(`  \u251C${border}\u2524`));
+  const scoreLine = `  ${scoreBar(score, grade)}  ${chalk2.bold.white(String(score))}/100  ${gradeBadge(grade)}`;
+  output.log(`  ${B("\u2502")}${padR(scoreLine, BOX_W)}${B("\u2502")}`);
+  output.log(B(`  \u2570${border}\u256F`));
+  output.log("");
+  output.log(sectionHeader(t("label.budget")));
+  printCompactBudget(report.budget, output);
+  if (report.findings.length > 0) {
+    output.log("");
+    printFindingsTable(report.findings, output);
+    printTopIssues(report.findings, output);
+  }
+  output.log("");
+  if (report.findings.length === 0) {
+    output.log(chalk2.green(`  ${t("status.perfectScore")}`));
+  } else {
+    const criticals = report.findings.filter(
+      (f) => f.severity === "critical"
+    ).length;
+    const warnings = report.findings.filter(
+      (f) => f.severity === "warning"
+    ).length;
+    const infos = report.findings.filter((f) => f.severity === "info").length;
+    const parts = [];
+    if (criticals > 0)
+      parts.push(
+        chalk2.red(t("severity.critical", { count: String(criticals) }))
+      );
+    if (warnings > 0)
+      parts.push(
+        chalk2.yellow(
+          t("severity.warnings", {
+            count: String(warnings),
+            s: plural(warnings)
+          })
+        )
+      );
+    if (infos > 0)
+      parts.push(
+        chalk2.blue(
+          t("severity.suggestions", { count: String(infos), s: plural(infos) })
+        )
+      );
+    const summary = parts.join(chalk2.gray(" \xB7 "));
+    const summaryVisible = summary.replace(ANSI_RE, "");
+    const pad = Math.max(0, BOX_W - 2 - summaryVisible.length);
+    output.log(
+      chalk2.gray(`  \u2500\u2500`) + ` ${summary} ` + chalk2.gray("\u2500".repeat(pad))
+    );
+  }
+  output.log("");
+}
+function reportJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function mdSeverityIcon(f) {
+  if (f.severity === "critical") return "\u{1F534}";
+  if (f.severity === "warning") return "\u{1F7E1}";
+  return "\u2139\uFE0F";
+}
+function reportMarkdown(report, extraSections = []) {
+  const { project, tool, score, grade, findings } = report;
+  const criticals = findings.filter((f) => f.severity === "critical").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  const lines = [
+    `# ${t("markdown.title", { project })}`,
+    "",
+    t("markdown.scoreLine", { score: String(score), grade, tool }),
+    "",
+    t("markdown.summary"),
+    "",
+    `| ${t("markdown.severity")} | ${t("markdown.count")} |`,
+    "|----------|-------|",
+    `| ${t("markdown.critical")} | ${criticals} |`,
+    `| ${t("markdown.warning")} | ${warnings} |`,
+    `| ${t("markdown.info")} | ${infos} |`,
+    ""
+  ];
+  const categories = [
+    {
+      labelKey: "markdown.contradictions",
+      filter: (f) => f.category === "contradiction"
+    },
+    {
+      labelKey: "markdown.staleReferences",
+      filter: (f) => f.category === "stale-ref"
+    },
+    {
+      labelKey: "markdown.deadRules",
+      filter: (f) => f.category === "dead-rule"
+    },
+    {
+      labelKey: "markdown.duplicateRules",
+      filter: (f) => f.category === "duplicate"
+    },
+    {
+      labelKey: "markdown.budgetIssues",
+      filter: (f) => f.category === "budget"
+    },
+    {
+      labelKey: "markdown.refactoringOpportunities",
+      filter: (f) => f.category === "structure"
+    }
+  ];
+  for (const { labelKey, filter } of categories) {
+    const group = findings.filter(filter);
+    if (group.length === 0) continue;
+    lines.push(`## ${t(labelKey)}`, "");
+    for (const f of group) {
+      const loc = f.line != null ? ` ${t("markdown.lineRef", { line: String(f.line) })}` : "";
+      lines.push(
+        `- ${mdSeverityIcon(f)} ${t(f.messageKey, f.messageParams)}${loc}`
+      );
+    }
+    lines.push("");
+  }
+  if (report.actionPlan.length > 0) {
+    lines.push(t("markdown.actionPlan"), "");
+    for (let i = 0; i < Math.min(report.actionPlan.length, 10); i++) {
+      const item = report.actionPlan[i];
+      lines.push(`${i + 1}. ${item.description}`);
+    }
+    lines.push("");
+  }
+  if (extraSections.length > 0) {
+    lines.push(...extraSections);
+  }
+  lines.push("---", t("markdown.attribution"));
+  return lines.join("\n");
+}
+
+// src/fixers/line-remover.ts
+import { readFileSync as readFileSync6, writeFileSync } from "fs";
+function removeLines(findings, categories) {
+  const catSet = new Set(categories);
+  const fixable = findings.filter(
+    (f) => catSet.has(f.category) && f.autoFixable && f.line != null
+  );
+  const byFile = /* @__PURE__ */ new Map();
+  for (const f of fixable) {
+    const arr = byFile.get(f.file) ?? [];
+    arr.push(f.line);
+    byFile.set(f.file, arr);
+  }
+  let totalFixed = 0;
+  for (const [filePath, lineNumbers] of byFile) {
+    const uniqueSorted = [...new Set(lineNumbers)].sort((a, b) => b - a);
+    const content = readFileSync6(filePath, "utf8");
+    const lines = content.split("\n");
+    for (const lineNum of uniqueSorted) {
+      const idx = lineNum - 1;
+      if (idx >= 0 && idx < lines.length) {
+        lines.splice(idx, 1);
+      }
+    }
+    writeFileSync(filePath, lines.join("\n"));
+    totalFixed += uniqueSorted.length;
+  }
+  return totalFixed;
+}
+
+// src/fixers/remove-dead.ts
+function removeDeadRules(findings) {
+  return removeLines(findings, ["dead-rule"]);
+}
+
+// src/fixers/remove-stale.ts
+function removeStaleRefs(findings) {
+  return removeLines(findings, ["stale-ref"]);
+}
+
+// src/fixers/deduplicate.ts
+function deduplicateRules(findings) {
+  return removeLines(findings, ["duplicate"]);
+}
+
+// src/fixers/structure-suggestions.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { relative as relative2 } from "path";
+import chalk3 from "chalk";
+function readFileLine(filePath, lineNumber) {
+  try {
+    const content = readFileSync7(filePath, "utf8");
+    return content.split("\n")[lineNumber - 1]?.trim() ?? "";
+  } catch {
+    return "";
+  }
+}
+var PATH_DIR_RE = /\b(src|tests?|lib|dist)\//i;
+function extractPathDir(text) {
+  const m = PATH_DIR_RE.exec(text);
+  return m?.[1]?.toLowerCase();
+}
+function buildHookSnippet(ruleText) {
+  const comment = ruleText.length > 80 ? `${ruleText.slice(0, 80)}\u2026` : ruleText;
+  return JSON.stringify(
+    {
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: "Bash",
+            hooks: [
+              {
+                type: "command",
+                command: `# TODO: implement enforcement of:
+# ${comment}`
+              }
+            ]
+          }
+        ]
+      }
+    },
+    null,
+    2
+  );
+}
+function buildPathScopedFile(pathDir, ruleText) {
+  const filePath = `.claude/rules/${pathDir}.md`;
+  const content = `---
+globs:
+  - "${pathDir}/**"
+---
+
+${ruleText}
+`;
+  return { filePath, content };
+}
+function buildStructureSuggestions(findings) {
+  const suggestions = [];
+  for (const finding of findings) {
+    if (finding.category !== "structure") continue;
+    if (finding.messageKey !== "structure.scopeHook" && finding.messageKey !== "structure.scopePathScoped") {
+      continue;
+    }
+    const ruleText = finding.line != null && finding.line > 0 ? readFileLine(finding.file, finding.line) || (finding.messageParams?.snippet ?? "") : finding.messageParams?.snippet ?? "";
+    if (finding.messageKey === "structure.scopeHook") {
+      suggestions.push({ finding, ruleText, type: "hook" });
+    } else {
+      const pathDir = extractPathDir(ruleText) || extractPathDir(finding.messageParams?.snippet ?? "") || "src";
+      suggestions.push({ finding, ruleText, type: "path-scoped", pathDir });
+    }
+  }
+  return suggestions;
+}
+function terminalCodeBlock(code, output) {
+  const lines = code.split("\n");
+  output.log(chalk3.gray("  \u250C" + "\u2500".repeat(62)));
+  for (const line of lines) {
+    output.log(`  ${chalk3.gray("\u2502")} ${chalk3.white(line)}`);
+  }
+  output.log(chalk3.gray("  \u2514" + "\u2500".repeat(62)));
+}
+function printStructureSuggestions(suggestions, projectRoot, output) {
+  if (suggestions.length === 0) return;
+  output.log("");
+  output.log(chalk3.bold.white(`  ${t("fix.manualActions")}`));
+  output.log(chalk3.gray("  \u2500".repeat(30)));
+  for (const s of suggestions) {
+    const relFile = relative2(projectRoot, s.finding.file);
+    const lineNum = s.finding.line ?? 0;
+    output.log("");
+    output.log(
+      `  ${chalk3.blue("\u2139")}  ${chalk3.white(t(s.finding.messageKey, s.finding.messageParams))}`
+    );
+    output.log("");
+    if (s.type === "hook") {
+      output.log(`  ${chalk3.cyan(t("fix.hookCreate"))}`);
+      terminalCodeBlock(buildHookSnippet(s.ruleText), output);
+      output.log(`  ${chalk3.yellow(t("fix.hookWarning"))}`);
+      if (lineNum > 0) {
+        output.log(
+          `  ${chalk3.gray(t("fix.thenRemoveLine", { line: String(lineNum), file: relFile }))}`
+        );
+      }
+    } else {
+      const dir = s.pathDir ?? "src";
+      const { filePath, content } = buildPathScopedFile(dir, s.ruleText);
+      output.log(`  ${chalk3.cyan(t("fix.pathScopedCreate", { path: filePath }))}`);
+      terminalCodeBlock(content, output);
+      if (lineNum > 0) {
+        output.log(
+          `  ${chalk3.gray(t("fix.thenRemoveLine", { line: String(lineNum), file: relFile }))}`
+        );
+      }
+    }
+  }
+  output.log("");
+}
+function markdownStructureSuggestions(suggestions, projectRoot) {
+  if (suggestions.length === 0) return [];
+  const lines = [`## ${t("fix.manualActions")}`, ""];
+  for (const s of suggestions) {
+    const relFile = relative2(projectRoot, s.finding.file);
+    const lineNum = s.finding.line ?? 0;
+    const icon = s.finding.severity === "critical" ? "\u{1F534}" : s.finding.severity === "warning" ? "\u{1F7E1}" : "\u2139\uFE0F";
+    lines.push(
+      `### ${icon} ${t(s.finding.messageKey, s.finding.messageParams)}`,
+      ""
+    );
+    if (s.type === "hook") {
+      lines.push(t("fix.hookCreate"), "", "```json", buildHookSnippet(s.ruleText), "```", "");
+      lines.push(`> ${t("fix.hookWarning")}`, "");
+      if (lineNum > 0) {
+        lines.push(
+          `_${t("fix.thenRemoveLine", { line: String(lineNum), file: relFile })}_`,
+          ""
+        );
+      }
+    } else {
+      const dir = s.pathDir ?? "src";
+      const { filePath, content } = buildPathScopedFile(dir, s.ruleText);
+      lines.push(t("fix.pathScopedCreate", { path: filePath }), "");
+      lines.push("```markdown", content, "```", "");
+      if (lineNum > 0) {
+        lines.push(
+          `_${t("fix.thenRemoveLine", { line: String(lineNum), file: relFile })}_`,
+          ""
+        );
+      }
+    }
+  }
+  return lines;
+}
+
+// src/commands/run-command.ts
+function isGitClean(cwd) {
+  try {
+    const out = execSync("git status --porcelain", { cwd, encoding: "utf8" });
+    return out.trim().length === 0;
+  } catch {
+    return true;
+  }
+}
+async function runAll(opts, output = console) {
+  initLocale(opts.lang);
+  await ensureInitialized();
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const scan = scanProject(projectRoot, opts.tool);
+  if (scan.tool === "unknown") {
+    output.error(t("error.unknownTool"));
+    return { exitCode: 1, errorMessage: "unknown tool" };
+  }
+  if (scan.rootFilePath === null) {
+    output.error(t("error.missingRootFile", { tool: scan.tool }));
+    return { exitCode: 1, errorMessage: "missing root file" };
+  }
+  if (opts.fix && !opts.force && !isGitClean(projectRoot)) {
+    output.error(t("error.dirtyWorkingTree"));
+    return { exitCode: 1, errorMessage: "dirty working tree" };
+  }
+  const instructions = loadProject(projectRoot, scan.tool);
+  const { findings: budgetFindings, summary } = analyzeBudget(instructions);
+  const { findings: deadRuleFindings } = analyzeDeadRules(
+    instructions,
+    projectRoot
+  );
+  const { findings: structureFindings } = analyzeStructure(
+    instructions,
+    projectRoot
+  );
+  const allFindings = [
+    ...budgetFindings,
+    ...deadRuleFindings,
+    ...structureFindings
+  ];
+  const { score, grade } = calculateScore(allFindings, summary);
+  const actionPlan = buildActionPlan(allFindings);
+  const report = {
+    project: basename2(projectRoot),
+    tool: instructions.tool,
+    score,
+    grade,
+    locale: getLocale(),
+    tokenMethod: summary.tokenMethod,
+    findings: allFindings,
+    budget: summary,
+    actionPlan
+  };
+  if (opts.fix) {
+    const suggestions = buildStructureSuggestions(allFindings);
+    const deadFixed = removeDeadRules(allFindings);
+    const staleFixed = removeStaleRefs(allFindings);
+    const dupeFixed = deduplicateRules(allFindings);
+    const total = deadFixed + staleFixed + dupeFixed;
+    if (total === 0) {
+      output.log(chalk4.green(`  ${t("status.noAutoFixable")}`));
+    } else {
+      output.log("");
+      output.log(chalk4.bold.white(`  ${t("label.fixSummary")}`));
+      output.log(chalk4.gray("  \u2500".repeat(30)));
+      if (deadFixed > 0)
+        output.log(
+          `  ${chalk4.yellow("\u26A0")}  ${t("fix.removedDeadRules", { count: String(deadFixed), s: plural(deadFixed) })}`
+        );
+      if (staleFixed > 0)
+        output.log(
+          `  ${chalk4.yellow("\u26A0")}  ${t("fix.removedStaleRefs", { count: String(staleFixed), s: plural(staleFixed) })}`
+        );
+      if (dupeFixed > 0)
+        output.log(
+          `  ${chalk4.yellow("\u26A0")}  ${t("fix.removedDuplicates", { count: String(dupeFixed), s: plural(dupeFixed) })}`
+        );
+      output.log(chalk4.gray("  \u2500".repeat(30)));
+      output.log(
+        chalk4.green(
+          `  ${t("status.fixedIssues", { count: String(total), s: plural(total) })}`
+        )
+      );
+      output.log("");
+    }
+    printStructureSuggestions(suggestions, projectRoot, output);
+    return { exitCode: 0 };
+  }
+  if (opts.format === "json") {
+    output.log(reportJson(report));
+    return { exitCode: 0 };
+  }
+  if (opts.format === "markdown") {
+    const mdSuggestions = buildStructureSuggestions(allFindings);
+    const mdExtra = markdownStructureSuggestions(mdSuggestions, projectRoot);
+    output.log(reportMarkdown(report, mdExtra));
+    return { exitCode: 0 };
+  }
+  printCombinedTerminal(report, output);
+  return { exitCode: 0 };
+}
+
+// src/commands/deadrules-command.ts
+import chalk5 from "chalk";
+function printDeadRulesTerminal(findings, output = console) {
+  const overlaps = findings.filter((f) => f.category === "dead-rule");
+  const duplicates = findings.filter((f) => f.category === "duplicate");
+  output.log("");
+  output.log(chalk5.bold.white(`  ${t("label.deadRules")}`));
+  output.log(chalk5.gray("  \u2500".repeat(30)));
+  if (overlaps.length > 0) {
+    output.log(chalk5.bold(`  ${t("label.redundantByConfig")}`));
+    for (const f of overlaps) {
+      output.log(`  ${chalk5.yellow("\u26A0")}  ${t(f.messageKey, f.messageParams)}`);
+    }
+    output.log("");
+  }
+  if (duplicates.length > 0) {
+    output.log(chalk5.bold(`  ${t("label.duplicates")}`));
+    for (const f of duplicates) {
+      const icon = f.severity === "warning" ? chalk5.yellow("\u26A0") : chalk5.blue("\u2139");
+      output.log(`  ${icon}  ${t(f.messageKey, f.messageParams)}`);
+    }
+    output.log("");
+  }
+  output.log(chalk5.gray("  \u2500".repeat(30)));
+  if (findings.length === 0) {
+    output.log(chalk5.green(`  ${t("status.noDeadRules")}`));
+  } else {
+    const sep = getLocale() === "zh-TW" ? "\u3001" : ", ";
+    const parts = [];
+    if (overlaps.length > 0)
+      parts.push(
+        t("summary.redundantRules", {
+          count: String(overlaps.length),
+          s: plural(overlaps.length)
+        })
+      );
+    if (duplicates.length > 0)
+      parts.push(
+        t("summary.duplicates", {
+          count: String(duplicates.length),
+          s: plural(duplicates.length)
+        })
+      );
+    output.log(
+      chalk5.yellow(`  ${t("summary.found", { parts: parts.join(sep) })}`)
+    );
+  }
+  output.log("");
+}
+async function runDeadRules(opts, output = console) {
+  initLocale(opts.lang);
+  await ensureInitialized();
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const scan = scanProject(projectRoot, opts.tool);
+  if (scan.tool === "unknown") {
+    output.error(t("error.unknownTool"));
+    return { exitCode: 1, errorMessage: "unknown tool" };
+  }
+  if (scan.rootFilePath === null) {
+    output.error(t("error.missingRootFile", { tool: scan.tool }));
+    return { exitCode: 1, errorMessage: "missing root file" };
+  }
+  const instructions = loadProject(projectRoot, scan.tool);
+  const { findings } = analyzeDeadRules(instructions, projectRoot);
+  if (opts.format === "json") {
+    output.log(JSON.stringify({ findings }, null, 2));
+    return { exitCode: 0 };
+  }
+  printDeadRulesTerminal(findings, output);
+  return { exitCode: 0 };
+}
+
+// src/commands/structure-command.ts
+import chalk6 from "chalk";
+function printStructureTerminal(findings, output = console) {
+  const contradictions = findings.filter((f) => f.category === "contradiction");
+  const staleRefs = findings.filter((f) => f.category === "stale-ref");
+  const scoped = findings.filter((f) => f.category === "structure");
+  output.log("");
+  output.log(chalk6.bold.white(`  ${t("label.structure")}`));
+  output.log(chalk6.gray("  \u2500".repeat(30)));
+  if (contradictions.length > 0) {
+    output.log(chalk6.bold(`  ${t("label.contradictions")}`));
+    for (const f of contradictions) {
+      output.log(`  ${chalk6.red("\u2716")}  ${t(f.messageKey, f.messageParams)}`);
+    }
+    output.log("");
+  }
+  if (staleRefs.length > 0) {
+    output.log(chalk6.bold(`  ${t("label.staleReferences")}`));
+    for (const f of staleRefs) {
+      output.log(`  ${chalk6.yellow("\u26A0")}  ${t(f.messageKey, f.messageParams)}`);
+    }
+    output.log("");
+  }
+  if (scoped.length > 0) {
+    output.log(chalk6.bold(`  ${t("label.refactoringOpportunities")}`));
+    for (const f of scoped) {
+      output.log(`  ${chalk6.blue("\u2139")}  ${t(f.messageKey, f.messageParams)}`);
+    }
+    output.log("");
+  }
+  output.log(chalk6.gray("  \u2500".repeat(30)));
+  if (findings.length === 0) {
+    output.log(chalk6.green(`  ${t("status.noStructuralIssues")}`));
+  } else {
+    const sep = getLocale() === "zh-TW" ? "\u3001" : ", ";
+    const parts = [];
+    if (contradictions.length > 0)
+      parts.push(
+        t("summary.contradictions", {
+          count: String(contradictions.length),
+          s: plural(contradictions.length)
+        })
+      );
+    if (staleRefs.length > 0)
+      parts.push(
+        t("summary.staleRefs", {
+          count: String(staleRefs.length),
+          s: plural(staleRefs.length)
+        })
+      );
+    if (scoped.length > 0)
+      parts.push(
+        t("summary.refactoringSuggestions", {
+          count: String(scoped.length),
+          s: plural(scoped.length)
+        })
+      );
+    output.log(
+      chalk6.yellow(`  ${t("summary.found", { parts: parts.join(sep) })}`)
+    );
+  }
+  output.log("");
+}
+async function runStructure(opts, output = console) {
+  initLocale(opts.lang);
+  await ensureInitialized();
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const scan = scanProject(projectRoot, opts.tool);
+  if (scan.tool === "unknown") {
+    output.error(t("error.unknownTool"));
+    return { exitCode: 1, errorMessage: "unknown tool" };
+  }
+  if (scan.rootFilePath === null) {
+    output.error(t("error.missingRootFile", { tool: scan.tool }));
+    return { exitCode: 1, errorMessage: "missing root file" };
+  }
+  const instructions = loadProject(projectRoot, scan.tool);
+  const { findings } = analyzeStructure(instructions, projectRoot);
+  if (opts.format === "json") {
+    output.log(JSON.stringify({ findings }, null, 2));
+    return { exitCode: 0 };
+  }
+  printStructureTerminal(findings, output);
+  return { exitCode: 0 };
+}
+
+// src/commands/ci-command.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3 } from "path";
+
+// src/reporters/sarif.ts
+function severityToLevel(severity) {
+  if (severity === "critical") return "error";
+  if (severity === "warning") return "warning";
+  return "note";
+}
+function findingToRuleId(f) {
+  return `instrlint/${f.category}/${f.messageKey.replace(/\./g, "/")}`;
+}
+function buildRules(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const rules = [];
+  for (const f of findings) {
+    const id = findingToRuleId(f);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    rules.push({
+      id,
+      name: f.messageKey,
+      shortDescription: { text: `${f.category}: ${f.messageKey}` }
+    });
+  }
+  return rules;
+}
+function reportSarif(report) {
+  const rules = buildRules(report.findings);
+  const results = report.findings.map((f) => ({
+    ruleId: findingToRuleId(f),
+    level: severityToLevel(f.severity),
+    message: { text: f.suggestion },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: {
+            uri: f.file.replace(/\\/g, "/"),
+            uriBaseId: "%SRCROOT%"
+          },
+          ...f.line != null ? { region: { startLine: f.line } } : {}
+        }
+      }
+    ]
+  }));
+  const log = {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "instrlint",
+            version: "0.1.0",
+            informationUri: "https://github.com/jed1978/instrlint",
+            rules
+          }
+        },
+        results
+      }
+    ]
+  };
+  return JSON.stringify(log, null, 2);
+}
+
+// src/commands/ci-command.ts
+function shouldFail(findings, failOn) {
+  if (failOn === "info") return findings.length > 0;
+  if (failOn === "warning")
+    return findings.some(
+      (f) => f.severity === "critical" || f.severity === "warning"
+    );
+  return findings.some((f) => f.severity === "critical");
+}
+async function runCi(opts, output = console) {
+  initLocale(opts.lang);
+  await ensureInitialized();
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const failOn = opts.failOn ?? "critical";
+  const format = opts.format ?? "terminal";
+  const scan = scanProject(projectRoot, opts.tool);
+  if (scan.tool === "unknown") {
+    output.error(t("error.unknownTool"));
+    return { exitCode: 1, errorMessage: "unknown tool" };
+  }
+  if (scan.rootFilePath === null) {
+    output.error(t("error.missingRootFile", { tool: scan.tool }));
+    return { exitCode: 1, errorMessage: "missing root file" };
+  }
+  const instructions = loadProject(projectRoot, scan.tool);
+  const { findings: budgetFindings, summary } = analyzeBudget(instructions);
+  const { findings: deadRuleFindings } = analyzeDeadRules(
+    instructions,
+    projectRoot
+  );
+  const { findings: structureFindings } = analyzeStructure(
+    instructions,
+    projectRoot
+  );
+  const allFindings = [
+    ...budgetFindings,
+    ...deadRuleFindings,
+    ...structureFindings
+  ];
+  const { score, grade } = calculateScore(allFindings, summary);
+  const actionPlan = buildActionPlan(allFindings);
+  const report = {
+    project: basename3(projectRoot),
+    tool: instructions.tool,
+    score,
+    grade,
+    locale: getLocale(),
+    tokenMethod: summary.tokenMethod,
+    findings: allFindings,
+    budget: summary,
+    actionPlan
+  };
+  let formatted;
+  if (format === "sarif") {
+    formatted = reportSarif(report);
+  } else if (format === "json") {
+    formatted = reportJson(report);
+  } else if (format === "markdown") {
+    formatted = reportMarkdown(report);
+  } else {
+    formatted = reportJson(report);
+  }
+  if (opts.output != null) {
+    writeFileSync2(opts.output, formatted, "utf8");
+    const pass = !shouldFail(allFindings, failOn);
+    const statusKey = pass ? "ci.passed" : "ci.failed";
+    output.error(
+      `${t(statusKey, { score: String(score), grade })}  ${t("ci.writtenTo", { file: opts.output })}`
+    );
+  } else {
+    output.log(formatted);
+  }
+  const failed = shouldFail(allFindings, failOn);
+  return { exitCode: failed ? 1 : 0 };
+}
+
+// src/commands/init-ci-command.ts
+import { existsSync as existsSync7, mkdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+function githubWorkflow() {
+  return `name: instrlint
+
+on:
+  push:
+    paths:
+      - 'CLAUDE.md'
+      - '.claude/**'
+      - 'AGENTS.md'
+      - '.agents/**'
+      - '.cursorrules'
+      - '.cursor/**'
+  pull_request:
+    paths:
+      - 'CLAUDE.md'
+      - '.claude/**'
+      - 'AGENTS.md'
+      - '.agents/**'
+      - '.cursorrules'
+      - '.cursor/**'
+
+jobs:
+  instrlint:
+    name: Lint instruction files
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Run instrlint
+        run: npx instrlint@latest ci --fail-on warning --format sarif --output instrlint.sarif
+
+      - name: Upload SARIF
+        if: always()
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: instrlint.sarif
+          category: instrlint
+`;
+}
+function gitlabSnippet() {
+  return `# Add this to your .gitlab-ci.yml
+instrlint:
+  image: node:20
+  stage: test
+  rules:
+    - changes:
+        - CLAUDE.md
+        - .claude/**/*
+        - AGENTS.md
+        - .agents/**/*
+        - .cursorrules
+        - .cursor/**/*
+  script:
+    - npx instrlint@latest ci --fail-on warning --format json
+  allow_failure: false
+`;
+}
+function runInitCi(opts, output = console) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  if (opts.github) {
+    const workflowDir = join7(projectRoot, ".github", "workflows");
+    const workflowPath = join7(workflowDir, "instrlint.yml");
+    if (existsSync7(workflowPath) && !opts.force) {
+      output.error(t("initCi.alreadyExists", { path: workflowPath }));
+      return { exitCode: 1, errorMessage: "file already exists" };
+    }
+    mkdirSync(workflowDir, { recursive: true });
+    writeFileSync3(workflowPath, githubWorkflow(), "utf8");
+    output.log(t("initCi.created", { path: workflowPath }));
+    return { exitCode: 0 };
+  }
+  if (opts.gitlab) {
+    output.log(gitlabSnippet());
+    return { exitCode: 0 };
+  }
+  output.error("init-ci: specify --github or --gitlab");
+  return { exitCode: 1, errorMessage: "no target specified" };
+}
+
+// src/commands/install-command.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+function resolveSkillFile(target) {
+  const thisFile = fileURLToPath(import.meta.url);
+  const packageRoot = join8(thisFile, "..", "..", "..");
+  const skillPath = join8(
+    packageRoot,
+    "skills",
+    target === "claude-code" ? "claude-code" : "codex",
+    "SKILL.md"
+  );
+  return skillPath;
+}
+function readSkillContent(target) {
+  const skillPath = resolveSkillFile(target);
+  try {
+    return readFileSync8(skillPath, "utf8");
+  } catch {
+    throw new Error(
+      `Could not read skill file at ${skillPath}. Make sure the package is properly installed.`
+    );
+  }
+}
+function installClaudeCode(content, projectRoot, isProject, force, output) {
+  const targetDir = isProject ? join8(projectRoot, ".claude", "skills", "instrlint") : join8(homedir(), ".claude", "skills", "instrlint");
+  const targetPath = join8(targetDir, "SKILL.md");
+  if (existsSync8(targetPath) && !force) {
+    output.error(t("install.alreadyExists", { path: targetPath }));
+    return { exitCode: 1, errorMessage: "file already exists" };
+  }
+  mkdirSync2(targetDir, { recursive: true });
+  writeFileSync4(targetPath, content, "utf8");
+  output.log(t("install.installed", { path: targetPath }));
+  return { exitCode: 0 };
+}
+function installCodex(content, projectRoot, force, output) {
+  const targetDir = join8(projectRoot, ".agents", "skills", "instrlint");
+  const targetPath = join8(targetDir, "SKILL.md");
+  if (existsSync8(targetPath) && !force) {
+    output.error(t("install.alreadyExists", { path: targetPath }));
+    return { exitCode: 1, errorMessage: "file already exists" };
+  }
+  mkdirSync2(targetDir, { recursive: true });
+  writeFileSync4(targetPath, content, "utf8");
+  output.log(t("install.installed", { path: targetPath }));
+  return { exitCode: 0 };
+}
+function runInstall(opts, output = console) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const force = opts.force ?? false;
+  if (opts.claudeCode) {
+    let content;
+    try {
+      content = readSkillContent("claude-code");
+    } catch (err) {
+      output.error(String(err));
+      return { exitCode: 1, errorMessage: String(err) };
+    }
+    return installClaudeCode(
+      content,
+      projectRoot,
+      opts.project ?? false,
+      force,
+      output
+    );
+  }
+  if (opts.codex) {
+    let content;
+    try {
+      content = readSkillContent("codex");
+    } catch (err) {
+      output.error(String(err));
+      return { exitCode: 1, errorMessage: String(err) };
+    }
+    return installCodex(content, projectRoot, force, output);
+  }
+  output.error(t("install.unknownTarget"));
+  return { exitCode: 1, errorMessage: "no target specified" };
+}
+
+// src/cli.ts
+var program = new Command();
+program.enablePositionalOptions().name("instrlint").description(
+  "Lint and optimize your CLAUDE.md / AGENTS.md \u2014 find dead rules, token waste, and structural issues"
+).version("0.1.0").option(
+  "--format <type>",
+  "output format (terminal|json|markdown)",
+  "terminal"
+).option("--lang <locale>", "output language (en|zh-TW)", "en").option("--tool <name>", "force tool detection (claude-code|codex|cursor)").option("--fix", "auto-fix safe issues (dead rules, stale refs, dupes)").option("--force", "skip git clean check when using --fix").action(async function() {
+  const opts = this.opts();
+  const result = await runAll(opts);
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("budget").description("Token budget analysis only").option(
+  "--format <type>",
+  "output format (terminal|json|markdown)",
+  "terminal"
+).option("--tool <name>", "force tool detection (claude-code|codex|cursor)").action(async function() {
+  const opts = this.opts();
+  const lang = this.parent?.opts()?.lang;
+  const result = await runBudget({
+    ...opts,
+    ...lang !== void 0 && { lang }
+  });
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("deadrules").description("Dead rule detection only").option("--format <type>", "output format (terminal|json)", "terminal").option("--tool <name>", "force tool detection (claude-code|codex|cursor)").action(async function() {
+  const opts = this.opts();
+  const lang = this.parent?.opts()?.lang;
+  const result = await runDeadRules({
+    ...opts,
+    ...lang !== void 0 && { lang }
+  });
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("structure").description("Structural analysis only").option("--format <type>", "output format (terminal|json)", "terminal").option("--tool <name>", "force tool detection (claude-code|codex|cursor)").action(async function() {
+  const opts = this.opts();
+  const lang = this.parent?.opts()?.lang;
+  const result = await runStructure({
+    ...opts,
+    ...lang !== void 0 && { lang }
+  });
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("ci").description(
+  "CI mode: run full analysis and exit 1 if findings exceed threshold"
+).option(
+  "--fail-on <level>",
+  "failure threshold (critical|warning|info)",
+  "critical"
+).option("--format <type>", "output format (json|markdown|sarif)", "json").option("--output <file>", "write output to file instead of stdout").option("--tool <name>", "force tool detection (claude-code|codex|cursor)").action(async function() {
+  const opts = this.opts();
+  const lang = this.parent?.opts()?.lang;
+  initLocale(lang);
+  const result = await runCi({
+    failOn: opts.failOn,
+    format: opts.format,
+    ...opts.output !== void 0 && { output: opts.output },
+    ...opts.tool !== void 0 && { tool: opts.tool },
+    ...lang !== void 0 && { lang }
+  });
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("init-ci").description("Generate CI configuration for instrlint").option("--github", "Generate GitHub Actions workflow").option("--gitlab", "Generate GitLab CI snippet (prints to stdout)").option("--force", "overwrite existing files").action(function() {
+  const opts = this.opts();
+  const result = runInitCi(opts);
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.command("install").description("Install instrlint as a skill").option("--claude-code", "Install as Claude Code skill").option("--codex", "Install as Codex skill").option("--project", "Install into current project (instead of global)").option("--force", "overwrite existing skill file").action(function() {
+  const opts = this.opts();
+  const result = runInstall(opts);
+  if (result.exitCode !== 0) process.exit(result.exitCode);
+});
+program.parse();
+//# sourceMappingURL=cli.js.map