uidex 0.2.0 → 0.2.4

package/dist/scripts/cli.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,23 +29,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-
-// scripts/init.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var readline = __toESM(require("readline"), 1);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // scripts/cli-utils.ts
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  red: "\x1B[31m"
-};
+var cli_utils_exports = {};
+__export(cli_utils_exports, {
+  colors: () => colors,
+  error: () => error,
+  formatDate: () => formatDate,
+  formatError: () => formatError,
+  heading: () => heading,
+  info: () => info,
+  pad: () => pad,
+  parseFlags: () => parseFlags,
+  success: () => success,
+  truncate: () => truncate,
+  warn: () => warn
+});
 function success(message) {
   console.log(`${colors.green}\u2713${colors.reset} ${message}`);
 }
@@ -56,202 +63,125 @@ function heading(message) {
 ${colors.bold}${colors.cyan}${message}${colors.reset}
 `);
 }
-
-// scripts/init.ts
-function log(message) {
-  console.log(message);
-}
-function detectProject() {
-  const cwd = process.cwd();
-  const packageJsonPath = path.join(cwd, "package.json");
-  let packageJson = {};
-  if (fs.existsSync(packageJsonPath)) {
-    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-  }
-  const deps = {
-    ...packageJson.dependencies,
-    ...packageJson.devDependencies
-  };
-  const name = packageJson.name || path.basename(cwd);
-  const usesTypeScript = fs.existsSync(path.join(cwd, "tsconfig.json")) || !!deps["typescript"];
-  const hasSrcDir = fs.existsSync(path.join(cwd, "src"));
-  const srcDir = hasSrcDir ? "src" : ".";
-  if (deps["next"]) {
-    const usesAppRouter = fs.existsSync(path.join(cwd, "src", "app")) || fs.existsSync(path.join(cwd, "app"));
-    return {
-      type: "nextjs",
-      name,
-      srcDir,
-      usesTypeScript,
-      usesAppRouter
-    };
-  }
-  if (deps["vite"] || fs.existsSync(path.join(cwd, "vite.config.ts")) || fs.existsSync(path.join(cwd, "vite.config.js"))) {
-    return {
-      type: "vite",
-      name,
-      srcDir,
-      usesTypeScript,
-      usesAppRouter: false
-    };
-  }
-  if (deps["react-scripts"]) {
-    return {
-      type: "cra",
-      name,
-      srcDir,
-      usesTypeScript,
-      usesAppRouter: false
-    };
+function parseFlags(args2) {
+  const flags = {};
+  for (const arg of args2) {
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (eq !== -1) {
+        flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+      }
+    }
   }
-  return {
-    type: "unknown",
-    name,
-    srcDir,
-    usesTypeScript,
-    usesAppRouter: false
-  };
+  return flags;
 }
-function createConfigContent(project) {
-  const config = {
-    $schema: "node_modules/uidex/uidex.schema.json",
-    defaults: {
-      color: "#3b82f6",
-      borderStyle: "solid",
-      borderWidth: 2,
-      showLabel: true,
-      labelPosition: "top-left"
-    },
-    colors: {
-      primary: "#3b82f6",
-      secondary: "#8b5cf6",
-      success: "#10b981",
-      warning: "#f59e0b",
-      error: "#ef4444",
-      info: "#0ea5e9"
-    },
-    scanner: {
-      rootDir: project.srcDir,
-      include: ["**/*.tsx", "**/*.jsx"],
-      exclude: ["**/*.test.*", "**/*.spec.*", "**/*.gen.ts"],
-      outputPath: `${project.srcDir}/uidex.gen.ts`
-    }
-  };
-  return JSON.stringify(config, null, 2);
+function truncate(str, len) {
+  if (str.length <= len) return str;
+  return str.slice(0, len - 1) + "\u2026";
 }
-function addToGitignore(entry) {
-  const cwd = process.cwd();
-  const gitignorePath = path.join(cwd, ".gitignore");
-  let content = "";
-  if (fs.existsSync(gitignorePath)) {
-    content = fs.readFileSync(gitignorePath, "utf-8");
-  }
-  const lines = content.split("\n");
-  if (lines.some((line) => line.trim() === entry)) {
-    return false;
-  }
-  const newContent = content.endsWith("\n") || content === "" ? `${content}${entry}
-` : `${content}
-${entry}
-`;
-  fs.writeFileSync(gitignorePath, newContent, "utf-8");
-  return true;
+function pad(str, len) {
+  return str.padEnd(len).slice(0, len);
 }
-function createPrompt() {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+function formatDate(dateStr) {
+  const d = new Date(dateStr);
+  return d.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
   });
 }
-async function askYesNo(rl, question, defaultYes = true) {
-  const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve4) => {
-    rl.question(`${question} ${colors.dim}${hint}${colors.reset} `, (answer) => {
-      const normalized = answer.trim().toLowerCase();
-      if (normalized === "") {
-        resolve4(defaultYes);
-      } else {
-        resolve4(normalized === "y" || normalized === "yes");
-      }
-    });
-  });
+function formatError(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-function getEntryPointHint(project) {
-  if (project.type === "nextjs") {
-    if (project.usesAppRouter) {
-      return project.srcDir === "src" ? "src/app/layout.tsx" : "app/layout.tsx";
-    }
-    return project.srcDir === "src" ? "src/pages/_app.tsx" : "pages/_app.tsx";
+var colors;
+var init_cli_utils = __esm({
+  "scripts/cli-utils.ts"() {
+    "use strict";
+    colors = {
+      reset: "\x1B[0m",
+      bold: "\x1B[1m",
+      dim: "\x1B[2m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      cyan: "\x1B[36m",
+      red: "\x1B[31m"
+    };
   }
-  return project.srcDir === "src" ? "src/main.tsx" : "main.tsx";
-}
-async function init() {
-  heading("uidex init");
-  const cwd = process.cwd();
-  const configPath = path.join(cwd, ".uidex.json");
-  if (fs.existsSync(configPath)) {
-    warn(".uidex.json already exists");
-    const rl = createPrompt();
-    const overwrite = await askYesNo(rl, "Overwrite existing config?", false);
-    rl.close();
-    if (!overwrite) {
-      info("Keeping existing configuration");
-      return;
+});
+
+// scripts/config-discovery.ts
+function discoverConfigs(from) {
+  const startDir = from ?? process.cwd();
+  const results = [];
+  const queue = [[startDir, 0]];
+  while (queue.length > 0) {
+    const [dir, depth] = queue.shift();
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const childDir = path2.join(dir, entry.name);
+      const candidatePath = path2.join(childDir, CONFIG_FILENAME);
+      if (fs2.existsSync(candidatePath)) {
+        results.push({
+          configPath: candidatePath,
+          configDir: childDir
+        });
+        continue;
+      }
+      if (depth + 1 < MAX_DEPTH) {
+        queue.push([childDir, depth + 1]);
+      }
     }
   }
-  const project = detectProject();
-  log(`Detected project: ${colors.bold}${project.name}${colors.reset}`);
-  log(`Project type: ${colors.bold}${project.type}${colors.reset}`);
-  log(
-    `Language: ${colors.bold}${project.usesTypeScript ? "TypeScript" : "JavaScript"}${colors.reset}`
-  );
-  if (project.type === "nextjs") {
-    log(
-      `Router: ${colors.bold}${project.usesAppRouter ? "App Router" : "Pages Router"}${colors.reset}`
-    );
+  return results.sort((a, b) => a.configPath.localeCompare(b.configPath));
+}
+function resolveConfigs(from) {
+  const startDir = from ?? process.cwd();
+  if (cachedResult && cachedResult.from === startDir) {
+    return cachedResult.configs;
   }
-  heading("Creating configuration");
-  const configContent = createConfigContent(project);
-  fs.writeFileSync(configPath, configContent, "utf-8");
-  success("Created .uidex.json");
-  const genFile = "*.gen.ts";
-  if (addToGitignore(genFile)) {
-    success(`Added ${genFile} to .gitignore`);
+  const localConfig = path2.join(startDir, CONFIG_FILENAME);
+  let configs;
+  if (fs2.existsSync(localConfig)) {
+    configs = [{
+      configPath: localConfig,
+      configDir: startDir
+    }];
   } else {
-    info(`${genFile} already in .gitignore`);
+    configs = discoverConfigs(startDir);
   }
-  heading("Next steps");
-  const entryPoint = getEntryPointHint(project);
-  log("1. Add data-uidex attributes to elements you want to track:");
-  log("");
-  log(`   ${colors.green}<button${colors.reset} data-uidex="submit-btn"${colors.green}>${colors.reset}Submit${colors.green}</button>${colors.reset}`);
-  log("");
-  log("2. Run the scanner to generate the components registry:");
-  log("");
-  log(`   ${colors.yellow}npx uidex-scan${colors.reset}`);
-  log("");
-  log("3. Import the generated file in your entry point:");
-  log("");
-  log(`   ${colors.dim}// ${entryPoint}${colors.reset}`);
-  log(`   ${colors.cyan}import${colors.reset} './${project.srcDir === "src" ? "" : "src/"}uidex.gen';`);
-  log("");
-  log("4. Add the UidexDevtools component anywhere in your app:");
-  log("");
-  log(`   ${colors.cyan}import${colors.reset} { UidexDevtools } ${colors.cyan}from${colors.reset} 'uidex';`);
-  log("");
-  log(`   ${colors.green}<UidexDevtools />${colors.reset}`);
-  log("");
-  success("Setup complete!");
-  log("");
+  cachedResult = { from: startDir, configs };
+  return configs;
 }
-
-// scripts/scan.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
+var fs2, path2, SKIP_DIRS, CONFIG_FILENAME, MAX_DEPTH, cachedResult;
+var init_config_discovery = __esm({
+  "scripts/config-discovery.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"), 1);
+    path2 = __toESM(require("path"), 1);
+    SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "dist",
+      ".next",
+      "build",
+      ".workshop",
+      ".workshop-archive"
+    ]);
+    CONFIG_FILENAME = ".uidex.json";
+    MAX_DEPTH = 4;
+    cachedResult = null;
+  }
+});
 
 // scripts/scanner-utils.ts
-var UIDEX_PAGE_FILENAME = "UIDEX_PAGE.md";
-var UIDEX_FEATURE_FILENAME = "UIDEX_FEATURE.md";
 function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
   if (!match) {
@@ -264,6 +194,18 @@ function parseFrontmatter(content) {
   let inComponents = false;
   const components = [];
   for (const line of lines) {
+    const rootMatch = line.match(/^root:\s+(.+)$/);
+    if (rootMatch) {
+      frontmatter.root = rootMatch[1].trim();
+      inComponents = false;
+      continue;
+    }
+    const descMatch = line.match(/^description:\s+(.+)$/);
+    if (descMatch) {
+      frontmatter.description = descMatch[1].trim();
+      inComponents = false;
+      continue;
+    }
     if (/^components:\s*$/.test(line.trimEnd())) {
       inComponents = true;
       continue;
@@ -356,31 +298,75 @@ function parseAcceptanceCriteria(content) {
     }
     if (inAcceptance) {
       if (/^##\s+/.test(line)) break;
-      const match = line.match(/^-\s+(.+)$/);
+      const match = line.match(/^-\s+(?:\[[ x]\]\s*)?(.+)$/);
       if (match) criteria.push(match[1].trim());
     }
   }
   return criteria;
 }
+function normalizeAcceptanceCriteria(content) {
+  const lines = content.split("\n");
+  let inAcceptance = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^##\s+Acceptance/.test(lines[i])) {
+      inAcceptance = true;
+      continue;
+    }
+    if (inAcceptance) {
+      if (/^##\s+/.test(lines[i])) {
+        inAcceptance = false;
+        continue;
+      }
+      if (/^-\s+\[[ x]\]/.test(lines[i])) continue;
+      const match = lines[i].match(/^-\s+(.+)$/);
+      if (match) {
+        lines[i] = `- [ ] ${match[1]}`;
+      }
+    }
+  }
+  return lines.join("\n");
+}
 function parseMarkdownTitle(content) {
   const match = content.match(/^#\s+(.+)$/m);
   return match ? match[1].trim() : null;
 }
+function parseBlockquoteDescription(content) {
+  const lines = content.split("\n");
+  let pastTitle = false;
+  const descLines = [];
+  for (const line of lines) {
+    if (!pastTitle) {
+      if (/^#\s+/.test(line)) pastTitle = true;
+      continue;
+    }
+    if (descLines.length === 0 && line.trim() === "") continue;
+    if (line.startsWith("> ")) {
+      descLines.push(line.slice(2));
+    } else if (line === ">") {
+      descLines.push("");
+    } else {
+      break;
+    }
+  }
+  return descLines.length > 0 ? descLines.join(" ").trim() : null;
+}
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function extractComponents(content) {
   const results = [];
   const jsDocBlocks = extractJSDocBlocks(content);
-  const regex = /data-uidex\s*=\s*(?:"([^"]+)"|'([^']+)'|\{["'`]([^"'`]+)["'`]\})/g;
+  const componentRegex = /data-uidex(?!-block)(?!-primitive)\s*=\s*(?:"([^"]+)"|'([^']+)'|\{["'`]([^"'`]+)["'`]\})/g;
+  const blockRegex = /data-uidex-block\s*=\s*(?:"([^"]+)"|'([^']+)'|\{["'`]([^"'`]+)["'`]\})/g;
+  const primitiveRegex = /data-uidex-primitive\s*=\s*(?:"([^"]+)"|'([^']+)'|\{["'`]([^"'`]+)["'`]\})/g;
   const lines = content.split("\n");
   lines.forEach((line, index) => {
+    const lineNumber = index + 1;
     let match;
-    regex.lastIndex = 0;
-    while ((match = regex.exec(line)) !== null) {
+    componentRegex.lastIndex = 0;
+    while ((match = componentRegex.exec(line)) !== null) {
       const id = match[1] || match[2] || match[3];
       if (id) {
-        const lineNumber = index + 1;
         const matchingBlocks = jsDocBlocks.filter(
           (block) => block.id === id && block.endLine <= lineNumber && lineNumber - block.endLine <= 5
         );
@@ -390,72 +376,830 @@ function extractComponents(content) {
         results.push({
           id,
           line: lineNumber,
+          kind: "component",
           ...matchingBlock?.description ? { doc: matchingBlock.description } : {}
         });
       }
     }
+    blockRegex.lastIndex = 0;
+    while ((match = blockRegex.exec(line)) !== null) {
+      const id = match[1] || match[2] || match[3];
+      if (id) {
+        results.push({
+          id,
+          line: lineNumber,
+          kind: "block"
+        });
+      }
+    }
+    primitiveRegex.lastIndex = 0;
+    while ((match = primitiveRegex.exec(line)) !== null) {
+      const id = match[1] || match[2] || match[3];
+      if (id) {
+        results.push({
+          id,
+          line: lineNumber,
+          kind: "primitive"
+        });
+      }
+    }
   });
   return results;
 }
-
-// scripts/scan.ts
-var DEFAULT_SOURCE = {
-  rootDir: "src",
-  include: ["**/*.tsx", "**/*.jsx"]
-};
-var DEFAULT_CONFIG = {
-  sources: [DEFAULT_SOURCE],
-  exclude: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**", "**/*.gen.ts"],
-  outputPath: "src/uidex.gen.ts"
-};
-function loadConfig() {
-  const configPath = path2.resolve(process.cwd(), ".uidex.json");
-  if (!fs2.existsSync(configPath)) {
-    console.log("No .uidex.json found, using defaults");
-    return DEFAULT_CONFIG;
+var UIDEX_PAGE_FILENAME, UIDEX_FEATURE_FILENAME;
+var init_scanner_utils = __esm({
+  "scripts/scanner-utils.ts"() {
+    "use strict";
+    UIDEX_PAGE_FILENAME = "UIDEX_PAGE.md";
+    UIDEX_FEATURE_FILENAME = "UIDEX_FEATURE.md";
   }
-  try {
-    const content = fs2.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(content);
-    if (!config.scanner) {
-      console.log("No scanner config in .uidex.json, using defaults");
-      return DEFAULT_CONFIG;
+});
+
+// scripts/primitives.ts
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function resolvePrimitiveScope(filePath, sourceRoot) {
+  const absFile = path3.resolve(sourceRoot, filePath);
+  let dir = path3.dirname(absFile);
+  const absRoot = path3.resolve(sourceRoot);
+  while (dir.length >= absRoot.length) {
+    if (fs3.existsSync(path3.join(dir, UIDEX_FEATURE_FILENAME))) {
+      return `feature:${path3.basename(dir)}`;
     }
-    const scanner = config.scanner;
-    return {
-      sources: scanner.sources?.length ? scanner.sources.map((source) => ({
-        rootDir: source.rootDir,
-        include: source.include,
-        exclude: source.exclude,
-        prefix: source.prefix
-      })) : DEFAULT_CONFIG.sources,
-      exclude: scanner.exclude ?? DEFAULT_CONFIG.exclude,
-      outputPath: scanner.outputPath ?? DEFAULT_CONFIG.outputPath
-    };
-  } catch (error2) {
-    console.error("Error reading .uidex.json:", error2);
-    return DEFAULT_CONFIG;
+    if (fs3.existsSync(path3.join(dir, UIDEX_PAGE_FILENAME))) {
+      return `page:${path3.basename(dir)}`;
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
+  return "global";
 }
-function globToRegex(glob) {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}/g, ".*");
-  return new RegExp(`^${escaped}$`);
+function buildPrimitivesFromAnnotations(extracted) {
+  return extracted.map((p) => ({
+    name: p.name,
+    filePath: p.outputPath,
+    absolutePath: p.absolutePath,
+    line: p.line,
+    scope: resolvePrimitiveScope(p.relativePath, p.rootDir),
+    composes: [],
+    usedBy: [],
+    kind: "primitive"
+  }));
 }
-function compilePatterns(patterns) {
-  return patterns.map(globToRegex);
+var fs3, path3;
+var init_primitives = __esm({
+  "scripts/primitives.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"), 1);
+    path3 = __toESM(require("path"), 1);
+    init_scanner_utils();
+  }
+});
+
+// scripts/provenance.ts
+function extractImports(content) {
+  const specifiers = [];
+  const re = /import\s+(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    specifiers.push(m[1]);
+  }
+  return specifiers;
 }
-function matchesPatterns(filePath, patterns) {
-  const normalizedPath = filePath.replace(/\\/g, "/");
-  return patterns.some((regex) => regex.test(normalizedPath));
+function resolveAlias(specifier, tsconfigPaths, absoluteBaseUrl) {
+  for (const [pattern, mappings] of Object.entries(tsconfigPaths)) {
+    const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "(.*)");
+    const re = new RegExp(`^${escaped}$`);
+    const match = specifier.match(re);
+    if (match) {
+      for (const mapping of mappings) {
+        const resolved = mapping.replace("*", match[1] ?? "");
+        return path4.resolve(absoluteBaseUrl, resolved);
+      }
+    }
+  }
+  return null;
 }
-function walkDir(dir, baseDir = dir) {
-  const result = { files: [], pageDocs: /* @__PURE__ */ new Map(), featureDocs: /* @__PURE__ */ new Map() };
-  if (!fs2.existsSync(dir)) {
-    return result;
+function resolveSpecifier(specifier, fromAbsolutePath, tsconfigPaths, absoluteBaseUrl) {
+  let resolved = null;
+  if (specifier.startsWith(".")) {
+    const fromDir = path4.dirname(fromAbsolutePath);
+    resolved = path4.resolve(fromDir, specifier);
+  } else if (tsconfigPaths && absoluteBaseUrl) {
+    const aliased = resolveAlias(specifier, tsconfigPaths, absoluteBaseUrl);
+    if (aliased) {
+      resolved = aliased;
+    }
   }
-  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  if (!resolved) return null;
+  const extensions = [".tsx", ".ts", ".jsx", ".js"];
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    if (fs4.existsSync(candidate)) {
+      return toPosix(candidate);
+    }
+  }
+  if (fs4.existsSync(resolved)) {
+    return toPosix(resolved);
+  }
+  return null;
+}
+function buildPrimitiveIndex(primitives) {
+  const index = /* @__PURE__ */ new Map();
+  for (const p of primitives) {
+    const existing = index.get(p.absolutePath);
+    if (existing) {
+      existing.push(p);
+    } else {
+      index.set(p.absolutePath, [p]);
+    }
+  }
+  return index;
+}
+function computeProvenance(files, primitives, tsconfigPaths, absoluteBaseUrl) {
+  const primitiveIndex = buildPrimitiveIndex(primitives);
+  const fileScopeSets = /* @__PURE__ */ new Map();
+  const usedByMap = /* @__PURE__ */ new Map();
+  const composesMap = /* @__PURE__ */ new Map();
+  let provenanceLinks = 0;
+  for (const file of files) {
+    const imports = extractImports(file.content);
+    const fileScopes = /* @__PURE__ */ new Set();
+    for (const specifier of imports) {
+      const resolved = resolveSpecifier(
+        specifier,
+        file.absolutePath,
+        tsconfigPaths,
+        absoluteBaseUrl
+      );
+      if (!resolved) continue;
+      const matchedPrimitives = primitiveIndex.get(resolved);
+      if (!matchedPrimitives) continue;
+      provenanceLinks++;
+      for (const prim of matchedPrimitives) {
+        fileScopes.add(prim.scope);
+        const consumerPrimitives = primitiveIndex.get(file.absolutePath);
+        if (consumerPrimitives) {
+          for (const consumerPrim of consumerPrimitives) {
+            if (consumerPrim.absolutePath !== prim.absolutePath) {
+              let composes = composesMap.get(consumerPrim.absolutePath);
+              if (!composes) {
+                composes = /* @__PURE__ */ new Set();
+                composesMap.set(consumerPrim.absolutePath, composes);
+              }
+              composes.add(prim.filePath);
+            }
+          }
+        } else {
+          const isInScope = isFileInScope(file.outputPath, prim.scope);
+          if (prim.scope === "global" || isInScope) {
+            let usedBy = usedByMap.get(prim.absolutePath);
+            if (!usedBy) {
+              usedBy = /* @__PURE__ */ new Set();
+              usedByMap.set(prim.absolutePath, usedBy);
+            }
+            usedBy.add(file.outputPath);
+          }
+        }
+      }
+    }
+    if (fileScopes.size > 0) {
+      fileScopeSets.set(file.outputPath, fileScopes);
+    }
+  }
+  const updatedPrimitives = primitives.map((p) => ({
+    ...p,
+    composes: [...composesMap.get(p.absolutePath) ?? []].sort(),
+    usedBy: [...usedByMap.get(p.absolutePath) ?? []].sort()
+  }));
+  return { primitives: updatedPrimitives, fileScopeSets, provenanceLinks };
+}
+function isFileInScope(filePath, scope) {
+  if (scope === "global") return true;
+  const colonIdx = scope.indexOf(":");
+  if (colonIdx === -1) return false;
+  const scopeName = scope.substring(colonIdx + 1);
+  const segments = filePath.split("/");
+  return segments.includes(scopeName);
+}
+function stripJsonComments(input) {
+  let out = "";
+  let inString = false;
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    const next = input[i + 1];
+    if (inString) {
+      if (ch === "\\" && next !== void 0) {
+        out += ch + next;
+        i += 2;
+        continue;
+      }
+      if (ch === '"') inString = false;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      while (i < input.length && input[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < input.length - 1 && !(input[i] === "*" && input[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function loadTsconfigPaths(configDir) {
+  let dir = path4.resolve(configDir);
+  let tsconfigPath = null;
+  while (true) {
+    const candidate = path4.join(dir, "tsconfig.json");
+    if (fs4.existsSync(candidate)) {
+      tsconfigPath = candidate;
+      break;
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!tsconfigPath) return {};
+  try {
+    const content = fs4.readFileSync(tsconfigPath, "utf-8");
+    const stripped = stripJsonComments(content);
+    const parsed = JSON.parse(stripped);
+    const paths = parsed.compilerOptions?.paths;
+    const baseUrl = parsed.compilerOptions?.baseUrl ?? ".";
+    const absoluteBaseUrl = toPosix(
+      path4.resolve(path4.dirname(tsconfigPath), baseUrl)
+    );
+    return { paths, absoluteBaseUrl };
+  } catch {
+    return {};
+  }
+}
+var fs4, path4;
+var init_provenance = __esm({
+  "scripts/provenance.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"), 1);
+    path4 = __toESM(require("path"), 1);
+    init_primitives();
+  }
+});
+
+// scripts/scope-leak.ts
+function checkScopeLeaks(files, primitives, tsconfigPaths, absoluteBaseUrl) {
+  if (primitives.length === 0) {
+    return { errors: [], barrelWarning: false };
+  }
+  const primitiveIndex = buildPrimitiveIndex(primitives);
+  const errors = [];
+  let anyProvenanceLinks = false;
+  for (const file of files) {
+    const content = fs5.readFileSync(file.fullPath, "utf-8");
+    const lines = content.split("\n");
+    const imports = extractImports(content);
+    for (const specifier of imports) {
+      const resolved = resolveSpecifier(
+        specifier,
+        file.absolutePath,
+        tsconfigPaths,
+        absoluteBaseUrl
+      );
+      if (!resolved) continue;
+      const matched = primitiveIndex.get(resolved);
+      if (!matched) continue;
+      anyProvenanceLinks = true;
+      for (const prim of matched) {
+        if (prim.scope === "global") continue;
+        if (!isFileInScope(file.outputPath, prim.scope)) {
+          const importLine = lines.findIndex(
+            (l) => l.includes(specifier) && /import\s/.test(l)
+          );
+          errors.push({
+            consumer: file.outputPath,
+            line: importLine >= 0 ? importLine + 1 : 1,
+            primitiveName: prim.name,
+            primitiveScope: prim.scope,
+            category: "scope-leak"
+          });
+        }
+      }
+    }
+  }
+  const barrelWarning = primitives.length > 0 && !anyProvenanceLinks;
+  return { errors, barrelWarning };
+}
+function runScopeLeakCheck(configDir, files, primitives) {
+  const tsconfig = loadTsconfigPaths(configDir);
+  const scopeLeakFiles = files.map((f) => ({
+    absolutePath: toPosix(f.fullPath),
+    outputPath: f.outputPath,
+    fullPath: f.fullPath
+  }));
+  return checkScopeLeaks(
+    scopeLeakFiles,
+    primitives,
+    tsconfig.paths,
+    tsconfig.absoluteBaseUrl
+  );
+}
+function printScopeLeakReport(result) {
+  if (result.errors.length > 0) {
+    console.error(`
+Scope-leak violations (${result.errors.length}):`);
+    for (const err of result.errors) {
+      console.error(
+        `  ${err.consumer}:${err.line}: "${err.primitiveName}" belongs to ${err.primitiveScope}, not accessible from this file`
+      );
+    }
+    console.error("");
+  }
+  if (result.barrelWarning) {
+    console.warn(
+      "\nNote: primitives detected but zero provenance links found. If you import primitives"
+    );
+    console.warn(
+      "  through barrel exports (index.ts), import directly for scope tracking to work."
+    );
+    console.warn("");
+  }
+}
+var fs5;
+var init_scope_leak = __esm({
+  "scripts/scope-leak.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"), 1);
+    init_provenance();
+    init_primitives();
+  }
+});
+
+// scripts/lint.ts
+var lint_exports = {};
+__export(lint_exports, {
+  isNonVisual: () => isNonVisual,
+  isPresentational: () => isPresentational,
+  lintFile: () => lintFile,
+  printLintJson: () => printLintJson,
+  printLintReport: () => printLintReport,
+  runLint: () => runLint
+});
+function hasAnnotation(lines, lineIndex, attr) {
+  const start = Math.max(0, lineIndex - 3);
+  const end = Math.min(lines.length, lineIndex + 10);
+  const window = lines.slice(start, end).join("\n");
+  if (attr === "data-uidex") {
+    return /data-uidex(?!-block)/.test(window);
+  }
+  return window.includes(attr);
+}
+function extractTextContent(line) {
+  const match = line.match(/>([^<]+)</);
+  return match ? match[1].trim() || null : null;
+}
+function getSurroundingCode(lines, lineIndex) {
+  const start = Math.max(0, lineIndex - 2);
+  const end = Math.min(lines.length, lineIndex + 3);
+  return lines.slice(start, end).join("\n");
+}
+function extractComponentName(content) {
+  const match = content.match(
+    /export\s+(?:default\s+)?function\s+([A-Z]\w*)/
+  );
+  return match ? match[1] : null;
+}
+function extractJsxTags(content) {
+  JSX_TAG_RE.lastIndex = 0;
+  const tags = [];
+  let match;
+  while ((match = JSX_TAG_RE.exec(content)) !== null) {
+    tags.push(match[1]);
+  }
+  return tags;
+}
+function isNonVisual(filePath, content) {
+  JSX_TAG_RE.lastIndex = 0;
+  if (!JSX_TAG_RE.test(content)) {
+    return { skip: true, reason: "no JSX elements" };
+  }
+  if (content.includes("createContext(") || content.includes("createContext<")) {
+    const tags = extractJsxTags(content);
+    if (tags.every((tag) => PROVIDER_TAG_RE.test(tag))) {
+      return { skip: true, reason: "context provider" };
+    }
+  }
+  if (CHILDREN_ONLY_RE.test(content)) {
+    const tags = extractJsxTags(content);
+    if (tags.length <= 1) {
+      return { skip: true, reason: "children-only wrapper" };
+    }
+  }
+  if (!content.includes("data-uidex")) {
+    const basename4 = path5.basename(filePath);
+    const tags = extractJsxTags(content);
+    const hasHtmlElements = tags.some((tag) => HTML_ELEMENT_RE.test(tag));
+    if (HOOK_FILE_RE.test(basename4) && !hasHtmlElements) {
+      return { skip: true, reason: "hook filename" };
+    }
+    if (CONTEXT_PROVIDER_FILE_RE.test(basename4) && !hasHtmlElements) {
+      return { skip: true, reason: "context/provider filename" };
+    }
+  }
+  return { skip: false };
+}
+function isPresentational(filePath, content) {
+  if (PAGE_FILE_RE.test(filePath)) return false;
+  const componentName = content.match(
+    /export\s+(?:default\s+)?function\s+([A-Z]\w*)/
+  );
+  if (!componentName) return false;
+  if (DATA_HOOK_RE.test(content)) return false;
+  if (FETCH_CALL_RE.test(content)) return false;
+  if (SERVER_ACTION_RE.test(content)) return false;
+  const tags = extractJsxTags(content);
+  const htmlTags = tags.filter((t) => HTML_ELEMENT_RE.test(t));
+  if (htmlTags.length === 0) return false;
+  const composedTags = tags.filter((t) => !HTML_ELEMENT_RE.test(t));
+  const UTILITY_TAG_RE = /^(Slot|Fragment|Spinner|Icon\w*|Svg\w*|Suspense|ErrorBoundary)$/;
+  const appLevelTags = composedTags.filter((t) => !UTILITY_TAG_RE.test(t));
+  if (appLevelTags.length > htmlTags.length) return false;
+  const hasPassthrough = CHILDREN_PROP_RE.test(content) || CLASSNAME_PROP_RE.test(content) || SPREAD_PROPS_RE.test(content);
+  if (!hasPassthrough) return false;
+  return true;
+}
+function buildElementRegex(elements) {
+  const escaped = elements.map(escapeRegex);
+  return new RegExp(`<(${escaped.join("|")})(?:\\s|>|\\/|$)`, "g");
+}
+function toKebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function lintFile(filePath, content, lintConfig) {
+  const componentName = extractComponentName(content);
+  if (PRIMITIVE_ATTR_RE.test(content)) {
+    return {
+      file: filePath,
+      componentName,
+      hasRootBlock: false,
+      existingIds: [],
+      violations: [],
+      skipped: true,
+      skipReason: "primitive definition"
+    };
+  }
+  if (isPresentational(filePath, content)) {
+    const kebab = toKebab(componentName ?? path5.basename(filePath, path5.extname(filePath)));
+    return {
+      file: filePath,
+      componentName,
+      hasRootBlock: false,
+      existingIds: [],
+      violations: [{
+        line: 1,
+        tier: "root",
+        element: "root",
+        textContent: null,
+        surroundingCode: content.split("\n").slice(0, 5).join("\n"),
+        suggestedType: "data-uidex-primitive"
+      }],
+      suggestPrimitive: true
+    };
+  }
+  const autoSkip = isNonVisual(filePath, content);
+  if (autoSkip.skip) {
+    return {
+      file: filePath,
+      componentName,
+      hasRootBlock: false,
+      existingIds: [],
+      violations: [],
+      skipped: true,
+      skipReason: autoSkip.reason
+    };
+  }
+  const existingIds = extractComponents(content).map((r) => r.id);
+  const lines = content.split("\n");
+  const violations = [];
+  const hasRootBlock = content.includes("data-uidex-block");
+  if (!hasRootBlock) {
+    violations.push({
+      line: 1,
+      tier: "root",
+      element: "root",
+      textContent: null,
+      surroundingCode: getSurroundingCode(lines, 0),
+      suggestedType: "data-uidex-block"
+    });
+  }
+  const regionRegex = buildElementRegex(lintConfig.regionElements);
+  for (let i = 0; i < lines.length; i++) {
+    regionRegex.lastIndex = 0;
+    let match;
+    while ((match = regionRegex.exec(lines[i])) !== null) {
+      if (!hasAnnotation(lines, i, "data-uidex-block")) {
+        violations.push({
+          line: i + 1,
+          tier: "region",
+          element: match[1],
+          textContent: extractTextContent(lines[i]),
+          surroundingCode: getSurroundingCode(lines, i),
+          suggestedType: "data-uidex-block"
+        });
+      }
+    }
+  }
+  const interactiveRegex = buildElementRegex(
+    lintConfig.interactiveElements
+  );
+  const tagViolationLines = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    interactiveRegex.lastIndex = 0;
+    let match;
+    while ((match = interactiveRegex.exec(lines[i])) !== null) {
+      if (!hasAnnotation(lines, i, "data-uidex")) {
+        tagViolationLines.add(i);
+        violations.push({
+          line: i + 1,
+          tier: "interactive",
+          element: match[1],
+          textContent: extractTextContent(lines[i]),
+          surroundingCode: getSurroundingCode(lines, i),
+          suggestedType: "data-uidex"
+        });
+      }
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (tagViolationLines.has(i)) continue;
+    ROLE_REGEX.lastIndex = 0;
+    let match;
+    while ((match = ROLE_REGEX.exec(lines[i])) !== null) {
+      if (!hasAnnotation(lines, i, "data-uidex")) {
+        violations.push({
+          line: i + 1,
+          tier: "interactive",
+          element: `role="${match[1]}"`,
+          textContent: extractTextContent(lines[i]),
+          surroundingCode: getSurroundingCode(lines, i),
+          suggestedType: "data-uidex"
+        });
+      }
+    }
+  }
+  const presentational = violations.length > 0 && isPresentational(filePath, content);
+  if (presentational) {
+    for (const v of violations) {
+      v.suggestedType = "data-uidex-primitive";
+    }
+  }
+  return {
+    file: filePath,
+    componentName,
+    hasRootBlock,
+    existingIds,
+    violations,
+    ...presentational ? { suggestPrimitive: true } : {}
+  };
+}
+function runLint(configDir, options) {
+  const scannerConfig = loadConfig({ silent: true, configDir });
+  const lintConfig = loadLintConfig(configDir);
+  const verbose = options?.verbose ?? false;
+  const skipRegexes = compilePatterns(lintConfig.skipPaths);
+  const allFiles = [];
+  for (const source of scannerConfig.sources) {
+    const sourceResult = findFilesForSource(source, scannerConfig.exclude, scannerConfig.configDir);
+    for (const file of sourceResult.files) {
+      allFiles.push({
+        outputPath: file.outputPath,
+        fullPath: file.fullPath
+      });
+    }
+  }
+  const results = [];
+  const skippedFiles = [];
+  for (const file of allFiles) {
+    if (matchesPatterns(file.outputPath, skipRegexes)) {
+      if (verbose) {
+        const idx = skipRegexes.findIndex((re) => re.test(file.outputPath));
+        skippedFiles.push({
+          file: file.outputPath,
+          reason: `skip path: ${lintConfig.skipPaths[idx] ?? "unknown"}`
+        });
+      }
+      continue;
+    }
+    const content = fs6.readFileSync(file.fullPath, "utf-8");
+    const result = lintFile(file.outputPath, content, lintConfig);
+    if (result.skipped) {
+      if (verbose) {
+        skippedFiles.push({
+          file: file.outputPath,
+          reason: result.skipReason ?? "unknown"
+        });
+      }
+      continue;
+    }
+    if (result.violations.length > 0) {
+      results.push(result);
+    }
+  }
+  const stats = {
+    totalFiles: allFiles.length,
+    filesWithViolations: results.length,
+    totalViolations: results.reduce(
+      (sum, r) => sum + r.violations.length,
+      0
+    ),
+    byTier: {
+      root: results.reduce(
+        (sum, r) => sum + r.violations.filter((v) => v.tier === "root").length,
+        0
+      ),
+      region: results.reduce(
+        (sum, r) => sum + r.violations.filter((v) => v.tier === "region").length,
+        0
+      ),
+      interactive: results.reduce(
+        (sum, r) => sum + r.violations.filter((v) => v.tier === "interactive").length,
+        0
+      )
+    }
+  };
+  if (verbose) {
+    stats.autoSkipped = skippedFiles.length;
+  }
+  return {
+    files: results,
+    stats,
+    ...verbose ? { skipped: skippedFiles } : {}
+  };
+}
+function printLintReport(result) {
+  if (result.stats.totalViolations === 0) {
+    success(
+      `All ${result.stats.totalFiles} files pass lint checks`
+    );
+  } else {
+    console.error("");
+    warn(
+      `Found ${result.stats.totalViolations} missing annotations in ${result.stats.filesWithViolations} files`
+    );
+    console.error("");
+    for (const file of result.files) {
+      const name = file.componentName ? `${file.file} (${file.componentName})` : file.file;
+      info(name);
+      if (file.suggestPrimitive) {
+        console.error(`    \u2192 presentational component \u2014 add data-uidex-primitive="${toKebab(file.componentName ?? path5.basename(file.file, path5.extname(file.file)))}" to root element`);
+      }
+      for (const v of file.violations) {
+        const label = v.tier === "root" ? "missing root data-uidex-block" : v.tier === "region" ? `<${v.element}> missing data-uidex-block` : v.element.startsWith("role=") ? `${v.element} missing data-uidex` : `<${v.element}>${v.textContent ? v.textContent : ""}${v.textContent ? `</${v.element}>` : ""} missing data-uidex`;
+        console.error(`    line ${v.line}: ${label} (suggest: ${v.suggestedType})`);
+      }
+      console.error("");
+    }
+    console.error(
+      `  Breakdown: ${result.stats.byTier.root} root, ${result.stats.byTier.region} region, ${result.stats.byTier.interactive} interactive`
+    );
+    console.error("");
+  }
+  if (result.skipped && result.skipped.length > 0) {
+    console.error("  Auto-skipped files:");
+    for (const s of result.skipped) {
+      console.error(`    ${s.file} (${s.reason})`);
+    }
+    console.error("");
+  }
+}
+function printLintJson(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+var fs6, path5, PRIMITIVE_ATTR_RE, JSX_TAG_RE, PROVIDER_TAG_RE, CHILDREN_ONLY_RE, HOOK_FILE_RE, CONTEXT_PROVIDER_FILE_RE, HTML_ELEMENT_RE, DATA_HOOK_RE, FETCH_CALL_RE, SERVER_ACTION_RE, PAGE_FILE_RE, SPREAD_PROPS_RE, CHILDREN_PROP_RE, CLASSNAME_PROP_RE, ROLE_REGEX;
+var init_lint = __esm({
+  "scripts/lint.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"), 1);
+    path5 = __toESM(require("path"), 1);
+    init_scan();
+    init_scanner_utils();
+    init_cli_utils();
+    PRIMITIVE_ATTR_RE = /data-uidex-primitive\s*=/;
+    JSX_TAG_RE = /(?:^|[^a-zA-Z0-9_])<([A-Z][a-zA-Z0-9.]*|[a-z][a-z0-9]*)[\s>\/]/gm;
+    PROVIDER_TAG_RE = /^([A-Z][a-zA-Z0-9]*\.Provider|[A-Z][a-zA-Z0-9]*Provider)$/;
+    CHILDREN_ONLY_RE = /return\s*\(?\s*<(\w[\w.]*)(?:\s[^>]*)?>[\s\n]*\{children\}[\s\n]*<\/\1>\s*\)?/;
+    HOOK_FILE_RE = /^use[A-Z].*\.[jt]sx$/;
+    CONTEXT_PROVIDER_FILE_RE = /context|provider/i;
+    HTML_ELEMENT_RE = /^[a-z]/;
+    DATA_HOOK_RE = /\b(useQuery|useMutation|useSuspenseQuery|useInfiniteQuery|useSWR|useSWRMutation)\s*[<(]/;
+    FETCH_CALL_RE = /\bfetch\s*\(/;
+    SERVER_ACTION_RE = /\buse server\b/;
+    PAGE_FILE_RE = /(?:^|[\\/])(?:page|layout|template|loading|error|not-found)\.[jt]sx?$/;
+    SPREAD_PROPS_RE = /\.\.\.\s*(?:props|rest)\b/;
+    CHILDREN_PROP_RE = /\bchildren\b/;
+    CLASSNAME_PROP_RE = /\bclassName\b/;
+    ROLE_REGEX = /role=["'](button|link|tab)["']/g;
+  }
+});
+
+// scripts/scan.ts
+function readConfigFile(configDir) {
+  const configPath = path6.resolve(configDir ?? process.cwd(), CONFIG_FILENAME);
+  try {
+    return JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function loadConfig(options) {
+  const dir = options?.configDir ?? process.cwd();
+  const raw = readConfigFile(dir);
+  const log2 = options?.silent ? () => {
+  } : console.log.bind(console);
+  if (!raw) {
+    log2("No .uidex.json found, using defaults");
+    return { ...DEFAULT_CONFIG, configDir: dir };
+  }
+  if (!raw.scanner) {
+    log2("No scanner config in .uidex.json, using defaults");
+    return { ...DEFAULT_CONFIG, configDir: dir };
+  }
+  const scanner = raw.scanner;
+  let sources;
+  if (scanner.sources?.length) {
+    sources = scanner.sources.map((source) => ({
+      rootDir: source.rootDir,
+      include: source.include,
+      exclude: source.exclude,
+      prefix: source.prefix
+    }));
+  } else if (scanner.rootDir) {
+    sources = [{
+      rootDir: scanner.rootDir,
+      include: scanner.include ?? ["**/*.tsx", "**/*.jsx"]
+    }];
+  } else {
+    sources = DEFAULT_CONFIG.sources;
+  }
+  return {
+    sources,
+    exclude: scanner.exclude ?? DEFAULT_CONFIG.exclude,
+    outputPath: scanner.outputPath ?? DEFAULT_CONFIG.outputPath,
+    configDir: dir
+  };
+}
+function loadLintConfig(configDir) {
+  const raw = readConfigFile(configDir);
+  if (!raw?.lint) {
+    return DEFAULT_LINT_CONFIG;
+  }
+  const useDefaults = raw.lint.skipPathDefaults !== false;
+  const userPaths = raw.lint.skipPaths ?? [];
+  const skipPaths = useDefaults ? [...DEFAULT_SKIP_PATHS, ...userPaths] : userPaths;
+  return {
+    interactiveElements: raw.lint.interactiveElements ?? DEFAULT_LINT_CONFIG.interactiveElements,
+    regionElements: raw.lint.regionElements ?? DEFAULT_LINT_CONFIG.regionElements,
+    skipPaths,
+    skipPathDefaults: useDefaults
+  };
+}
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/{{GLOBSTAR}}\//g, "(?:.*/)?").replace(/{{GLOBSTAR}}/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function compilePatterns(patterns) {
+  return patterns.map(globToRegex);
+}
+function matchesPatterns(filePath, patterns) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return patterns.some((regex) => regex.test(normalizedPath));
+}
+function parentDir(filePath) {
+  const i = filePath.lastIndexOf("/");
+  return i === -1 ? "." : filePath.substring(0, i);
+}
+function walkDir(dir, baseDir = dir) {
+  const result = { files: [], pageDocs: /* @__PURE__ */ new Map(), featureDocs: /* @__PURE__ */ new Map(), routeDirs: /* @__PURE__ */ new Set() };
+  if (!fs7.existsSync(dir)) {
+    return result;
+  }
+  const entries = fs7.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules") continue;
       const sub = walkDir(fullPath, baseDir);
@@ -466,25 +1210,31 @@ function walkDir(dir, baseDir = dir) {
       for (const [k, v] of sub.featureDocs) {
         result.featureDocs.set(k, v);
       }
+      for (const d of sub.routeDirs) {
+        result.routeDirs.add(d);
+      }
     } else if (entry.isFile()) {
+      const relativeDir = path6.relative(baseDir, dir).replace(/\\/g, "/") || ".";
       if (entry.name === UIDEX_PAGE_FILENAME || entry.name === UIDEX_FEATURE_FILENAME) {
-        const relativeDir = path2.relative(baseDir, dir).replace(/\\/g, "/") || ".";
-        const content = fs2.readFileSync(fullPath, "utf-8");
+        const content = fs7.readFileSync(fullPath, "utf-8");
         if (entry.name === UIDEX_PAGE_FILENAME) {
           result.pageDocs.set(relativeDir, content);
         } else {
           result.featureDocs.set(relativeDir, content);
         }
       } else {
-        const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = path6.relative(baseDir, fullPath).replace(/\\/g, "/");
         result.files.push(relativePath);
+        if (/^page\.[tjm]sx?$/.test(entry.name)) {
+          result.routeDirs.add(relativeDir);
+        }
       }
     }
   }
   return result;
 }
-function findFilesForSource(source, globalExclude) {
-  const rootDir = path2.resolve(process.cwd(), source.rootDir);
+function findFilesForSource(source, globalExclude, configDir = process.cwd()) {
+  const rootDir = path6.resolve(configDir, source.rootDir);
   const walkResult = walkDir(rootDir);
   const includeRegexes = compilePatterns(source.include);
   const excludeRegexes = compilePatterns([...globalExclude, ...source.exclude ?? []]);
@@ -496,7 +1246,7 @@ function findFilesForSource(source, globalExclude) {
     const outputPath = source.prefix ? `${source.prefix}/${relativePath}` : relativePath;
     return {
       relativePath,
-      fullPath: path2.join(rootDir, relativePath),
+      fullPath: path6.join(rootDir, relativePath),
       outputPath
     };
   });
@@ -508,10 +1258,21 @@ function findFilesForSource(source, globalExclude) {
     }
     return result;
   }
+  const scannedDirs = new Set(files.map((f) => parentDir(f.relativePath)));
+  const routeDirs = /* @__PURE__ */ new Set();
+  for (const dir of walkResult.routeDirs) {
+    const hasScannedFiles = [...scannedDirs].some(
+      (sDir) => sDir === dir || sDir.startsWith(dir + "/")
+    );
+    if (hasScannedFiles) {
+      routeDirs.add(source.prefix ? `${source.prefix}/${dir}` : dir);
+    }
+  }
   return {
     files,
     pageDocs: applyPrefix(walkResult.pageDocs),
-    featureDocs: applyPrefix(walkResult.featureDocs)
+    featureDocs: applyPrefix(walkResult.featureDocs),
+    routeDirs
   };
 }
 function buildPages(docs, sourceComponentIds, sourceRootDir) {
@@ -523,7 +1284,7 @@ function buildPages(docs, sourceComponentIds, sourceRootDir) {
   }
   for (const [id, filePaths] of sourceComponentIds) {
     for (const filePath of filePaths) {
-      const fileDir = filePath.includes("/") ? filePath.substring(0, filePath.lastIndexOf("/")) : ".";
+      const fileDir = parentDir(filePath);
       const nearestDir = docDirs.find(
         (dir) => dir === "." || fileDir === dir || fileDir.startsWith(dir + "/")
       );
@@ -534,24 +1295,111 @@ function buildPages(docs, sourceComponentIds, sourceRootDir) {
   }
   return docDirs.map((dir) => {
     const fullDir = dir === "." ? sourceRootDir : `${sourceRootDir}/${dir}`;
+    const doc = docs.get(dir);
+    const ids = pageComponentSets.get(dir);
+    for (const id of doc.explicitComponents) {
+      ids.add(id);
+    }
     return {
       dir: fullDir,
-      content: docs.get(dir),
-      componentIds: [...pageComponentSets.get(dir)].sort()
+      content: doc.body,
+      componentIds: [...ids].sort(),
+      ...doc.rootId ? { rootId: doc.rootId } : {},
+      ...doc.description ? { description: doc.description } : {}
     };
   });
 }
-function buildFeatures(featureDocs, sourceRootDir) {
-  const features = [];
-  for (const [dir, { body, explicitComponents }] of featureDocs) {
+function buildFeatures(featureDocs, sourceComponentIds, sourceRootDir) {
+  if (featureDocs.size === 0) return [];
+  const docDirs = [...featureDocs.keys()].sort((a, b) => b.length - a.length);
+  const featureComponentSets = /* @__PURE__ */ new Map();
+  for (const dir of docDirs) {
+    featureComponentSets.set(dir, /* @__PURE__ */ new Set());
+  }
+  for (const [id, filePaths] of sourceComponentIds) {
+    for (const filePath of filePaths) {
+      const fileDir = parentDir(filePath);
+      const nearestDir = docDirs.find(
+        (dir) => dir === "." || fileDir === dir || fileDir.startsWith(dir + "/")
+      );
+      if (nearestDir) {
+        featureComponentSets.get(nearestDir).add(id);
+      }
+    }
+  }
+  return docDirs.map((dir) => {
     const fullDir = dir === "." ? sourceRootDir : `${sourceRootDir}/${dir}`;
-    features.push({
+    const doc = featureDocs.get(dir);
+    const ids = featureComponentSets.get(dir);
+    for (const id of doc.explicitComponents) {
+      ids.add(id);
+    }
+    return {
       dir: fullDir,
-      content: body,
-      componentIds: [...explicitComponents].sort()
-    });
+      content: doc.body,
+      componentIds: [...ids].sort(),
+      ...doc.description ? { description: doc.description } : {}
+    };
+  });
+}
+function detectGitContext() {
+  const branchEnvVars = [
+    "GITHUB_HEAD_REF",
+    "GITHUB_REF_NAME",
+    "VERCEL_GIT_COMMIT_REF",
+    "CF_PAGES_BRANCH",
+    "RAILWAY_GIT_BRANCH",
+    "NETLIFY_BRANCH",
+    "CI_COMMIT_BRANCH",
+    "CIRCLE_BRANCH",
+    "BITBUCKET_BRANCH"
+  ];
+  let branch;
+  for (const envVar of branchEnvVars) {
+    const val = process.env[envVar];
+    if (val) {
+      branch = val;
+      break;
+    }
+  }
+  const commitEnvVars = [
+    "GITHUB_SHA",
+    "VERCEL_GIT_COMMIT_SHA",
+    "CF_PAGES_COMMIT_SHA",
+    "RAILWAY_GIT_COMMIT_SHA",
+    "COMMIT_REF",
+    "CI_COMMIT_SHA",
+    "CIRCLE_SHA1",
+    "BITBUCKET_COMMIT"
+  ];
+  let commit;
+  for (const envVar of commitEnvVars) {
+    const val = process.env[envVar];
+    if (val) {
+      commit = val;
+      break;
+    }
   }
-  return features;
+  if (!branch) {
+    try {
+      branch = (0, import_child_process.execSync)("git rev-parse --abbrev-ref HEAD", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      if (branch === "HEAD") branch = void 0;
+    } catch {
+    }
+  }
+  if (!commit) {
+    try {
+      commit = (0, import_child_process.execSync)("git rev-parse HEAD", {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+    }
+  }
+  return { branch, commit };
 }
 function generateTestOutput(components, pages, features) {
   const sortedIds = Object.keys(components).sort();
@@ -568,7 +1416,8 @@ export type Route = typeof routes[keyof typeof routes];
 export const pages = [
 ${pageRoutes.map((p) => {
     const ids = p.componentIds.map((id) => `"${id}"`).join(", ");
-    return `  { dir: "${p.dir}", route: "${p.route}", componentIds: [${ids}] as const }`;
+    const rootPart = p.rootId ? `, rootId: "${p.rootId}"` : "";
+    return `  { dir: "${p.dir}", route: "${p.route}", componentIds: [${ids}] as const${rootPart} }`;
   }).join(",\n")}
 ] as const;
 ` : "";
@@ -588,15 +1437,23 @@ export const componentIds = [${idsArrayStr}] as const;
 export type ComponentId = typeof componentIds[number];
 ${routesStr}${pagesStr}${featuresStr}`;
 }
-function generateOutput(components, pages, features) {
+function generateOutput(components, pages, features, gitContext, uiComponents) {
   const sortedIds = Object.keys(components).sort();
   const entriesStr = sortedIds.map((id) => {
     const locations = components[id].map((loc) => {
-      const parts = [`filePath: "${loc.filePath}"`, `line: ${loc.line}`];
+      const parts = [
+        `filePath: "${loc.filePath}"`,
+        `line: ${loc.line}`,
+        `kind: "${loc.kind}"`
+      ];
       if (loc.doc) {
         const escapedDoc = loc.doc.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
         parts.push(`doc: "${escapedDoc}"`);
       }
+      if (loc.scopes && loc.scopes.length > 0) {
+        const scopesList = loc.scopes.map((s) => `"${s}"`).join(", ");
+        parts.push(`scopes: [${scopesList}]`);
+      }
       return `{ ${parts.join(", ")} }`;
     }).join(", ");
     return `  "${id}": [${locations}]`;
@@ -606,7 +1463,9 @@ function generateOutput(components, pages, features) {
     return entries.map((entry) => {
       const escaped = entry.content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
       const ids = entry.componentIds.map((id) => `"${id}"`).join(", ");
-      return `  { dir: "${entry.dir}", content: \`${escaped}\`, componentIds: [${ids}] }`;
+      const rootPart = entry.rootId ? `, rootId: "${entry.rootId}"` : "";
+      const descPart = entry.description ? `, description: "${entry.description.replace(/"/g, '\\"')}"` : "";
+      return `  { dir: "${entry.dir}", content: \`${escaped}\`, componentIds: [${ids}]${rootPart}${descPart} }`;
     }).join(",\n");
   }
   const pagesStr = pages.length > 0 ? `
@@ -621,60 +1480,115 @@ ${serializeDocEntries(features)}
 ` : "";
   const hasPages = pages.length > 0;
   const hasFeatures = features.length > 0;
+  const hasGitContext = gitContext?.branch != null;
+  const hasUiComponents = (uiComponents ?? []).length > 0;
+  const uiComponentsStr = hasUiComponents ? `
+export const uiComponents = [
+${(uiComponents ?? []).sort((a, b) => a.filePath.localeCompare(b.filePath)).map((p) => {
+    const composesStr = p.composes.map((c) => `"${c}"`).join(", ");
+    const usedByStr = p.usedBy.map((u) => `"${u}"`).join(", ");
+    return `  { name: "${p.name}", filePath: "${p.filePath}", scope: "${p.scope}", composes: [${composesStr}], usedBy: [${usedByStr}], kind: "primitive" as const }`;
+  }).join(",\n")}
+];
+` : "";
   const importParts = ["registerComponents"];
   if (hasPages) importParts.push("registerPages");
   if (hasFeatures) importParts.push("registerFeatures");
-  const imports = `import { ${importParts.join(", ")} } from 'uidex';`;
+  if (hasGitContext) importParts.push("registerGitContext");
+  importParts.push("createUidexDevtools");
+  const typeParts = ["UidexMap"];
+  if (hasUiComponents) typeParts.push("PrimitiveEntry");
+  const imports = `import { ${importParts.join(", ")} } from 'uidex';
+import type { ${typeParts.join(", ")} } from 'uidex';`;
   const regParts = ["registerComponents(components);"];
   if (hasPages) regParts.push("registerPages(pages);");
   if (hasFeatures) regParts.push("registerFeatures(features);");
+  if (hasGitContext) {
+    const commitPart = gitContext.commit ? `, commit: "${gitContext.commit}"` : "";
+    regParts.push(`registerGitContext({ branch: "${gitContext.branch}"${commitPart} });`);
+  }
   const registrations = `// Auto-register
 ${regParts.join("\n")}
 `;
-  return `// Auto-generated by uidex scanner
+  const factoryArgs = ["components"];
+  if (hasPages) factoryArgs.push("pages");
+  if (hasFeatures) factoryArgs.push("features");
+  if (hasUiComponents) factoryArgs.push("uiComponents");
+  const defaultExport = `export default createUidexDevtools({ ${factoryArgs.join(", ")} });
+`;
+  return `"use client";
+// Auto-generated by uidex scanner
 // Do not edit this file manually
 
 ${imports}
 
 export const components = {
 ${entriesStr}
-};
+} satisfies UidexMap;
 
 export const componentIds = [${idsArrayStr}] as const;
 
 export type ComponentId = typeof componentIds[number];
-${pagesStr}${featuresStr}
-${registrations}`;
+${pagesStr}${featuresStr}${uiComponentsStr}
+${registrations}
+${defaultExport}`;
 }
 function ensureOutputDir(outputPath) {
-  const dir = path2.dirname(outputPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const dir = path6.dirname(outputPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
 }
 function runScan(config) {
   const components = {};
   const pages = [];
   const features = [];
+  let allUiComponents = [];
+  const routeDirs = /* @__PURE__ */ new Set();
   let totalComponents = 0;
   let totalFiles = 0;
+  const allProvenanceFiles = [];
+  const allExtractedPrimitives = [];
   for (const source of config.sources) {
-    const sourceResult = findFilesForSource(source, config.exclude);
+    const sourceResult = findFilesForSource(source, config.exclude, config.configDir);
     totalFiles += sourceResult.files.length;
+    for (const d of sourceResult.routeDirs) {
+      routeDirs.add(d === "." ? source.rootDir : `${source.rootDir}/${d}`);
+    }
     console.log(
       `Scanning ${source.rootDir}: ${sourceResult.files.length} files${source.prefix ? ` (\u2192 ${source.prefix}/*)` : ""}`
     );
     const sourceComponentIds = /* @__PURE__ */ new Map();
     for (const file of sourceResult.files) {
-      const content = fs2.readFileSync(file.fullPath, "utf-8");
+      const content = fs7.readFileSync(file.fullPath, "utf-8");
+      allProvenanceFiles.push({
+        absolutePath: toPosix(file.fullPath),
+        outputPath: file.outputPath,
+        content
+      });
       const fileComponents = extractComponents(content);
+      const seenIdsInFile = /* @__PURE__ */ new Set();
       for (const component of fileComponents) {
+        if (component.kind === "primitive") {
+          allExtractedPrimitives.push({
+            name: component.id,
+            line: component.line,
+            outputPath: file.outputPath,
+            absolutePath: toPosix(file.fullPath),
+            relativePath: file.relativePath,
+            rootDir: path6.resolve(config.configDir, source.rootDir)
+          });
+          continue;
+        }
+        if (seenIdsInFile.has(component.id)) continue;
+        seenIdsInFile.add(component.id);
         if (!components[component.id]) {
           components[component.id] = [];
         }
         components[component.id].push({
           filePath: file.outputPath,
           line: component.line,
+          kind: component.kind,
           ...component.doc ? { doc: component.doc } : {}
         });
         if (!sourceComponentIds.has(component.id)) {
@@ -684,8 +1598,19 @@ function runScan(config) {
         totalComponents++;
       }
     }
+    const parsedPageDocs = /* @__PURE__ */ new Map();
+    for (const [dir, rawContent] of sourceResult.pageDocs) {
+      const { frontmatter, body } = parseFrontmatter(rawContent);
+      const description = frontmatter.description ?? parseBlockquoteDescription(body);
+      parsedPageDocs.set(dir, {
+        body: normalizeAcceptanceCriteria(body),
+        explicitComponents: frontmatter.components ?? [],
+        ...frontmatter.root ? { rootId: frontmatter.root } : {},
+        ...description ? { description } : {}
+      });
+    }
     const sourcePages = buildPages(
-      sourceResult.pageDocs,
+      parsedPageDocs,
       sourceComponentIds,
       source.rootDir
     );
@@ -693,15 +1618,47 @@ function runScan(config) {
     const parsedFeatureDocs = /* @__PURE__ */ new Map();
     for (const [dir, rawContent] of sourceResult.featureDocs) {
       const { frontmatter, body } = parseFrontmatter(rawContent);
+      const featureDescription = frontmatter.description ?? parseBlockquoteDescription(body);
       parsedFeatureDocs.set(dir, {
         body,
-        explicitComponents: frontmatter.components ?? []
+        explicitComponents: frontmatter.components ?? [],
+        ...featureDescription ? { description: featureDescription } : {}
       });
     }
-    const sourceFeatures = buildFeatures(parsedFeatureDocs, source.rootDir);
+    const sourceFeatures = buildFeatures(parsedFeatureDocs, sourceComponentIds, source.rootDir);
     features.push(...sourceFeatures);
   }
-  return { components, pages, features, totalComponents, totalFiles };
+  allUiComponents = buildPrimitivesFromAnnotations(allExtractedPrimitives);
+  let provenanceLinks = 0;
+  if (allUiComponents.length > 0) {
+    const tsconfig = loadTsconfigPaths(config.configDir);
+    const provenance = computeProvenance(
+      allProvenanceFiles,
+      allUiComponents,
+      tsconfig.paths,
+      tsconfig.absoluteBaseUrl
+    );
+    allUiComponents = provenance.primitives;
+    provenanceLinks = provenance.provenanceLinks;
+    for (const [, locations] of Object.entries(components)) {
+      for (const loc of locations) {
+        const scopeSet = provenance.fileScopeSets.get(loc.filePath);
+        if (scopeSet && scopeSet.size > 0) {
+          loc.scopes = [...scopeSet].sort();
+        }
+      }
+    }
+  }
+  return {
+    components,
+    pages,
+    features,
+    uiComponents: allUiComponents,
+    routeDirs,
+    totalComponents,
+    totalFiles,
+    provenanceLinks
+  };
 }
 function printSummary(result) {
   console.log("");
@@ -733,8 +1690,14 @@ function printSummary(result) {
     }
     console.log("");
   }
+  if (result.uiComponents.length > 0) {
+    console.log(
+      `Primitives: ${result.uiComponents.length} detected, ${result.provenanceLinks} provenance links`
+    );
+    console.log("");
+  }
 }
-function checkCoverage(result) {
+function checkCoverage(result, config) {
   const allComponentIds = Object.keys(result.components);
   const coveredIds = /* @__PURE__ */ new Set([
     ...result.pages.flatMap((p) => p.componentIds),
@@ -742,16 +1705,23 @@ function checkCoverage(result) {
   ]);
   const uncoveredIds = allComponentIds.filter((id) => !coveredIds.has(id));
   const orphanedPages = result.pages.filter((p) => p.componentIds.length === 0);
+  const orphanedFeatures = result.features.filter(
+    (f) => f.componentIds.every((id) => !result.components[id])
+  );
+  const pagesWithoutDescription = result.pages.filter((p) => !p.description);
+  const featuresWithoutDescription = result.features.filter((f) => !f.description);
   let passed = true;
   if (uncoveredIds.length > 0) {
     passed = false;
-    console.log(`Components missing UIDEX_PAGE.md coverage (${uncoveredIds.length}):`);
+    console.log(`Components missing doc coverage (${uncoveredIds.length}):`);
     for (const id of uncoveredIds.sort()) {
       const locations = result.components[id];
       for (const loc of locations) {
         console.log(`  "${id}" at ${loc.filePath}:${loc.line}`);
       }
     }
+    console.log("  Hint: add a UIDEX_PAGE.md in the component directory, or list the");
+    console.log("  component in a UIDEX_FEATURE.md (e.g. features/<name>/UIDEX_FEATURE.md)");
     console.log("");
   }
   if (orphanedPages.length > 0) {
@@ -762,18 +1732,84 @@ function checkCoverage(result) {
     }
     console.log("");
   }
-  if (passed) {
-    const totalDocs = result.pages.length + result.features.length;
-    console.log(
-      `All ${allComponentIds.length} components covered by ${totalDocs} UIDEX docs (${result.pages.length} pages, ${result.features.length} features)`
-    );
+  if (orphanedFeatures.length > 0) {
+    passed = false;
+    console.log(`UIDEX_FEATURE.md files referencing no known components (${orphanedFeatures.length}):`);
+    for (const feature of orphanedFeatures) {
+      console.log(`  ${feature.dir}/UIDEX_FEATURE.md`);
+    }
+    console.log("");
   }
-  return passed;
-}
-function printConfig(config) {
-  console.log("Configuration:");
-  console.log(`  Sources: ${config.sources.length}`);
-  for (const source of config.sources) {
+  if (pagesWithoutDescription.length > 0 || featuresWithoutDescription.length > 0) {
+    passed = false;
+    const total = pagesWithoutDescription.length + featuresWithoutDescription.length;
+    console.log(`Docs missing > description blockquote (${total}):`);
+    for (const page of pagesWithoutDescription) {
+      console.log(`  ${page.dir}/UIDEX_PAGE.md`);
+    }
+    for (const feature of featuresWithoutDescription) {
+      console.log(`  ${feature.dir}/UIDEX_FEATURE.md`);
+    }
+    console.log("");
+  }
+  const featureDirs = [];
+  let hasAnyFeaturesDir = false;
+  for (const source of config.sources) {
+    const featuresPath = path6.resolve(config.configDir, source.rootDir, "features");
+    if (fs7.existsSync(featuresPath) && fs7.statSync(featuresPath).isDirectory()) {
+      hasAnyFeaturesDir = true;
+      const entries = fs7.readdirSync(featuresPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const featureDocPath = path6.join(featuresPath, entry.name, UIDEX_FEATURE_FILENAME);
+        if (!fs7.existsSync(featureDocPath)) {
+          const rel = source.prefix ? `${source.prefix}/features/${entry.name}` : `features/${entry.name}`;
+          featureDirs.push(rel);
+        }
+      }
+    }
+  }
+  if (featureDirs.length > 0) {
+    passed = false;
+    console.log(`Feature directories missing UIDEX_FEATURE.md (${featureDirs.length}):`);
+    for (const dir of featureDirs) {
+      console.log(`  ${dir}/`);
+    }
+    console.log("");
+  }
+  if (!hasAnyFeaturesDir) {
+    console.log(
+      "Note: no features/ directory found under any scanner root. Consider adding"
+    );
+    console.log(
+      "  a features/ directory for cross-cutting feature documentation."
+    );
+    console.log("");
+  }
+  const pageDirs = new Set(result.pages.map((p) => p.dir));
+  const routesWithoutPage = [...result.routeDirs].filter((dir) => !pageDirs.has(dir)).sort();
+  if (routesWithoutPage.length > 0) {
+    passed = false;
+    console.log(`Route directories missing UIDEX_PAGE.md (${routesWithoutPage.length}):`);
+    for (const dir of routesWithoutPage) {
+      console.log(`  ${dir}/`);
+    }
+    console.log("  Hint: each route with a page.tsx should have its own UIDEX_PAGE.md");
+    console.log("  to prevent components from being absorbed by a parent page doc.");
+    console.log("");
+  }
+  if (passed) {
+    const totalDocs = result.pages.length + result.features.length;
+    console.log(
+      `All ${allComponentIds.length} components covered by ${totalDocs} UIDEX docs (${result.pages.length} pages, ${result.features.length} features)`
+    );
+  }
+  return passed;
+}
+function printConfig(config) {
+  console.log("Configuration:");
+  console.log(`  Sources: ${config.sources.length}`);
+  for (const source of config.sources) {
     const prefix = source.prefix ? ` (prefix: ${source.prefix})` : "";
     console.log(`    - ${source.rootDir}${prefix}`);
     console.log(`      Include: ${source.include.join(", ")}`);
@@ -785,32 +1821,383 @@ function printConfig(config) {
   console.log(`  Output: ${config.outputPath}
 `);
 }
-function scan() {
-  const isCheck = process.argv.includes("--check");
-  console.log(`uidex scanner${isCheck ? " (check mode)" : ""} starting...
-`);
-  const config = loadConfig();
+function scanSingle(configDir) {
+  const config = loadConfig({ configDir });
   printConfig(config);
   const result = runScan(config);
   printSummary(result);
-  if (isCheck) {
-    const passed = checkCoverage(result);
-    process.exit(passed ? 0 : 1);
-  }
-  const outputPath = path2.resolve(process.cwd(), config.outputPath);
+  const outputPath = path6.resolve(config.configDir, config.outputPath);
   ensureOutputDir(outputPath);
-  const output = generateOutput(result.components, result.pages, result.features);
-  fs2.writeFileSync(outputPath, output, "utf-8");
+  const gitCtx = detectGitContext();
+  if (gitCtx.branch) {
+    console.log(`Git context: branch=${gitCtx.branch}${gitCtx.commit ? ` commit=${gitCtx.commit.slice(0, 8)}` : ""}`);
+  }
+  const output = generateOutput(result.components, result.pages, result.features, gitCtx, result.uiComponents);
+  fs7.writeFileSync(outputPath, output, "utf-8");
   console.log(`Generated: ${config.outputPath}`);
   const testOutputPath = outputPath.replace(/\.ts$/, ".test.ts");
   const testOutput = generateTestOutput(result.components, result.pages, result.features);
-  fs2.writeFileSync(testOutputPath, testOutput, "utf-8");
+  fs7.writeFileSync(testOutputPath, testOutput, "utf-8");
   console.log(`Generated: ${config.outputPath.replace(/\.ts$/, ".test.ts")}`);
 }
+function printConfigHeader(configDir) {
+  console.log(`--- ${path6.relative(process.cwd(), configDir)}/ ---
+`);
+}
+function scan() {
+  const isAudit = process.argv.includes("--audit") || process.argv.includes("--check") || process.argv.includes("--lint");
+  const isJson = process.argv.includes("--json");
+  const isVerbose = process.argv.includes("--verbose");
+  const configs = resolveConfigs();
+  if (configs.length === 0) {
+    console.error("No .uidex.json found in this directory or subdirectories.");
+    console.error("Run `npx uidex init` to create one.");
+    process.exit(1);
+  }
+  const isMulti = configs.length > 1 || configs[0].configDir !== process.cwd();
+  if (isMulti) {
+    console.log(`Found ${configs.length} uidex config(s):`);
+    for (const c of configs) {
+      console.log(`  ${path6.relative(process.cwd(), c.configDir)}/`);
+    }
+    console.log("");
+  }
+  if (isAudit) {
+    const { runLint: runLint2, printLintReport: printLintReport2 } = (init_lint(), __toCommonJS(lint_exports));
+    console.log("uidex audit starting...\n");
+    let checkPassed = true;
+    for (const c of configs) {
+      if (isMulti) printConfigHeader(c.configDir);
+      const config = loadConfig({ configDir: c.configDir });
+      const result = runScan(config);
+      const uniqueIds = Object.keys(result.components).length;
+      console.log(
+        `Scanned ${result.totalFiles} files, found ${result.totalComponents} components (${uniqueIds} unique IDs), ${result.pages.length} pages, ${result.features.length} features
+`
+      );
+      const passed = checkCoverage(result, config);
+      if (!passed) checkPassed = false;
+    }
+    let scopeLeakCount = 0;
+    const allScopeLeakResults = [];
+    for (const c of configs) {
+      const config = loadConfig({ configDir: c.configDir, silent: true });
+      const result = runScan(config);
+      if (result.uiComponents.length > 0) {
+        const aggregatedFiles = [];
+        for (const source of config.sources) {
+          const sourceResult = findFilesForSource(source, config.exclude, config.configDir);
+          aggregatedFiles.push(...sourceResult.files);
+        }
+        const scopeLeakResult = runScopeLeakCheck(
+          config.configDir,
+          aggregatedFiles,
+          result.uiComponents
+        );
+        allScopeLeakResults.push(scopeLeakResult);
+        scopeLeakCount += scopeLeakResult.errors.length;
+        if (!isJson) {
+          printScopeLeakReport(scopeLeakResult);
+        }
+      }
+    }
+    console.log("\n--- Lint ---\n");
+    let totalViolations = 0;
+    for (const c of configs) {
+      if (isMulti) printConfigHeader(c.configDir);
+      const result = runLint2(c.configDir, { verbose: isVerbose });
+      totalViolations += result.stats.totalViolations;
+      if (isJson) {
+        const jsonResult = {
+          ...result,
+          scopeLeaks: allScopeLeakResults.flatMap((r) => r.errors)
+        };
+        console.log(JSON.stringify(jsonResult, null, 2));
+      } else {
+        printLintReport2(result);
+      }
+    }
+    process.exit(!checkPassed || totalViolations > 0 || scopeLeakCount > 0 ? 1 : 0);
+  }
+  console.log("uidex scanner starting...\n");
+  for (const c of configs) {
+    if (isMulti) printConfigHeader(c.configDir);
+    scanSingle(c.configDir);
+  }
+}
+var fs7, path6, import_child_process, DEFAULT_SOURCE, DEFAULT_SKIP_PATHS, DEFAULT_LINT_CONFIG, DEFAULT_CONFIG;
+var init_scan = __esm({
+  "scripts/scan.ts"() {
+    "use strict";
+    fs7 = __toESM(require("fs"), 1);
+    path6 = __toESM(require("path"), 1);
+    import_child_process = require("child_process");
+    init_config_discovery();
+    init_scanner_utils();
+    init_primitives();
+    init_provenance();
+    init_scope_leak();
+    DEFAULT_SOURCE = {
+      rootDir: "src",
+      include: ["**/*.tsx", "**/*.jsx"]
+    };
+    DEFAULT_SKIP_PATHS = [
+      "**/contexts/**",
+      "**/providers/**",
+      "**/hooks/**"
+    ];
+    DEFAULT_LINT_CONFIG = {
+      interactiveElements: [
+        "button",
+        "a",
+        "input",
+        "select",
+        "textarea",
+        "Button",
+        "Input",
+        "Select",
+        "Checkbox"
+      ],
+      regionElements: [
+        "section",
+        "nav",
+        "form",
+        "table",
+        "aside",
+        "article",
+        "header",
+        "footer",
+        "main"
+      ],
+      skipPaths: DEFAULT_SKIP_PATHS,
+      skipPathDefaults: true
+    };
+    DEFAULT_CONFIG = {
+      sources: [DEFAULT_SOURCE],
+      exclude: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**", "**/*.gen.ts"],
+      outputPath: "src/uidex.gen.ts"
+    };
+  }
+});
+
+// scripts/init.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var readline = __toESM(require("readline"), 1);
+init_cli_utils();
+function log(message) {
+  console.log(message);
+}
+function detectProject() {
+  const cwd = process.cwd();
+  const packageJsonPath = path.join(cwd, "package.json");
+  let packageJson = {};
+  if (fs.existsSync(packageJsonPath)) {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  }
+  const deps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  const name = packageJson.name || path.basename(cwd);
+  const usesTypeScript = fs.existsSync(path.join(cwd, "tsconfig.json")) || !!deps["typescript"];
+  const hasSrcDir = fs.existsSync(path.join(cwd, "src"));
+  const srcDir = hasSrcDir ? "src" : ".";
+  if (deps["next"]) {
+    const usesAppRouter = fs.existsSync(path.join(cwd, "src", "app")) || fs.existsSync(path.join(cwd, "app"));
+    return {
+      type: "nextjs",
+      name,
+      srcDir,
+      usesTypeScript,
+      usesAppRouter
+    };
+  }
+  if (deps["vite"] || fs.existsSync(path.join(cwd, "vite.config.ts")) || fs.existsSync(path.join(cwd, "vite.config.js"))) {
+    return {
+      type: "vite",
+      name,
+      srcDir,
+      usesTypeScript,
+      usesAppRouter: false
+    };
+  }
+  if (deps["react-scripts"]) {
+    return {
+      type: "cra",
+      name,
+      srcDir,
+      usesTypeScript,
+      usesAppRouter: false
+    };
+  }
+  return {
+    type: "unknown",
+    name,
+    srcDir,
+    usesTypeScript,
+    usesAppRouter: false
+  };
+}
+function createConfigContent(project) {
+  const extensions = ["**/*.tsx", "**/*.jsx"];
+  const exclude = ["**/*.test.*", "**/*.spec.*", "**/*.gen.ts"];
+  let sources;
+  if (project.type === "nextjs" && project.usesAppRouter) {
+    const prefix = project.srcDir === "src" ? "src/" : "";
+    sources = [
+      { rootDir: `${prefix}app`, include: extensions },
+      { rootDir: `${prefix}components`, include: extensions }
+    ];
+    const featuresDir = path.join(process.cwd(), `${prefix}features`);
+    if (fs.existsSync(featuresDir) && fs.statSync(featuresDir).isDirectory()) {
+      sources.push({ rootDir: `${prefix}features`, include: extensions });
+    }
+  } else {
+    sources = [{ rootDir: project.srcDir, include: extensions }];
+  }
+  const config = {
+    $schema: "node_modules/uidex/uidex.schema.json",
+    defaults: {
+      color: "#3b82f6",
+      borderStyle: "solid",
+      borderWidth: 2,
+      showLabel: true,
+      labelPosition: "top-left"
+    },
+    colors: {
+      primary: "#3b82f6",
+      secondary: "#8b5cf6",
+      success: "#10b981",
+      warning: "#f59e0b",
+      error: "#ef4444",
+      info: "#0ea5e9"
+    },
+    scanner: {
+      sources,
+      exclude,
+      outputPath: `${project.srcDir}/uidex.gen.ts`
+    }
+  };
+  return JSON.stringify(config, null, 2);
+}
+function addToGitignore(entry) {
+  const cwd = process.cwd();
+  const gitignorePath = path.join(cwd, ".gitignore");
+  let content = "";
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, "utf-8");
+  }
+  const lines = content.split("\n");
+  if (lines.some((line) => line.trim() === entry)) {
+    return false;
+  }
+  const newContent = content.endsWith("\n") || content === "" ? `${content}${entry}
+` : `${content}
+${entry}
+`;
+  fs.writeFileSync(gitignorePath, newContent, "utf-8");
+  return true;
+}
+function createPrompt() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function askYesNo(rl, question, defaultYes = true) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve6) => {
+    rl.question(`${question} ${colors.dim}${hint}${colors.reset} `, (answer) => {
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve6(defaultYes);
+      } else {
+        resolve6(normalized === "y" || normalized === "yes");
+      }
+    });
+  });
+}
+function getEntryPointHint(project) {
+  if (project.type === "nextjs") {
+    if (project.usesAppRouter) {
+      return project.srcDir === "src" ? "src/app/layout.tsx" : "app/layout.tsx";
+    }
+    return project.srcDir === "src" ? "src/pages/_app.tsx" : "pages/_app.tsx";
+  }
+  return project.srcDir === "src" ? "src/main.tsx" : "main.tsx";
+}
+async function init() {
+  heading("uidex init");
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, ".uidex.json");
+  if (fs.existsSync(configPath)) {
+    warn(".uidex.json already exists");
+    const rl = createPrompt();
+    const overwrite = await askYesNo(rl, "Overwrite existing config?", false);
+    rl.close();
+    if (!overwrite) {
+      info("Keeping existing configuration");
+      return;
+    }
+  }
+  const project = detectProject();
+  log(`Detected project: ${colors.bold}${project.name}${colors.reset}`);
+  log(`Project type: ${colors.bold}${project.type}${colors.reset}`);
+  log(
+    `Language: ${colors.bold}${project.usesTypeScript ? "TypeScript" : "JavaScript"}${colors.reset}`
+  );
+  if (project.type === "nextjs") {
+    log(
+      `Router: ${colors.bold}${project.usesAppRouter ? "App Router" : "Pages Router"}${colors.reset}`
+    );
+  }
+  heading("Creating configuration");
+  const configContent = createConfigContent(project);
+  fs.writeFileSync(configPath, configContent, "utf-8");
+  success("Created .uidex.json");
+  const genPatterns = ["*.gen.ts", "*.gen.test.ts"];
+  for (const pattern of genPatterns) {
+    if (addToGitignore(pattern)) {
+      success(`Added ${pattern} to .gitignore`);
+    } else {
+      info(`${pattern} already in .gitignore`);
+    }
+  }
+  heading("Next steps");
+  const entryPoint = getEntryPointHint(project);
+  log("1. Add data-uidex attributes to elements you want to track:");
+  log("");
+  log(`   ${colors.green}<button${colors.reset} data-uidex="submit-btn"${colors.green}>${colors.reset}Submit${colors.green}</button>${colors.reset}`);
+  log("");
+  log("2. Run the scanner to generate the components registry:");
+  log("");
+  log(`   ${colors.yellow}npx uidex-scan${colors.reset}`);
+  log("");
+  log("3. Import the generated file in your entry point:");
+  log("");
+  log(`   ${colors.dim}// ${entryPoint}${colors.reset}`);
+  log(`   ${colors.cyan}import${colors.reset} './${project.srcDir === "src" ? "" : "src/"}uidex.gen';`);
+  log("");
+  log("4. Add the UidexDevtools component anywhere in your app:");
+  log("");
+  log(`   ${colors.cyan}import${colors.reset} { UidexDevtools } ${colors.cyan}from${colors.reset} 'uidex';`);
+  log("");
+  log(`   ${colors.green}<UidexDevtools />${colors.reset}`);
+  log("");
+  success("Setup complete!");
+  log("");
+}
+
+// scripts/cli.ts
+init_scan();
 
 // scripts/scaffold.ts
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+init_scan();
+init_scanner_utils();
+init_cli_utils();
 function toTestFileName(dir, title) {
   if (title) {
     return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -820,7 +2207,6 @@ function toTestFileName(dir, title) {
 }
 function generateTestFile(entry, fixtureImport) {
   const title = parseMarkdownTitle(entry.content) ?? entry.dir;
-  const criteria = parseAcceptanceCriteria(entry.content);
   const componentList = entry.componentIds.map((id) => `"${id}"`).join(", ");
   const docFile = entry.kind === "page" ? "UIDEX_PAGE.md" : "UIDEX_FEATURE.md";
   let body = "";
@@ -847,35 +2233,36 @@ function generateTestFile(entry, fixtureImport) {
 `;
     body += `  });
 `;
-  } else {
-    body += `  // Components: ${componentList}
-`;
-  }
-  if (criteria.length > 0) {
-    body += "\n";
-    for (const criterion of criteria) {
-      const escaped = criterion.replace(/'/g, "\\'");
-      body += `  test.todo('${escaped}');
+    const criteria = parseAcceptanceCriteria(entry.content);
+    if (criteria.length > 0) {
+      body += "\n";
+      for (const criterion of criteria) {
+        const escaped = criterion.replace(/'/g, "\\'");
+        body += `  test.todo('${escaped}');
 `;
+      }
     }
+  } else {
+    body += `  // Components: ${componentList}
+`;
   }
   body += `});
 `;
   return body;
 }
-function scaffold(outputDir) {
+function scaffold(outputDir, configDir) {
   const dir = outputDir ?? "e2e";
   heading("uidex scaffold");
   info(`Output directory: ${dir}/`);
-  const config = loadConfig();
+  const config = loadConfig({ configDir });
   const result = runScan(config);
   if (result.pages.length === 0 && result.features.length === 0) {
     warn("No pages or features found. Create UIDEX_PAGE.md or UIDEX_FEATURE.md files first.");
     return;
   }
-  const absDir = path3.resolve(process.cwd(), dir);
-  if (!fs3.existsSync(absDir)) {
-    fs3.mkdirSync(absDir, { recursive: true });
+  const absDir = path7.resolve(process.cwd(), dir);
+  if (!fs8.existsSync(absDir)) {
+    fs8.mkdirSync(absDir, { recursive: true });
   }
   const fixtureImport = "./fixtures";
   let generated = 0;
@@ -887,221 +2274,1535 @@ function scaffold(outputDir) {
   for (const entry of entries) {
     const title = parseMarkdownTitle(entry.content);
     const fileName = `${entry.kind}-${toTestFileName(entry.dir, title)}.spec.ts`;
-    const filePath = path3.join(absDir, fileName);
-    if (fs3.existsSync(filePath)) {
+    const filePath = path7.join(absDir, fileName);
+    if (fs8.existsSync(filePath)) {
       info(`Skipped ${fileName} (already exists)`);
       skipped++;
       continue;
     }
     const content = generateTestFile(entry, fixtureImport);
-    fs3.writeFileSync(filePath, content, "utf-8");
+    fs8.writeFileSync(filePath, content, "utf-8");
     success(`Generated ${fileName}`);
     generated++;
   }
-  const fixturesPath = path3.join(absDir, "fixtures.ts");
-  if (!fs3.existsSync(fixturesPath)) {
-    fs3.writeFileSync(
-      fixturesPath,
-      `export { test, expect } from 'uidex/playwright';
-`,
-      "utf-8"
-    );
-    success("Generated fixtures.ts");
-    generated++;
+  const fixturesPath = path7.join(absDir, "fixtures.ts");
+  if (!fs8.existsSync(fixturesPath)) {
+    fs8.writeFileSync(
+      fixturesPath,
+      `export { test, expect } from 'uidex/playwright';
+`,
+      "utf-8"
+    );
+    success("Generated fixtures.ts");
+    generated++;
+  }
+  console.log("");
+  info(`${generated} file(s) generated, ${skipped} skipped`);
+  if (generated > 0) {
+    console.log("");
+    info("Next steps:");
+    console.log("  1. Replace test.todo() calls with test implementations");
+    console.log("  2. Use the uidex fixture for type-safe selectors:");
+    console.log("");
+    console.log("     test('add todo', async ({ uidex }) => {");
+    console.log("       await uidex('todo-input').fill('Buy milk');");
+    console.log("       await uidex('todo-add-button').click();");
+    console.log("     });");
+    console.log("");
+  }
+}
+
+// scripts/claude-setup.ts
+var fs9 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+init_cli_utils();
+function readTemplate(filename) {
+  const candidates = [
+    // Built package: __dirname = <pkg>/dist/scripts → ../../claude/
+    path8.resolve(__dirname, "..", "..", "claude", filename),
+    // Dev mode: __dirname = <repo>/scripts → ../claude/
+    path8.resolve(__dirname, "..", "claude", filename)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return fs9.readFileSync(candidate, "utf-8");
+    } catch {
+    }
+  }
+  throw new Error(
+    `Template not found: ${filename}. The uidex package may be corrupted \u2014 try reinstalling.`
+  );
+}
+function ensureDir(dirPath) {
+  fs9.mkdirSync(dirPath, { recursive: true });
+}
+function addRules() {
+  const cwd = process.cwd();
+  const targetDir = path8.join(cwd, ".claude", "rules");
+  const targetPath = path8.join(targetDir, "uidex.md");
+  const content = readTemplate("rules.md");
+  ensureDir(targetDir);
+  fs9.writeFileSync(targetPath, content, "utf-8");
+  success("Added .claude/rules/uidex.md");
+}
+function removeRules() {
+  const targetPath = path8.join(process.cwd(), ".claude", "rules", "uidex.md");
+  try {
+    fs9.unlinkSync(targetPath);
+    success("Removed .claude/rules/uidex.md");
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      info(".claude/rules/uidex.md does not exist");
+    } else {
+      throw e;
+    }
+  }
+}
+function addSkill() {
+  const cwd = process.cwd();
+  const targetDir = path8.join(cwd, ".claude", "commands", "uidex");
+  const targetPath = path8.join(targetDir, "audit.md");
+  const content = readTemplate("audit-command.md");
+  ensureDir(targetDir);
+  fs9.writeFileSync(targetPath, content, "utf-8");
+  success("Added .claude/commands/uidex/audit.md (/uidex:audit)");
+  const legacyPath = path8.join(cwd, ".claude", "commands", "uidex-audit.md");
+  try {
+    fs9.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+function removeSkill() {
+  const targetPath = path8.join(process.cwd(), ".claude", "commands", "uidex", "audit.md");
+  try {
+    fs9.unlinkSync(targetPath);
+    success("Removed .claude/commands/uidex/audit.md");
+    const dir = path8.dirname(targetPath);
+    try {
+      fs9.rmdirSync(dir);
+    } catch {
+    }
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      info(".claude/commands/uidex/audit.md does not exist");
+    } else {
+      throw e;
+    }
+  }
+  const legacyPath = path8.join(process.cwd(), ".claude", "commands", "uidex-audit.md");
+  try {
+    fs9.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+var UIDEX_HOOK_COMMAND = "npx uidex scan --audit";
+function isUidexHookEntry(entry) {
+  return entry.hooks?.some((h) => h.command === UIDEX_HOOK_COMMAND) ?? false;
+}
+function readSettings(settingsPath) {
+  try {
+    return JSON.parse(fs9.readFileSync(settingsPath, "utf-8"));
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return {};
+    }
+    error(`Failed to parse .claude/settings.json: ${e.message}`);
+    process.exit(1);
+  }
+}
+function addHooks() {
+  const cwd = process.cwd();
+  const settingsDir = path8.join(cwd, ".claude");
+  const settingsPath = path8.join(settingsDir, "settings.json");
+  const settings = readSettings(settingsPath);
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse = [];
+  }
+  if (settings.hooks.PostToolUse.some(isUidexHookEntry)) {
+    info("uidex hook already configured in .claude/settings.json");
+    return;
+  }
+  settings.hooks.PostToolUse.push({
+    matcher: "Edit|Write",
+    hooks: [
+      {
+        type: "command",
+        command: UIDEX_HOOK_COMMAND,
+        timeout: 30
+      }
+    ]
+  });
+  ensureDir(settingsDir);
+  fs9.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  success("Added uidex hook to .claude/settings.json");
+}
+function removeHooks() {
+  const settingsPath = path8.join(process.cwd(), ".claude", "settings.json");
+  const settings = readSettings(settingsPath);
+  if (!Array.isArray(settings.hooks?.PostToolUse)) {
+    info("No PostToolUse hooks configured");
+    return;
+  }
+  const before = settings.hooks.PostToolUse.length;
+  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
+    (entry) => !isUidexHookEntry(entry)
+  );
+  const after = settings.hooks.PostToolUse.length;
+  if (before === after) {
+    info("No uidex hook found in .claude/settings.json");
+    return;
+  }
+  if (settings.hooks.PostToolUse.length === 0) {
+    delete settings.hooks.PostToolUse;
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  fs9.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  success("Removed uidex hook from .claude/settings.json");
+}
+function claudeInstall() {
+  heading("uidex claude install");
+  addRules();
+  addSkill();
+  addHooks();
+  console.log("");
+  success("Claude Code integration ready");
+}
+function claudeUninstall() {
+  heading("uidex claude uninstall");
+  removeRules();
+  removeSkill();
+  removeHooks();
+  console.log("");
+  success("Claude Code integration removed");
+}
+function printClaudeHelp() {
+  heading("uidex claude");
+  console.log("Manage Claude Code integration for uidex.\n");
+  console.log("Usage: uidex claude <command> [action]\n");
+  console.log("Commands:");
+  console.log("  install             Add rules, skill, and hooks");
+  console.log("  uninstall           Remove rules, skill, and hooks");
+  console.log("  rules [add|remove]  Manage .claude/rules/uidex.md");
+  console.log("  skill [add|remove]  Manage .claude/commands/uidex/audit.md (/uidex:audit)");
+  console.log("  hooks [add|remove]  Manage .claude/settings.json hook");
+  console.log("");
+}
+
+// scripts/login.ts
+var import_http = __toESM(require("http"), 1);
+var import_crypto = require("crypto");
+init_cli_utils();
+
+// scripts/config.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_os = __toESM(require("os"), 1);
+init_config_discovery();
+init_scan();
+var CONFIG_DIR = import_path.default.join(import_os.default.homedir(), ".uidex");
+var CONFIG_PATH = import_path.default.join(CONFIG_DIR, "config.json");
+var DEFAULT_ENDPOINT = "https://app.uidex.dev";
+function ensureConfigDir() {
+  import_fs.default.mkdirSync(CONFIG_DIR, { mode: 448, recursive: true });
+}
+function readGlobalConfig() {
+  try {
+    const raw = import_fs.default.readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { links: {} };
+  }
+}
+function writeGlobalConfig(config) {
+  ensureConfigDir();
+  const tmp = CONFIG_PATH + ".tmp";
+  import_fs.default.writeFileSync(tmp, JSON.stringify(config, null, 2), {
+    mode: 384
+  });
+  import_fs.default.renameSync(tmp, CONFIG_PATH);
+}
+function getToken() {
+  return process.env.UIDEX_TOKEN || readGlobalConfig().token;
+}
+function setToken(token) {
+  const config = readGlobalConfig();
+  config.token = token;
+  writeGlobalConfig(config);
+}
+function removeToken() {
+  const config = readGlobalConfig();
+  delete config.token;
+  writeGlobalConfig(config);
+}
+function getLinkContext(cwd) {
+  const dir = cwd || process.cwd();
+  const config = readGlobalConfig();
+  return config.links[dir];
+}
+function setLinkContext(link2, cwd) {
+  const dir = cwd || process.cwd();
+  const config = readGlobalConfig();
+  config.links[dir] = link2;
+  writeGlobalConfig(config);
+}
+function readProjectConfig() {
+  const configs = resolveConfigs();
+  if (configs.length === 0) return {};
+  return readConfigFile(configs[0].configDir) ?? {};
+}
+function resolveEndpoint(link2) {
+  return process.env.UIDEX_ENDPOINT || link2?.endpoint || readProjectConfig().api?.endpoint || DEFAULT_ENDPOINT;
+}
+function resolveContext() {
+  const config = readGlobalConfig();
+  const link2 = config.links[process.cwd()];
+  const token = process.env.UIDEX_TOKEN || config.token;
+  if (!token) return null;
+  const orgId = process.env.UIDEX_ORG_ID || link2?.orgId;
+  const projectId = process.env.UIDEX_PROJECT_ID || link2?.projectId;
+  if (!orgId || !projectId) return null;
+  return {
+    token,
+    endpoint: resolveEndpoint(link2),
+    orgId,
+    orgSlug: link2?.orgSlug || "",
+    projectId,
+    projectSlug: link2?.projectSlug || "",
+    environment: link2?.environment || ""
+  };
+}
+function requireContext() {
+  const ctx = resolveContext();
+  if (!ctx) {
+    const { error: error2 } = (init_cli_utils(), __toCommonJS(cli_utils_exports));
+    error2("No project linked. Run `uidex link` first.");
+    process.exit(1);
+  }
+  return ctx;
+}
+
+// scripts/login.ts
+function openBrowser(url) {
+  const { exec } = require("child_process");
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+async function login(args2) {
+  const flags = parseFlags(args2);
+  const endpoint = flags.endpoint || resolveEndpoint();
+  const code = (0, import_crypto.randomBytes)(4).toString("hex").toUpperCase();
+  const tokenPromise = new Promise((resolve6, reject) => {
+    let timeout;
+    const server = import_http.default.createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://127.0.0.1`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const receivedCode = url.searchParams.get("code");
+      const receivedToken = url.searchParams.get("token");
+      if (receivedCode !== code) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Code mismatch");
+        clearTimeout(timeout);
+        reject(new Error("Code mismatch \u2014 possible CSRF attempt"));
+        server.close();
+        return;
+      }
+      if (!receivedToken) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing token");
+        clearTimeout(timeout);
+        reject(new Error("No token received"));
+        server.close();
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("OK");
+      clearTimeout(timeout);
+      resolve6(receivedToken);
+      server.close();
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start callback server"));
+        return;
+      }
+      const port = addr.port;
+      const authUrl = `${endpoint}/cli-auth?code=${code}&port=${port}`;
+      console.log("");
+      info("Opening browser for authentication...");
+      console.log(
+        `
+  Confirmation code: ${colors.bold}${code}${colors.reset}
+`
+      );
+      console.log(
+        `  If the browser doesn't open, visit:
+  ${colors.dim}${authUrl}${colors.reset}
+`
+      );
+      openBrowser(authUrl);
+    });
+    timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 120 seconds"));
+    }, 12e4);
+  });
+  try {
+    const token = await tokenPromise;
+    setToken(token);
+    success("Logged in successfully.");
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+function logout() {
+  const token = getToken();
+  if (!token) {
+    info("Not logged in.");
+    return;
+  }
+  removeToken();
+  success("Logged out.");
+}
+
+// scripts/link.ts
+var import_readline = __toESM(require("readline"), 1);
+init_cli_utils();
+
+// src/api/feedback.ts
+function buildQuery(params) {
+  const parts = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+      }
+    } else {
+      parts.push(
+        `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+      );
+    }
+  }
+  return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+function createFeedbackAPI(fetcher) {
+  return {
+    async list(orgId, projectId, params = {}) {
+      const query = buildQuery(params);
+      return fetcher(
+        `/api/organizations/${orgId}/projects/${projectId}/feedback${query}`
+      );
+    },
+    async get(orgId, projectId, feedbackId) {
+      return fetcher(
+        `/api/organizations/${orgId}/projects/${projectId}/feedback/${feedbackId}`
+      );
+    },
+    async update(orgId, projectId, feedbackId, params) {
+      return fetcher(
+        `/api/organizations/${orgId}/projects/${projectId}/feedback/${feedbackId}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(params)
+        }
+      );
+    },
+    async delete(orgId, projectId, feedbackId) {
+      await fetcher(
+        `/api/organizations/${orgId}/projects/${projectId}/feedback/${feedbackId}`,
+        { method: "DELETE" }
+      );
+    }
+  };
+}
+
+// src/api/triage.ts
+function createTriageAPI(fetcher) {
+  return {
+    async run(orgId, projectId) {
+      return fetcher(
+        `/api/organizations/${orgId}/projects/${projectId}/triage`,
+        { method: "POST" }
+      );
+    }
+  };
+}
+
+// src/api/drafts.ts
+function createDraftsAPI(fetcher) {
+  return {
+    async list(orgId, projectId, params = {}) {
+      const query = new URLSearchParams();
+      query.set("projectId", projectId);
+      if (params.status) query.set("status", params.status);
+      if (params.composed_by) query.set("composed_by", params.composed_by);
+      return fetcher(
+        `/api/organizations/${orgId}/issue-drafts?${query.toString()}`
+      );
+    },
+    async get(orgId, draftId) {
+      return fetcher(
+        `/api/organizations/${orgId}/issue-drafts/${draftId}`
+      );
+    },
+    async update(orgId, draftId, params) {
+      return fetcher(
+        `/api/organizations/${orgId}/issue-drafts/${draftId}`,
+        {
+          method: "PATCH",
+          body: JSON.stringify(params)
+        }
+      );
+    },
+    async submit(orgId, draftId) {
+      return fetcher(
+        `/api/organizations/${orgId}/issue-drafts/${draftId}/submit`,
+        { method: "POST" }
+      );
+    }
+  };
+}
+
+// src/api/projects.ts
+function createProjectsAPI(fetcher) {
+  return {
+    async list(orgId) {
+      return fetcher(`/api/organizations/${orgId}/projects`);
+    }
+  };
+}
+
+// src/api/orgs.ts
+function createOrgsAPI(fetcher) {
+  return {
+    async list() {
+      return fetcher("/api/organizations");
+    }
+  };
+}
+
+// src/api/tokens.ts
+function createUserAPI(fetcher) {
+  return {
+    async createToken(label, expiresAt) {
+      return fetcher("/api/user/tokens", {
+        method: "POST",
+        body: JSON.stringify({
+          label,
+          expires_at: expiresAt ?? null
+        })
+      });
+    },
+    async listTokens() {
+      return fetcher("/api/user/tokens");
+    },
+    async revokeToken(tokenId) {
+      await fetcher(`/api/user/tokens/${tokenId}`, {
+        method: "DELETE"
+      });
+    }
+  };
+}
+
+// src/api/integrations.ts
+function createIntegrationsAPI(fetcher) {
+  return {
+    async list(orgId) {
+      return fetcher(
+        `/api/organizations/${orgId}/integrations`
+      );
+    },
+    async create(orgId, params) {
+      return fetcher(
+        `/api/organizations/${orgId}/integrations`,
+        {
+          method: "POST",
+          body: JSON.stringify(params)
+        }
+      );
+    },
+    async get(orgId, integrationId) {
+      return fetcher(
+        `/api/organizations/${orgId}/integrations/${integrationId}`
+      );
+    },
+    async delete(orgId, integrationId) {
+      await fetcher(
+        `/api/organizations/${orgId}/integrations/${integrationId}`,
+        { method: "DELETE" }
+      );
+    },
+    async test(orgId, integrationId) {
+      return fetcher(
+        `/api/organizations/${orgId}/integrations/${integrationId}/test`,
+        { method: "POST" }
+      );
+    },
+    async listTargets(orgId, integrationId, parentId) {
+      const query = parentId ? `?parentId=${encodeURIComponent(parentId)}` : "";
+      return fetcher(
+        `/api/organizations/${orgId}/integrations/${integrationId}/targets${query}`
+      );
+    }
+  };
+}
+
+// src/api/client.ts
+var ApiError = class extends Error {
+  status;
+  constructor(status2, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status2;
+  }
+};
+function createFetcher(config) {
+  return async (path10, init2) => {
+    const res = await fetch(`${config.endpoint}${path10}`, {
+      ...init2,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.token}`,
+        ...init2?.headers
+      }
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new ApiError(
+        res.status,
+        body.error || res.statusText
+      );
+    }
+    if (res.status === 204) return null;
+    return res.json();
+  };
+}
+function createClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    feedback: createFeedbackAPI(fetcher),
+    triage: createTriageAPI(fetcher),
+    drafts: createDraftsAPI(fetcher),
+    projects: createProjectsAPI(fetcher),
+    orgs: createOrgsAPI(fetcher),
+    user: createUserAPI(fetcher),
+    integrations: createIntegrationsAPI(fetcher)
+  };
+}
+
+// scripts/link.ts
+function prompt(question) {
+  const rl = import_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve6) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve6(answer.trim());
+    });
+  });
+}
+async function pickFromList(items, display, label) {
+  console.log("");
+  for (let i = 0; i < items.length; i++) {
+    console.log(`  ${colors.dim}${i + 1}.${colors.reset} ${display(items[i], i)}`);
+  }
+  console.log("");
+  const answer = await prompt(`Select ${label} (1-${items.length}): `);
+  const idx = parseInt(answer, 10) - 1;
+  if (isNaN(idx) || idx < 0 || idx >= items.length) {
+    error("Invalid selection");
+    process.exit(1);
+  }
+  return items[idx];
+}
+async function link(args2) {
+  const flags = parseFlags(args2);
+  const orgSlugArg = flags.org;
+  const projectSlugArg = flags.project;
+  const envArg = flags.env;
+  const endpointArg = flags.endpoint;
+  const token = getToken();
+  if (!token) {
+    error("Not logged in. Run `uidex login` first.");
+    process.exit(1);
+  }
+  const existingLink = getLinkContext();
+  const endpoint = endpointArg || resolveEndpoint(existingLink);
+  const client = createClient({ endpoint, token });
+  if (envArg && !orgSlugArg && !projectSlugArg && existingLink) {
+    setLinkContext({ ...existingLink, environment: envArg });
+    success(
+      `Switched to ${existingLink.orgSlug}/${existingLink.projectSlug} (${envArg})`
+    );
+    return;
+  }
+  let orgs;
+  try {
+    orgs = await client.orgs.list();
+  } catch (err) {
+    error(
+      `Failed to fetch organizations: ${formatError(err)}`
+    );
+    process.exit(1);
+  }
+  if (orgs.length === 0) {
+    warn("No organizations found. Create one in the web UI first.");
+    process.exit(1);
+  }
+  let selectedOrg;
+  if (orgSlugArg) {
+    const match = orgs.find((o) => o.slug === orgSlugArg);
+    if (!match) {
+      error(`Organization "${orgSlugArg}" not found`);
+      process.exit(1);
+    }
+    selectedOrg = match;
+  } else if (orgs.length === 1) {
+    selectedOrg = orgs[0];
+    info(`Using organization: ${selectedOrg.name}`);
+  } else {
+    heading("Select organization");
+    selectedOrg = await pickFromList(
+      orgs,
+      (o) => `${o.name} ${colors.dim}(${o.slug})${colors.reset}`,
+      "organization"
+    );
+  }
+  let projects;
+  try {
+    projects = await client.projects.list(selectedOrg.id);
+  } catch (err) {
+    error(
+      `Failed to fetch projects: ${formatError(err)}`
+    );
+    process.exit(1);
+  }
+  if (projects.length === 0) {
+    warn("No projects found. Create one in the web UI first.");
+    process.exit(1);
+  }
+  let selectedProject;
+  if (projectSlugArg) {
+    const match = projects.find((p) => p.slug === projectSlugArg);
+    if (!match) {
+      error(`Project "${projectSlugArg}" not found`);
+      process.exit(1);
+    }
+    selectedProject = match;
+  } else if (projects.length === 1) {
+    selectedProject = projects[0];
+    info(`Using project: ${selectedProject.name}`);
+  } else {
+    heading("Select project");
+    selectedProject = await pickFromList(
+      projects,
+      (p) => `${p.name} ${colors.dim}(${p.slug})${colors.reset}`,
+      "project"
+    );
+  }
+  const environment = envArg || "production";
+  setLinkContext({
+    orgId: selectedOrg.id,
+    orgSlug: selectedOrg.slug,
+    projectId: selectedProject.id,
+    projectSlug: selectedProject.slug,
+    environment,
+    endpoint
+  });
+  success(
+    `Linked to ${selectedOrg.slug}/${selectedProject.slug} (${environment})`
+  );
+}
+function status() {
+  const config = readGlobalConfig();
+  const token = process.env.UIDEX_TOKEN || config.token;
+  const link2 = config.links[process.cwd()];
+  heading("uidex status");
+  if (!token) {
+    info("Auth: not logged in");
+    console.log(`  Run ${colors.cyan}uidex login${colors.reset} to authenticate.`);
+    return;
+  }
+  info(`Auth: logged in (token: ${token.slice(0, 8)}...)`);
+  if (!link2) {
+    console.log("");
+    info("Project: not linked");
+    console.log(`  Run ${colors.cyan}uidex link${colors.reset} to link a project.`);
+    return;
+  }
+  console.log("");
+  info(`Organization: ${link2.orgSlug}`);
+  info(`Project: ${link2.projectSlug}`);
+  info(`Environment: ${link2.environment}`);
+  info(`Endpoint: ${link2.endpoint}`);
+}
+
+// scripts/feedback.ts
+var import_readline2 = __toESM(require("readline"), 1);
+init_cli_utils();
+async function listFeedback(args2) {
+  const ctx = requireContext();
+  const flags = parseFlags(args2);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  const params = {};
+  if (flags.status) params.status = flags.status.split(",");
+  if (flags.type) params.type = flags.type.split(",");
+  if (flags.severity) params.severity = flags.severity.split(",");
+  if (flags.limit) params.limit = parseInt(flags.limit, 10);
+  if (flags.page) params.page = parseInt(flags.page, 10);
+  if (flags.sort) params.sort = flags.sort;
+  if (flags.order && (flags.order === "asc" || flags.order === "desc")) {
+    params.order = flags.order;
+  }
+  if (flags.search) params.search = flags.search;
+  try {
+    const result = await client.feedback.list(
+      ctx.orgId,
+      ctx.projectId,
+      params
+    );
+    if (result.data.length === 0) {
+      info("No feedback found.");
+      return;
+    }
+    heading(`Feedback (${ctx.orgSlug}/${ctx.projectSlug})`);
+    console.log(
+      `  ${colors.dim}${pad("#", 6)} ${pad("TYPE", 12)} ${pad("SEVERITY", 10)} ${pad("STATUS", 12)} ${pad("DESCRIPTION", 40)} ${pad("CREATED", 14)}${colors.reset}`
+    );
+    for (const f of result.data) {
+      const desc = truncate(f.title || f.description, 40);
+      console.log(
+        `  ${pad(String(f.sequence_number), 6)} ${pad(f.type, 12)} ${pad(f.severity, 10)} ${pad(f.status, 12)} ${pad(desc, 40)} ${pad(formatDate(f.created_at), 14)}`
+      );
+    }
+    console.log(
+      `
+  ${colors.dim}Page ${result.page} of ${Math.ceil(result.total / result.limit)}, ${result.total} total${colors.reset}`
+    );
+  } catch (err) {
+    error(`Failed to list feedback: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function showFeedback(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex feedback show <id>");
+    process.exit(1);
+  }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    let feedback;
+    const seqNum = parseInt(id, 10);
+    if (!isNaN(seqNum) && String(seqNum) === id) {
+      const result = await client.feedback.list(ctx.orgId, ctx.projectId, {
+        sequence_number: seqNum,
+        limit: 1
+      });
+      if (result.data.length === 0) {
+        error(`Feedback #${seqNum} not found`);
+        process.exit(1);
+      }
+      feedback = result.data[0];
+    } else {
+      feedback = await client.feedback.get(ctx.orgId, ctx.projectId, id);
+    }
+    heading(`Feedback #${feedback.sequence_number}`);
+    const fields = [
+      ["Type", feedback.type],
+      ["Severity", feedback.severity],
+      ["Status", feedback.status],
+      ["Priority", feedback.priority || "-"],
+      ["Component", feedback.component_id],
+      ["URL", feedback.url],
+      ["Reporter", feedback.reporter_email || feedback.reporter_name || "-"],
+      ["Tags", feedback.tags?.join(", ") || "-"],
+      ["Created", formatDate(feedback.created_at)],
+      ["Updated", formatDate(feedback.updated_at)]
+    ];
+    for (const [label, value] of fields) {
+      console.log(`  ${colors.dim}${pad(label, 12)}${colors.reset} ${value}`);
+    }
+    if (feedback.title) {
+      console.log(`
+  ${colors.bold}${feedback.title}${colors.reset}`);
+    }
+    console.log(`
+  ${feedback.description}`);
+    if (feedback.console_logs && feedback.console_logs.length > 0) {
+      console.log(`
+  ${colors.dim}Console Logs:${colors.reset}`);
+      for (const log2 of feedback.console_logs) {
+        const levelColor = log2.level === "error" ? colors.red : log2.level === "warn" ? colors.yellow : colors.dim;
+        console.log(
+          `    ${levelColor}[${log2.level}]${colors.reset} ${log2.message}`
+        );
+      }
+    }
+    if (feedback.network_errors && feedback.network_errors.length > 0) {
+      console.log(`
+  ${colors.dim}Network Errors:${colors.reset}`);
+      for (const ne of feedback.network_errors) {
+        console.log(
+          `    ${colors.red}${ne.method} ${ne.url} \u2192 ${ne.status || "failed"}${colors.reset}`
+        );
+      }
+    }
+  } catch (err) {
+    error(`Failed to show feedback: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function updateFeedback(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error(
+      "Usage: uidex feedback update <id> [--status=...] [--priority=...] [--tags=...]"
+    );
+    process.exit(1);
+  }
+  const flags = parseFlags(args2.slice(1));
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  const params = {};
+  if (flags.status) params.status = flags.status;
+  if (flags.priority) params.priority = flags.priority;
+  if (flags.resolution) params.resolution = flags.resolution;
+  if (flags.tags) params.tags = flags.tags.split(",");
+  if (flags.assign) params.assignee_id = flags.assign;
+  if (Object.keys(params).length === 0) {
+    error("No update flags provided. Use --status, --priority, --tags, etc.");
+    process.exit(1);
+  }
+  try {
+    const updated = await client.feedback.update(
+      ctx.orgId,
+      ctx.projectId,
+      id,
+      params
+    );
+    success(`Updated feedback #${updated.sequence_number}`);
+  } catch (err) {
+    error(`Failed to update feedback: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function deleteFeedback(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex feedback delete <id> [--force]");
+    process.exit(1);
+  }
+  const force = args2.includes("--force");
+  if (!force) {
+    const rl = import_readline2.default.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve6) => {
+      rl.question(`Delete feedback ${id}? (y/N): `, (ans) => {
+        rl.close();
+        resolve6(ans);
+      });
+    });
+    if (answer.trim().toLowerCase() !== "y") {
+      info("Cancelled.");
+      return;
+    }
+  }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    await client.feedback.delete(ctx.orgId, ctx.projectId, id);
+    success(`Deleted feedback ${id}`);
+  } catch (err) {
+    error(`Failed to delete feedback: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+function printFeedbackHelp() {
+  console.log("\nUsage: uidex feedback <command>\n");
+  console.log("Commands:");
+  console.log("  list              List feedback with optional filters");
+  console.log("  show <id>         Show feedback details");
+  console.log("  update <id>       Update feedback status/priority/tags");
+  console.log("  delete <id>       Delete feedback");
+  console.log("");
+  console.log("Flags for list:");
+  console.log("  --status=open,triaged    Filter by status");
+  console.log("  --type=bug               Filter by type");
+  console.log("  --severity=high,critical Filter by severity");
+  console.log("  --limit=25               Items per page");
+  console.log("  --page=1                 Page number");
+  console.log("  --sort=created_at        Sort field");
+  console.log("  --order=desc             Sort order");
+  console.log("");
+}
+async function handleFeedback(args2) {
+  const subcommand = args2[0];
+  switch (subcommand) {
+    case "list":
+      return listFeedback(args2.slice(1));
+    case "show":
+      return showFeedback(args2.slice(1));
+    case "update":
+      return updateFeedback(args2.slice(1));
+    case "delete":
+      return deleteFeedback(args2.slice(1));
+    default:
+      printFeedbackHelp();
+  }
+}
+
+// scripts/triage.ts
+init_cli_utils();
+async function runTriage() {
+  const ctx = requireContext();
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  info("Running triage...");
+  try {
+    const result = await client.triage.run(ctx.orgId, ctx.projectId);
+    if (result.proposals.length === 0 && result.updated.length === 0) {
+      info("No untriaged feedback to process.");
+      return;
+    }
+    if (result.proposals.length > 0) {
+      success(
+        `Created ${result.proposals.length} proposal(s) from untriaged feedback`
+      );
+      for (const p of result.proposals) {
+        console.log(
+          `  ${colors.dim}-${colors.reset} ${p.title} ${colors.dim}(${p.feedback_count || 0} feedback)${colors.reset}`
+        );
+      }
+    }
+    if (result.updated.length > 0) {
+      info(`Updated ${result.updated.length} existing proposal(s)`);
+    }
+  } catch (err) {
+    error(`Failed to run triage: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function listDrafts(args2) {
+  const ctx = requireContext();
+  const flags = parseFlags(args2);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const drafts = await client.drafts.list(ctx.orgId, ctx.projectId, {
+      status: flags.status,
+      composed_by: flags["composed-by"]
+    });
+    if (drafts.length === 0) {
+      info("No issue drafts found.");
+      return;
+    }
+    heading(`Issue Drafts (${ctx.orgSlug}/${ctx.projectSlug})`);
+    console.log(
+      `  ${colors.dim}${pad("ID", 10)} ${pad("TITLE", 40)} ${pad("STATUS", 12)} ${pad("BY", 8)} ${pad("FB#", 5)} ${pad("CREATED", 14)}${colors.reset}`
+    );
+    for (const d of drafts) {
+      console.log(
+        `  ${pad(d.id.slice(0, 8), 10)} ${pad(truncate(d.title, 40), 40)} ${pad(d.status, 12)} ${pad(d.composed_by, 8)} ${pad(String(d.feedback_count || 0), 5)} ${pad(formatDate(d.created_at), 14)}`
+      );
+    }
+  } catch (err) {
+    error(`Failed to list drafts: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function showDraft(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex triage show <id>");
+    process.exit(1);
+  }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const draft = await client.drafts.get(ctx.orgId, id);
+    heading(`Draft: ${draft.title}`);
+    const fields = [
+      ["Status", draft.status],
+      ["Composed by", draft.composed_by],
+      ["Labels", (draft.labels || []).join(", ") || "-"],
+      ["Created", formatDate(draft.created_at)]
+    ];
+    for (const [label, value] of fields) {
+      console.log(
+        `  ${colors.dim}${pad(label, 14)}${colors.reset} ${value}`
+      );
+    }
+    console.log(`
+${draft.body}`);
+    if (draft.reasoning) {
+      console.log(
+        `
+  ${colors.dim}Reasoning:${colors.reset} ${draft.reasoning}`
+      );
+    }
+    if (draft.feedback_ids && draft.feedback_ids.length > 0) {
+      console.log(
+        `
+  ${colors.dim}Linked feedback:${colors.reset} ${draft.feedback_ids.length} item(s)`
+      );
+    }
+  } catch (err) {
+    error(`Failed to show draft: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function approveDraft(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex triage approve <id>");
+    process.exit(1);
+  }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const updated = await client.drafts.update(ctx.orgId, id, {
+      status: "draft"
+    });
+    success(`Approved: ${updated.title} (status: draft)`);
+  } catch (err) {
+    error(`Failed to approve draft: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function dismissDraft(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex triage dismiss <id>");
+    process.exit(1);
+  }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const updated = await client.drafts.update(ctx.orgId, id, {
+      status: "dismissed"
+    });
+    success(`Dismissed: ${updated.title}`);
+  } catch (err) {
+    error(`Failed to dismiss draft: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+async function submitDraft(args2) {
+  const ctx = requireContext();
+  const id = args2[0];
+  if (!id) {
+    error("Usage: uidex triage submit <id>");
+    process.exit(1);
   }
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const result = await client.drafts.submit(ctx.orgId, id);
+    success(`Submitted! External issue: ${result.external_url}`);
+  } catch (err) {
+    error(`Failed to submit draft: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+function printTriageHelp() {
+  console.log("\nUsage: uidex triage <command>\n");
+  console.log("Commands:");
+  console.log("  run               Run AI triage on untriaged feedback");
+  console.log("  list              List issue draft proposals");
+  console.log("  show <id>         Show draft details and linked feedback");
+  console.log("  approve <id>      Move draft from suggested to approved");
+  console.log("  dismiss <id>      Dismiss a draft proposal");
+  console.log("  submit <id>       Submit draft to external issue tracker");
   console.log("");
-  info(`${generated} file(s) generated, ${skipped} skipped`);
-  if (generated > 0) {
-    console.log("");
-    info("Next steps:");
-    console.log("  1. Replace test.todo() calls with test implementations");
-    console.log("  2. Use the uidex fixture for type-safe selectors:");
-    console.log("");
-    console.log("     test('add todo', async ({ uidex }) => {");
-    console.log("       await uidex('todo-input').fill('Buy milk');");
-    console.log("       await uidex('todo-add-button').click();");
-    console.log("     });");
-    console.log("");
+  console.log("Flags for list:");
+  console.log("  --status=suggested,draft  Filter by status");
+  console.log("  --composed-by=auto        Filter by composition method");
+  console.log("");
+}
+async function handleTriage(args2) {
+  const subcommand = args2[0];
+  switch (subcommand) {
+    case "run":
+      return runTriage();
+    case "list":
+      return listDrafts(args2.slice(1));
+    case "show":
+      return showDraft(args2.slice(1));
+    case "approve":
+      return approveDraft(args2.slice(1));
+    case "dismiss":
+      return dismissDraft(args2.slice(1));
+    case "submit":
+      return submitDraft(args2.slice(1));
+    default:
+      printTriageHelp();
   }
 }
 
-// scripts/claude-setup.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-function readTemplate(filename) {
-  const candidates = [
-    // Built package: __dirname = <pkg>/dist/scripts → ../../claude/
-    path4.resolve(__dirname, "..", "..", "claude", filename),
-    // Dev mode: __dirname = <repo>/scripts → ../claude/
-    path4.resolve(__dirname, "..", "claude", filename)
-  ];
-  for (const candidate of candidates) {
-    try {
-      return fs4.readFileSync(candidate, "utf-8");
-    } catch {
-    }
+// scripts/integrations.ts
+var import_readline3 = __toESM(require("readline"), 1);
+init_cli_utils();
+function resolveOrgContext(flags) {
+  const token = getToken();
+  if (!token) {
+    error("Not logged in. Run `uidex login` first.");
+    process.exit(1);
   }
-  throw new Error(
-    `Template not found: ${filename}. The uidex package may be corrupted \u2014 try reinstalling.`
-  );
+  const link2 = getLinkContext();
+  const endpoint = resolveEndpoint(link2 ?? void 0);
+  const orgId = flags.org || process.env.UIDEX_ORG_ID || link2?.orgId;
+  if (!orgId) {
+    error("No organization context. Run `uidex link` first or pass --org=<id>.");
+    process.exit(1);
+  }
+  return { token, endpoint, orgId };
 }
-function ensureDir(dirPath) {
-  fs4.mkdirSync(dirPath, { recursive: true });
+function prompt2(question, mask = false) {
+  const rl = import_readline3.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  if (mask) {
+    const origWrite = rl._writeToOutput;
+    rl._writeToOutput = (s) => {
+      if (s.includes(question)) {
+        origWrite.call(rl, s);
+      } else {
+        origWrite.call(rl, "*".repeat(s.replace(/\r?\n/, "").length));
+      }
+    };
+  }
+  return new Promise((resolve6) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      if (mask) console.log();
+      resolve6(answer.trim());
+    });
+  });
 }
-function addRules() {
-  const cwd = process.cwd();
-  const targetDir = path4.join(cwd, ".claude", "rules");
-  const targetPath = path4.join(targetDir, "uidex.md");
-  const content = readTemplate("rules.md");
-  ensureDir(targetDir);
-  fs4.writeFileSync(targetPath, content, "utf-8");
-  success("Added .claude/rules/uidex.md");
+function confirm(question) {
+  return prompt2(question).then((a) => a.toLowerCase() === "y");
 }
-function removeRules() {
-  const targetPath = path4.join(process.cwd(), ".claude", "rules", "uidex.md");
+async function listIntegrations(args2) {
+  const flags = parseFlags(args2);
+  const ctx = resolveOrgContext(flags);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
   try {
-    fs4.unlinkSync(targetPath);
-    success("Removed .claude/rules/uidex.md");
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      info(".claude/rules/uidex.md does not exist");
-    } else {
-      throw e;
+    const integrations = await client.integrations.list(ctx.orgId);
+    if (integrations.length === 0) {
+      info(
+        "No integrations configured. Run `uidex integrations add` to add one."
+      );
+      return;
+    }
+    console.log(
+      `
+  ${colors.dim}${pad("ID", 20)} ${pad("PROVIDER", 10)} ${pad("LABEL", 24)} ${pad("CREATED", 14)}${colors.reset}`
+    );
+    for (const i of integrations) {
+      console.log(
+        `  ${pad(i.id.slice(0, 18), 20)} ${pad(i.provider, 10)} ${pad(i.label, 24)} ${pad(formatDate(i.created_at), 14)}`
+      );
     }
+    console.log();
+  } catch (err) {
+    error(`Failed to list integrations: ${formatError(err)}`);
+    process.exit(1);
   }
 }
-function addSkill() {
-  const cwd = process.cwd();
-  const targetDir = path4.join(cwd, ".claude", "commands");
-  const targetPath = path4.join(targetDir, "uidex-audit.md");
-  const content = readTemplate("audit-command.md");
-  ensureDir(targetDir);
-  fs4.writeFileSync(targetPath, content, "utf-8");
-  success("Added .claude/commands/uidex-audit.md");
+async function addJiraInteractive(client, orgId, flagLabel) {
+  const label = flagLabel || await prompt2("Label (Jira): ") || "Jira";
+  const url = await prompt2("Instance URL (e.g. https://team.atlassian.net): ");
+  if (!url) {
+    error("Instance URL is required.");
+    process.exit(1);
+  }
+  const email = await prompt2("Email: ");
+  if (!email) {
+    error("Email is required.");
+    process.exit(1);
+  }
+  const apiToken = await prompt2("API token: ", true);
+  if (!apiToken) {
+    error("API token is required.");
+    process.exit(1);
+  }
+  await createJiraIntegration(client, orgId, label, url, email, apiToken);
 }
-function removeSkill() {
-  const targetPath = path4.join(process.cwd(), ".claude", "commands", "uidex-audit.md");
+async function createJiraIntegration(client, orgId, label, url, email, apiToken) {
+  info("Testing connection...");
   try {
-    fs4.unlinkSync(targetPath);
-    success("Removed .claude/commands/uidex-audit.md");
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      info(".claude/commands/uidex-audit.md does not exist");
-    } else {
-      throw e;
+    const integration = await client.integrations.create(orgId, {
+      provider: "jira",
+      label,
+      config: { baseUrl: url },
+      credentials: { email, apiToken }
+    });
+    const result = await client.integrations.test(orgId, integration.id);
+    if (!result.ok) {
+      error(`Connection test failed: ${result.error}`);
+      const retry = await confirm("Retry with different credentials? (y/N): ");
+      if (retry) {
+        await client.integrations.delete(orgId, integration.id);
+        return addJiraInteractive(client, orgId, label);
+      }
+      await client.integrations.delete(orgId, integration.id);
+      process.exit(1);
     }
+    success(`Integration created: ${label} (id: ${integration.id})`);
+  } catch (err) {
+    error(`Failed to create integration: ${formatError(err)}`);
+    process.exit(1);
   }
 }
-var UIDEX_HOOK_COMMAND = "npx uidex scan --check";
-function isUidexHookEntry(entry) {
-  return entry.hooks?.some((h) => h.command === UIDEX_HOOK_COMMAND) ?? false;
-}
-function readSettings(settingsPath) {
+async function addGithub(client, orgId, endpoint) {
+  let slug = null;
   try {
-    return JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      return {};
+    const res = await fetch(`${endpoint}/api/server/info`);
+    if (res.ok) {
+      const data = await res.json();
+      slug = data.githubAppSlug;
     }
-    error(`Failed to parse .claude/settings.json: ${e.message}`);
+  } catch {
+  }
+  if (!slug) {
+    error("GitHub App is not configured on this uidex instance.");
     process.exit(1);
   }
+  const existingBefore = await client.integrations.list(orgId);
+  const installUrl = `https://github.com/apps/${slug}/installations/new`;
+  info("Opening browser for GitHub App installation...");
+  console.log(
+    `
+  If the browser doesn't open, visit:
+  ${colors.dim}${installUrl}${colors.reset}
+`
+  );
+  openBrowser2(installUrl);
+  info("Waiting for GitHub App installation...");
+  const deadline = Date.now() + 12e4;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    try {
+      const current = await client.integrations.list(orgId);
+      const newIntegration = current.find(
+        (i) => i.provider === "github" && !existingBefore.some((e) => e.id === i.id)
+      );
+      if (newIntegration) {
+        success(
+          `Integration created: ${newIntegration.label} (id: ${newIntegration.id})`
+        );
+        return;
+      }
+    } catch {
+    }
+  }
+  error("Timed out waiting for GitHub App installation.");
+  process.exit(1);
 }
-function addHooks() {
-  const cwd = process.cwd();
-  const settingsDir = path4.join(cwd, ".claude");
-  const settingsPath = path4.join(settingsDir, "settings.json");
-  const settings = readSettings(settingsPath);
-  if (!settings.hooks) {
-    settings.hooks = {};
+function openBrowser2(url) {
+  const { exec } = require("child_process");
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+async function addIntegration(args2) {
+  const provider = args2[0];
+  if (!provider || provider !== "jira" && provider !== "github") {
+    error("Usage: uidex integrations add <jira|github> [--label=...]");
+    process.exit(1);
   }
-  if (!Array.isArray(settings.hooks.PostToolUse)) {
-    settings.hooks.PostToolUse = [];
+  const flags = parseFlags(args2.slice(1));
+  const ctx = resolveOrgContext(flags);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  if (provider === "jira") {
+    if (flags.url && flags.email && flags.token) {
+      const label = flags.label || "Jira";
+      await createJiraIntegration(
+        client,
+        ctx.orgId,
+        label,
+        flags.url,
+        flags.email,
+        flags.token
+      );
+    } else {
+      await addJiraInteractive(client, ctx.orgId, flags.label);
+    }
+  } else {
+    await addGithub(client, ctx.orgId, ctx.endpoint);
   }
-  if (settings.hooks.PostToolUse.some(isUidexHookEntry)) {
-    info("uidex hook already configured in .claude/settings.json");
-    return;
+}
+async function testIntegration(args2) {
+  const integrationId = args2[0];
+  if (!integrationId) {
+    error("Usage: uidex integrations test <integrationId>");
+    process.exit(1);
+  }
+  const flags = parseFlags(args2.slice(1));
+  const ctx = resolveOrgContext(flags);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const result = await client.integrations.test(ctx.orgId, integrationId);
+    if (result.ok) {
+      success("Connection OK");
+    } else {
+      error(result.error || "Connection test failed");
+      process.exit(1);
+    }
+  } catch (err) {
+    error(`Failed to test integration: ${formatError(err)}`);
+    process.exit(1);
   }
-  settings.hooks.PostToolUse.push({
-    matcher: "Edit|Write",
-    hooks: [
-      {
-        type: "command",
-        command: UIDEX_HOOK_COMMAND,
-        timeout: 30
-      }
-    ]
-  });
-  ensureDir(settingsDir);
-  fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  success("Added uidex hook to .claude/settings.json");
 }
-function removeHooks() {
-  const settingsPath = path4.join(process.cwd(), ".claude", "settings.json");
-  const settings = readSettings(settingsPath);
-  if (!Array.isArray(settings.hooks?.PostToolUse)) {
-    info("No PostToolUse hooks configured");
-    return;
+async function removeIntegration(args2) {
+  const integrationId = args2[0];
+  if (!integrationId) {
+    error("Usage: uidex integrations remove <integrationId> [--force]");
+    process.exit(1);
   }
-  const before = settings.hooks.PostToolUse.length;
-  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
-    (entry) => !isUidexHookEntry(entry)
-  );
-  const after = settings.hooks.PostToolUse.length;
-  if (before === after) {
-    info("No uidex hook found in .claude/settings.json");
-    return;
+  const flags = parseFlags(args2.slice(1));
+  const force = args2.includes("--force");
+  const ctx = resolveOrgContext(flags);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  if (!force) {
+    let label = integrationId;
+    try {
+      const integration = await client.integrations.get(
+        ctx.orgId,
+        integrationId
+      );
+      label = `'${integration.label}' (${integrationId})`;
+    } catch {
+    }
+    const confirmed = await confirm(`Remove integration ${label}? (y/N): `);
+    if (!confirmed) {
+      info("Cancelled.");
+      return;
+    }
   }
-  if (settings.hooks.PostToolUse.length === 0) {
-    delete settings.hooks.PostToolUse;
+  try {
+    await client.integrations.delete(ctx.orgId, integrationId);
+    success(`Removed integration ${integrationId}`);
+  } catch (err) {
+    error(`Failed to remove integration: ${formatError(err)}`);
+    process.exit(1);
   }
-  if (Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
+}
+async function listTargets(args2) {
+  const integrationId = args2[0];
+  if (!integrationId) {
+    error("Usage: uidex integrations targets <integrationId> [--parent=...]");
+    process.exit(1);
+  }
+  const flags = parseFlags(args2.slice(1));
+  const ctx = resolveOrgContext(flags);
+  const client = createClient({ endpoint: ctx.endpoint, token: ctx.token });
+  try {
+    const targets = await client.integrations.listTargets(
+      ctx.orgId,
+      integrationId,
+      flags.parent
+    );
+    if (targets.length === 0) {
+      info("No targets found.");
+      return;
+    }
+    console.log(
+      `
+  ${colors.dim}${pad("ID", 24)} ${pad("LABEL", 32)} ${"HAS CHILDREN"}${colors.reset}`
+    );
+    for (const t of targets) {
+      console.log(
+        `  ${pad(t.id, 24)} ${pad(t.label, 32)} ${t.children ? "yes" : "-"}`
+      );
+    }
+    console.log();
+  } catch (err) {
+    error(`Failed to list targets: ${formatError(err)}`);
+    process.exit(1);
   }
-  fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-  success("Removed uidex hook from .claude/settings.json");
 }
-function claudeInit() {
-  heading("uidex claude init");
-  addRules();
-  addSkill();
-  addHooks();
+function printIntegrationsHelp() {
+  console.log("\nUsage: uidex integrations <command>\n");
+  console.log("Commands:");
+  console.log("  list                        List configured integrations");
+  console.log("  add <jira|github>           Add a new integration");
+  console.log("  test <integrationId>        Test integration connection");
+  console.log("  remove <integrationId>      Remove an integration");
+  console.log(
+    "  targets <integrationId>     List available targets (repos, projects)"
+  );
   console.log("");
-  success("Claude Code integration ready");
-}
-function claudeTeardown() {
-  heading("uidex claude teardown");
-  removeRules();
-  removeSkill();
-  removeHooks();
+  console.log("Flags:");
+  console.log("  --org=<orgId>               Override organization");
   console.log("");
-  success("Claude Code integration removed");
-}
-function printClaudeHelp() {
-  heading("uidex claude");
-  console.log("Manage Claude Code integration for uidex.\n");
-  console.log("Usage: uidex claude <command> [action]\n");
-  console.log("Commands:");
-  console.log("  init                Add rules, skill, and hooks");
-  console.log("  teardown            Remove rules, skill, and hooks");
-  console.log("  rules [add|remove]  Manage .claude/rules/uidex.md");
-  console.log("  skill [add|remove]  Manage .claude/commands/uidex-audit.md");
-  console.log("  hooks [add|remove]  Manage .claude/settings.json hook");
+  console.log("Flags for add jira (non-interactive):");
+  console.log("  --label=<name>              Integration label");
+  console.log("  --url=<url>                 Jira instance URL");
+  console.log("  --email=<email>             Jira email");
+  console.log("  --token=<token>             Jira API token");
   console.log("");
+  console.log("Flags for remove:");
+  console.log("  --force                     Skip confirmation prompt");
+  console.log("");
+  console.log("Flags for targets:");
+  console.log("  --parent=<parentId>         Filter targets by parent");
+  console.log("");
+}
+async function handleIntegrations(args2) {
+  const subcommand = args2[0];
+  switch (subcommand) {
+    case "list":
+      return listIntegrations(args2.slice(1));
+    case "add":
+      return addIntegration(args2.slice(1));
+    case "test":
+      return testIntegration(args2.slice(1));
+    case "remove":
+      return removeIntegration(args2.slice(1));
+    case "targets":
+      return listTargets(args2.slice(1));
+    default:
+      printIntegrationsHelp();
+  }
 }
 
 // scripts/cli.ts
+init_cli_utils();
 function printHelp() {
   console.log(`
 ${colors.bold}${colors.cyan}uidex${colors.reset}
 `);
   console.log("Usage: uidex <command>\n");
-  console.log("Commands:");
-  console.log("  init              Initialize uidex in your project");
-  console.log("  scan              Run the component scanner");
-  console.log("  scan --check      Validate UIDEX_PAGE.md coverage");
-  console.log("  scaffold [dir]    Generate Playwright test stubs from pages/features");
-  console.log("  claude            Manage Claude Code integration");
+  console.log(`${colors.dim}Setup${colors.reset}`);
+  console.log("  init                Initialize uidex in your project");
+  console.log("  scan                Run the component scanner");
+  console.log("  scan --audit        Validate coverage and annotations");
+  console.log("  scaffold [dir]      Generate Playwright test stubs");
+  console.log("  claude              Manage Claude Code integration");
+  console.log("");
+  console.log(`${colors.dim}Server${colors.reset}`);
+  console.log("  login               Authenticate with uidex server");
+  console.log("  logout              Remove stored credentials");
+  console.log("  link                Link current directory to org/project");
+  console.log("  status              Show auth and link state");
+  console.log("  feedback            Manage feedback (list, show, update, delete)");
+  console.log("  triage              Manage triage (run, list, show, approve, dismiss, submit)");
+  console.log("  integrations        Manage integrations (list, add, remove, test)");
   console.log("");
 }
 function parseAction(raw) {
@@ -1117,11 +3818,11 @@ function handleClaude(args2) {
     process.exit(1);
   }
   switch (subcommand) {
-    case "init":
-      claudeInit();
+    case "install":
+      claudeInstall();
       break;
-    case "teardown":
-      claudeTeardown();
+    case "uninstall":
+      claudeUninstall();
       break;
     case "rules":
       action === "remove" ? removeRules() : addRules();
@@ -1141,6 +3842,10 @@ var args = process.argv.slice(2);
 var command = args[0];
 switch (command) {
   case void 0:
+  case "--help":
+  case "-h":
+    printHelp();
+    break;
   case "init":
     init().catch((err) => {
       console.error("Error during initialization:", err);
@@ -1156,9 +3861,41 @@ switch (command) {
   case "claude":
     handleClaude(args.slice(1));
     break;
-  case "--help":
-  case "-h":
-    printHelp();
+  case "login":
+    login(args.slice(1)).catch((err) => {
+      console.error("Login error:", err);
+      process.exit(1);
+    });
+    break;
+  case "logout":
+    logout();
+    break;
+  case "link":
+    link(args.slice(1)).catch((err) => {
+      console.error("Link error:", err);
+      process.exit(1);
+    });
+    break;
+  case "status":
+    status();
+    break;
+  case "feedback":
+    handleFeedback(args.slice(1)).catch((err) => {
+      console.error("Feedback error:", err);
+      process.exit(1);
+    });
+    break;
+  case "triage":
+    handleTriage(args.slice(1)).catch((err) => {
+      console.error("Triage error:", err);
+      process.exit(1);
+    });
+    break;
+  case "integrations":
+    handleIntegrations(args.slice(1)).catch((err) => {
+      console.error("Integrations error:", err);
+      process.exit(1);
+    });
     break;
   default:
     console.error(`Unknown command: ${command}`);