uilint 0.2.1 → 0.2.4

package/dist/index.js

@@ -237,8 +237,8 @@ async function initializeLangfuseIfEnabled() {
               },
               { asType: "generation" }
             );
-            await new Promise((resolve7) => {
-              resolveTrace = resolve7;
+            await new Promise((resolve8) => {
+              resolveTrace = resolve8;
             });
             if (endData && generationRef) {
               const usageDetails = endData.usage ? Object.fromEntries(
@@ -329,6 +329,26 @@ function registerShutdownHandler() {
 }
 registerShutdownHandler();
 
+// src/utils/timing.ts
+function nsNow() {
+  return process.hrtime.bigint();
+}
+function nsToMs(ns) {
+  return Number(ns) / 1e6;
+}
+function formatMs(ms) {
+  if (!Number.isFinite(ms)) return "n/a";
+  if (ms < 1e3) return `${ms.toFixed(ms < 10 ? 2 : ms < 100 ? 1 : 0)}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(s < 10 ? 2 : 1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = s - m * 60;
+  return `${m}m ${rem.toFixed(rem < 10 ? 1 : 0)}s`;
+}
+function maybeMs(ms) {
+  return ms == null ? "n/a" : formatMs(ms);
+}
+
 // src/utils/prompts.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
@@ -337,8 +357,8 @@ import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 function getCLIVersion() {
   try {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkgPath = join2(__dirname, "..", "..", "package.json");
+    const __dirname3 = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join2(__dirname3, "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
@@ -369,7 +389,7 @@ async function withSpinner(message, fn) {
   const s = p.spinner();
   s.start(message);
   try {
-    const result = await fn();
+    const result = fn.length >= 1 ? await fn(s) : await fn();
     s.stop(pc.green("\u2713 ") + message);
     return result;
   } catch (error) {
@@ -642,6 +662,7 @@ async function scan(options) {
     } else if (dbg && styleSummary) {
       debugLog(dbg, "Style summary (preview)", preview(styleSummary, 800));
     }
+    const prepStartNs = nsNow();
     if (!isJsonOutput) {
       await withSpinner("Preparing Ollama", async () => {
         await ensureOllamaReady();
@@ -649,6 +670,7 @@ async function scan(options) {
     } else {
       await ensureOllamaReady();
     }
+    const prepEndNs = nsNow();
     const client = await createLLMClient({});
     let result;
     const prompt = snapshot.kind === "dom" ? buildAnalysisPrompt(styleSummary ?? "", styleGuide) : buildSourceAnalysisPrompt(snapshot.source, styleGuide, {
@@ -764,7 +786,33 @@ async function scan(options) {
     } else {
       const s = createSpinner();
       s.start("Analyzing with LLM");
-      const onProgress = (latestLine) => {
+      let thinkingStarted = false;
+      const analysisStartNs = nsNow();
+      let firstTokenNs = null;
+      let firstThinkingNs = null;
+      let lastThinkingNs = null;
+      let firstAnswerNs = null;
+      let lastAnswerNs = null;
+      const onProgress = (latestLine, _fullResponse, delta, thinkingDelta) => {
+        const nowNs = nsNow();
+        if (!firstTokenNs && (thinkingDelta || delta)) firstTokenNs = nowNs;
+        if (thinkingDelta) {
+          if (!firstThinkingNs) firstThinkingNs = nowNs;
+          lastThinkingNs = nowNs;
+        }
+        if (delta) {
+          if (!firstAnswerNs) firstAnswerNs = nowNs;
+          lastAnswerNs = nowNs;
+        }
+        if (thinkingDelta) {
+          if (!thinkingStarted) {
+            thinkingStarted = true;
+            s.stop(pc.dim("[scan] streaming thinking:"));
+            process.stderr.write(pc.dim("Thinking:\n"));
+          }
+          process.stderr.write(thinkingDelta);
+          return;
+        }
         const maxLen = 60;
         const displayLine = latestLine.length > maxLen ? latestLine.slice(0, maxLen) + "\u2026" : latestLine;
         s.message(`Analyzing: ${pc.dim(displayLine || "...")}`);
@@ -790,6 +838,29 @@ async function scan(options) {
           }
         );
         s.stop(pc.green("\u2713 ") + "Analyzing with LLM");
+        if (process.stdout.isTTY) {
+          const analysisEndNs = nsNow();
+          const prepMs = nsToMs(prepEndNs - prepStartNs);
+          const totalMs = nsToMs(analysisEndNs - analysisStartNs);
+          const endToEndMs = nsToMs(analysisEndNs - prepStartNs);
+          const ttftMs = firstTokenNs ? nsToMs(firstTokenNs - analysisStartNs) : null;
+          const thinkingMs = firstThinkingNs && (firstAnswerNs || lastThinkingNs) ? nsToMs(
+            (firstAnswerNs ?? lastThinkingNs ?? analysisEndNs) - firstThinkingNs
+          ) : null;
+          const outputMs = firstAnswerNs && (lastAnswerNs || analysisEndNs) ? nsToMs((lastAnswerNs ?? analysisEndNs) - firstAnswerNs) : null;
+          note2(
+            [
+              `Prepare Ollama: ${formatMs(prepMs)}`,
+              `Time to first token: ${maybeMs(ttftMs)}`,
+              `Thinking: ${maybeMs(thinkingMs)}`,
+              `Outputting: ${maybeMs(outputMs)}`,
+              `LLM total: ${formatMs(totalMs)}`,
+              `End-to-end: ${formatMs(endToEndMs)}`,
+              result?.analysisTime ? pc.dim(`(core analysisTime: ${formatMs(result.analysisTime)})`) : pc.dim("(core analysisTime: n/a)")
+            ].join("\n"),
+            "Timings"
+          );
+        }
       } catch (error) {
         s.stop(pc.red("\u2717 ") + "Analyzing with LLM");
         throw error;
@@ -970,6 +1041,7 @@ async function analyze(options) {
     } else if (resolvedStyle.path && !isJsonOutput) {
       logSuccess(`Using styleguide: ${pc.dim(resolvedStyle.path)}`);
     }
+    const prepStartNs = nsNow();
     if (!isJsonOutput) {
       await withSpinner("Preparing Ollama", async () => {
         await ensureOllamaReady2();
@@ -977,6 +1049,7 @@ async function analyze(options) {
     } else {
       await ensureOllamaReady2();
     }
+    const prepEndNs = nsNow();
     const client = await createLLMClient({});
     const promptContext = {
       filePath: options.filePath || (options.inputFile ? options.inputFile : void 0) || "component.tsx",
@@ -1065,17 +1138,65 @@ async function analyze(options) {
       if (!isJsonOutput) {
         const s = createSpinner();
         s.start("Analyzing with LLM");
+        let thinkingStarted = false;
+        const analysisStartNs = nsNow();
+        let firstTokenNs = null;
+        let firstThinkingNs = null;
+        let lastThinkingNs = null;
+        let firstAnswerNs = null;
+        let lastAnswerNs = null;
         try {
           responseText = await client.complete(prompt, {
             json: true,
             stream: true,
-            onProgress: (latestLine) => {
+            onProgress: (latestLine, _fullResponse, delta, thinkingDelta) => {
+              const nowNs = nsNow();
+              if (!firstTokenNs && (thinkingDelta || delta)) firstTokenNs = nowNs;
+              if (thinkingDelta) {
+                if (!firstThinkingNs) firstThinkingNs = nowNs;
+                lastThinkingNs = nowNs;
+              }
+              if (delta) {
+                if (!firstAnswerNs) firstAnswerNs = nowNs;
+                lastAnswerNs = nowNs;
+              }
+              if (thinkingDelta) {
+                if (!thinkingStarted) {
+                  thinkingStarted = true;
+                  s.stop(pc.dim("[analyze] streaming thinking:"));
+                  process.stderr.write(pc.dim("Thinking:\n"));
+                }
+                process.stderr.write(thinkingDelta);
+                return;
+              }
               const maxLen = 60;
               const line = latestLine.length > maxLen ? latestLine.slice(0, maxLen) + "\u2026" : latestLine;
               s.message(`Analyzing: ${pc.dim(line || "...")}`);
             }
           });
           s.stop(pc.green("\u2713 ") + "Analyzing with LLM");
+          if (process.stdout.isTTY) {
+            const analysisEndNs = nsNow();
+            const prepMs = nsToMs(prepEndNs - prepStartNs);
+            const totalMs = nsToMs(analysisEndNs - analysisStartNs);
+            const endToEndMs = nsToMs(analysisEndNs - prepStartNs);
+            const ttftMs = firstTokenNs ? nsToMs(firstTokenNs - analysisStartNs) : null;
+            const thinkingMs = firstThinkingNs && (firstAnswerNs || lastThinkingNs) ? nsToMs(
+              (firstAnswerNs ?? lastThinkingNs ?? analysisEndNs) - firstThinkingNs
+            ) : null;
+            const outputMs = firstAnswerNs && (lastAnswerNs || analysisEndNs) ? nsToMs((lastAnswerNs ?? analysisEndNs) - firstAnswerNs) : null;
+            note2(
+              [
+                `Prepare Ollama: ${formatMs(prepMs)}`,
+                `Time to first token: ${maybeMs(ttftMs)}`,
+                `Thinking: ${maybeMs(thinkingMs)}`,
+                `Outputting: ${maybeMs(outputMs)}`,
+                `LLM total: ${formatMs(totalMs)}`,
+                `End-to-end: ${formatMs(endToEndMs)}`
+              ].join("\n"),
+              "Timings"
+            );
+          }
         } catch (e) {
           s.stop(pc.red("\u2717 ") + "Analyzing with LLM");
           throw e;
@@ -1128,14 +1249,14 @@ import {
 } from "uilint-core";
 import { ensureOllamaReady as ensureOllamaReady3 } from "uilint-core/node";
 async function readStdin2() {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let data = "";
     const rl = createInterface({ input: process.stdin });
     rl.on("line", (line) => {
       data += line;
     });
     rl.on("close", () => {
-      resolve7(data);
+      resolve8(data);
     });
   });
 }
@@ -1354,13 +1475,13 @@ async function update(options) {
 }
 
 // src/commands/install.ts
-import { join as join12 } from "path";
+import { join as join16 } from "path";
 import { ruleRegistry as ruleRegistry2 } from "uilint-eslint";
 
 // src/commands/install/analyze.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4 } from "fs";
-import { join as join7 } from "path";
-import { findWorkspaceRoot as findWorkspaceRoot4 } from "uilint-core/node";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
+import { findWorkspaceRoot as findWorkspaceRoot5 } from "uilint-core/node";
 
 // src/utils/next-detect.ts
 import { existsSync as existsSync4, readdirSync } from "fs";
@@ -1444,10 +1565,113 @@ function findNextAppRouterProjects(rootDir, options) {
   return results;
 }
 
-// src/utils/package-detect.ts
+// src/utils/vite-detect.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join4, relative } from "path";
+import { join as join4 } from "path";
+var VITE_CONFIG_EXTS = [".ts", ".mjs", ".js", ".cjs"];
+function findViteConfigFile(projectPath) {
+  for (const ext of VITE_CONFIG_EXTS) {
+    const rel = `vite.config${ext}`;
+    if (existsSync5(join4(projectPath, rel))) return rel;
+  }
+  return null;
+}
+function looksLikeReactPackage(projectPath) {
+  try {
+    const pkgPath = join4(projectPath, "package.json");
+    if (!existsSync5(pkgPath)) return false;
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const deps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+    return "react" in deps || "react-dom" in deps;
+  } catch {
+    return false;
+  }
+}
+function fileExists2(projectPath, relPath) {
+  return existsSync5(join4(projectPath, relPath));
+}
+function detectViteReact(projectPath) {
+  const configFile = findViteConfigFile(projectPath);
+  if (!configFile) return null;
+  if (!looksLikeReactPackage(projectPath)) return null;
+  const entryRoot = "src";
+  const candidates = [];
+  const entryCandidates = [
+    join4(entryRoot, "main.tsx"),
+    join4(entryRoot, "main.jsx"),
+    join4(entryRoot, "main.ts"),
+    join4(entryRoot, "main.js")
+  ];
+  for (const rel of entryCandidates) {
+    if (fileExists2(projectPath, rel)) candidates.push(rel);
+  }
+  const fallbackCandidates = [
+    join4(entryRoot, "App.tsx"),
+    join4(entryRoot, "App.jsx")
+  ];
+  for (const rel of fallbackCandidates) {
+    if (!candidates.includes(rel) && fileExists2(projectPath, rel)) {
+      candidates.push(rel);
+    }
+  }
+  return {
+    configFile,
+    configFileAbs: join4(projectPath, configFile),
+    entryRoot,
+    candidates
+  };
+}
 var DEFAULT_IGNORE_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".vercel",
+  ".cursor",
+  "coverage",
+  ".uilint"
+]);
+function findViteReactProjects(rootDir, options) {
+  const maxDepth = options?.maxDepth ?? 4;
+  const ignoreDirs = options?.ignoreDirs ?? DEFAULT_IGNORE_DIRS2;
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    if (visited.has(dir)) return;
+    visited.add(dir);
+    const detection = detectViteReact(dir);
+    if (detection) {
+      results.push({ projectPath: dir, detection });
+      return;
+    }
+    let entries = [];
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true }).map((d) => ({
+        name: d.name,
+        isDirectory: d.isDirectory()
+      }));
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory) continue;
+      if (ignoreDirs.has(ent.name)) continue;
+      if (ent.name.startsWith(".") && ent.name !== ".") continue;
+      walk(join4(dir, ent.name), depth + 1);
+    }
+  }
+  walk(rootDir, 0);
+  return results;
+}
+
+// src/utils/package-detect.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5, relative } from "path";
+var DEFAULT_IGNORE_DIRS3 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
   ".next",
@@ -1463,6 +1687,7 @@ var DEFAULT_IGNORE_DIRS2 = /* @__PURE__ */ new Set([
 ]);
 var ESLINT_CONFIG_FILES = [
   "eslint.config.js",
+  "eslint.config.ts",
   "eslint.config.mjs",
   "eslint.config.cjs",
   ".eslintrc.js",
@@ -1489,16 +1714,34 @@ function isFrontendPackage(pkgJson) {
   };
   return FRONTEND_INDICATORS.some((pkg) => pkg in deps);
 }
+function isTypeScriptPackage(dir, pkgJson) {
+  if (existsSync6(join5(dir, "tsconfig.json"))) {
+    return true;
+  }
+  const deps = {
+    ...pkgJson.dependencies,
+    ...pkgJson.devDependencies
+  };
+  if ("typescript" in deps) {
+    return true;
+  }
+  for (const configFile of ESLINT_CONFIG_FILES) {
+    if (configFile.endsWith(".ts") && existsSync6(join5(dir, configFile))) {
+      return true;
+    }
+  }
+  return false;
+}
 function hasEslintConfig(dir) {
   for (const file of ESLINT_CONFIG_FILES) {
-    if (existsSync5(join4(dir, file))) {
+    if (existsSync6(join5(dir, file))) {
       return true;
     }
   }
   try {
-    const pkgPath = join4(dir, "package.json");
-    if (existsSync5(pkgPath)) {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const pkgPath = join5(dir, "package.json");
+    if (existsSync6(pkgPath)) {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       if (pkg.eslintConfig) return true;
     }
   } catch {
@@ -1507,14 +1750,14 @@ function hasEslintConfig(dir) {
 }
 function findPackages(rootDir, options) {
   const maxDepth = options?.maxDepth ?? 5;
-  const ignoreDirs = options?.ignoreDirs ?? DEFAULT_IGNORE_DIRS2;
+  const ignoreDirs = options?.ignoreDirs ?? DEFAULT_IGNORE_DIRS3;
   const results = [];
   const visited = /* @__PURE__ */ new Set();
   function processPackage(dir, isRoot) {
-    const pkgPath = join4(dir, "package.json");
-    if (!existsSync5(pkgPath)) return null;
+    const pkgPath = join5(dir, "package.json");
+    if (!existsSync6(pkgPath)) return null;
     try {
-      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
       const name = pkg.name || relative(rootDir, dir) || ".";
       return {
         path: dir,
@@ -1522,7 +1765,8 @@ function findPackages(rootDir, options) {
         name,
         hasEslintConfig: hasEslintConfig(dir),
         isFrontend: isFrontendPackage(pkg),
-        isRoot
+        isRoot,
+        isTypeScript: isTypeScriptPackage(dir, pkg)
       };
     } catch {
       return null;
@@ -1538,7 +1782,7 @@ function findPackages(rootDir, options) {
     }
     let entries = [];
     try {
-      entries = readdirSync2(dir, { withFileTypes: true }).map((d) => ({
+      entries = readdirSync3(dir, { withFileTypes: true }).map((d) => ({
         name: d.name,
         isDirectory: d.isDirectory()
       }));
@@ -1549,7 +1793,7 @@ function findPackages(rootDir, options) {
       if (!ent.isDirectory) continue;
       if (ignoreDirs.has(ent.name)) continue;
       if (ent.name.startsWith(".")) continue;
-      walk(join4(dir, ent.name), depth + 1);
+      walk(join5(dir, ent.name), depth + 1);
     }
   }
   walk(rootDir, 0);
@@ -1574,18 +1818,18 @@ function formatPackageOption(pkg) {
 }
 
 // src/utils/package-manager.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { spawn } from "child_process";
-import { dirname as dirname5, join as join5 } from "path";
+import { dirname as dirname5, join as join6 } from "path";
 function detectPackageManager(projectPath) {
   let dir = projectPath;
   for (; ; ) {
-    if (existsSync6(join5(dir, "pnpm-lock.yaml"))) return "pnpm";
-    if (existsSync6(join5(dir, "pnpm-workspace.yaml"))) return "pnpm";
-    if (existsSync6(join5(dir, "yarn.lock"))) return "yarn";
-    if (existsSync6(join5(dir, "bun.lockb"))) return "bun";
-    if (existsSync6(join5(dir, "bun.lock"))) return "bun";
-    if (existsSync6(join5(dir, "package-lock.json"))) return "npm";
+    if (existsSync7(join6(dir, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync7(join6(dir, "pnpm-workspace.yaml"))) return "pnpm";
+    if (existsSync7(join6(dir, "yarn.lock"))) return "yarn";
+    if (existsSync7(join6(dir, "bun.lockb"))) return "bun";
+    if (existsSync7(join6(dir, "bun.lock"))) return "bun";
+    if (existsSync7(join6(dir, "package-lock.json"))) return "npm";
     const parent = dirname5(dir);
     if (parent === dir) break;
     dir = parent;
@@ -1593,7 +1837,7 @@ function detectPackageManager(projectPath) {
   return "npm";
 }
 function spawnAsync(command, args, cwd) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn(command, args, {
       cwd,
       stdio: "inherit",
@@ -1601,7 +1845,7 @@ function spawnAsync(command, args, cwd) {
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve7();
+      if (code === 0) resolve8();
       else
         reject(new Error(`${command} ${args.join(" ")} exited with ${code}`));
     });
@@ -1627,14 +1871,15 @@ async function installDependencies(pm, projectPath, packages) {
 }
 
 // src/utils/eslint-config-inject.ts
-import { existsSync as existsSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7, relative as relative2, dirname as dirname6 } from "path";
 import { parseExpression, parseModule, generateCode } from "magicast";
-var CONFIG_EXTENSIONS = [".mjs", ".js", ".cjs"];
+import { findWorkspaceRoot as findWorkspaceRoot4 } from "uilint-core/node";
+var CONFIG_EXTENSIONS = [".ts", ".mjs", ".js", ".cjs"];
 function findEslintConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS) {
-    const configPath = join6(projectPath, `eslint.config${ext}`);
-    if (existsSync7(configPath)) {
+    const configPath = join7(projectPath, `eslint.config${ext}`);
+    if (existsSync8(configPath)) {
       return configPath;
     }
   }
@@ -1644,25 +1889,6 @@ function getEslintConfigFilename(configPath) {
   const parts = configPath.split("/");
   return parts[parts.length - 1] || "eslint.config.mjs";
 }
-function hasUilintImport(source) {
-  return source.includes('from "uilint-eslint"') || source.includes("from 'uilint-eslint'") || source.includes('require("uilint-eslint")') || source.includes("require('uilint-eslint')");
-}
-function hasUilintConfigsUsage(source) {
-  return /\builint\s*\.\s*configs\s*\./.test(source);
-}
-function walkAst(node, visit) {
-  if (!node || typeof node !== "object") return;
-  visit(node);
-  for (const key of Object.keys(node)) {
-    const v = node[key];
-    if (!v) continue;
-    if (Array.isArray(v)) {
-      for (const item of v) walkAst(item, visit);
-    } else if (typeof v === "object" && v.type) {
-      walkAst(v, visit);
-    }
-  }
-}
 function isIdentifier(node, name) {
   return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
 }
@@ -1687,35 +1913,6 @@ function hasSpreadProperties(obj) {
     (p2) => p2 && (p2.type === "SpreadElement" || p2.type === "SpreadProperty")
   );
 }
-var IGNORED_AST_KEYS = /* @__PURE__ */ new Set([
-  "loc",
-  "start",
-  "end",
-  "extra",
-  "leadingComments",
-  "trailingComments",
-  "innerComments"
-]);
-function normalizeAstForCompare(node) {
-  if (node === null) return null;
-  if (node === void 0) return void 0;
-  if (typeof node !== "object") return node;
-  if (Array.isArray(node)) return node.map(normalizeAstForCompare);
-  const out = {};
-  const keys = Object.keys(node).filter((k) => !IGNORED_AST_KEYS.has(k)).sort();
-  for (const k of keys) {
-    if (k.startsWith("$")) continue;
-    out[k] = normalizeAstForCompare(node[k]);
-  }
-  return out;
-}
-function astEquivalent(a, b) {
-  try {
-    return JSON.stringify(normalizeAstForCompare(a)) === JSON.stringify(normalizeAstForCompare(b));
-  } catch {
-    return false;
-  }
-}
 function collectUilintRuleIdsFromRulesObject(rulesObj) {
   const ids = /* @__PURE__ */ new Set();
   if (!rulesObj || rulesObj.type !== "ObjectExpression") return ids;
@@ -1726,13 +1923,14 @@ function collectUilintRuleIdsFromRulesObject(rulesObj) {
     if (!isStringLiteral(key)) continue;
     const val = key.value;
     if (typeof val !== "string") continue;
-    if (!val.startsWith("uilint/")) continue;
-    ids.add(val.slice("uilint/".length));
+    if (val.startsWith("uilint/")) {
+      ids.add(val.slice("uilint/".length));
+    }
   }
   return ids;
 }
 function findExportedConfigArrayExpression(mod) {
-  function unwrapExpression(expr) {
+  function unwrapExpression2(expr) {
     let e = expr;
     while (e) {
       if (e.type === "TSAsExpression" || e.type === "TSNonNullExpression") {
@@ -1758,11 +1956,11 @@ function findExportedConfigArrayExpression(mod) {
       for (const decl of stmt.declarations ?? []) {
         const id = decl?.id;
         if (!isIdentifier(id, name)) continue;
-        const init = unwrapExpression(decl?.init);
+        const init = unwrapExpression2(decl?.init);
         if (!init) return null;
         if (init.type === "ArrayExpression") return init;
-        if (init.type === "CallExpression" && isIdentifier(init.callee, "defineConfig") && unwrapExpression(init.arguments?.[0])?.type === "ArrayExpression") {
-          return unwrapExpression(init.arguments?.[0]);
+        if (init.type === "CallExpression" && isIdentifier(init.callee, "defineConfig") && unwrapExpression2(init.arguments?.[0])?.type === "ArrayExpression") {
+          return unwrapExpression2(init.arguments?.[0]);
         }
         return null;
       }
@@ -1773,15 +1971,15 @@ function findExportedConfigArrayExpression(mod) {
   if (program2 && program2.type === "Program") {
     for (const stmt of program2.body ?? []) {
       if (!stmt || stmt.type !== "ExportDefaultDeclaration") continue;
-      const decl = unwrapExpression(stmt.declaration);
+      const decl = unwrapExpression2(stmt.declaration);
       if (!decl) break;
       if (decl.type === "ArrayExpression") {
         return { kind: "esm", arrayExpr: decl, program: program2 };
       }
-      if (decl.type === "CallExpression" && isIdentifier(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ArrayExpression") {
+      if (decl.type === "CallExpression" && isIdentifier(decl.callee, "defineConfig") && unwrapExpression2(decl.arguments?.[0])?.type === "ArrayExpression") {
         return {
           kind: "esm",
-          arrayExpr: unwrapExpression(decl.arguments?.[0]),
+          arrayExpr: unwrapExpression2(decl.arguments?.[0]),
           program: program2
         };
       }
@@ -1820,24 +2018,6 @@ function findExportedConfigArrayExpression(mod) {
   }
   return null;
 }
-function findUsesUilintConfigs(program2) {
-  let found = false;
-  walkAst(program2, (n) => {
-    if (found) return;
-    if (n?.type === "MemberExpression") {
-      const obj = n.object;
-      const prop = n.property;
-      if (isIdentifier(prop, "configs") && isIdentifier(obj, "uilint")) {
-        found = true;
-        return;
-      }
-      if (obj?.type === "MemberExpression" && isIdentifier(obj.object, "uilint") && isIdentifier(obj.property, "configs")) {
-        found = true;
-      }
-    }
-  });
-  return found;
-}
 function collectConfiguredUilintRuleIdsFromConfigArray(arrayExpr) {
   const ids = /* @__PURE__ */ new Set();
   if (!arrayExpr || arrayExpr.type !== "ArrayExpression") return ids;
@@ -1890,69 +2070,68 @@ function chooseUniqueIdentifier(base, used) {
   while (used.has(`${base}${i}`)) i++;
   return `${base}${i}`;
 }
-function getEsmUilintDefaultImportLocal(mod) {
-  const items = mod?.imports?.$items ?? [];
-  const found = items.find(
-    (it) => it?.from === "uilint-eslint" && it?.imported === "default"
-  );
-  return found?.local ?? null;
-}
-function ensureUilintImportAst(mod) {
-  const existing = getEsmUilintDefaultImportLocal(mod);
-  if (existing) return { local: existing, changed: false };
-  mod.imports.$prepend({
-    imported: "default",
-    local: "uilint",
-    from: "uilint-eslint"
-  });
-  return { local: "uilint", changed: true };
-}
-function findCjsUilintRequireBinding(program2) {
-  if (!program2 || program2.type !== "Program") return null;
-  for (const stmt of program2.body ?? []) {
-    if (stmt?.type !== "VariableDeclaration") continue;
-    for (const decl of stmt.declarations ?? []) {
-      const id = decl?.id;
-      const init = decl?.init;
-      if (!isIdentifier(id)) continue;
-      if (init?.type === "CallExpression" && isIdentifier(init.callee, "require") && isStringLiteral(init.arguments?.[0]) && init.arguments[0].value === "uilint-eslint") {
-        return id.name;
-      }
-    }
+function addLocalRuleImportsAst(mod, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
+  const importNames = /* @__PURE__ */ new Map();
+  let changed = false;
+  const configDir = dirname6(configPath);
+  const rulesDir = join7(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
+  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
+  const used = collectTopLevelBindings(mod.$ast);
+  for (const rule of selectedRules) {
+    const importName = chooseUniqueIdentifier(
+      `${rule.id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase())}Rule`,
+      used
+    );
+    importNames.set(rule.id, importName);
+    used.add(importName);
+    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
+    mod.imports.$add({
+      imported: "default",
+      local: importName,
+      from: rulePath
+    });
+    changed = true;
   }
-  return null;
+  return { importNames, changed };
 }
-function ensureUilintRequireAst(program2) {
+function addLocalRuleRequiresAst(program2, selectedRules, configPath, rulesRoot, fileExtension = ".js") {
+  const importNames = /* @__PURE__ */ new Map();
+  let changed = false;
   if (!program2 || program2.type !== "Program") {
-    return { local: "uilint", changed: false };
+    return { importNames, changed };
   }
-  const existing = findCjsUilintRequireBinding(program2);
-  if (existing) return { local: existing, changed: false };
+  const configDir = dirname6(configPath);
+  const rulesDir = join7(rulesRoot, ".uilint", "rules");
+  const relativeRulesPath = relative2(configDir, rulesDir).replace(/\\/g, "/");
+  const normalizedRulesPath = relativeRulesPath.startsWith("./") || relativeRulesPath.startsWith("../") ? relativeRulesPath : `./${relativeRulesPath}`;
   const used = collectTopLevelBindings(program2);
-  const local = chooseUniqueIdentifier("uilint", used);
-  const stmtMod = parseModule(`const ${local} = require("uilint-eslint");`);
-  const stmt = stmtMod.$ast.body?.[0];
-  if (!stmt) return { local, changed: false };
-  let insertAt = 0;
-  const first = program2.body?.[0];
-  if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
-    insertAt = 1;
-  }
-  program2.body.splice(insertAt, 0, stmt);
-  return { local, changed: true };
-}
-function buildUilintRuleProperty(rule) {
-  const ruleKey = `uilint/${rule.id}`;
-  const valueCode = rule.defaultOptions && rule.defaultOptions.length > 0 ? `["${rule.defaultSeverity}", ...${JSON.stringify(
-    rule.defaultOptions,
-    null,
-    2
-  )}]` : `"${rule.defaultSeverity}"`;
-  const expr = parseExpression(`({ "${ruleKey}": ${valueCode} })`);
-  const obj = expr.$ast;
-  return obj.properties?.[0];
-}
-function appendUilintConfigBlockToArray(arrayExpr, selectedRules, uilintRef) {
+  for (const rule of selectedRules) {
+    const importName = chooseUniqueIdentifier(
+      `${rule.id.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase())}Rule`,
+      used
+    );
+    importNames.set(rule.id, importName);
+    used.add(importName);
+    const rulePath = `${normalizedRulesPath}/${rule.id}${fileExtension}`;
+    const stmtMod = parseModule(
+      `const ${importName} = require("${rulePath}");`
+    );
+    const stmt = stmtMod.$ast.body?.[0];
+    if (stmt) {
+      let insertAt = 0;
+      const first = program2.body?.[0];
+      if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
+        insertAt = 1;
+      }
+      program2.body.splice(insertAt, 0, stmt);
+      changed = true;
+    }
+  }
+  return { importNames, changed };
+}
+function appendUilintConfigBlockToArray(arrayExpr, selectedRules, ruleImportNames) {
+  const pluginRulesCode = Array.from(ruleImportNames.entries()).map(([ruleId, importName]) => `      "${ruleId}": ${importName},`).join("\n");
   const rulesPropsCode = selectedRules.map((r) => {
     const ruleKey = `uilint/${r.id}`;
     const valueCode = r.defaultOptions && r.defaultOptions.length > 0 ? `["${r.defaultSeverity}", ...${JSON.stringify(
@@ -1968,7 +2147,13 @@ function appendUilintConfigBlockToArray(arrayExpr, selectedRules, uilintRef) {
       "app/**/*.{js,jsx,ts,tsx}",
       "pages/**/*.{js,jsx,ts,tsx}",
     ],
-    plugins: { uilint: ${uilintRef} },
+    plugins: {
+      uilint: {
+        rules: {
+${pluginRulesCode}
+        },
+      },
+    },
     rules: {
 ${rulesPropsCode}
     },
@@ -1985,14 +2170,13 @@ function getUilintEslintConfigInfoFromSourceAst(source) {
         error: "Could not locate an exported ESLint flat config array (expected `export default [...]`, `export default defineConfig([...])`, `module.exports = [...]`, or `module.exports = defineConfig([...])`)."
       };
     }
-    const usesUilintConfigs = findUsesUilintConfigs(found.program);
     const configuredRuleIds = collectConfiguredUilintRuleIdsFromConfigArray(
       found.arrayExpr
     );
     const existingUilint = findExistingUilintRulesObject(found.arrayExpr);
-    const configured = usesUilintConfigs || configuredRuleIds.size > 0 || existingUilint.configObj !== null || hasUilintImport(source);
+    const configured = configuredRuleIds.size > 0 || existingUilint.configObj !== null;
     return {
-      info: { usesUilintConfigs, configuredRuleIds, configured },
+      info: { configuredRuleIds, configured },
       mod,
       arrayExpr: found.arrayExpr,
       kind: found.kind
@@ -2007,11 +2191,9 @@ function getUilintEslintConfigInfoFromSource(source) {
   const ast = getUilintEslintConfigInfoFromSourceAst(source);
   if ("error" in ast) {
     const configuredRuleIds = extractConfiguredUilintRuleIds(source);
-    const usesUilintConfigs = hasUilintConfigsUsage(source);
     return {
-      usesUilintConfigs,
       configuredRuleIds,
-      configured: usesUilintConfigs || configuredRuleIds.size > 0 || hasUilintImport(source)
+      configured: configuredRuleIds.size > 0
     };
   }
   return ast.info;
@@ -2041,7 +2223,7 @@ async function installEslintPlugin(opts) {
     };
   }
   const configFilename = getEslintConfigFilename(configPath);
-  const original = readFileSync3(configPath, "utf-8");
+  const original = readFileSync4(configPath, "utf-8");
   const isCommonJS = configPath.endsWith(".cjs");
   const ast = getUilintEslintConfigInfoFromSourceAst(original);
   if ("error" in ast) {
@@ -2054,10 +2236,15 @@ async function installEslintPlugin(opts) {
     };
   }
   const { info, mod, arrayExpr, kind } = ast;
-  const usesUilintConfigs = info.usesUilintConfigs;
   const configuredIds = info.configuredRuleIds;
-  const missingRules = usesUilintConfigs ? [] : getMissingSelectedRules(opts.selectedRules, configuredIds);
-  const rulesToUpdate = usesUilintConfigs ? [] : getRulesNeedingUpdate(opts.selectedRules, configuredIds);
+  const missingRules = getMissingSelectedRules(
+    opts.selectedRules,
+    configuredIds
+  );
+  const rulesToUpdate = getRulesNeedingUpdate(
+    opts.selectedRules,
+    configuredIds
+  );
   let rulesToApply = [];
   if (!info.configured) {
     rulesToApply = opts.selectedRules;
@@ -2078,47 +2265,79 @@ async function installEslintPlugin(opts) {
       }
     }
   }
+  if (rulesToApply.length === 0) {
+    return {
+      configFile: configFilename,
+      modified: false,
+      missingRuleIds: missingRules.map((r) => r.id),
+      configured: info.configured
+    };
+  }
   let modifiedAst = false;
-  if (!usesUilintConfigs && rulesToApply.length > 0) {
-    const existing = findExistingUilintRulesObject(arrayExpr);
-    if (existing.safeToMutate && existing.rulesObj) {
-      let changedRules = false;
-      for (const rule of rulesToApply) {
-        const fullKey = `uilint/${rule.id}`;
-        const props = existing.rulesObj.properties ?? [];
-        const existingProp = props.find((p2) => {
-          if (!p2) return false;
-          if (p2.type !== "ObjectProperty" && p2.type !== "Property")
-            return false;
-          return isStringLiteral(p2.key) && p2.key.value === fullKey;
-        });
-        const newProp = buildUilintRuleProperty(rule);
-        if (!newProp) continue;
-        if (existingProp) {
-          if (!astEquivalent(existingProp.value, newProp.value)) {
-            existingProp.value = newProp.value;
-            changedRules = true;
-          }
-        } else {
-          props.push(newProp);
-          changedRules = true;
-        }
-      }
-      if (changedRules) modifiedAst = true;
-    } else {
-      const uilintRef = kind === "esm" ? ensureUilintImportAst(mod).local : ensureUilintRequireAst(mod.$ast).local;
-      appendUilintConfigBlockToArray(arrayExpr, rulesToApply, uilintRef);
-      modifiedAst = true;
+  const localRulesDir = join7(opts.projectPath, ".uilint", "rules");
+  const workspaceRoot = findWorkspaceRoot4(opts.projectPath);
+  const workspaceRulesDir = join7(workspaceRoot, ".uilint", "rules");
+  const rulesRoot = existsSync8(localRulesDir) ? opts.projectPath : workspaceRoot;
+  let fileExtension = ".js";
+  if (rulesToApply.length > 0) {
+    const firstRulePath = join7(
+      rulesRoot,
+      ".uilint",
+      "rules",
+      `${rulesToApply[0].id}.ts`
+    );
+    if (existsSync8(firstRulePath)) {
+      fileExtension = ".ts";
     }
-  } else if (!info.configured && !usesUilintConfigs) {
   }
-  if (modifiedAst || info.configured) {
+  let ruleImportNames;
+  if (kind === "esm") {
+    const result = addLocalRuleImportsAst(
+      mod,
+      rulesToApply,
+      configPath,
+      rulesRoot,
+      fileExtension
+    );
+    ruleImportNames = result.importNames;
+    if (result.changed) modifiedAst = true;
+  } else {
+    const result = addLocalRuleRequiresAst(
+      mod.$ast,
+      rulesToApply,
+      configPath,
+      rulesRoot,
+      fileExtension
+    );
+    ruleImportNames = result.importNames;
+    if (result.changed) modifiedAst = true;
+  }
+  if (ruleImportNames && ruleImportNames.size > 0) {
+    appendUilintConfigBlockToArray(arrayExpr, rulesToApply, ruleImportNames);
+    modifiedAst = true;
+  }
+  if (!info.configured) {
     if (kind === "esm") {
-      const { changed } = ensureUilintImportAst(mod);
-      if (changed) modifiedAst = true;
-    } else if (kind === "cjs") {
-      const { changed } = ensureUilintRequireAst(mod.$ast);
-      if (changed) modifiedAst = true;
+      mod.imports.$add({
+        imported: "createRule",
+        local: "createRule",
+        from: "uilint-eslint"
+      });
+      modifiedAst = true;
+    } else {
+      const stmtMod = parseModule(
+        `const { createRule } = require("uilint-eslint");`
+      );
+      const stmt = stmtMod.$ast.body?.[0];
+      if (stmt) {
+        let insertAt = 0;
+        const first = mod.$ast.body?.[0];
+        if (first?.type === "ExpressionStatement" && first.expression?.type === "StringLiteral" && first.expression.value === "use strict") {
+          insertAt = 1;
+        }
+        mod.$ast.body.splice(insertAt, 0, stmt);
+        modifiedAst = true;
+      }
     }
   }
   const updated = modifiedAst ? generateCode(mod).code : original;
@@ -2143,36 +2362,36 @@ async function installEslintPlugin(opts) {
 var LEGACY_HOOK_FILES = ["uilint-validate.sh", "uilint-validate.js"];
 function safeParseJson(filePath) {
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
   }
 }
 async function analyze2(projectPath = process.cwd()) {
-  const workspaceRoot = findWorkspaceRoot4(projectPath);
+  const workspaceRoot = findWorkspaceRoot5(projectPath);
   const packageManager = detectPackageManager(projectPath);
-  const cursorDir = join7(projectPath, ".cursor");
-  const cursorDirExists = existsSync8(cursorDir);
-  const mcpPath = join7(cursorDir, "mcp.json");
-  const mcpExists = existsSync8(mcpPath);
+  const cursorDir = join8(projectPath, ".cursor");
+  const cursorDirExists = existsSync9(cursorDir);
+  const mcpPath = join8(cursorDir, "mcp.json");
+  const mcpExists = existsSync9(mcpPath);
   const mcpConfig = mcpExists ? safeParseJson(mcpPath) : void 0;
-  const hooksPath = join7(cursorDir, "hooks.json");
-  const hooksExists = existsSync8(hooksPath);
+  const hooksPath = join8(cursorDir, "hooks.json");
+  const hooksExists = existsSync9(hooksPath);
   const hooksConfig = hooksExists ? safeParseJson(hooksPath) : void 0;
-  const hooksDir = join7(cursorDir, "hooks");
+  const hooksDir = join8(cursorDir, "hooks");
   const legacyPaths = [];
   for (const legacyFile of LEGACY_HOOK_FILES) {
-    const legacyPath = join7(hooksDir, legacyFile);
-    if (existsSync8(legacyPath)) {
+    const legacyPath = join8(hooksDir, legacyFile);
+    if (existsSync9(legacyPath)) {
       legacyPaths.push(legacyPath);
     }
   }
-  const styleguidePath = join7(projectPath, ".uilint", "styleguide.md");
-  const styleguideExists = existsSync8(styleguidePath);
-  const commandsDir = join7(cursorDir, "commands");
-  const genstyleguideExists = existsSync8(join7(commandsDir, "genstyleguide.md"));
-  const genrulesExists = existsSync8(join7(commandsDir, "genrules.md"));
+  const styleguidePath = join8(projectPath, ".uilint", "styleguide.md");
+  const styleguideExists = existsSync9(styleguidePath);
+  const commandsDir = join8(cursorDir, "commands");
+  const genstyleguideExists = existsSync9(join8(commandsDir, "genstyleguide.md"));
+  const genrulesExists = existsSync9(join8(commandsDir, "genrules.md"));
   const nextApps = [];
   const directDetection = detectNextAppRouter(projectPath);
   if (directDetection) {
@@ -2186,6 +2405,19 @@ async function analyze2(projectPath = process.cwd()) {
       });
     }
   }
+  const viteApps = [];
+  const directVite = detectViteReact(projectPath);
+  if (directVite) {
+    viteApps.push({ projectPath, detection: directVite });
+  } else {
+    const matches = findViteReactProjects(workspaceRoot, { maxDepth: 5 });
+    for (const match of matches) {
+      viteApps.push({
+        projectPath: match.projectPath,
+        detection: match.detection
+      });
+    }
+  }
   const rawPackages = findPackages(workspaceRoot);
   const packages = rawPackages.map((pkg) => {
     const eslintConfigPath = findEslintConfigFile(pkg.path);
@@ -2195,9 +2427,9 @@ async function analyze2(projectPath = process.cwd()) {
     if (eslintConfigPath) {
       eslintConfigFilename = getEslintConfigFilename(eslintConfigPath);
       try {
-        const source = readFileSync4(eslintConfigPath, "utf-8");
+        const source = readFileSync5(eslintConfigPath, "utf-8");
         const info = getUilintEslintConfigInfoFromSource(source);
-        hasRules = info.configuredRuleIds.size > 0 || info.usesUilintConfigs;
+        hasRules = info.configuredRuleIds.size > 0;
         configuredRuleIds = Array.from(info.configuredRuleIds);
       } catch {
       }
@@ -2239,13 +2471,14 @@ async function analyze2(projectPath = process.cwd()) {
       genrules: genrulesExists
     },
     nextApps,
+    viteApps,
     packages
   };
 }
 
 // src/commands/install/plan.ts
-import { join as join8 } from "path";
-import { createRequire } from "module";
+import { join as join11 } from "path";
+import { createRequire as createRequire2 } from "module";
 
 // src/commands/install/constants.ts
 var HOOKS_CONFIG = {
@@ -2633,11 +2866,179 @@ Generate in \`.uilint/rules/\`:
 - **Minimal rules** - generate 3-5 high-impact rules, not dozens
 `;
 
-// src/commands/install/plan.ts
+// src/utils/skill-loader.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync2, existsSync as existsSync10 } from "fs";
+import { join as join9, dirname as dirname7, relative as relative3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename = fileURLToPath2(import.meta.url);
+var __dirname = dirname7(__filename);
+function getSkillsDir() {
+  const devPath = join9(__dirname, "..", "..", "skills");
+  const prodPath = join9(__dirname, "..", "skills");
+  if (existsSync10(devPath)) {
+    return devPath;
+  }
+  if (existsSync10(prodPath)) {
+    return prodPath;
+  }
+  throw new Error(
+    "Could not find skills directory. This is a bug in uilint installation."
+  );
+}
+function collectFiles(dir, baseDir) {
+  const files = [];
+  const entries = readdirSync4(dir);
+  for (const entry of entries) {
+    const fullPath = join9(dir, entry);
+    const stat = statSync2(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(fullPath, baseDir));
+    } else if (stat.isFile()) {
+      const relativePath = relative3(baseDir, fullPath);
+      const content = readFileSync6(fullPath, "utf-8");
+      files.push({ relativePath, content });
+    }
+  }
+  return files;
+}
+function loadSkill(name) {
+  const skillsDir = getSkillsDir();
+  const skillDir = join9(skillsDir, name);
+  if (!existsSync10(skillDir)) {
+    throw new Error(`Skill "${name}" not found in ${skillsDir}`);
+  }
+  const skillMdPath = join9(skillDir, "SKILL.md");
+  if (!existsSync10(skillMdPath)) {
+    throw new Error(`Skill "${name}" is missing SKILL.md`);
+  }
+  const files = collectFiles(skillDir, skillDir);
+  return { name, files };
+}
+
+// src/utils/rule-loader.ts
+import { readFileSync as readFileSync7, existsSync as existsSync11 } from "fs";
+import { join as join10, dirname as dirname8 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { createRequire } from "module";
+var __filename2 = fileURLToPath3(import.meta.url);
+var __dirname2 = dirname8(__filename2);
 var require2 = createRequire(import.meta.url);
+function getUilintEslintPackageRoot() {
+  const entry = require2.resolve("uilint-eslint");
+  const entryDir = dirname8(entry);
+  return dirname8(entryDir);
+}
+function getUilintEslintSrcDir() {
+  const devPath = join10(
+    __dirname2,
+    "..",
+    "..",
+    "..",
+    "..",
+    "uilint-eslint",
+    "src"
+  );
+  if (existsSync11(devPath)) return devPath;
+  const pkgRoot = getUilintEslintPackageRoot();
+  const srcPath = join10(pkgRoot, "src");
+  if (existsSync11(srcPath)) return srcPath;
+  throw new Error(
+    'Could not find uilint-eslint "src/" directory. If you are using a published install of uilint-eslint, ensure it includes source files, or run a JS-only rules install.'
+  );
+}
+function getUilintEslintDistDir() {
+  const devPath = join10(
+    __dirname2,
+    "..",
+    "..",
+    "..",
+    "..",
+    "uilint-eslint",
+    "dist"
+  );
+  if (existsSync11(devPath)) return devPath;
+  const pkgRoot = getUilintEslintPackageRoot();
+  const distPath = join10(pkgRoot, "dist");
+  if (existsSync11(distPath)) return distPath;
+  throw new Error(
+    'Could not find uilint-eslint "dist/" directory. This is a bug in uilint installation.'
+  );
+}
+function transformRuleContent(content) {
+  let transformed = content;
+  transformed = transformed.replace(
+    /import\s+{\s*createRule\s*}\s+from\s+["']\.\.\/utils\/create-rule\.js["'];?/g,
+    'import { createRule } from "uilint-eslint";'
+  );
+  transformed = transformed.replace(
+    /import\s+createRule\s+from\s+["']\.\.\/utils\/create-rule\.js["'];?/g,
+    'import { createRule } from "uilint-eslint";'
+  );
+  transformed = transformed.replace(
+    /import\s+{([^}]+)}\s+from\s+["']\.\.\/utils\/([^"']+)\.js["'];?/g,
+    (match, imports, utilFile) => {
+      const utilsFromPackage = ["cache", "styleguide-loader", "import-graph"];
+      if (utilsFromPackage.includes(utilFile)) {
+        return `import {${imports}} from "uilint-eslint";`;
+      }
+      return match;
+    }
+  );
+  return transformed;
+}
+function loadRule(ruleId, options = { typescript: true }) {
+  const { typescript } = options;
+  const extension = typescript ? ".ts" : ".js";
+  if (typescript) {
+    const rulesDir = join10(getUilintEslintSrcDir(), "rules");
+    const implPath = join10(rulesDir, `${ruleId}.ts`);
+    const testPath = join10(rulesDir, `${ruleId}.test.ts`);
+    if (!existsSync11(implPath)) {
+      throw new Error(`Rule "${ruleId}" not found at ${implPath}`);
+    }
+    const rawContent = readFileSync7(implPath, "utf-8");
+    const transformedContent = transformRuleContent(rawContent);
+    const implementation = {
+      relativePath: `${ruleId}.ts`,
+      content: transformedContent
+    };
+    const test = existsSync11(testPath) ? {
+      relativePath: `${ruleId}.test.ts`,
+      content: transformRuleContent(readFileSync7(testPath, "utf-8"))
+    } : void 0;
+    return {
+      ruleId,
+      implementation,
+      test
+    };
+  } else {
+    const rulesDir = join10(getUilintEslintDistDir(), "rules");
+    const implPath = join10(rulesDir, `${ruleId}.js`);
+    if (!existsSync11(implPath)) {
+      throw new Error(
+        `Rule "${ruleId}" not found at ${implPath}. Make sure uilint-eslint has been built.`
+      );
+    }
+    const content = readFileSync7(implPath, "utf-8");
+    const implementation = {
+      relativePath: `${ruleId}.js`,
+      content
+    };
+    return {
+      ruleId,
+      implementation
+    };
+  }
+}
+function loadSelectedRules(ruleIds, options = { typescript: true }) {
+  return ruleIds.map((id) => loadRule(id, options));
+}
+
+// src/commands/install/plan.ts
+var require3 = createRequire2(import.meta.url);
 function getSelfDependencyVersionRange(pkgName) {
   try {
-    const pkgJson = require2("uilint/package.json");
+    const pkgJson = require3("uilint/package.json");
     const deps = pkgJson?.dependencies;
     const optDeps = pkgJson?.optionalDependencies;
     const peerDeps = pkgJson?.peerDependencies;
@@ -2683,7 +3084,7 @@ function createPlan(state, choices, options = {}) {
   const dependencies = [];
   const { force = false } = options;
   const { items } = choices;
-  const needsCursorDir = items.includes("mcp") || items.includes("hooks") || items.includes("genstyleguide") || items.includes("genrules");
+  const needsCursorDir = items.includes("mcp") || items.includes("hooks") || items.includes("genstyleguide") || items.includes("genrules") || items.includes("skill");
   if (needsCursorDir && !state.cursorDir.exists) {
     actions.push({
       type: "create_directory",
@@ -2712,7 +3113,7 @@ function createPlan(state, choices, options = {}) {
     }
   }
   if (items.includes("hooks")) {
-    const hooksDir = join8(state.cursorDir.path, "hooks");
+    const hooksDir = join11(state.cursorDir.path, "hooks");
     actions.push({
       type: "create_directory",
       path: hooksDir
@@ -2738,58 +3139,92 @@ function createPlan(state, choices, options = {}) {
     });
     actions.push({
       type: "create_file",
-      path: join8(hooksDir, "uilint-session-start.sh"),
+      path: join11(hooksDir, "uilint-session-start.sh"),
       content: SESSION_START_SCRIPT,
       permissions: 493
     });
     actions.push({
       type: "create_file",
-      path: join8(hooksDir, "uilint-track.sh"),
+      path: join11(hooksDir, "uilint-track.sh"),
       content: TRACK_SCRIPT,
       permissions: 493
     });
     actions.push({
       type: "create_file",
-      path: join8(hooksDir, "uilint-session-end.sh"),
+      path: join11(hooksDir, "uilint-session-end.sh"),
       content: SESSION_END_SCRIPT,
       permissions: 493
     });
   }
   if (items.includes("genstyleguide")) {
-    const commandsDir = join8(state.cursorDir.path, "commands");
+    const commandsDir = join11(state.cursorDir.path, "commands");
     actions.push({
       type: "create_directory",
       path: commandsDir
     });
     actions.push({
       type: "create_file",
-      path: join8(commandsDir, "genstyleguide.md"),
+      path: join11(commandsDir, "genstyleguide.md"),
       content: GENSTYLEGUIDE_COMMAND_MD
     });
   }
   if (items.includes("genrules")) {
-    const commandsDir = join8(state.cursorDir.path, "commands");
+    const commandsDir = join11(state.cursorDir.path, "commands");
     actions.push({
       type: "create_directory",
       path: commandsDir
     });
     actions.push({
       type: "create_file",
-      path: join8(commandsDir, "genrules.md"),
+      path: join11(commandsDir, "genrules.md"),
       content: GENRULES_COMMAND_MD
     });
   }
-  if (items.includes("next") && choices.next) {
-    const { projectPath, detection } = choices.next;
+  if (items.includes("skill")) {
+    const skillsDir = join11(state.cursorDir.path, "skills");
     actions.push({
-      type: "install_next_routes",
-      projectPath,
-      appRoot: detection.appRoot
+      type: "create_directory",
+      path: skillsDir
     });
-    dependencies.push({
-      packagePath: projectPath,
-      packageManager: state.packageManager,
-      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+    try {
+      const skill = loadSkill("ui-consistency-enforcer");
+      const skillDir = join11(skillsDir, skill.name);
+      actions.push({
+        type: "create_directory",
+        path: skillDir
+      });
+      for (const file of skill.files) {
+        const filePath = join11(skillDir, file.relativePath);
+        const fileDir = join11(
+          skillDir,
+          file.relativePath.split("/").slice(0, -1).join("/")
+        );
+        if (fileDir !== skillDir && file.relativePath.includes("/")) {
+          actions.push({
+            type: "create_directory",
+            path: fileDir
+          });
+        }
+        actions.push({
+          type: "create_file",
+          path: filePath,
+          content: file.content
+        });
+      }
+    } catch {
+    }
+  }
+  if (items.includes("next") && choices.next) {
+    const { projectPath, detection } = choices.next;
+    actions.push({
+      type: "install_next_routes",
+      projectPath,
+      appRoot: detection.appRoot
+    });
+    dependencies.push({
+      packagePath: projectPath,
+      packageManager: state.packageManager,
+      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
     });
     actions.push({
       type: "inject_react",
@@ -2801,10 +3236,57 @@ function createPlan(state, choices, options = {}) {
       projectPath
     });
   }
+  if (items.includes("vite") && choices.vite) {
+    const { projectPath, detection } = choices.vite;
+    dependencies.push({
+      packagePath: projectPath,
+      packageManager: state.packageManager,
+      packages: ["uilint-react", "uilint-core", "jsx-loc-plugin"]
+    });
+    actions.push({
+      type: "inject_react",
+      projectPath,
+      appRoot: detection.entryRoot,
+      mode: "vite"
+    });
+    actions.push({
+      type: "inject_vite_config",
+      projectPath
+    });
+  }
   if (items.includes("eslint") && choices.eslint) {
     const { packagePaths, selectedRules } = choices.eslint;
     for (const pkgPath of packagePaths) {
       const pkgInfo = state.packages.find((p2) => p2.path === pkgPath);
+      const rulesDir = join11(pkgPath, ".uilint", "rules");
+      actions.push({
+        type: "create_directory",
+        path: rulesDir
+      });
+      const isTypeScript = pkgInfo?.isTypeScript ?? true;
+      try {
+        const ruleFiles = loadSelectedRules(
+          selectedRules.map((r) => r.id),
+          {
+            typescript: isTypeScript
+          }
+        );
+        for (const ruleFile of ruleFiles) {
+          actions.push({
+            type: "create_file",
+            path: join11(rulesDir, ruleFile.implementation.relativePath),
+            content: ruleFile.implementation.content
+          });
+          if (ruleFile.test && isTypeScript) {
+            actions.push({
+              type: "create_file",
+              path: join11(rulesDir, ruleFile.test.relativePath),
+              content: ruleFile.test.content
+            });
+          }
+        }
+      } catch {
+      }
       dependencies.push({
         packagePath: pkgPath,
         packageManager: state.packageManager,
@@ -2820,7 +3302,7 @@ function createPlan(state, choices, options = {}) {
         });
       }
     }
-    const gitignorePath = join8(state.workspaceRoot, ".gitignore");
+    const gitignorePath = join11(state.workspaceRoot, ".gitignore");
     actions.push({
       type: "append_to_file",
       path: gitignorePath,
@@ -2833,34 +3315,49 @@ function createPlan(state, choices, options = {}) {
 
 // src/commands/install/execute.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync3,
-  writeFileSync as writeFileSync6,
-  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync7,
+  readFileSync as readFileSync11,
   unlinkSync,
   chmodSync
 } from "fs";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/utils/react-inject.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join12 } from "path";
 import { parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
 function getDefaultCandidates(projectPath, appRoot) {
+  const viteMainCandidates = [
+    join12(appRoot, "main.tsx"),
+    join12(appRoot, "main.jsx"),
+    join12(appRoot, "main.ts"),
+    join12(appRoot, "main.js")
+  ];
+  const existingViteMain = viteMainCandidates.filter(
+    (rel) => existsSync12(join12(projectPath, rel))
+  );
+  if (existingViteMain.length > 0) return existingViteMain;
+  const viteAppCandidates = [join12(appRoot, "App.tsx"), join12(appRoot, "App.jsx")];
+  const existingViteApp = viteAppCandidates.filter(
+    (rel) => existsSync12(join12(projectPath, rel))
+  );
+  if (existingViteApp.length > 0) return existingViteApp;
   const layoutCandidates = [
-    join9(appRoot, "layout.tsx"),
-    join9(appRoot, "layout.jsx"),
-    join9(appRoot, "layout.ts"),
-    join9(appRoot, "layout.js")
+    join12(appRoot, "layout.tsx"),
+    join12(appRoot, "layout.jsx"),
+    join12(appRoot, "layout.ts"),
+    join12(appRoot, "layout.js")
   ];
   const existingLayouts = layoutCandidates.filter(
-    (rel) => existsSync9(join9(projectPath, rel))
+    (rel) => existsSync12(join12(projectPath, rel))
   );
   if (existingLayouts.length > 0) {
     return existingLayouts;
   }
-  const pageCandidates = [join9(appRoot, "page.tsx"), join9(appRoot, "page.jsx")];
-  return pageCandidates.filter((rel) => existsSync9(join9(projectPath, rel)));
+  const pageCandidates = [join12(appRoot, "page.tsx"), join12(appRoot, "page.jsx")];
+  return pageCandidates.filter((rel) => existsSync12(join12(projectPath, rel)));
 }
 function isUseClientDirective(stmt) {
   return stmt?.type === "ExpressionStatement" && stmt.expression?.type === "StringLiteral" && stmt.expression.value === "use client";
@@ -2873,16 +3370,16 @@ function findImportDeclaration(program2, from) {
   }
   return null;
 }
-function walkAst2(node, visit) {
+function walkAst(node, visit) {
   if (!node || typeof node !== "object") return;
   if (node.type) visit(node);
   for (const key of Object.keys(node)) {
     const v = node[key];
     if (!v) continue;
     if (Array.isArray(v)) {
-      for (const item of v) walkAst2(item, visit);
+      for (const item of v) walkAst(item, visit);
     } else if (typeof v === "object" && v.type) {
-      walkAst2(v, visit);
+      walkAst(v, visit);
     }
   }
 }
@@ -2914,7 +3411,7 @@ function ensureNamedImport(program2, from, name) {
 }
 function hasUILintProviderJsx(program2) {
   let found = false;
-  walkAst2(program2, (node) => {
+  walkAst(program2, (node) => {
     if (found) return;
     if (node.type !== "JSXElement") return;
     const name = node.openingElement?.name;
@@ -2934,7 +3431,7 @@ function wrapFirstChildrenExpressionWithProvider(program2) {
   if (!providerJsx || providerJsx.type !== "JSXElement")
     return { changed: false };
   let replaced = false;
-  walkAst2(program2, (node) => {
+  walkAst(program2, (node) => {
     if (replaced) return;
     if (node.type === "JSXExpressionContainer" && node.expression?.type === "Identifier" && node.expression.name === "children") {
       Object.keys(node).forEach((k) => delete node[k]);
@@ -2947,11 +3444,44 @@ function wrapFirstChildrenExpressionWithProvider(program2) {
   }
   return { changed: true };
 }
+function wrapFirstRenderCallArgumentWithProvider(program2) {
+  if (!program2 || program2.type !== "Program") return { changed: false };
+  if (hasUILintProviderJsx(program2)) return { changed: false };
+  const providerMod = parseModule2(
+    'const __uilint_provider = (<UILintProvider enabled={process.env.NODE_ENV !== "production"}></UILintProvider>);'
+  );
+  const providerJsx = providerMod.$ast.body?.[0]?.declarations?.[0]?.init ?? null;
+  if (!providerJsx || providerJsx.type !== "JSXElement")
+    return { changed: false };
+  providerJsx.children = providerJsx.children ?? [];
+  let wrapped = false;
+  walkAst(program2, (node) => {
+    if (wrapped) return;
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "MemberExpression") return;
+    const prop = callee.property;
+    const isRender = prop?.type === "Identifier" && prop.name === "render" || prop?.type === "StringLiteral" && prop.value === "render" || prop?.type === "Literal" && prop.value === "render";
+    if (!isRender) return;
+    const arg0 = node.arguments?.[0];
+    if (!arg0) return;
+    if (arg0.type !== "JSXElement" && arg0.type !== "JSXFragment") return;
+    providerJsx.children = [arg0];
+    node.arguments[0] = providerJsx;
+    wrapped = true;
+  });
+  if (!wrapped) {
+    throw new Error(
+      "Could not find a `.render(<...>)` call to wrap. Expected a React entry like `createRoot(...).render(<App />)`."
+    );
+  }
+  return { changed: true };
+}
 async function installReactUILintOverlay(opts) {
   const candidates = getDefaultCandidates(opts.projectPath, opts.appRoot);
   if (!candidates.length) {
     throw new Error(
-      `No suitable Next.js entry files found under ${opts.appRoot} (expected layout.* or page.*).`
+      `No suitable entry files found under ${opts.appRoot} (expected Next.js layout/page or Vite main/App).`
     );
   }
   let chosen;
@@ -2960,8 +3490,8 @@ async function installReactUILintOverlay(opts) {
   } else {
     chosen = candidates[0];
   }
-  const absTarget = join9(opts.projectPath, chosen);
-  const original = readFileSync5(absTarget, "utf-8");
+  const absTarget = join12(opts.projectPath, chosen);
+  const original = readFileSync8(absTarget, "utf-8");
   let mod;
   try {
     mod = parseModule2(original);
@@ -2979,7 +3509,8 @@ async function installReactUILintOverlay(opts) {
     "UILintProvider"
   );
   if (importRes.changed) changed = true;
-  const wrapRes = wrapFirstChildrenExpressionWithProvider(program2);
+  const mode = opts.mode ?? "next";
+  const wrapRes = mode === "vite" ? wrapFirstRenderCallArgumentWithProvider(program2) : wrapFirstChildrenExpressionWithProvider(program2);
   if (wrapRes.changed) changed = true;
   const updated = changed ? generateCode2(mod).code : original;
   const modified = updated !== original;
@@ -2994,14 +3525,14 @@ async function installReactUILintOverlay(opts) {
 }
 
 // src/utils/next-config-inject.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
 import { parseModule as parseModule3, generateCode as generateCode3 } from "magicast";
 var CONFIG_EXTENSIONS2 = [".ts", ".mjs", ".js", ".cjs"];
 function findNextConfigFile(projectPath) {
   for (const ext of CONFIG_EXTENSIONS2) {
-    const configPath = join10(projectPath, `next.config${ext}`);
-    if (existsSync10(configPath)) {
+    const configPath = join13(projectPath, `next.config${ext}`);
+    if (existsSync13(configPath)) {
       return configPath;
     }
   }
@@ -3114,7 +3645,7 @@ async function installJsxLocPlugin(opts) {
     return { configFile: null, modified: false };
   }
   const configFilename = getNextConfigFilename(configPath);
-  const original = readFileSync6(configPath, "utf-8");
+  const original = readFileSync9(configPath, "utf-8");
   let mod;
   try {
     mod = parseModule3(original);
@@ -3143,10 +3674,221 @@ async function installJsxLocPlugin(opts) {
   return { configFile: configFilename, modified: false };
 }
 
+// src/utils/vite-config-inject.ts
+import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
+import { parseModule as parseModule4, generateCode as generateCode4 } from "magicast";
+var CONFIG_EXTENSIONS3 = [".ts", ".mjs", ".js", ".cjs"];
+function findViteConfigFile2(projectPath) {
+  for (const ext of CONFIG_EXTENSIONS3) {
+    const configPath = join14(projectPath, `vite.config${ext}`);
+    if (existsSync14(configPath)) return configPath;
+  }
+  return null;
+}
+function getViteConfigFilename(configPath) {
+  const parts = configPath.split("/");
+  return parts[parts.length - 1] || "vite.config.ts";
+}
+function isIdentifier3(node, name) {
+  return !!node && node.type === "Identifier" && (name ? node.name === name : typeof node.name === "string");
+}
+function isStringLiteral3(node) {
+  return !!node && (node.type === "StringLiteral" || node.type === "Literal") && typeof node.value === "string";
+}
+function unwrapExpression(expr) {
+  let e = expr;
+  while (e) {
+    if (e.type === "TSAsExpression" || e.type === "TSNonNullExpression") {
+      e = e.expression;
+      continue;
+    }
+    if (e.type === "TSSatisfiesExpression") {
+      e = e.expression;
+      continue;
+    }
+    if (e.type === "ParenthesizedExpression") {
+      e = e.expression;
+      continue;
+    }
+    break;
+  }
+  return e;
+}
+function findExportedConfigObjectExpression(mod) {
+  const program2 = mod?.$ast;
+  if (!program2 || program2.type !== "Program") return null;
+  for (const stmt of program2.body ?? []) {
+    if (!stmt || stmt.type !== "ExportDefaultDeclaration") continue;
+    const decl = unwrapExpression(stmt.declaration);
+    if (!decl) break;
+    if (decl.type === "ObjectExpression") {
+      return { kind: "esm", objExpr: decl, program: program2 };
+    }
+    if (decl.type === "CallExpression" && isIdentifier3(decl.callee, "defineConfig") && unwrapExpression(decl.arguments?.[0])?.type === "ObjectExpression") {
+      return {
+        kind: "esm",
+        objExpr: unwrapExpression(decl.arguments?.[0]),
+        program: program2
+      };
+    }
+    break;
+  }
+  for (const stmt of program2.body ?? []) {
+    if (!stmt || stmt.type !== "ExpressionStatement") continue;
+    const expr = stmt.expression;
+    if (!expr || expr.type !== "AssignmentExpression") continue;
+    const left = expr.left;
+    const right = unwrapExpression(expr.right);
+    const isModuleExports = left?.type === "MemberExpression" && isIdentifier3(left.object, "module") && isIdentifier3(left.property, "exports");
+    if (!isModuleExports) continue;
+    if (right?.type === "ObjectExpression") {
+      return { kind: "cjs", objExpr: right, program: program2 };
+    }
+    if (right?.type === "CallExpression" && isIdentifier3(right.callee, "defineConfig") && unwrapExpression(right.arguments?.[0])?.type === "ObjectExpression") {
+      return {
+        kind: "cjs",
+        objExpr: unwrapExpression(right.arguments?.[0]),
+        program: program2
+      };
+    }
+  }
+  return null;
+}
+function getObjectProperty(obj, keyName) {
+  if (!obj || obj.type !== "ObjectExpression") return null;
+  for (const prop of obj.properties ?? []) {
+    if (!prop) continue;
+    if (prop.type !== "ObjectProperty" && prop.type !== "Property") continue;
+    const key = prop.key;
+    const keyMatch = key?.type === "Identifier" && key.name === keyName || isStringLiteral3(key) && key.value === keyName;
+    if (keyMatch) return prop;
+  }
+  return null;
+}
+function ensureEsmJsxLocImport(program2) {
+  if (!program2 || program2.type !== "Program") return { changed: false };
+  const existing = (program2.body ?? []).find(
+    (s) => s?.type === "ImportDeclaration" && s.source?.value === "jsx-loc-plugin/vite"
+  );
+  if (existing) {
+    const has = (existing.specifiers ?? []).some(
+      (sp) => sp?.type === "ImportSpecifier" && (sp.imported?.name === "jsxLoc" || sp.imported?.value === "jsxLoc")
+    );
+    if (has) return { changed: false };
+    const spec = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0]?.specifiers?.[0];
+    if (!spec) return { changed: false };
+    existing.specifiers = [...existing.specifiers ?? [], spec];
+    return { changed: true };
+  }
+  const importDecl = parseModule4('import { jsxLoc } from "jsx-loc-plugin/vite";').$ast.body?.[0];
+  if (!importDecl) return { changed: false };
+  const body = program2.body ?? [];
+  let insertAt = 0;
+  while (insertAt < body.length && body[insertAt]?.type === "ImportDeclaration") {
+    insertAt++;
+  }
+  program2.body.splice(insertAt, 0, importDecl);
+  return { changed: true };
+}
+function ensureCjsJsxLocRequire(program2) {
+  if (!program2 || program2.type !== "Program") return { changed: false };
+  for (const stmt of program2.body ?? []) {
+    if (stmt?.type !== "VariableDeclaration") continue;
+    for (const decl of stmt.declarations ?? []) {
+      const init = decl?.init;
+      if (init?.type === "CallExpression" && isIdentifier3(init.callee, "require") && isStringLiteral3(init.arguments?.[0]) && init.arguments[0].value === "jsx-loc-plugin/vite") {
+        if (decl.id?.type === "ObjectPattern") {
+          const has = (decl.id.properties ?? []).some((p2) => {
+            if (p2?.type !== "ObjectProperty" && p2?.type !== "Property") return false;
+            return isIdentifier3(p2.key, "jsxLoc");
+          });
+          if (has) return { changed: false };
+          const prop = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0]?.declarations?.[0]?.id?.properties?.[0];
+          if (!prop) return { changed: false };
+          decl.id.properties = [...decl.id.properties ?? [], prop];
+          return { changed: true };
+        }
+        return { changed: false };
+      }
+    }
+  }
+  const reqDecl = parseModule4('const { jsxLoc } = require("jsx-loc-plugin/vite");').$ast.body?.[0];
+  if (!reqDecl) return { changed: false };
+  program2.body.unshift(reqDecl);
+  return { changed: true };
+}
+function pluginsHasJsxLoc(arr) {
+  if (!arr || arr.type !== "ArrayExpression") return false;
+  for (const el of arr.elements ?? []) {
+    const e = unwrapExpression(el);
+    if (!e) continue;
+    if (e.type === "CallExpression" && isIdentifier3(e.callee, "jsxLoc")) return true;
+  }
+  return false;
+}
+function ensurePluginsContainsJsxLoc(configObj) {
+  const pluginsProp = getObjectProperty(configObj, "plugins");
+  if (!pluginsProp) {
+    const prop = parseModule4("export default { plugins: [jsxLoc()] };").$ast.body?.find((s) => s.type === "ExportDefaultDeclaration")?.declaration?.properties?.find((p2) => {
+      const k = p2?.key;
+      return k?.type === "Identifier" && k.name === "plugins" || isStringLiteral3(k) && k.value === "plugins";
+    });
+    if (!prop) return { changed: false };
+    configObj.properties = [...configObj.properties ?? [], prop];
+    return { changed: true };
+  }
+  const value = unwrapExpression(pluginsProp.value);
+  if (!value) return { changed: false };
+  if (value.type === "ArrayExpression") {
+    if (pluginsHasJsxLoc(value)) return { changed: false };
+    const jsxLocCall2 = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+    if (!jsxLocCall2) return { changed: false };
+    value.elements.push(jsxLocCall2);
+    return { changed: true };
+  }
+  const jsxLocCall = parseModule4("const __x = jsxLoc();").$ast.body?.[0]?.declarations?.[0]?.init;
+  if (!jsxLocCall) return { changed: false };
+  const spread = { type: "SpreadElement", argument: value };
+  pluginsProp.value = { type: "ArrayExpression", elements: [spread, jsxLocCall] };
+  return { changed: true };
+}
+async function installViteJsxLocPlugin(opts) {
+  const configPath = findViteConfigFile2(opts.projectPath);
+  if (!configPath) return { configFile: null, modified: false };
+  const configFilename = getViteConfigFilename(configPath);
+  const original = readFileSync10(configPath, "utf-8");
+  const isCjs = configPath.endsWith(".cjs");
+  let mod;
+  try {
+    mod = parseModule4(original);
+  } catch {
+    return { configFile: configFilename, modified: false };
+  }
+  const found = findExportedConfigObjectExpression(mod);
+  if (!found) return { configFile: configFilename, modified: false };
+  let changed = false;
+  if (isCjs) {
+    const reqRes = ensureCjsJsxLocRequire(found.program);
+    if (reqRes.changed) changed = true;
+  } else {
+    const impRes = ensureEsmJsxLocImport(found.program);
+    if (impRes.changed) changed = true;
+  }
+  const pluginsRes = ensurePluginsContainsJsxLoc(found.objExpr);
+  if (pluginsRes.changed) changed = true;
+  const updated = changed ? generateCode4(mod).code : original;
+  if (updated !== original) {
+    writeFileSync6(configPath, updated, "utf-8");
+    return { configFile: configFilename, modified: true };
+  }
+  return { configFile: configFilename, modified: false };
+}
+
 // src/utils/next-routes.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
-import { join as join11 } from "path";
+import { join as join15 } from "path";
 var DEV_SOURCE_ROUTE_TS = `/**
  * Dev-only API route for fetching source files
  *
@@ -3161,7 +3903,8 @@ var DEV_SOURCE_ROUTE_TS = `/**
 
 import { NextRequest, NextResponse } from "next/server";
 import { readFileSync, existsSync } from "fs";
-import { resolve, relative, dirname, extname } from "path";
+import { resolve, relative, dirname, extname, sep } from "path";
+import { fileURLToPath } from "url";
 
 export const runtime = "nodejs";
 
@@ -3169,23 +3912,36 @@ export const runtime = "nodejs";
 const ALLOWED_EXTENSIONS = new Set([".tsx", ".ts", ".jsx", ".js", ".css"]);
 
 /**
- * Find the project root by looking for package.json or next.config
+ * Best-effort: resolve the Next.js project root (the dir that owns .next/) even in monorepos.
+ *
+ * Why: In monorepos, process.cwd() might be the workspace root (it also has package.json),
+ * which would incorrectly store/read files under the wrong directory.
  */
-function findProjectRoot(startDir: string): string {
-  let dir = startDir;
-  for (let i = 0; i < 10; i++) {
-    if (
-      existsSync(resolve(dir, "package.json")) ||
-      existsSync(resolve(dir, "next.config.js")) ||
-      existsSync(resolve(dir, "next.config.ts"))
-    ) {
-      return dir;
+function findNextProjectRoot(): string {
+  // Prefer discovering via this route module's on-disk path.
+  // In Next, route code is executed from within ".next/server/...".
+  try {
+    const selfPath = fileURLToPath(import.meta.url);
+    const marker = sep + ".next" + sep;
+    const idx = selfPath.lastIndexOf(marker);
+    if (idx !== -1) {
+      return selfPath.slice(0, idx);
     }
+  } catch {
+    // ignore
+  }
+
+  // Fallback: walk up from cwd looking for .next/
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(resolve(dir, ".next"))) return dir;
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return startDir;
+
+  // Final fallback: cwd
+  return process.cwd();
 }
 
 /**
@@ -3244,8 +4000,8 @@ export async function GET(request: NextRequest) {
     );
   }
 
-  // Find project root
-  const projectRoot = findProjectRoot(process.cwd());
+  // Find project root (prefer Next project root over workspace root)
+  const projectRoot = findNextProjectRoot();
 
   // Resolve the file path
   const resolvedPath = resolve(filePath);
@@ -3274,6 +4030,8 @@ export async function GET(request: NextRequest) {
     return NextResponse.json({
       content,
       relativePath,
+      projectRoot,
+      workspaceRoot,
     });
   } catch (error) {
     console.error("[Dev Source API] Error reading file:", error);
@@ -3281,20 +4039,331 @@ export async function GET(request: NextRequest) {
   }
 }
 `;
+var SCREENSHOT_ROUTE_TS = `/**
+ * Dev-only API route for saving and retrieving vision analysis screenshots
+ *
+ * This route allows the UILint overlay to:
+ * - POST: Save screenshots and element manifests for vision analysis
+ * - GET: Retrieve screenshots or list available screenshots
+ *
+ * Security:
+ * - Only available in development mode
+ * - Saves to .uilint/screenshots/ directory within project
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { resolve, join, dirname, basename, sep } from "path";
+import { fileURLToPath } from "url";
+
+export const runtime = "nodejs";
+
+// Maximum screenshot size (10MB)
+const MAX_SCREENSHOT_SIZE = 10 * 1024 * 1024;
+
+/**
+ * Best-effort: resolve the Next.js project root (the dir that owns .next/) even in monorepos.
+ */
+function findNextProjectRoot(): string {
+  try {
+    const selfPath = fileURLToPath(import.meta.url);
+    const marker = sep + ".next" + sep;
+    const idx = selfPath.lastIndexOf(marker);
+    if (idx !== -1) {
+      return selfPath.slice(0, idx);
+    }
+  } catch {
+    // ignore
+  }
+
+  let dir = process.cwd();
+  for (let i = 0; i < 20; i++) {
+    if (existsSync(resolve(dir, ".next"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return process.cwd();
+}
+
+/**
+ * Get the screenshots directory path, creating it if needed
+ */
+function getScreenshotsDir(projectRoot: string): string {
+  const screenshotsDir = join(projectRoot, ".uilint", "screenshots");
+  if (!existsSync(screenshotsDir)) {
+    mkdirSync(screenshotsDir, { recursive: true });
+  }
+  return screenshotsDir;
+}
+
+/**
+ * Validate filename to prevent path traversal
+ */
+function isValidFilename(filename: string): boolean {
+  // Only allow alphanumeric, hyphens, underscores, and dots
+  // Must end with .png, .jpeg, .jpg, or .json
+  const validPattern = /^[a-zA-Z0-9_-]+\\.(png|jpeg|jpg|json)$/;
+  return validPattern.test(filename) && !filename.includes("..");
+}
+
+/**
+ * POST: Save a screenshot and optionally its manifest
+ */
+export async function POST(request: NextRequest) {
+  // Block in production
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "Not available in production" },
+      { status: 404 }
+    );
+  }
+
+  try {
+    const body = await request.json();
+    const { filename, imageData, manifest, analysisResult } = body;
+
+    if (!filename) {
+      return NextResponse.json({ error: "Missing 'filename'" }, { status: 400 });
+    }
+
+    // Validate filename
+    if (!isValidFilename(filename)) {
+      return NextResponse.json(
+        { error: "Invalid filename format" },
+        { status: 400 }
+      );
+    }
+
+    // Allow "sidecar-only" updates (manifest/analysisResult) without re-sending image bytes.
+    const hasImageData = typeof imageData === "string" && imageData.length > 0;
+    const hasSidecar =
+      typeof manifest !== "undefined" || typeof analysisResult !== "undefined";
+
+    if (!hasImageData && !hasSidecar) {
+      return NextResponse.json(
+        { error: "Nothing to save (provide imageData and/or manifest/analysisResult)" },
+        { status: 400 }
+      );
+    }
+
+    // Check size (image only)
+    if (hasImageData && imageData.length > MAX_SCREENSHOT_SIZE) {
+      return NextResponse.json(
+        { error: "Screenshot too large (max 10MB)" },
+        { status: 413 }
+      );
+    }
+
+    const projectRoot = findNextProjectRoot();
+    const screenshotsDir = getScreenshotsDir(projectRoot);
+
+    const imagePath = join(screenshotsDir, filename);
+
+    // Save the image (base64 data URL) if provided
+    if (hasImageData) {
+      const base64Data = imageData.includes(",")
+        ? imageData.split(",")[1]
+        : imageData;
+      writeFileSync(imagePath, Buffer.from(base64Data, "base64"));
+    }
+
+    // Save manifest and analysis result as JSON sidecar
+    if (hasSidecar) {
+      const jsonFilename = filename.replace(/\\.(png|jpeg|jpg)$/, ".json");
+      const jsonPath = join(screenshotsDir, jsonFilename);
+
+      // If a sidecar already exists, merge updates (lets us POST analysisResult later without re-sending image).
+      let existing: any = null;
+      if (existsSync(jsonPath)) {
+        try {
+          existing = JSON.parse(readFileSync(jsonPath, "utf-8"));
+        } catch {
+          existing = null;
+        }
+      }
+
+      const routeFromAnalysis =
+        analysisResult && typeof analysisResult === "object"
+          ? (analysisResult as any).route
+          : undefined;
+      const issuesFromAnalysis =
+        analysisResult && typeof analysisResult === "object"
+          ? (analysisResult as any).issues
+          : undefined;
+
+      const jsonData = {
+        ...(existing && typeof existing === "object" ? existing : {}),
+        timestamp: Date.now(),
+        filename,
+        screenshotFile: filename,
+        route:
+          typeof routeFromAnalysis === "string"
+            ? routeFromAnalysis
+            : (existing as any)?.route ?? null,
+        issues:
+          Array.isArray(issuesFromAnalysis)
+            ? issuesFromAnalysis
+            : (existing as any)?.issues ?? null,
+        manifest: typeof manifest === "undefined" ? existing?.manifest ?? null : manifest,
+        analysisResult:
+          typeof analysisResult === "undefined"
+            ? existing?.analysisResult ?? null
+            : analysisResult,
+      };
+      writeFileSync(jsonPath, JSON.stringify(jsonData, null, 2));
+    }
+
+    return NextResponse.json({
+      success: true,
+      path: imagePath,
+      projectRoot,
+      screenshotsDir,
+    });
+  } catch (error) {
+    console.error("[Screenshot API] Error saving screenshot:", error);
+    return NextResponse.json(
+      { error: "Failed to save screenshot" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET: Retrieve a screenshot or list available screenshots
+ */
+export async function GET(request: NextRequest) {
+  // Block in production
+  if (process.env.NODE_ENV === "production") {
+    return NextResponse.json(
+      { error: "Not available in production" },
+      { status: 404 }
+    );
+  }
+
+  const { searchParams } = new URL(request.url);
+  const filename = searchParams.get("filename");
+  const list = searchParams.get("list");
+
+  const projectRoot = findNextProjectRoot();
+  const screenshotsDir = getScreenshotsDir(projectRoot);
+
+  // List mode: return all screenshots
+  if (list === "true") {
+    try {
+      const files = readdirSync(screenshotsDir);
+      const screenshots = files
+        .filter((f) => /\\.(png|jpeg|jpg)$/.test(f))
+        .map((f) => {
+          const jsonFile = f.replace(/\\.(png|jpeg|jpg)$/, ".json");
+          const jsonPath = join(screenshotsDir, jsonFile);
+          let metadata = null;
+          if (existsSync(jsonPath)) {
+            try {
+              metadata = JSON.parse(readFileSync(jsonPath, "utf-8"));
+            } catch {
+              // Ignore parse errors
+            }
+          }
+          return {
+            filename: f,
+            metadata,
+          };
+        })
+        .sort((a, b) => {
+          // Sort by timestamp descending (newest first)
+          const aTime = a.metadata?.timestamp || 0;
+          const bTime = b.metadata?.timestamp || 0;
+          return bTime - aTime;
+        });
+
+      return NextResponse.json({ screenshots, projectRoot, screenshotsDir });
+    } catch (error) {
+      console.error("[Screenshot API] Error listing screenshots:", error);
+      return NextResponse.json(
+        { error: "Failed to list screenshots" },
+        { status: 500 }
+      );
+    }
+  }
+
+  // Retrieve mode: get specific screenshot
+  if (!filename) {
+    return NextResponse.json(
+      { error: "Missing 'filename' parameter" },
+      { status: 400 }
+    );
+  }
+
+  if (!isValidFilename(filename)) {
+    return NextResponse.json(
+      { error: "Invalid filename format" },
+      { status: 400 }
+    );
+  }
+
+  const filePath = join(screenshotsDir, filename);
+
+  if (!existsSync(filePath)) {
+    return NextResponse.json(
+      { error: "Screenshot not found" },
+      { status: 404 }
+    );
+  }
+
+  try {
+    const content = readFileSync(filePath);
+    
+    // Determine content type
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const contentType =
+      ext === "json"
+        ? "application/json"
+        : ext === "png"
+        ? "image/png"
+        : "image/jpeg";
+
+    if (ext === "json") {
+      return NextResponse.json(JSON.parse(content.toString()));
+    }
+
+    return new NextResponse(content, {
+      headers: {
+        "Content-Type": contentType,
+        "Cache-Control": "no-cache",
+      },
+    });
+  } catch (error) {
+    console.error("[Screenshot API] Error reading screenshot:", error);
+    return NextResponse.json(
+      { error: "Failed to read screenshot" },
+      { status: 500 }
+    );
+  }
+}
+`;
 async function writeRouteFile(absPath, relPath, content, opts) {
-  if (existsSync11(absPath) && !opts.force) return;
+  if (existsSync15(absPath) && !opts.force) return;
   await writeFile(absPath, content, "utf-8");
 }
 async function installNextUILintRoutes(opts) {
-  const baseRel = join11(opts.appRoot, "api", ".uilint");
-  const baseAbs = join11(opts.projectPath, baseRel);
-  await mkdir(join11(baseAbs, "source"), { recursive: true });
+  const baseRel = join15(opts.appRoot, "api", ".uilint");
+  const baseAbs = join15(opts.projectPath, baseRel);
+  await mkdir(join15(baseAbs, "source"), { recursive: true });
   await writeRouteFile(
-    join11(baseAbs, "source", "route.ts"),
-    join11(baseRel, "source", "route.ts"),
+    join15(baseAbs, "source", "route.ts"),
+    join15(baseRel, "source", "route.ts"),
     DEV_SOURCE_ROUTE_TS,
     opts
   );
+  await mkdir(join15(baseAbs, "screenshots"), { recursive: true });
+  await writeRouteFile(
+    join15(baseAbs, "screenshots", "route.ts"),
+    join15(baseRel, "screenshots", "route.ts"),
+    SCREENSHOT_ROUTE_TS,
+    opts
+  );
 }
 
 // src/commands/install/execute.ts
@@ -3310,7 +4379,7 @@ async function executeAction(action, options) {
             wouldDo: `Create directory: ${action.path}`
           };
         }
-        if (!existsSync12(action.path)) {
+        if (!existsSync16(action.path)) {
           mkdirSync3(action.path, { recursive: true });
         }
         return { action, success: true };
@@ -3323,11 +4392,11 @@ async function executeAction(action, options) {
             wouldDo: `Create file: ${action.path}${action.permissions ? ` (mode: ${action.permissions.toString(8)})` : ""}`
           };
         }
-        const dir = dirname6(action.path);
-        if (!existsSync12(dir)) {
+        const dir = dirname9(action.path);
+        if (!existsSync16(dir)) {
           mkdirSync3(dir, { recursive: true });
         }
-        writeFileSync6(action.path, action.content, "utf-8");
+        writeFileSync7(action.path, action.content, "utf-8");
         if (action.permissions) {
           chmodSync(action.path, action.permissions);
         }
@@ -3342,18 +4411,18 @@ async function executeAction(action, options) {
           };
         }
         let existing = {};
-        if (existsSync12(action.path)) {
+        if (existsSync16(action.path)) {
           try {
-            existing = JSON.parse(readFileSync7(action.path, "utf-8"));
+            existing = JSON.parse(readFileSync11(action.path, "utf-8"));
           } catch {
           }
         }
         const merged = deepMerge(existing, action.merge);
-        const dir = dirname6(action.path);
-        if (!existsSync12(dir)) {
+        const dir = dirname9(action.path);
+        if (!existsSync16(dir)) {
           mkdirSync3(dir, { recursive: true });
         }
-        writeFileSync6(action.path, JSON.stringify(merged, null, 2), "utf-8");
+        writeFileSync7(action.path, JSON.stringify(merged, null, 2), "utf-8");
         return { action, success: true };
       }
       case "delete_file": {
@@ -3364,7 +4433,7 @@ async function executeAction(action, options) {
             wouldDo: `Delete file: ${action.path}`
           };
         }
-        if (existsSync12(action.path)) {
+        if (existsSync16(action.path)) {
           unlinkSync(action.path);
         }
         return { action, success: true };
@@ -3377,12 +4446,12 @@ async function executeAction(action, options) {
             wouldDo: `Append to file: ${action.path}`
           };
         }
-        if (existsSync12(action.path)) {
-          const content = readFileSync7(action.path, "utf-8");
+        if (existsSync16(action.path)) {
+          const content = readFileSync11(action.path, "utf-8");
           if (action.ifNotContains && content.includes(action.ifNotContains)) {
             return { action, success: true };
           }
-          writeFileSync6(action.path, content + action.content, "utf-8");
+          writeFileSync7(action.path, content + action.content, "utf-8");
         }
         return { action, success: true };
       }
@@ -3395,6 +4464,9 @@ async function executeAction(action, options) {
       case "inject_next_config": {
         return await executeInjectNextConfig(action, options);
       }
+      case "inject_vite_config": {
+        return await executeInjectViteConfig(action, options);
+      }
       case "install_next_routes": {
         return await executeInstallNextRoutes(action, options);
       }
@@ -3450,6 +4522,7 @@ async function executeInjectReact(action, options) {
   const result = await installReactUILintOverlay({
     projectPath: action.projectPath,
     appRoot: action.appRoot,
+    mode: action.mode,
     force: false,
     // Auto-select first choice for execute phase
     confirmFileChoice: async (choices) => choices[0]
@@ -3461,6 +4534,25 @@ async function executeInjectReact(action, options) {
     error: success ? void 0 : "Failed to configure React overlay"
   };
 }
+async function executeInjectViteConfig(action, options) {
+  const { dryRun = false } = options;
+  if (dryRun) {
+    return {
+      action,
+      success: true,
+      wouldDo: `Inject jsx-loc-plugin into vite.config: ${action.projectPath}`
+    };
+  }
+  const result = await installViteJsxLocPlugin({
+    projectPath: action.projectPath,
+    force: false
+  });
+  return {
+    action,
+    success: result.modified || result.configFile !== null,
+    error: result.configFile === null ? "No vite.config found" : void 0
+  };
+}
 async function executeInjectNextConfig(action, options) {
   const { dryRun = false } = options;
   if (dryRun) {
@@ -3518,6 +4610,7 @@ function buildSummary(actionsPerformed, dependencyResults, items) {
   const filesDeleted = [];
   const eslintTargets = [];
   let nextApp;
+  let viteApp;
   for (const result of actionsPerformed) {
     if (!result.success) continue;
     const { action } = result;
@@ -3540,6 +4633,12 @@ function buildSummary(actionsPerformed, dependencyResults, items) {
         });
         break;
       case "inject_react":
+        if (action.mode === "vite") {
+          viteApp = { entryRoot: action.appRoot };
+        } else {
+          nextApp = { appRoot: action.appRoot };
+        }
+        break;
       case "install_next_routes":
         nextApp = { appRoot: action.appRoot };
         break;
@@ -3561,7 +4660,8 @@ function buildSummary(actionsPerformed, dependencyResults, items) {
     filesDeleted,
     dependenciesInstalled,
     eslintTargets,
-    nextApp
+    nextApp,
+    viteApp
   };
 }
 async function execute(plan, options = {}) {
@@ -3611,11 +4711,14 @@ async function execute(plan, options = {}) {
       if (action.path.includes("hooks.json")) items.push("hooks");
       if (action.path.includes("genstyleguide.md")) items.push("genstyleguide");
       if (action.path.includes("genrules.md")) items.push("genrules");
+      if (action.path.includes("/skills/") && action.path.includes("SKILL.md")) items.push("skill");
     }
     if (action.type === "inject_eslint") items.push("eslint");
-    if (action.type === "inject_react" || action.type === "install_next_routes") {
-      items.push("next");
+    if (action.type === "install_next_routes") items.push("next");
+    if (action.type === "inject_react") {
+      items.push(action.mode === "vite" ? "vite" : "next");
     }
+    if (action.type === "inject_vite_config") items.push("vite");
   }
   const uniqueItems = [...new Set(items)];
   const summary = buildSummary(
@@ -3641,13 +4744,18 @@ var cliPrompter = {
         {
           value: "eslint",
           label: "ESLint plugin",
-          hint: "Installs uilint-eslint and configures eslint.config.js"
+          hint: "Installs uilint-eslint and configures eslint.config.*"
         },
         {
           value: "next",
           label: "UI overlay",
           hint: "Installs routes + UILintProvider (Alt+Click to inspect)"
         },
+        {
+          value: "vite",
+          label: "UI overlay (Vite)",
+          hint: "Installs jsx-loc-plugin + UILintProvider (Alt+Click to inspect)"
+        },
         {
           value: "genstyleguide",
           label: "/genstyleguide command",
@@ -3667,10 +4775,15 @@ var cliPrompter = {
           value: "genrules",
           label: "/genrules command",
           hint: "Adds .cursor/commands/genrules.md for ESLint rule generation"
+        },
+        {
+          value: "skill",
+          label: "UI Consistency Agent Skill",
+          hint: "Cursor agent skill for generating ESLint rules from UI patterns"
         }
       ],
       required: true,
-      initialValues: ["eslint", "next", "genstyleguide"]
+      initialValues: ["eslint", "next", "genstyleguide", "skill"]
     });
   },
   async confirmMcpMerge() {
@@ -3700,6 +4813,17 @@ var cliPrompter = {
     });
     return apps.find((a) => a.projectPath === chosen) || apps[0];
   },
+  async selectViteApp(apps) {
+    const chosen = await select2({
+      message: "Which Vite + React project should UILint install into?",
+      options: apps.map((app) => ({
+        value: app.projectPath,
+        label: app.projectPath
+      })),
+      initialValue: apps[0].projectPath
+    });
+    return apps.find((a) => a.projectPath === chosen) || apps[0];
+  },
   async selectEslintPackages(packages) {
     if (packages.length === 1) {
       const confirmed = await confirm2({
@@ -3856,13 +4980,14 @@ async function promptForField(field, ruleName) {
 }
 async function gatherChoices(state, options, prompter) {
   let items;
-  const hasExplicitFlags = options.mcp !== void 0 || options.hooks !== void 0 || options.genstyleguide !== void 0 || options.genrules !== void 0 || options.routes !== void 0 || options.react !== void 0;
+  const hasExplicitFlags = options.mcp !== void 0 || options.hooks !== void 0 || options.genstyleguide !== void 0 || options.genrules !== void 0 || options.skill !== void 0 || options.routes !== void 0 || options.react !== void 0;
   if (hasExplicitFlags || options.eslint) {
     items = [];
     if (options.mcp) items.push("mcp");
     if (options.hooks) items.push("hooks");
     if (options.genstyleguide) items.push("genstyleguide");
     if (options.genrules) items.push("genrules");
+    if (options.skill) items.push("skill");
     if (options.routes || options.react) items.push("next");
     if (options.eslint) items.push("eslint");
   } else if (options.mode) {
@@ -3901,6 +5026,25 @@ async function gatherChoices(state, options, prompter) {
       };
     }
   }
+  let viteChoices;
+  if (items.includes("vite")) {
+    if (state.viteApps.length === 0) {
+      throw new Error(
+        "Could not find a Vite + React project (expected vite.config.* + react deps). Run this from your Vite project root."
+      );
+    } else if (state.viteApps.length === 1) {
+      viteChoices = {
+        projectPath: state.viteApps[0].projectPath,
+        detection: state.viteApps[0].detection
+      };
+    } else {
+      const selected = await prompter.selectViteApp(state.viteApps);
+      viteChoices = {
+        projectPath: selected.projectPath,
+        detection: selected.detection
+      };
+    }
+  }
   let eslintChoices;
   if (items.includes("eslint")) {
     const packagesWithEslint = state.packages.filter(
@@ -3908,7 +5052,7 @@ async function gatherChoices(state, options, prompter) {
     );
     if (packagesWithEslint.length === 0) {
       throw new Error(
-        "No packages with eslint.config.{mjs,js,cjs} found. Create an ESLint config first."
+        "No packages with eslint.config.{ts,mjs,js,cjs} found. Create an ESLint config first."
       );
     }
     const packagePaths = await prompter.selectEslintPackages(
@@ -3940,6 +5084,7 @@ async function gatherChoices(state, options, prompter) {
     mcpMerge,
     hooksMerge,
     next: nextChoices,
+    vite: viteChoices,
     eslint: eslintChoices
   };
 }
@@ -3988,7 +5133,7 @@ function displayResults(result) {
   if (summary.nextApp) {
     installedItems.push(
       `${pc.cyan("Next Routes")} \u2192 ${pc.dim(
-        join12(summary.nextApp.appRoot, "api/.uilint")
+        join16(summary.nextApp.appRoot, "api/.uilint")
       )}`
     );
     installedItems.push(
@@ -4000,6 +5145,16 @@ function displayResults(result) {
       )}`
     );
   }
+  if (summary.viteApp) {
+    installedItems.push(
+      `${pc.cyan("Vite Overlay")} \u2192 ${pc.dim("<UILintProvider> injected")}`
+    );
+    installedItems.push(
+      `${pc.cyan("JSX Loc Plugin")} \u2192 ${pc.dim(
+        "vite.config plugins patched with jsxLoc()"
+      )}`
+    );
+  }
   if (summary.eslintTargets.length > 0) {
     installedItems.push(
       `${pc.cyan("ESLint Plugin")} \u2192 installed in ${summary.eslintTargets.length} package(s)`
@@ -4039,9 +5194,14 @@ function displayResults(result) {
   if (summary.installedItems.includes("hooks")) {
     steps.push("Hooks will auto-validate UI files when the agent stops");
   }
-  if (summary.nextApp) {
+  if (summary.nextApp) {
+    steps.push(
+      "Run your Next.js dev server - use Alt+Click on any element to inspect"
+    );
+  }
+  if (summary.viteApp) {
     steps.push(
-      "Run your Next.js dev server - use Alt+Click on any element to inspect"
+      "Run your Vite dev server - use Alt+Click on any element to inspect"
     );
   }
   if (summary.eslintTargets.length > 0) {
@@ -4108,12 +5268,207 @@ async function install(options = {}, prompter = cliPrompter, executeOptions = {}
 }
 
 // src/commands/serve.ts
-import { existsSync as existsSync13, statSync as statSync2, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { dirname as dirname7, resolve as resolve5, relative as relative2, join as join13 } from "path";
+import { existsSync as existsSync18, statSync as statSync4, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname11, resolve as resolve5, relative as relative4, join as join18, parse as parse2 } from "path";
 import { WebSocketServer, WebSocket } from "ws";
 import { watch } from "chokidar";
-import { findWorkspaceRoot as findWorkspaceRoot5 } from "uilint-core/node";
+import {
+  findWorkspaceRoot as findWorkspaceRoot6,
+  getVisionAnalyzer as getCoreVisionAnalyzer
+} from "uilint-core/node";
+
+// src/utils/vision-run.ts
+import { dirname as dirname10, join as join17, parse } from "path";
+import { existsSync as existsSync17, statSync as statSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync8 } from "fs";
+import {
+  ensureOllamaReady as ensureOllamaReady5,
+  findStyleGuidePath as findStyleGuidePath4,
+  findUILintStyleGuideUpwards as findUILintStyleGuideUpwards3,
+  readStyleGuide as readStyleGuide4,
+  VisionAnalyzer,
+  UILINT_DEFAULT_VISION_MODEL
+} from "uilint-core/node";
+async function resolveVisionStyleGuide(args) {
+  const projectPath = args.projectPath;
+  const startDir = args.startDir ?? projectPath;
+  if (args.styleguide) {
+    const styleguideArg = resolvePathSpecifier(args.styleguide, projectPath);
+    if (existsSync17(styleguideArg)) {
+      const stat = statSync3(styleguideArg);
+      if (stat.isFile()) {
+        return {
+          styleguideLocation: styleguideArg,
+          styleGuide: await readStyleGuide4(styleguideArg)
+        };
+      }
+      if (stat.isDirectory()) {
+        const found = findStyleGuidePath4(styleguideArg);
+        return {
+          styleguideLocation: found,
+          styleGuide: found ? await readStyleGuide4(found) : null
+        };
+      }
+    }
+    return { styleGuide: null, styleguideLocation: null };
+  }
+  const upwards = findUILintStyleGuideUpwards3(startDir);
+  const fallback = upwards ?? findStyleGuidePath4(projectPath);
+  return {
+    styleguideLocation: fallback,
+    styleGuide: fallback ? await readStyleGuide4(fallback) : null
+  };
+}
+var ollamaReadyOnce = /* @__PURE__ */ new Map();
+async function ensureOllamaReadyCached(params) {
+  const key = `${params.baseUrl}::${params.model}`;
+  const existing = ollamaReadyOnce.get(key);
+  if (existing) return existing;
+  const p2 = ensureOllamaReady5({ model: params.model, baseUrl: params.baseUrl }).then(() => void 0).catch((e) => {
+    ollamaReadyOnce.delete(key);
+    throw e;
+  });
+  ollamaReadyOnce.set(key, p2);
+  return p2;
+}
+function writeVisionDebugDump(params) {
+  const resolvedDirOrFile = resolvePathSpecifier(
+    params.dumpPath,
+    process.cwd()
+  );
+  const safeStamp = params.now.toISOString().replace(/[:.]/g, "-");
+  const dumpFile = resolvedDirOrFile.endsWith(".json") || resolvedDirOrFile.endsWith(".jsonl") ? resolvedDirOrFile : `${resolvedDirOrFile}/vision-debug-${safeStamp}.json`;
+  mkdirSync4(dirname10(dumpFile), { recursive: true });
+  writeFileSync8(
+    dumpFile,
+    JSON.stringify(
+      {
+        version: 1,
+        timestamp: params.now.toISOString(),
+        runtime: params.runtime,
+        metadata: params.metadata ?? null,
+        inputs: {
+          imageBase64: params.includeSensitive ? params.inputs.imageBase64 : "(omitted; set debugDumpIncludeSensitive=true)",
+          manifest: params.inputs.manifest,
+          styleguideLocation: params.inputs.styleguideLocation,
+          styleGuide: params.includeSensitive ? params.inputs.styleGuide : "(omitted; set debugDumpIncludeSensitive=true)"
+        }
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+  return dumpFile;
+}
+async function runVisionAnalysis(args) {
+  const visionModel = args.model || UILINT_DEFAULT_VISION_MODEL;
+  const baseUrl = args.baseUrl ?? "http://localhost:11434";
+  let styleGuide = null;
+  let styleguideLocation = null;
+  if (args.styleGuide !== void 0) {
+    styleGuide = args.styleGuide;
+    styleguideLocation = args.styleguideLocation ?? null;
+  } else {
+    args.onPhase?.("Resolving styleguide...");
+    const resolved = await resolveVisionStyleGuide({
+      projectPath: args.projectPath,
+      styleguide: args.styleguide,
+      startDir: args.styleguideStartDir
+    });
+    styleGuide = resolved.styleGuide;
+    styleguideLocation = resolved.styleguideLocation;
+  }
+  if (!args.skipEnsureOllama) {
+    args.onPhase?.("Preparing Ollama...");
+    await ensureOllamaReadyCached({ model: visionModel, baseUrl });
+  }
+  if (args.debugDump) {
+    writeVisionDebugDump({
+      dumpPath: args.debugDump,
+      now: /* @__PURE__ */ new Date(),
+      runtime: { visionModel, baseUrl },
+      inputs: {
+        imageBase64: args.imageBase64,
+        manifest: args.manifest,
+        styleguideLocation,
+        styleGuide
+      },
+      includeSensitive: Boolean(args.debugDumpIncludeSensitive),
+      metadata: args.debugDumpMetadata
+    });
+  }
+  const analyzer = args.analyzer ?? new VisionAnalyzer({
+    baseUrl: args.baseUrl,
+    visionModel
+  });
+  args.onPhase?.(`Analyzing ${args.manifest.length} elements...`);
+  const result = await analyzer.analyzeScreenshot(
+    args.imageBase64,
+    args.manifest,
+    {
+      styleGuide,
+      onProgress: args.onProgress
+    }
+  );
+  args.onPhase?.(
+    `Done (${result.issues.length} issues, ${result.analysisTime}ms)`
+  );
+  return {
+    issues: result.issues,
+    analysisTime: result.analysisTime,
+    // Prompt is available in newer uilint-core versions; keep this resilient across versions.
+    prompt: result.prompt,
+    rawResponse: result.rawResponse,
+    styleguideLocation,
+    visionModel,
+    baseUrl
+  };
+}
+function writeVisionMarkdownReport(args) {
+  const p2 = parse(args.imagePath);
+  const outPath = args.outPath ?? join17(p2.dir, `${p2.name || p2.base}.vision.md`);
+  const lines = [];
+  lines.push(`# UILint Vision Report`);
+  lines.push(``);
+  lines.push(`- Image: \`${p2.base}\``);
+  if (args.route) lines.push(`- Route: \`${args.route}\``);
+  if (typeof args.timestamp === "number") {
+    lines.push(`- Timestamp: \`${new Date(args.timestamp).toISOString()}\``);
+  }
+  if (args.visionModel) lines.push(`- Model: \`${args.visionModel}\``);
+  if (args.baseUrl) lines.push(`- Ollama baseUrl: \`${args.baseUrl}\``);
+  if (typeof args.analysisTimeMs === "number")
+    lines.push(`- Analysis time: \`${args.analysisTimeMs}ms\``);
+  lines.push(`- Generated: \`${(/* @__PURE__ */ new Date()).toISOString()}\``);
+  lines.push(``);
+  if (args.metadata && Object.keys(args.metadata).length > 0) {
+    lines.push(`## Metadata`);
+    lines.push(``);
+    lines.push("```json");
+    lines.push(JSON.stringify(args.metadata, null, 2));
+    lines.push("```");
+    lines.push(``);
+  }
+  lines.push(`## Prompt`);
+  lines.push(``);
+  lines.push("```text");
+  lines.push((args.prompt ?? "").trim());
+  lines.push("```");
+  lines.push(``);
+  lines.push(`## Raw Response`);
+  lines.push(``);
+  lines.push("```text");
+  lines.push((args.rawResponse ?? "").trim());
+  lines.push("```");
+  lines.push(``);
+  const content = lines.join("\n");
+  mkdirSync4(dirname10(outPath), { recursive: true });
+  writeFileSync8(outPath, content, "utf-8");
+  return { outPath, content };
+}
+
+// src/commands/serve.ts
 function pickAppRoot(params) {
   const { cwd, workspaceRoot } = params;
   if (detectNextAppRouter(cwd)) return cwd;
@@ -4128,11 +5483,23 @@ function pickAppRoot(params) {
 }
 var cache = /* @__PURE__ */ new Map();
 var eslintInstances = /* @__PURE__ */ new Map();
+var visionAnalyzer = null;
+function getVisionAnalyzerInstance() {
+  if (!visionAnalyzer) {
+    visionAnalyzer = getCoreVisionAnalyzer();
+  }
+  return visionAnalyzer;
+}
+var serverAppRootForVision = process.cwd();
+function isValidScreenshotFilename(filename) {
+  const validPattern = /^[a-zA-Z0-9_-]+\.(png|jpeg|jpg)$/;
+  return validPattern.test(filename) && !filename.includes("..");
+}
 var resolvedPathCache = /* @__PURE__ */ new Map();
 var subscriptions = /* @__PURE__ */ new Map();
 var fileWatcher = null;
 var connectedClients = 0;
-var localRequire = createRequire2(import.meta.url);
+var localRequire = createRequire3(import.meta.url);
 function buildLineStarts(code) {
   const starts = [0];
   for (let i = 0; i < code.length; i++) {
@@ -4146,8 +5513,8 @@ function offsetFromLineCol(lineStarts, line1, col0, codeLength) {
   return Math.max(0, Math.min(codeLength, base + Math.max(0, col0)));
 }
 function buildJsxElementSpans(code, dataLocFile) {
-  const { parse } = localRequire("@typescript-eslint/typescript-estree");
-  const ast = parse(code, {
+  const { parse: parse3 } = localRequire("@typescript-eslint/typescript-estree");
+  const ast = parse3(code, {
     loc: true,
     range: true,
     jsx: true,
@@ -4210,10 +5577,10 @@ function findESLintCwd(startDir) {
   let dir = startDir;
   for (let i = 0; i < 30; i++) {
     for (const cfg of ESLINT_CONFIG_FILES2) {
-      if (existsSync13(join13(dir, cfg))) return dir;
+      if (existsSync18(join18(dir, cfg))) return dir;
     }
-    if (existsSync13(join13(dir, "package.json"))) return dir;
-    const parent = dirname7(dir);
+    if (existsSync18(join18(dir, "package.json"))) return dir;
+    const parent = dirname11(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4226,7 +5593,7 @@ function normalizeDataLocFilePath(absoluteFilePath, projectCwd) {
   const abs = normalizePathSlashes(resolve5(absoluteFilePath));
   const cwd = normalizePathSlashes(resolve5(projectCwd));
   if (abs === cwd || abs.startsWith(cwd + "/")) {
-    return normalizePathSlashes(relative2(cwd, abs));
+    return normalizePathSlashes(relative4(cwd, abs));
   }
   return abs;
 }
@@ -4238,25 +5605,25 @@ function resolveRequestedFilePath(filePath) {
   if (cached) return cached;
   const cwd = process.cwd();
   const fromCwd = resolve5(cwd, filePath);
-  if (existsSync13(fromCwd)) {
+  if (existsSync18(fromCwd)) {
     resolvedPathCache.set(filePath, fromCwd);
     return fromCwd;
   }
-  const wsRoot = findWorkspaceRoot5(cwd);
+  const wsRoot = findWorkspaceRoot6(cwd);
   const fromWs = resolve5(wsRoot, filePath);
-  if (existsSync13(fromWs)) {
+  if (existsSync18(fromWs)) {
     resolvedPathCache.set(filePath, fromWs);
     return fromWs;
   }
   for (const top of ["apps", "packages"]) {
-    const base = join13(wsRoot, top);
-    if (!existsSync13(base)) continue;
+    const base = join18(wsRoot, top);
+    if (!existsSync18(base)) continue;
     try {
-      const entries = readdirSync3(base, { withFileTypes: true });
+      const entries = readdirSync5(base, { withFileTypes: true });
       for (const ent of entries) {
         if (!ent.isDirectory()) continue;
         const p2 = resolve5(base, ent.name, filePath);
-        if (existsSync13(p2)) {
+        if (existsSync18(p2)) {
           resolvedPathCache.set(filePath, p2);
           return p2;
         }
@@ -4271,7 +5638,7 @@ async function getESLintForProject(projectCwd) {
   const cached = eslintInstances.get(projectCwd);
   if (cached) return cached;
   try {
-    const req = createRequire2(join13(projectCwd, "package.json"));
+    const req = createRequire3(join18(projectCwd, "package.json"));
     const mod = req("eslint");
     const ESLintCtor = mod?.ESLint ?? mod?.default?.ESLint ?? mod?.default ?? mod;
     if (!ESLintCtor) return null;
@@ -4284,13 +5651,13 @@ async function getESLintForProject(projectCwd) {
 }
 async function lintFile(filePath, onProgress) {
   const absolutePath = resolveRequestedFilePath(filePath);
-  if (!existsSync13(absolutePath)) {
+  if (!existsSync18(absolutePath)) {
     onProgress(`File not found: ${pc.dim(absolutePath)}`);
     return [];
   }
   const mtimeMs = (() => {
     try {
-      return statSync2(absolutePath).mtimeMs;
+      return statSync4(absolutePath).mtimeMs;
     } catch {
       return 0;
     }
@@ -4300,7 +5667,7 @@ async function lintFile(filePath, onProgress) {
     onProgress("Cache hit (unchanged)");
     return cached.issues;
   }
-  const fileDir = dirname7(absolutePath);
+  const fileDir = dirname11(absolutePath);
   const projectCwd = findESLintCwd(fileDir);
   onProgress(`Resolving ESLint project... ${pc.dim(projectCwd)}`);
   const eslint = await getESLintForProject(projectCwd);
@@ -4323,7 +5690,7 @@ async function lintFile(filePath, onProgress) {
     let codeLength = 0;
     try {
       onProgress("Building JSX map...");
-      const code = readFileSync8(absolutePath, "utf-8");
+      const code = readFileSync12(absolutePath, "utf-8");
       codeLength = code.length;
       lineStarts = buildLineStarts(code);
       spans = buildJsxElementSpans(code, dataLocFile);
@@ -4392,6 +5759,7 @@ async function handleMessage(ws, data) {
         message.filePath ?? "(all)"
       )}`
     );
+  } else if (message.type === "vision:analyze") {
   }
   switch (message.type) {
     case "lint:file": {
@@ -4404,9 +5772,9 @@ async function handleMessage(ws, data) {
       });
       const startedAt = Date.now();
       const resolved = resolveRequestedFilePath(filePath);
-      if (!existsSync13(resolved)) {
+      if (!existsSync18(resolved)) {
         const cwd = process.cwd();
-        const wsRoot = findWorkspaceRoot5(cwd);
+        const wsRoot = findWorkspaceRoot6(cwd);
         logWarning(
           [
             `${pc.dim("[ws]")} File not found for request`,
@@ -4492,6 +5860,167 @@ async function handleMessage(ws, data) {
       }
       break;
     }
+    case "vision:analyze": {
+      const {
+        route,
+        timestamp,
+        screenshot,
+        screenshotFile,
+        manifest,
+        requestId
+      } = message;
+      logInfo(
+        `${pc.dim("[ws]")} ${pc.bold("vision:analyze")} ${pc.dim(route)}${requestId ? ` ${pc.dim(`(req ${requestId})`)}` : ""}`
+      );
+      sendMessage(ws, {
+        type: "vision:progress",
+        route,
+        requestId,
+        phase: "Starting vision analysis..."
+      });
+      const startedAt = Date.now();
+      const analyzer = getVisionAnalyzerInstance();
+      try {
+        const screenshotBytes = typeof screenshot === "string" ? Buffer.byteLength(screenshot) : 0;
+        const analyzerModel = typeof analyzer.getModel === "function" ? analyzer.getModel() : void 0;
+        const analyzerBaseUrl = typeof analyzer.getBaseUrl === "function" ? analyzer.getBaseUrl() : void 0;
+        logInfo(
+          [
+            `${pc.dim("[ws]")} ${pc.dim("vision")} details`,
+            `  route:        ${pc.dim(route)}`,
+            `  requestId:    ${pc.dim(requestId ?? "(none)")}`,
+            `  manifest:     ${pc.dim(String(manifest.length))} element(s)`,
+            `  screenshot:   ${pc.dim(
+              screenshot ? `${Math.round(screenshotBytes / 1024)}kb` : "none"
+            )}`,
+            `  screenshotFile: ${pc.dim(screenshotFile ?? "(none)")}`,
+            `  ollamaUrl:    ${pc.dim(analyzerBaseUrl ?? "(default)")}`,
+            `  visionModel:  ${pc.dim(analyzerModel ?? "(default)")}`
+          ].join("\n")
+        );
+        if (!screenshot) {
+          sendMessage(ws, {
+            type: "vision:result",
+            route,
+            issues: [],
+            analysisTime: Date.now() - startedAt,
+            error: "No screenshot provided for vision analysis",
+            requestId
+          });
+          break;
+        }
+        const result = await runVisionAnalysis({
+          imageBase64: screenshot,
+          manifest,
+          projectPath: serverAppRootForVision,
+          // In the overlay/server context, default to upward search from app root.
+          baseUrl: analyzerBaseUrl,
+          model: analyzerModel,
+          analyzer,
+          onPhase: (phase) => {
+            sendMessage(ws, {
+              type: "vision:progress",
+              route,
+              requestId,
+              phase
+            });
+          }
+        });
+        if (typeof screenshotFile === "string" && screenshotFile.length > 0) {
+          if (!isValidScreenshotFilename(screenshotFile)) {
+            logWarning(
+              `Skipping vision report write: invalid screenshotFile ${pc.dim(
+                screenshotFile
+              )}`
+            );
+          } else {
+            const screenshotsDir = join18(
+              serverAppRootForVision,
+              ".uilint",
+              "screenshots"
+            );
+            const imagePath = join18(screenshotsDir, screenshotFile);
+            try {
+              if (!existsSync18(imagePath)) {
+                logWarning(
+                  `Skipping vision report write: screenshot file not found ${pc.dim(
+                    imagePath
+                  )}`
+                );
+              } else {
+                const report = writeVisionMarkdownReport({
+                  imagePath,
+                  route,
+                  timestamp,
+                  visionModel: result.visionModel,
+                  baseUrl: result.baseUrl,
+                  analysisTimeMs: result.analysisTime,
+                  prompt: result.prompt ?? null,
+                  rawResponse: result.rawResponse ?? null,
+                  metadata: {
+                    screenshotFile: parse2(imagePath).base,
+                    appRoot: serverAppRootForVision,
+                    manifestElements: manifest.length,
+                    requestId: requestId ?? null
+                  }
+                });
+                logInfo(
+                  `${pc.dim("[ws]")} wrote vision report ${pc.dim(
+                    report.outPath
+                  )}`
+                );
+              }
+            } catch (e) {
+              logWarning(
+                `Failed to write vision report for ${pc.dim(screenshotFile)}: ${e instanceof Error ? e.message : String(e)}`
+              );
+            }
+          }
+        }
+        const elapsed = Date.now() - startedAt;
+        logInfo(
+          `${pc.dim("[ws]")} vision:analyze done ${pc.dim(route)} \u2192 ${pc.bold(
+            `${result.issues.length}`
+          )} issue(s) ${pc.dim(`(${elapsed}ms)`)}`
+        );
+        if (result.rawResponse) {
+          logInfo(
+            `${pc.dim("[ws]")} vision rawResponse ${pc.dim(
+              `${result.rawResponse.length} chars`
+            )}`
+          );
+        }
+        sendMessage(ws, {
+          type: "vision:result",
+          route,
+          issues: result.issues,
+          analysisTime: result.analysisTime,
+          requestId
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const stack = error instanceof Error ? error.stack : void 0;
+        logError(
+          [
+            `Vision analysis failed`,
+            `  route:     ${route}`,
+            `  requestId: ${requestId ?? "(none)"}`,
+            `  error:     ${errorMessage}`,
+            stack ? `  stack:
+${stack}` : ""
+          ].filter(Boolean).join("\n")
+        );
+        sendMessage(ws, {
+          type: "vision:result",
+          route,
+          issues: [],
+          analysisTime: Date.now() - startedAt,
+          error: errorMessage,
+          requestId
+        });
+      }
+      break;
+    }
   }
 }
 function handleDisconnect(ws) {
@@ -4520,8 +6049,9 @@ function handleFileChange(filePath) {
 async function serve(options) {
   const port = options.port || 9234;
   const cwd = process.cwd();
-  const wsRoot = findWorkspaceRoot5(cwd);
+  const wsRoot = findWorkspaceRoot6(cwd);
   const appRoot = pickAppRoot({ cwd, workspaceRoot: wsRoot });
+  serverAppRootForVision = appRoot;
   logInfo(`Workspace root: ${pc.dim(wsRoot)}`);
   logInfo(`App root:        ${pc.dim(appRoot)}`);
   logInfo(`Server cwd:     ${pc.dim(cwd)}`);
@@ -4561,22 +6091,505 @@ async function serve(options) {
     `UILint WebSocket server running on ${pc.cyan(`ws://localhost:${port}`)}`
   );
   logInfo("Press Ctrl+C to stop");
-  await new Promise((resolve7) => {
+  await new Promise((resolve8) => {
     process.on("SIGINT", () => {
       logInfo("Shutting down...");
       wss.close();
       fileWatcher?.close();
-      resolve7();
+      resolve8();
     });
   });
 }
 
+// src/commands/vision.ts
+import { dirname as dirname12, resolve as resolve6, join as join19 } from "path";
+import {
+  existsSync as existsSync19,
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync6
+} from "fs";
+import {
+  ensureOllamaReady as ensureOllamaReady6,
+  STYLEGUIDE_PATHS as STYLEGUIDE_PATHS2,
+  UILINT_DEFAULT_VISION_MODEL as UILINT_DEFAULT_VISION_MODEL2
+} from "uilint-core/node";
+function envTruthy3(name) {
+  const v = process.env[name];
+  if (!v) return false;
+  return v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes";
+}
+function preview3(text3, maxLen) {
+  if (text3.length <= maxLen) return text3;
+  return text3.slice(0, maxLen) + "\n\u2026<truncated>\u2026\n" + text3.slice(-maxLen);
+}
+function debugEnabled3(options) {
+  return Boolean(options.debug) || envTruthy3("UILINT_DEBUG");
+}
+function debugFullEnabled3(options) {
+  return Boolean(options.debugFull) || envTruthy3("UILINT_DEBUG_FULL");
+}
+function debugDumpPath3(options) {
+  const v = options.debugDump ?? process.env.UILINT_DEBUG_DUMP;
+  if (!v) return null;
+  if (v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes") {
+    return resolve6(process.cwd(), ".uilint");
+  }
+  return v;
+}
+function debugLog3(enabled, message, obj) {
+  if (!enabled) return;
+  if (obj === void 0) {
+    console.error(pc.dim("[uilint:debug]"), message);
+  } else {
+    try {
+      console.error(pc.dim("[uilint:debug]"), message, obj);
+    } catch {
+      console.error(pc.dim("[uilint:debug]"), message);
+    }
+  }
+}
+function findScreenshotsDirUpwards(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 20; i++) {
+    const candidate = join19(dir, ".uilint", "screenshots");
+    if (existsSync19(candidate)) return candidate;
+    const parent = dirname12(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function listScreenshotSidecars(dirPath) {
+  if (!existsSync19(dirPath)) return [];
+  const entries = readdirSync6(dirPath).filter((f) => f.endsWith(".json")).map((f) => join19(dirPath, f));
+  const out = [];
+  for (const p2 of entries) {
+    try {
+      const json = loadJsonFile(p2);
+      const issues = Array.isArray(json?.issues) ? json.issues : json?.analysisResult?.issues;
+      out.push({
+        path: p2,
+        filename: json?.filename || json?.screenshotFile || p2.split("/").pop() || p2,
+        timestamp: typeof json?.timestamp === "number" ? json.timestamp : void 0,
+        route: typeof json?.route === "string" ? json.route : void 0,
+        issueCount: Array.isArray(issues) ? issues.length : void 0
+      });
+    } catch {
+      out.push({
+        path: p2,
+        filename: p2.split("/").pop() || p2
+      });
+    }
+  }
+  out.sort((a, b) => {
+    const at = a.timestamp ?? 0;
+    const bt = b.timestamp ?? 0;
+    if (at !== bt) return bt - at;
+    return b.path.localeCompare(a.path);
+  });
+  return out;
+}
+function readImageAsBase64(imagePath) {
+  const bytes = readFileSync13(imagePath);
+  return { base64: bytes.toString("base64"), sizeBytes: bytes.byteLength };
+}
+function loadJsonFile(filePath) {
+  const raw = readFileSync13(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+function formatIssuesText(issues) {
+  if (issues.length === 0) return "No vision issues found.\n";
+  return issues.map((i) => {
+    const sev = i.severity || "info";
+    const cat = i.category || "other";
+    const where = i.dataLoc ? ` (${i.dataLoc})` : "";
+    return `- [${sev}/${cat}] ${i.message}${where}`;
+  }).join("\n") + "\n";
+}
+async function vision(options) {
+  const isJsonOutput = options.output === "json";
+  const dbg = debugEnabled3(options);
+  const dbgFull = debugFullEnabled3(options);
+  const dbgDump = debugDumpPath3(options);
+  if (!isJsonOutput) intro2("Vision (Screenshot) Analysis");
+  try {
+    const projectPath = process.cwd();
+    if (options.list) {
+      const base = (options.screenshotsDir ? resolvePathSpecifier(options.screenshotsDir, projectPath) : null) || findScreenshotsDirUpwards(projectPath);
+      if (!base) {
+        if (isJsonOutput) {
+          printJSON({ screenshotsDir: null, sidecars: [] });
+        } else {
+          logWarning(
+            "No `.uilint/screenshots` directory found (walked up from cwd)."
+          );
+        }
+        await flushLangfuse();
+        return;
+      }
+      const sidecars = listScreenshotSidecars(base);
+      if (isJsonOutput) {
+        printJSON({ screenshotsDir: base, sidecars });
+      } else {
+        logInfo(`Screenshots dir: ${pc.dim(base)}`);
+        if (sidecars.length === 0) {
+          process.stdout.write("No sidecars found.\n");
+        } else {
+          process.stdout.write(
+            sidecars.map((s, idx) => {
+              const stamp = s.timestamp ? new Date(s.timestamp).toLocaleString() : "(no timestamp)";
+              const route = s.route ? ` ${pc.dim(s.route)}` : "";
+              const count = typeof s.issueCount === "number" ? ` ${pc.dim(`(${s.issueCount} issues)`)}` : "";
+              return `${idx === 0 ? "*" : "-"} ${s.path}${pc.dim(
+                ` \u2014 ${stamp}`
+              )}${route}${count}`;
+            }).join("\n") + "\n"
+          );
+          process.stdout.write(
+            pc.dim(
+              `Tip: run \`uilint vision --sidecar <path>\` (the newest is marked with "*").
+`
+            )
+          );
+        }
+      }
+      await flushLangfuse();
+      return;
+    }
+    const imagePath = options.image ? resolvePathSpecifier(options.image, projectPath) : void 0;
+    const sidecarPath = options.sidecar ? resolvePathSpecifier(options.sidecar, projectPath) : void 0;
+    const manifestFilePath = options.manifestFile ? resolvePathSpecifier(options.manifestFile, projectPath) : void 0;
+    if (!imagePath && !sidecarPath) {
+      if (isJsonOutput) {
+        printJSON({ error: "No input provided", issues: [] });
+      } else {
+        logError("No input provided. Use --image or --sidecar.");
+      }
+      await flushLangfuse();
+      process.exit(1);
+    }
+    if (imagePath && !existsSync19(imagePath)) {
+      throw new Error(`Image not found: ${imagePath}`);
+    }
+    if (sidecarPath && !existsSync19(sidecarPath)) {
+      throw new Error(`Sidecar not found: ${sidecarPath}`);
+    }
+    if (manifestFilePath && !existsSync19(manifestFilePath)) {
+      throw new Error(`Manifest file not found: ${manifestFilePath}`);
+    }
+    const sidecar = sidecarPath ? loadJsonFile(sidecarPath) : null;
+    const routeLabel = options.route || (typeof sidecar?.route === "string" ? sidecar.route : void 0) || (sidecarPath ? `(from ${sidecarPath})` : "(unknown)");
+    let manifest = null;
+    if (options.manifestJson) {
+      manifest = JSON.parse(options.manifestJson);
+    } else if (manifestFilePath) {
+      manifest = loadJsonFile(manifestFilePath);
+    } else if (sidecar && Array.isArray(sidecar.manifest)) {
+      manifest = sidecar.manifest;
+    }
+    if (!manifest || manifest.length === 0) {
+      throw new Error(
+        "No manifest provided. Supply --manifest-json, --manifest-file, or a sidecar JSON with a `manifest` array."
+      );
+    }
+    let styleGuide = null;
+    let styleguideLocation = null;
+    const startPath = (imagePath ?? sidecarPath ?? manifestFilePath ?? void 0) || void 0;
+    {
+      const resolved = await resolveVisionStyleGuide({
+        projectPath,
+        styleguide: options.styleguide,
+        startDir: startPath ? dirname12(startPath) : projectPath
+      });
+      styleGuide = resolved.styleGuide;
+      styleguideLocation = resolved.styleguideLocation;
+    }
+    if (styleguideLocation && styleGuide) {
+      if (!isJsonOutput)
+        logSuccess(`Using styleguide: ${pc.dim(styleguideLocation)}`);
+    } else if (!styleGuide && !isJsonOutput) {
+      logWarning("No styleguide found");
+      note2(
+        [
+          `Searched in: ${options.styleguide || projectPath}`,
+          "",
+          "Looked for:",
+          ...STYLEGUIDE_PATHS2.map((p2) => `  \u2022 ${p2}`),
+          "",
+          `Create ${pc.cyan(
+            ".uilint/styleguide.md"
+          )} (recommended: run ${pc.cyan("/genstyleguide")} in Cursor).`
+        ].join("\n"),
+        "Missing Styleguide"
+      );
+    }
+    debugLog3(dbg, "Vision input (high-level)", {
+      imagePath: imagePath ?? null,
+      sidecarPath: sidecarPath ?? null,
+      manifestFile: manifestFilePath ?? null,
+      manifestElements: manifest.length,
+      route: routeLabel,
+      styleguideLocation,
+      styleGuideLength: styleGuide ? styleGuide.length : 0
+    });
+    const visionModel = options.model || UILINT_DEFAULT_VISION_MODEL2;
+    const prepStartNs = nsNow();
+    if (!isJsonOutput) {
+      await withSpinner("Preparing Ollama", async () => {
+        await ensureOllamaReady6({
+          model: visionModel,
+          baseUrl: options.baseUrl
+        });
+      });
+    } else {
+      await ensureOllamaReady6({ model: visionModel, baseUrl: options.baseUrl });
+    }
+    const prepEndNs = nsNow();
+    const resolvedImagePath = imagePath || (() => {
+      const screenshotFile = typeof sidecar?.screenshotFile === "string" ? sidecar.screenshotFile : typeof sidecar?.filename === "string" ? sidecar.filename : void 0;
+      if (!screenshotFile) return null;
+      const baseDir = sidecarPath ? dirname12(sidecarPath) : projectPath;
+      const abs = resolve6(baseDir, screenshotFile);
+      return abs;
+    })();
+    if (!resolvedImagePath) {
+      throw new Error(
+        "No image path could be resolved. Provide --image or a sidecar with `screenshotFile`/`filename`."
+      );
+    }
+    if (!existsSync19(resolvedImagePath)) {
+      throw new Error(`Image not found: ${resolvedImagePath}`);
+    }
+    const { base64, sizeBytes } = readImageAsBase64(resolvedImagePath);
+    debugLog3(dbg, "Image loaded", {
+      imagePath: resolvedImagePath,
+      sizeBytes,
+      base64Length: base64.length
+    });
+    if (dbgFull && styleGuide) {
+      debugLog3(dbg, "Styleguide (full)", styleGuide);
+    } else if (dbg && styleGuide) {
+      debugLog3(dbg, "Styleguide (preview)", preview3(styleGuide, 800));
+    }
+    let result = null;
+    const analysisStartNs = nsNow();
+    let firstTokenNs = null;
+    let firstThinkingNs = null;
+    let lastThinkingNs = null;
+    let firstAnswerNs = null;
+    let lastAnswerNs = null;
+    if (isJsonOutput) {
+      result = await runVisionAnalysis({
+        imageBase64: base64,
+        manifest,
+        projectPath,
+        styleGuide,
+        styleguideLocation,
+        baseUrl: options.baseUrl,
+        model: visionModel,
+        skipEnsureOllama: true,
+        debugDump: dbgDump ?? void 0,
+        debugDumpIncludeSensitive: dbgFull,
+        debugDumpMetadata: {
+          route: routeLabel,
+          imagePath: resolvedImagePath,
+          imageSizeBytes: sizeBytes,
+          imageBase64Length: base64.length
+        }
+      });
+    } else {
+      if (options.stream) {
+        let lastStatus = "";
+        let printedAnyText = false;
+        let inThinking = false;
+        result = await runVisionAnalysis({
+          imageBase64: base64,
+          manifest,
+          projectPath,
+          styleGuide,
+          styleguideLocation,
+          baseUrl: options.baseUrl,
+          model: visionModel,
+          skipEnsureOllama: true,
+          debugDump: dbgDump ?? void 0,
+          debugDumpIncludeSensitive: dbgFull,
+          debugDumpMetadata: {
+            route: routeLabel,
+            imagePath: resolvedImagePath,
+            imageSizeBytes: sizeBytes,
+            imageBase64Length: base64.length
+          },
+          onProgress: (latestLine, _fullResponse, delta, thinkingDelta) => {
+            const nowNs = nsNow();
+            if (!firstTokenNs && (thinkingDelta || delta)) firstTokenNs = nowNs;
+            if (thinkingDelta) {
+              if (!firstThinkingNs) firstThinkingNs = nowNs;
+              lastThinkingNs = nowNs;
+            }
+            if (delta) {
+              if (!firstAnswerNs) firstAnswerNs = nowNs;
+              lastAnswerNs = nowNs;
+            }
+            if (thinkingDelta) {
+              if (!printedAnyText) {
+                printedAnyText = true;
+                console.error(pc.dim("[vision] streaming:"));
+                process.stderr.write(pc.dim("Thinking:\n"));
+                inThinking = true;
+              } else if (!inThinking) {
+                process.stderr.write(pc.dim("\n\nThinking:\n"));
+                inThinking = true;
+              }
+              process.stderr.write(thinkingDelta);
+              return;
+            }
+            if (delta) {
+              if (!printedAnyText) {
+                printedAnyText = true;
+                console.error(pc.dim("[vision] streaming:"));
+              }
+              if (inThinking) {
+                process.stderr.write(pc.dim("\n\nAnswer:\n"));
+                inThinking = false;
+              }
+              process.stderr.write(delta);
+              return;
+            }
+            const line = (latestLine || "").trim();
+            if (!line || line === lastStatus) return;
+            lastStatus = line;
+            console.error(pc.dim("[vision]"), line);
+          }
+        });
+      } else {
+        result = await withSpinner(
+          "Analyzing screenshot with vision model",
+          async (s) => {
+            return await runVisionAnalysis({
+              imageBase64: base64,
+              manifest,
+              projectPath,
+              styleGuide,
+              styleguideLocation,
+              baseUrl: options.baseUrl,
+              model: visionModel,
+              skipEnsureOllama: true,
+              debugDump: dbgDump ?? void 0,
+              debugDumpIncludeSensitive: dbgFull,
+              debugDumpMetadata: {
+                route: routeLabel,
+                imagePath: resolvedImagePath,
+                imageSizeBytes: sizeBytes,
+                imageBase64Length: base64.length
+              },
+              onProgress: (latestLine, _fullResponse, delta, thinkingDelta) => {
+                const nowNs = nsNow();
+                if (!firstTokenNs && (thinkingDelta || delta))
+                  firstTokenNs = nowNs;
+                if (thinkingDelta) {
+                  if (!firstThinkingNs) firstThinkingNs = nowNs;
+                  lastThinkingNs = nowNs;
+                }
+                if (delta) {
+                  if (!firstAnswerNs) firstAnswerNs = nowNs;
+                  lastAnswerNs = nowNs;
+                }
+                const maxLen = 60;
+                const displayLine = latestLine.length > maxLen ? latestLine.slice(0, maxLen) + "\u2026" : latestLine;
+                s.message(`Analyzing: ${pc.dim(displayLine || "...")}`);
+              }
+            });
+          }
+        );
+      }
+    }
+    const analysisEndNs = nsNow();
+    const issues = result?.issues ?? [];
+    if (isJsonOutput) {
+      printJSON({
+        route: routeLabel,
+        model: visionModel,
+        issues,
+        analysisTime: result?.analysisTime ?? 0,
+        imagePath: resolvedImagePath,
+        imageSizeBytes: sizeBytes
+      });
+    } else {
+      logInfo(`Route: ${pc.dim(routeLabel)}`);
+      logInfo(`Model: ${pc.dim(visionModel)}`);
+      process.stdout.write(formatIssuesText(issues));
+      if (process.stdout.isTTY) {
+        const prepMs = nsToMs(prepEndNs - prepStartNs);
+        const totalMs = nsToMs(analysisEndNs - analysisStartNs);
+        const endToEndMs = nsToMs(analysisEndNs - prepStartNs);
+        const ttftMs = firstTokenNs ? nsToMs(firstTokenNs - analysisStartNs) : null;
+        const thinkingMs = firstThinkingNs && (firstAnswerNs || lastThinkingNs) ? nsToMs(
+          (firstAnswerNs ?? lastThinkingNs ?? analysisEndNs) - firstThinkingNs
+        ) : null;
+        const outputMs = firstAnswerNs && (lastAnswerNs || analysisEndNs) ? nsToMs((lastAnswerNs ?? analysisEndNs) - firstAnswerNs) : null;
+        note2(
+          [
+            `Prepare Ollama: ${formatMs(prepMs)}`,
+            `Time to first token: ${maybeMs(ttftMs)}`,
+            `Thinking: ${maybeMs(thinkingMs)}`,
+            `Outputting: ${maybeMs(outputMs)}`,
+            `LLM total: ${formatMs(totalMs)}`,
+            `End-to-end: ${formatMs(endToEndMs)}`,
+            result?.analysisTime ? pc.dim(`(core analysisTime: ${formatMs(result.analysisTime)})`) : pc.dim("(core analysisTime: n/a)")
+          ].join("\n"),
+          "Timings"
+        );
+      }
+    }
+    try {
+      writeVisionMarkdownReport({
+        imagePath: resolvedImagePath,
+        route: routeLabel,
+        visionModel,
+        baseUrl: options.baseUrl ?? "http://localhost:11434",
+        analysisTimeMs: result?.analysisTime ?? 0,
+        prompt: result?.prompt ?? null,
+        rawResponse: result?.rawResponse ?? null,
+        metadata: {
+          imageSizeBytes: sizeBytes,
+          styleguideLocation
+        }
+      });
+      debugLog3(dbg, "Wrote .vision.md report alongside image");
+    } catch (e) {
+      debugLog3(
+        dbg,
+        "Failed to write .vision.md report",
+        e instanceof Error ? e.message : e
+      );
+    }
+    if (issues.length > 0) {
+      await flushLangfuse();
+      process.exit(1);
+    }
+  } catch (error) {
+    if (options.output === "json") {
+      printJSON({
+        error: error instanceof Error ? error.message : "Unknown error",
+        issues: []
+      });
+    } else {
+      logError(
+        error instanceof Error ? error.message : "Vision analysis failed"
+      );
+    }
+    await flushLangfuse();
+    process.exit(1);
+  }
+  await flushLangfuse();
+}
+
 // src/commands/session.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9, writeFileSync as writeFileSync7, unlinkSync as unlinkSync2 } from "fs";
-import { basename, dirname as dirname8, resolve as resolve6 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync14, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
+import { basename, dirname as dirname13, resolve as resolve7 } from "path";
 import { createStyleSummary as createStyleSummary3 } from "uilint-core";
 import {
-  ensureOllamaReady as ensureOllamaReady5,
+  ensureOllamaReady as ensureOllamaReady7,
   parseCLIInput as parseCLIInput2,
   readStyleGuideFromProject as readStyleGuideFromProject2,
   readTailwindThemeTokens as readTailwindThemeTokens3
@@ -4584,18 +6597,18 @@ import {
 var SESSION_FILE = "/tmp/uilint-session.json";
 var UI_FILE_EXTENSIONS = [".tsx", ".jsx", ".css", ".scss", ".module.css"];
 function readSession() {
-  if (!existsSync14(SESSION_FILE)) {
+  if (!existsSync20(SESSION_FILE)) {
     return { files: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
   try {
-    const content = readFileSync9(SESSION_FILE, "utf-8");
+    const content = readFileSync14(SESSION_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return { files: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
 function writeSession(state) {
-  writeFileSync7(SESSION_FILE, JSON.stringify(state, null, 2), "utf-8");
+  writeFileSync10(SESSION_FILE, JSON.stringify(state, null, 2), "utf-8");
 }
 function isUIFile(filePath) {
   return UI_FILE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
@@ -4606,7 +6619,7 @@ function isScannableMarkupFile(filePath) {
   );
 }
 async function sessionClear() {
-  if (existsSync14(SESSION_FILE)) {
+  if (existsSync20(SESSION_FILE)) {
     unlinkSync2(SESSION_FILE);
   }
   console.log(JSON.stringify({ cleared: true }));
@@ -4673,17 +6686,17 @@ async function sessionScan(options = {}) {
     }
     return;
   }
-  await ensureOllamaReady5();
+  await ensureOllamaReady7();
   const client = await createLLMClient({});
   const results = [];
   for (const filePath of session.files) {
-    if (!existsSync14(filePath)) continue;
+    if (!existsSync20(filePath)) continue;
     if (!isScannableMarkupFile(filePath)) continue;
     try {
-      const absolutePath = resolve6(process.cwd(), filePath);
-      const htmlLike = readFileSync9(filePath, "utf-8");
+      const absolutePath = resolve7(process.cwd(), filePath);
+      const htmlLike = readFileSync14(filePath, "utf-8");
       const snapshot = parseCLIInput2(htmlLike);
-      const tailwindSearchDir = dirname8(absolutePath);
+      const tailwindSearchDir = dirname13(absolutePath);
       const tailwindTheme = readTailwindThemeTokens3(tailwindSearchDir);
       const styleSummary = createStyleSummary3(snapshot.styles, {
         html: snapshot.html,
@@ -4736,7 +6749,7 @@ async function sessionScan(options = {}) {
     };
     console.log(JSON.stringify(result));
   }
-  if (existsSync14(SESSION_FILE)) {
+  if (existsSync20(SESSION_FILE)) {
     unlinkSync2(SESSION_FILE);
   }
   await flushLangfuse();
@@ -4747,9 +6760,9 @@ async function sessionList() {
 }
 
 // src/index.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname9, join as join14 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname14, join as join20 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function assertNodeVersion(minMajor) {
   const ver = process.versions.node || "";
   const majorStr = ver.split(".")[0] || "";
@@ -4765,9 +6778,9 @@ assertNodeVersion(20);
 var program = new Command();
 function getCLIVersion2() {
   try {
-    const __dirname = dirname9(fileURLToPath2(import.meta.url));
-    const pkgPath = join14(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+    const __dirname3 = dirname14(fileURLToPath4(import.meta.url));
+    const pkgPath = join20(__dirname3, "..", "package.json");
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -4870,6 +6883,40 @@ program.command("serve").description("Start WebSocket server for real-time UI li
     port: parseInt(options.port, 10)
   });
 });
+program.command("vision").description("Analyze a screenshot with Ollama vision models (requires a manifest)").option("--list", "List available .uilint/screenshots sidecars and exit").option(
+  "--screenshots-dir <path>",
+  "Screenshots directory for --list (default: nearest .uilint/screenshots)"
+).option("--image <path>", "Path to a screenshot image (png/jpg)").option(
+  "--sidecar <path>",
+  "Path to a .uilint/screenshots/*.json sidecar (contains manifest + metadata)"
+).option("--manifest-file <path>", "Path to a manifest JSON file (array)").option("--manifest-json <json>", "Inline manifest JSON (array)").option("--route <route>", "Optional route label (e.g., /todos)").option(
+  "-s, --styleguide <path>",
+  "Path to style guide file OR project directory (falls back to upward search)"
+).option("-o, --output <format>", "Output format: text or json", "text").option("--model <name>", "Ollama vision model override", void 0).option("--base-url <url>", "Ollama base URL (default: http://localhost:11434)").option("--stream", "Stream model output/progress to stderr (text mode only)").option("--debug", "Enable debug logging (stderr)").option(
+  "--debug-full",
+  "Print full prompt/styleguide and include base64 in dumps (can be very large)"
+).option(
+  "--debug-dump <path>",
+  "Write full analysis payload dump to JSON file (or directory to auto-name)"
+).action(async (options) => {
+  await vision({
+    list: options.list,
+    screenshotsDir: options.screenshotsDir,
+    image: options.image,
+    sidecar: options.sidecar,
+    manifestFile: options.manifestFile,
+    manifestJson: options.manifestJson,
+    route: options.route,
+    styleguide: options.styleguide,
+    output: options.output,
+    model: options.model,
+    baseUrl: options.baseUrl,
+    stream: options.stream,
+    debug: options.debug,
+    debugFull: options.debugFull,
+    debugDump: options.debugDump
+  });
+});
 var sessionCmd = program.command("session").description(
   "Manage file tracking for agentic sessions (used by Cursor hooks)"
 );