@gettrace/cli 1.4.23 → 1.4.24

package/dist/index.js

@@ -1,2123 +1,2530 @@
 #!/usr/bin/env node
-// ============================================
-// TRACE CONNECT IDE BRIDGE
-// Allows Trace extension to interact with the local filesystem
-// ============================================
-import { program } from 'commander';
-import chalk from 'chalk';
-import { WebSocketServer, WebSocket } from 'ws';
-import * as fs from 'fs';
-import * as path from 'path';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import { withFileLock } from './file-lock.js';
-import { autoFormat } from './format.js';
-import { checkDiagnostics } from './lsp.js';
-import { searchCode } from './search.js';
-import { editJSXClassName } from './ast.js';
-const execAsync = promisify(exec);
-// ============================================
-// TERMINAL BUFFER
-// Rolling 500-line ring buffer of terminal output.
-// Shared across all WebSocket clients so every
-// connected extension gets the same live stream.
-// ============================================
-class TerminalBuffer {
-    lines = [];
-    MAX_LINES = 500;
-    push(chunk) {
-        // Strip ANSI escape codes so agents get clean text
-        const clean = chunk.replace(/\x1B\[[0-9;]*[mGKHFABCDEJsu]/g, '');
-        const newLines = clean.split('\n');
-        for (const line of newLines) {
-            if (line.trim() === '')
-                continue;
-            this.lines.push(line);
-            if (this.lines.length > this.MAX_LINES) {
-                this.lines.shift();
-            }
-        }
+
+// src/index.ts
+import { program } from "commander";
+import chalk from "chalk";
+import { WebSocketServer, WebSocket } from "ws";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { exec as exec4, spawn } from "child_process";
+import { promisify as promisify3 } from "util";
+import { fileURLToPath } from "url";
+
+// src/file-lock.ts
+var _locks = /* @__PURE__ */ new Map();
+async function withFileLock(filePath, fn) {
+  const prior = _locks.get(filePath) ?? Promise.resolve();
+  let release;
+  const hold = new Promise((resolve3) => release = resolve3);
+  _locks.set(filePath, hold);
+  try {
+    await prior;
+    return await fn();
+  } finally {
+    release();
+    if (_locks.get(filePath) === hold) {
+      _locks.delete(filePath);
     }
-    getLast(n = 100) {
-        return this.lines.slice(-n);
+  }
+}
+
+// src/format.ts
+import * as fs from "fs";
+import * as path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var JS_EXTS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
+var CSS_EXTS = /* @__PURE__ */ new Set([".css", ".scss", ".less"]);
+var HTML_EXTS = /* @__PURE__ */ new Set([".html", ".htm", ".vue", ".svelte"]);
+var ALL_FORMATTABLE = /* @__PURE__ */ new Set([
+  ...JS_EXTS,
+  ...CSS_EXTS,
+  ...HTML_EXTS,
+  ".json",
+  ".md",
+  ".yaml",
+  ".yml"
+]);
+async function autoFormat(filePath, projectPath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (!ALL_FORMATTABLE.has(ext))
+    return null;
+  const prettierBin = path.join(projectPath, "node_modules", ".bin", "prettier");
+  if (fs.existsSync(prettierBin)) {
+    try {
+      await execAsync(`"${prettierBin}" --write "${filePath}"`, { cwd: projectPath });
+      return "prettier";
+    } catch {
+    }
+  }
+  if (JS_EXTS.has(ext)) {
+    const eslintBin = path.join(projectPath, "node_modules", ".bin", "eslint");
+    if (fs.existsSync(eslintBin)) {
+      try {
+        await execAsync(`"${eslintBin}" --fix "${filePath}"`, { cwd: projectPath });
+        return "eslint";
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/lsp.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { exec as exec2 } from "child_process";
+var TS_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
+var JS_EXTS2 = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs"]);
+var CSS_EXTS2 = /* @__PURE__ */ new Set([".css", ".scss", ".less", ".sass"]);
+var CHECKER_TIMEOUT_MS = 6e3;
+var MAX_DIAGNOSTICS = 20;
+async function checkDiagnostics(filePath, projectPath) {
+  const SKIP = { diagnostics: [], summary: null, checkers: [], ran: false };
+  const ext = path2.extname(filePath).toLowerCase();
+  const all = [];
+  const checkers = [];
+  const pending = [];
+  if (TS_EXTS.has(ext) || JS_EXTS2.has(ext)) {
+    const tsconfig = path2.join(projectPath, "tsconfig.json");
+    if (fs2.existsSync(tsconfig)) {
+      const shouldRunForJs = JS_EXTS2.has(ext) && tsconfigAllowsJs(tsconfig);
+      if (TS_EXTS.has(ext) || shouldRunForJs) {
+        checkers.push("tsc");
+        pending.push(runTsc(projectPath));
+      }
     }
-    clear() {
-        this.lines = [];
+  }
+  if (TS_EXTS.has(ext) || JS_EXTS2.has(ext)) {
+    const eslintBin = path2.join(projectPath, "node_modules", ".bin", "eslint");
+    if (fs2.existsSync(eslintBin)) {
+      checkers.push("eslint");
+      pending.push(runEslint(eslintBin, filePath, projectPath));
     }
-    get length() {
-        return this.lines.length;
+  }
+  if (CSS_EXTS2.has(ext)) {
+    const stylelintBin = path2.join(projectPath, "node_modules", ".bin", "stylelint");
+    if (fs2.existsSync(stylelintBin)) {
+      checkers.push("stylelint");
+      pending.push(runStylelint(stylelintBin, filePath, projectPath));
     }
+  }
+  if (pending.length === 0)
+    return SKIP;
+  const results = await Promise.allSettled(pending);
+  for (const r of results) {
+    if (r.status === "fulfilled")
+      all.push(...r.value);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const unique = all.filter((d) => {
+    const key = `${d.file}:${d.line}:${d.col}:${d.message}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+  const rel = path2.relative(projectPath, filePath);
+  const sorted = [
+    ...unique.filter((d) => d.file === rel && d.severity === "error"),
+    ...unique.filter((d) => d.file !== rel && d.severity === "error"),
+    ...unique.filter((d) => d.severity === "warning")
+  ].slice(0, MAX_DIAGNOSTICS);
+  const errCount = sorted.filter((d) => d.severity === "error").length;
+  const warnCount = sorted.filter((d) => d.severity === "warning").length;
+  let summary = null;
+  if (errCount > 0) {
+    summary = `\u26A0 ${errCount} error${errCount > 1 ? "s" : ""}` + (warnCount > 0 ? ` + ${warnCount} warning${warnCount > 1 ? "s" : ""}` : "") + ` detected after write [${checkers.join("+")}]. Fix these before making more edits.`;
+  } else if (warnCount > 0) {
+    summary = `\u2139 ${warnCount} warning${warnCount > 1 ? "s" : ""} detected [${checkers.join("+")}]. No errors.`;
+  } else if (unique.length === 0 && checkers.length > 0) {
+    summary = `\u2713 No errors detected [${checkers.join("+")}].`;
+  }
+  return { diagnostics: sorted, summary, checkers, ran: true };
 }
-// Singleton — shared across all WS connections for `trace dev`
-const globalTerminalBuffer = new TerminalBuffer();
-let devProcess = null;
-// ============================================
-// DEV COMMAND DETECTION
-// Reads package.json to find the right script
-// and detects package manager from lockfiles.
-// ============================================
-function detectDevCommand(projectPath, override) {
-    // 1. If user passed an explicit command, use it directly
-    if (override) {
-        return { command: override, pm: 'custom', script: override };
+async function runTsc(projectPath) {
+  const localTsc = path2.join(projectPath, "node_modules", ".bin", "tsc");
+  const bin = fs2.existsSync(localTsc) ? `"${localTsc}"` : "tsc";
+  const cmd = `${bin} --noEmit --pretty false`;
+  try {
+    const raw = await spawnWithTimeout(cmd, projectPath);
+    return parseTscOutput(raw, projectPath);
+  } catch {
+    return [];
+  }
+}
+function parseTscOutput(output, projectPath) {
+  const diagnostics = [];
+  const pattern = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/gm;
+  let m;
+  while ((m = pattern.exec(output)) !== null) {
+    const [, rawFile, lineStr, colStr, severity, code, message] = m;
+    const absFile = path2.isAbsolute(rawFile) ? rawFile : path2.resolve(projectPath, rawFile);
+    diagnostics.push({
+      file: path2.relative(projectPath, absFile),
+      line: parseInt(lineStr, 10),
+      col: parseInt(colStr, 10),
+      severity,
+      code,
+      message: message.trim(),
+      source: "tsc"
+    });
+  }
+  return diagnostics;
+}
+async function runEslint(eslintBin, filePath, projectPath) {
+  const cmd = `"${eslintBin}" --format json "${filePath}"`;
+  try {
+    const raw = await spawnWithTimeout(cmd, projectPath);
+    return parseEslintOutput(raw, projectPath);
+  } catch {
+    return [];
+  }
+}
+function parseEslintOutput(raw, projectPath) {
+  const diagnostics = [];
+  const jsonStart = raw.indexOf("[");
+  if (jsonStart === -1)
+    return diagnostics;
+  try {
+    const results = JSON.parse(raw.slice(jsonStart));
+    for (const fileResult of results) {
+      const relFile = path2.relative(projectPath, fileResult.filePath);
+      for (const msg of fileResult.messages) {
+        if (msg.severity === 0)
+          continue;
+        diagnostics.push({
+          file: relFile,
+          line: msg.line ?? 1,
+          col: msg.column ?? 1,
+          severity: msg.severity >= 2 ? "error" : "warning",
+          code: msg.ruleId ?? "eslint",
+          message: msg.message,
+          source: "eslint"
+        });
+      }
     }
-    // 2. Detect package manager from lockfiles
-    let pm = 'npm';
-    if (fs.existsSync(path.join(projectPath, 'bun.lockb')))
-        pm = 'bun';
-    else if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml')))
-        pm = 'pnpm';
-    else if (fs.existsSync(path.join(projectPath, 'yarn.lock')))
-        pm = 'yarn';
-    // 3. Read package.json scripts
-    const pkgPath = path.join(projectPath, 'package.json');
-    let scripts = {};
-    if (fs.existsSync(pkgPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            scripts = pkg.scripts || {};
-        }
-        catch (e) { /* malformed package.json */ }
+  } catch {
+  }
+  return diagnostics;
+}
+async function runStylelint(stylelintBin, filePath, projectPath) {
+  const cmd = `"${stylelintBin}" --formatter json "${filePath}"`;
+  try {
+    const raw = await spawnWithTimeout(cmd, projectPath);
+    return parseStylelintOutput(raw, projectPath);
+  } catch {
+    return [];
+  }
+}
+function parseStylelintOutput(raw, projectPath) {
+  const diagnostics = [];
+  const jsonStart = raw.indexOf("[");
+  if (jsonStart === -1)
+    return diagnostics;
+  try {
+    const results = JSON.parse(raw.slice(jsonStart));
+    for (const fileResult of results) {
+      const relFile = path2.relative(projectPath, fileResult.source);
+      for (const w of fileResult.warnings) {
+        diagnostics.push({
+          file: relFile,
+          line: w.line ?? 1,
+          col: w.column ?? 1,
+          severity: w.severity === "error" ? "error" : "warning",
+          code: w.rule ?? "stylelint",
+          message: w.text,
+          source: "stylelint"
+        });
+      }
     }
-    // 4. Priority order: dev > start > serve > preview
-    const candidates = ['dev', 'start', 'serve', 'preview'];
-    const script = candidates.find(c => !!scripts[c]) || 'dev';
-    // 5. Build the final command
-    const runCmd = {
-        npm: `npm run ${script}`,
-        pnpm: `pnpm run ${script}`,
-        yarn: `yarn ${script}`,
-        bun: `bun run ${script}`,
-    };
-    return { command: runCmd[pm] ?? `npm run ${script}`, pm, script };
+  } catch {
+  }
+  return diagnostics;
 }
-// Read version from package.json so it never desyncs with the npm published version.
-import { createRequire as _createRequire } from 'module';
-const _pkgRequire = _createRequire(import.meta.url);
-const VERSION = _pkgRequire('../package.json').version;
-/** Levenshtein distance for fuzzy block matching */
-function levenshtein(a, b) {
-    if (a === '' || b === '')
-        return Math.max(a.length, b.length);
-    const matrix = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
-    for (let i = 1; i <= a.length; i++) {
-        for (let j = 1; j <= b.length; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-        }
+function spawnWithTimeout(cmd, cwd) {
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      proc.kill("SIGTERM");
+      reject(new Error(`Checker timed out: ${cmd.slice(0, 60)}`));
+    }, CHECKER_TIMEOUT_MS);
+    const proc = exec2(cmd, { cwd }, (_err, stdout, stderr) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(stdout + stderr);
+    });
+  });
+}
+function tsconfigAllowsJs(tsconfigPath) {
+  try {
+    const raw = fs2.readFileSync(tsconfigPath, "utf-8");
+    return /"allowJs"\s*:\s*true/.test(raw);
+  } catch {
+    return false;
+  }
+}
+
+// src/search.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec3);
+async function searchWithRipgrep(projectPath, query, opts) {
+  const flags = [
+    "--json",
+    "--line-number",
+    opts.isRegex ? "" : "--fixed-strings",
+    opts.caseSensitive ? "--case-sensitive" : "--ignore-case",
+    `--max-count=${opts.maxResults}`,
+    // Exclude directories that are never source code
+    "--glob",
+    "!node_modules/**",
+    "--glob",
+    "!.git/**",
+    "--glob",
+    "!dist/**",
+    "--glob",
+    "!build/**",
+    "--glob",
+    "!.next/**",
+    "--glob",
+    "!coverage/**",
+    "--glob",
+    "!.cache/**",
+    "--glob",
+    "!.turbo/**"
+  ].filter(Boolean);
+  const escapedQuery = query.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const cmd = `rg ${flags.join(" ")} "${escapedQuery}"`;
+  const { stdout } = await execAsync2(cmd, {
+    cwd: projectPath,
+    maxBuffer: 10 * 1024 * 1024
+    // 10 MB — generous for large codebases
+  });
+  const matches = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.startsWith("{"))
+      continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj.type !== "match")
+        continue;
+      matches.push({
+        file: path3.relative(projectPath, obj.data.path.text),
+        line: obj.data.line_number,
+        content: obj.data.lines.text.trimEnd().substring(0, 200)
+      });
+      if (matches.length >= opts.maxResults)
+        break;
+    } catch {
     }
-    return matrix[a.length][b.length];
+  }
+  return matches;
 }
-// --- Replacer 1: Exact string match ---
-const SimpleReplacer = function* (_content, find) {
-    yield find;
-};
-// --- Replacer 2: Trim whitespace from line ends ---
-const LineTrimmedReplacer = function* (content, find) {
-    const originalLines = content.split('\n');
-    const searchLines = find.split('\n');
-    if (searchLines[searchLines.length - 1] === '')
-        searchLines.pop();
-    for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
-        let matches = true;
-        for (let j = 0; j < searchLines.length; j++) {
-            if (originalLines[i + j].trim() !== searchLines[j].trim()) {
-                matches = false;
-                break;
-            }
-        }
-        if (matches) {
-            let start = 0;
-            for (let k = 0; k < i; k++)
-                start += originalLines[k].length + 1;
-            let end = start;
-            for (let k = 0; k < searchLines.length; k++) {
-                end += originalLines[i + k].length;
-                if (k < searchLines.length - 1)
-                    end += 1;
-            }
-            yield content.substring(start, end);
-        }
+var FS_SEARCH_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".ts",
+  ".jsx",
+  ".tsx",
+  ".vue",
+  ".svelte",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".html",
+  ".htm",
+  ".json",
+  ".md"
+]);
+var FS_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".cache",
+  "coverage",
+  ".turbo",
+  ".vercel",
+  ".output"
+]);
+function buildMatcher(query, opts) {
+  if (opts.isRegex) {
+    try {
+      const re = new RegExp(query, opts.caseSensitive ? "" : "i");
+      return (line) => re.test(line);
+    } catch {
     }
-};
-// --- Replacer 3: Block anchor (match first+last lines, fuzzy middle) ---
-const BlockAnchorReplacer = function* (content, find) {
-    const originalLines = content.split('\n');
-    const searchLines = find.split('\n');
-    if (searchLines.length < 3)
+  }
+  if (opts.caseSensitive) {
+    return (line) => line.includes(query);
+  }
+  const lowerQuery = query.toLowerCase();
+  return (line) => line.toLowerCase().includes(lowerQuery);
+}
+function searchWithFs(projectPath, query, opts) {
+  const results = [];
+  const matcher = buildMatcher(query, opts);
+  function walkDir(dir) {
+    if (results.length >= opts.maxResults)
+      return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= opts.maxResults)
         return;
-    if (searchLines[searchLines.length - 1] === '')
-        searchLines.pop();
-    const firstSearch = searchLines[0].trim();
-    const lastSearch = searchLines[searchLines.length - 1].trim();
-    const searchBlockSize = searchLines.length;
-    const candidates = [];
-    for (let i = 0; i < originalLines.length; i++) {
-        if (originalLines[i].trim() !== firstSearch)
-            continue;
-        for (let j = i + 2; j < originalLines.length; j++) {
-            if (originalLines[j].trim() === lastSearch) {
-                candidates.push({ startLine: i, endLine: j });
-                break;
-            }
+      if (FS_IGNORE_DIRS.has(entry) || entry.startsWith("."))
+        continue;
+      const fullPath = path3.join(dir, entry);
+      let stat;
+      try {
+        stat = fs3.statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        walkDir(fullPath);
+      } else if (FS_SEARCH_EXTENSIONS.has(path3.extname(entry).toLowerCase())) {
+        let content;
+        try {
+          content = fs3.readFileSync(fullPath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length && results.length < opts.maxResults; i++) {
+          if (matcher(lines[i])) {
+            results.push({
+              file: path3.relative(projectPath, fullPath),
+              line: i + 1,
+              content: lines[i].trim().substring(0, 200)
+            });
+          }
         }
+      }
     }
-    if (candidates.length === 0)
-        return;
-    // Pick best candidate by middle-line similarity
-    let bestMatch = null;
-    let maxSimilarity = -1;
-    const threshold = candidates.length === 1 ? 0.0 : 0.3;
-    for (const cand of candidates) {
-        const actualSize = cand.endLine - cand.startLine + 1;
-        let similarity = 0;
-        const linesToCheck = Math.min(searchBlockSize - 2, actualSize - 2);
-        if (linesToCheck > 0) {
-            for (let j = 1; j < searchBlockSize - 1 && j < actualSize - 1; j++) {
-                const orig = originalLines[cand.startLine + j].trim();
-                const srch = searchLines[j].trim();
-                const maxLen = Math.max(orig.length, srch.length);
-                if (maxLen === 0)
-                    continue;
-                similarity += (1 - levenshtein(orig, srch) / maxLen) / linesToCheck;
-            }
+  }
+  walkDir(projectPath);
+  return results;
+}
+async function searchCode(projectPath, query, opts = {}) {
+  const resolved = {
+    isRegex: opts.isRegex ?? false,
+    caseSensitive: opts.caseSensitive ?? true,
+    maxResults: opts.maxResults ?? 20
+  };
+  try {
+    const matches = await searchWithRipgrep(projectPath, query, resolved);
+    return { matches, engine: "ripgrep" };
+  } catch {
+    const matches = searchWithFs(projectPath, query, resolved);
+    return { matches, engine: "fs" };
+  }
+}
+
+// src/ast.ts
+import { parse } from "@babel/parser";
+import { createRequire } from "module";
+import * as t from "@babel/types";
+var _require = createRequire(import.meta.url);
+var _traverse = _require("@babel/traverse");
+var _generate = _require("@babel/generator");
+var traverse = _traverse.default ?? _traverse;
+var generate = _generate.default ?? _generate;
+function editJSXClassName(source, edit) {
+  let ast;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      errorRecovery: true
+      // tolerate minor syntax errors in source file
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { success: false, error: `Parse error: ${msg}` };
+  }
+  const candidates = [];
+  traverse(ast, {
+    JSXOpeningElement(nodePath) {
+      for (const attr of nodePath.node.attributes) {
+        if (!t.isJSXAttribute(attr))
+          continue;
+        if (!t.isJSXIdentifier(attr.name, { name: "className" }))
+          continue;
+        const line = attr.loc?.start.line ?? 0;
+        let score = 0;
+        if (edit.lineHint && line > 0) {
+          const dist = Math.abs(line - edit.lineHint);
+          if (dist <= 1)
+            score += 100;
+          else if (dist <= 5)
+            score += 50;
+          else if (dist <= 15)
+            score += 15;
         }
-        else {
-            similarity = 1.0;
+        const currentValue = _extractClassNameString(attr.value);
+        if (edit.oldValue) {
+          if (currentValue === edit.oldValue)
+            score += 80;
+          else if (currentValue?.includes(edit.oldValue))
+            score += 40;
+          else if (currentValue === null && edit.lineHint)
+            score += 20;
+        } else {
+          score += 20;
         }
-        if (similarity > maxSimilarity) {
-            maxSimilarity = similarity;
-            bestMatch = cand;
+        if (score > 0) {
+          candidates.push({ nodePath, attrNode: attr, score, line });
         }
+      }
     }
-    if (maxSimilarity >= threshold && bestMatch) {
-        let start = 0;
-        for (let k = 0; k < bestMatch.startLine; k++)
-            start += originalLines[k].length + 1;
-        let end = start;
-        for (let k = bestMatch.startLine; k <= bestMatch.endLine; k++) {
-            end += originalLines[k].length;
-            if (k < bestMatch.endLine)
-                end += 1;
-        }
-        yield content.substring(start, end);
+  });
+  if (candidates.length === 0) {
+    return { success: false, error: "No className attribute found matching the given hints." };
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  const best = candidates[0];
+  let strategy;
+  if (best.score >= 180)
+    strategy = "line_exact";
+  else if (best.score >= 100)
+    strategy = "line_proximity";
+  else if (best.score >= 80)
+    strategy = "value_exact";
+  else
+    strategy = "value_partial";
+  best.attrNode.value = t.stringLiteral(edit.newValue);
+  const output = generate(
+    ast,
+    { retainLines: true, jsescOption: { minimal: true } },
+    source
+  );
+  return {
+    success: true,
+    code: output.code,
+    strategy,
+    matchedLine: best.line
+  };
+}
+function _extractClassNameString(value) {
+  if (!value)
+    return "";
+  if (t.isStringLiteral(value))
+    return value.value;
+  if (t.isJSXExpressionContainer(value)) {
+    const expr = value.expression;
+    if (t.isStringLiteral(expr))
+      return expr.value;
+    if (t.isTemplateLiteral(expr) && expr.expressions.length === 0) {
+      return expr.quasis[0]?.value.cooked ?? null;
+    }
+  }
+  return null;
+}
+
+// src/index.ts
+import { createRequire as _createRequire } from "module";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+var execAsync3 = promisify3(exec4);
+var TerminalBuffer = class {
+  lines = [];
+  MAX_LINES = 500;
+  push(chunk) {
+    const clean = chunk.replace(/\x1B\[[0-9;]*[mGKHFABCDEJsu]/g, "");
+    const newLines = clean.split("\n");
+    for (const line of newLines) {
+      if (line.trim() === "")
+        continue;
+      this.lines.push(line);
+      if (this.lines.length > this.MAX_LINES) {
+        this.lines.shift();
+      }
     }
+  }
+  getLast(n = 100) {
+    return this.lines.slice(-n);
+  }
+  clear() {
+    this.lines = [];
+  }
+  get length() {
+    return this.lines.length;
+  }
 };
-// --- Replacer 4: Normalize all whitespace to single spaces ---
-const WhitespaceNormalizedReplacer = function* (content, find) {
-    const normalize = (text) => text.replace(/\s+/g, ' ').trim();
-    const normalizedFind = normalize(find);
-    const lines = content.split('\n');
-    for (const line of lines) {
-        if (normalize(line) === normalizedFind) {
-            yield line;
-        }
+var globalTerminalBuffer = new TerminalBuffer();
+var devProcess = null;
+function detectDevCommand(projectPath, override) {
+  if (override) {
+    return { command: override, pm: "custom", script: override };
+  }
+  let pm = "npm";
+  if (fs4.existsSync(path4.join(projectPath, "bun.lockb")))
+    pm = "bun";
+  else if (fs4.existsSync(path4.join(projectPath, "pnpm-lock.yaml")))
+    pm = "pnpm";
+  else if (fs4.existsSync(path4.join(projectPath, "yarn.lock")))
+    pm = "yarn";
+  const pkgPath = path4.join(projectPath, "package.json");
+  let scripts = {};
+  if (fs4.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      scripts = pkg.scripts || {};
+    } catch (e) {
     }
-    const findLines = find.split('\n');
-    if (findLines.length > 1) {
-        for (let i = 0; i <= lines.length - findLines.length; i++) {
-            const block = lines.slice(i, i + findLines.length);
-            if (normalize(block.join('\n')) === normalizedFind) {
-                yield block.join('\n');
-            }
-        }
+  }
+  const candidates = ["dev", "start", "serve", "preview"];
+  const script = candidates.find((c) => !!scripts[c]) || "dev";
+  const runCmd = {
+    npm: `npm run ${script}`,
+    pnpm: `pnpm run ${script}`,
+    yarn: `yarn ${script}`,
+    bun: `bun run ${script}`
+  };
+  return { command: runCmd[pm] ?? `npm run ${script}`, pm, script };
+}
+var _pkgRequire = _createRequire(import.meta.url);
+var VERSION = _pkgRequire("../package.json").version;
+function levenshtein(a, b) {
+  if (a === "" || b === "")
+    return Math.max(a.length, b.length);
+  const matrix = Array.from(
+    { length: a.length + 1 },
+    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
     }
+  }
+  return matrix[a.length][b.length];
+}
+var SimpleReplacer = function* (_content, find) {
+  yield find;
 };
-// --- Replacer 5: Strip indentation then compare ---
-const IndentationFlexibleReplacer = function* (content, find) {
-    const removeIndent = (text) => {
-        const lines = text.split('\n');
-        const nonEmpty = lines.filter(l => l.trim().length > 0);
-        if (nonEmpty.length === 0)
-            return text;
-        const minIndent = Math.min(...nonEmpty.map(l => { const m = l.match(/^(\s*)/); return m ? m[1].length : 0; }));
-        return lines.map(l => l.trim().length === 0 ? l : l.slice(minIndent)).join('\n');
-    };
-    const normalizedFind = removeIndent(find);
-    const contentLines = content.split('\n');
-    const findLines = find.split('\n');
-    for (let i = 0; i <= contentLines.length - findLines.length; i++) {
-        const block = contentLines.slice(i, i + findLines.length).join('\n');
-        if (removeIndent(block) === normalizedFind) {
-            yield block;
-        }
+var LineTrimmedReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines[searchLines.length - 1] === "")
+    searchLines.pop();
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      if (originalLines[i + j].trim() !== searchLines[j].trim()) {
+        matches = false;
+        break;
+      }
     }
+    if (matches) {
+      let start = 0;
+      for (let k = 0; k < i; k++)
+        start += originalLines[k].length + 1;
+      let end = start;
+      for (let k = 0; k < searchLines.length; k++) {
+        end += originalLines[i + k].length;
+        if (k < searchLines.length - 1)
+          end += 1;
+      }
+      yield content.substring(start, end);
+    }
+  }
 };
-// --- Replacer 6: Normalize escape sequences ---
-const EscapeNormalizedReplacer = function* (content, find) {
-    const unescape = (str) => str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, c) => {
-        switch (c) {
-            case 'n': return '\n';
-            case 't': return '\t';
-            case 'r': return '\r';
-            case "'": return "'";
-            case '"': return '"';
-            case '`': return '`';
-            case '\\': return '\\';
-            case '\n': return '\n';
-            case '$': return '$';
-            default: return match;
-        }
-    });
-    const unescapedFind = unescape(find);
-    if (content.includes(unescapedFind))
-        yield unescapedFind;
-    const lines = content.split('\n');
-    const findLines = unescapedFind.split('\n');
-    for (let i = 0; i <= lines.length - findLines.length; i++) {
-        const block = lines.slice(i, i + findLines.length).join('\n');
-        if (unescape(block) === unescapedFind)
-            yield block;
+var BlockAnchorReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines.length < 3)
+    return;
+  if (searchLines[searchLines.length - 1] === "")
+    searchLines.pop();
+  const firstSearch = searchLines[0].trim();
+  const lastSearch = searchLines[searchLines.length - 1].trim();
+  const searchBlockSize = searchLines.length;
+  const candidates = [];
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstSearch)
+      continue;
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastSearch) {
+        candidates.push({ startLine: i, endLine: j });
+        break;
+      }
+    }
+  }
+  if (candidates.length === 0)
+    return;
+  let bestMatch = null;
+  let maxSimilarity = -1;
+  const threshold = candidates.length === 1 ? 0 : 0.3;
+  for (const cand of candidates) {
+    const actualSize = cand.endLine - cand.startLine + 1;
+    let similarity = 0;
+    const linesToCheck = Math.min(searchBlockSize - 2, actualSize - 2);
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualSize - 1; j++) {
+        const orig = originalLines[cand.startLine + j].trim();
+        const srch = searchLines[j].trim();
+        const maxLen = Math.max(orig.length, srch.length);
+        if (maxLen === 0)
+          continue;
+        similarity += (1 - levenshtein(orig, srch) / maxLen) / linesToCheck;
+      }
+    } else {
+      similarity = 1;
+    }
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity;
+      bestMatch = cand;
     }
+  }
+  if (maxSimilarity >= threshold && bestMatch) {
+    let start = 0;
+    for (let k = 0; k < bestMatch.startLine; k++)
+      start += originalLines[k].length + 1;
+    let end = start;
+    for (let k = bestMatch.startLine; k <= bestMatch.endLine; k++) {
+      end += originalLines[k].length;
+      if (k < bestMatch.endLine)
+        end += 1;
+    }
+    yield content.substring(start, end);
+  }
 };
-// --- Replacer 7: Trim the entire block boundary ---
-const TrimmedBoundaryReplacer = function* (content, find) {
-    const trimmed = find.trim();
-    if (trimmed === find)
-        return;
-    if (content.includes(trimmed))
-        yield trimmed;
-    const lines = content.split('\n');
-    const findLines = find.split('\n');
+var WhitespaceNormalizedReplacer = function* (content, find) {
+  const normalize = (text) => text.replace(/\s+/g, " ").trim();
+  const normalizedFind = normalize(find);
+  const lines = content.split("\n");
+  for (const line of lines) {
+    if (normalize(line) === normalizedFind) {
+      yield line;
+    }
+  }
+  const findLines = find.split("\n");
+  if (findLines.length > 1) {
     for (let i = 0; i <= lines.length - findLines.length; i++) {
-        const block = lines.slice(i, i + findLines.length).join('\n');
-        if (block.trim() === trimmed)
-            yield block;
+      const block = lines.slice(i, i + findLines.length);
+      if (normalize(block.join("\n")) === normalizedFind) {
+        yield block.join("\n");
+      }
     }
+  }
 };
-// --- Replacer 8: Context-aware (first+last anchors, 50% middle similarity) ---
-const ContextAwareReplacer = function* (content, find) {
-    const findLines = find.split('\n');
-    if (findLines.length < 3)
-        return;
-    if (findLines[findLines.length - 1] === '')
-        findLines.pop();
-    const contentLines = content.split('\n');
-    const firstLine = findLines[0].trim();
-    const lastLine = findLines[findLines.length - 1].trim();
-    for (let i = 0; i < contentLines.length; i++) {
-        if (contentLines[i].trim() !== firstLine)
-            continue;
-        for (let j = i + 2; j < contentLines.length; j++) {
-            if (contentLines[j].trim() === lastLine) {
-                const blockLines = contentLines.slice(i, j + 1);
-                if (blockLines.length === findLines.length) {
-                    let matching = 0, total = 0;
-                    for (let k = 1; k < blockLines.length - 1; k++) {
-                        const bl = blockLines[k].trim(), fl = findLines[k].trim();
-                        if (bl.length > 0 || fl.length > 0) {
-                            total++;
-                            if (bl === fl)
-                                matching++;
-                        }
-                    }
-                    if (total === 0 || matching / total >= 0.5) {
-                        yield blockLines.join('\n');
-                        return;
-                    }
-                }
-                break;
-            }
-        }
+var IndentationFlexibleReplacer = function* (content, find) {
+  const removeIndent = (text) => {
+    const lines = text.split("\n");
+    const nonEmpty = lines.filter((l) => l.trim().length > 0);
+    if (nonEmpty.length === 0)
+      return text;
+    const minIndent = Math.min(...nonEmpty.map((l) => {
+      const m = l.match(/^(\s*)/);
+      return m ? m[1].length : 0;
+    }));
+    return lines.map((l) => l.trim().length === 0 ? l : l.slice(minIndent)).join("\n");
+  };
+  const normalizedFind = removeIndent(find);
+  const contentLines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join("\n");
+    if (removeIndent(block) === normalizedFind) {
+      yield block;
     }
+  }
 };
-// --- Replacer 9: Multi-occurrence finder ---
-const MultiOccurrenceReplacer = function* (content, find) {
-    let start = 0;
-    while (true) {
-        const idx = content.indexOf(find, start);
-        if (idx === -1)
-            break;
-        yield find;
-        start = idx + find.length;
+var EscapeNormalizedReplacer = function* (content, find) {
+  const unescape = (str) => str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, c) => {
+    switch (c) {
+      case "n":
+        return "\n";
+      case "t":
+        return "	";
+      case "r":
+        return "\r";
+      case "'":
+        return "'";
+      case '"':
+        return '"';
+      case "`":
+        return "`";
+      case "\\":
+        return "\\";
+      case "\n":
+        return "\n";
+      case "$":
+        return "$";
+      default:
+        return match;
     }
+  });
+  const unescapedFind = unescape(find);
+  if (content.includes(unescapedFind))
+    yield unescapedFind;
+  const lines = content.split("\n");
+  const findLines = unescapedFind.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (unescape(block) === unescapedFind)
+      yield block;
+  }
 };
-// --- Replacer 10: Blank-line tolerant (collapses empty lines before comparing) ---
-const BlankLineTolerantReplacer = function* (content, find) {
-    // Collapse consecutive blank lines into a single \n for comparison
-    const collapseBlankLines = (text) => text.replace(/\n\s*\n/g, '\n').trim();
-    const collapsedFind = collapseBlankLines(find);
-    if (!collapsedFind)
-        return;
-    // Try to find the collapsed version directly
-    const collapsedContent = collapseBlankLines(content);
-    if (collapsedContent.includes(collapsedFind)) {
-        // We need to find the ORIGINAL substring in content that matches
-        // Walk through content lines and find the region
-        const contentLines = content.split('\n');
-        const findLines = find.split('\n').filter(l => l.trim().length > 0);
-        if (findLines.length === 0)
-            return;
-        const firstNonEmpty = findLines[0].trim();
-        const lastNonEmpty = findLines[findLines.length - 1].trim();
-        for (let i = 0; i < contentLines.length; i++) {
-            if (contentLines[i].trim() !== firstNonEmpty)
-                continue;
-            // Found first line, now scan forward to find last line
-            // allowing blank lines in between
-            let foundEnd = -1;
-            let nonEmptyCount = 0;
-            for (let j = i; j < contentLines.length; j++) {
-                if (contentLines[j].trim().length > 0) {
-                    nonEmptyCount++;
-                }
-                if (contentLines[j].trim() === lastNonEmpty && nonEmptyCount >= findLines.length) {
-                    foundEnd = j;
-                    break;
-                }
-                // Don't scan too far (max 2x the expected size)
-                if (j - i > findLines.length * 2 + 5)
-                    break;
-            }
-            if (foundEnd >= 0) {
-                // Verify the non-empty lines match
-                const candidateLines = contentLines.slice(i, foundEnd + 1);
-                const candidateNonEmpty = candidateLines.filter(l => l.trim().length > 0);
-                let allMatch = candidateNonEmpty.length === findLines.length;
-                if (allMatch) {
-                    for (let m = 0; m < findLines.length; m++) {
-                        if (candidateNonEmpty[m].trim() !== findLines[m].trim()) {
-                            allMatch = false;
-                            break;
-                        }
-                    }
-                }
-                if (allMatch) {
-                    yield candidateLines.join('\n');
-                    return;
-                }
+var TrimmedBoundaryReplacer = function* (content, find) {
+  const trimmed = find.trim();
+  if (trimmed === find)
+    return;
+  if (content.includes(trimmed))
+    yield trimmed;
+  const lines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (block.trim() === trimmed)
+      yield block;
+  }
+};
+var ContextAwareReplacer = function* (content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3)
+    return;
+  if (findLines[findLines.length - 1] === "")
+    findLines.pop();
+  const contentLines = content.split("\n");
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine)
+      continue;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const blockLines = contentLines.slice(i, j + 1);
+        if (blockLines.length === findLines.length) {
+          let matching = 0, total = 0;
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const bl = blockLines[k].trim(), fl = findLines[k].trim();
+            if (bl.length > 0 || fl.length > 0) {
+              total++;
+              if (bl === fl)
+                matching++;
             }
+          }
+          if (total === 0 || matching / total >= 0.5) {
+            yield blockLines.join("\n");
+            return;
+          }
         }
+        break;
+      }
     }
+  }
 };
-/** Master replace function: cascades through all 10 replacers */
-function fuzzyReplace(content, oldString, newString, replaceAll = false) {
-    if (oldString === newString) {
-        return { error: 'No changes: oldString and newString are identical.' };
-    }
-    const replacers = [
-        ['exact', SimpleReplacer],
-        ['line-trimmed', LineTrimmedReplacer],
-        ['block-anchor', BlockAnchorReplacer],
-        ['whitespace-normalized', WhitespaceNormalizedReplacer],
-        ['indentation-flexible', IndentationFlexibleReplacer],
-        ['escape-normalized', EscapeNormalizedReplacer],
-        ['trimmed-boundary', TrimmedBoundaryReplacer],
-        ['context-aware', ContextAwareReplacer],
-        ['multi-occurrence', MultiOccurrenceReplacer],
-        ['blank-line-tolerant', BlankLineTolerantReplacer],
-    ];
-    let notFound = true;
-    for (const [name, replacer] of replacers) {
-        for (const search of replacer(content, oldString)) {
-            const index = content.indexOf(search);
-            if (index === -1)
-                continue;
-            notFound = false;
-            if (replaceAll) {
-                return { result: content.replaceAll(search, newString), strategy: name };
+var MultiOccurrenceReplacer = function* (content, find) {
+  let start = 0;
+  while (true) {
+    const idx = content.indexOf(find, start);
+    if (idx === -1)
+      break;
+    yield find;
+    start = idx + find.length;
+  }
+};
+var BlankLineTolerantReplacer = function* (content, find) {
+  const collapseBlankLines = (text) => text.replace(/\n\s*\n/g, "\n").trim();
+  const collapsedFind = collapseBlankLines(find);
+  if (!collapsedFind)
+    return;
+  const collapsedContent = collapseBlankLines(content);
+  if (collapsedContent.includes(collapsedFind)) {
+    const contentLines = content.split("\n");
+    const findLines = find.split("\n").filter((l) => l.trim().length > 0);
+    if (findLines.length === 0)
+      return;
+    const firstNonEmpty = findLines[0].trim();
+    const lastNonEmpty = findLines[findLines.length - 1].trim();
+    for (let i = 0; i < contentLines.length; i++) {
+      if (contentLines[i].trim() !== firstNonEmpty)
+        continue;
+      let foundEnd = -1;
+      let nonEmptyCount = 0;
+      for (let j = i; j < contentLines.length; j++) {
+        if (contentLines[j].trim().length > 0) {
+          nonEmptyCount++;
+        }
+        if (contentLines[j].trim() === lastNonEmpty && nonEmptyCount >= findLines.length) {
+          foundEnd = j;
+          break;
+        }
+        if (j - i > findLines.length * 2 + 5)
+          break;
+      }
+      if (foundEnd >= 0) {
+        const candidateLines = contentLines.slice(i, foundEnd + 1);
+        const candidateNonEmpty = candidateLines.filter((l) => l.trim().length > 0);
+        let allMatch = candidateNonEmpty.length === findLines.length;
+        if (allMatch) {
+          for (let m = 0; m < findLines.length; m++) {
+            if (candidateNonEmpty[m].trim() !== findLines[m].trim()) {
+              allMatch = false;
+              break;
             }
-            const lastIndex = content.lastIndexOf(search);
-            if (index !== lastIndex)
-                continue; // Multiple matches, try next replacer
-            return {
-                result: content.substring(0, index) + newString + content.substring(index + search.length),
-                strategy: name,
-            };
+          }
         }
+        if (allMatch) {
+          yield candidateLines.join("\n");
+          return;
+        }
+      }
     }
-    if (notFound) {
-        return { error: 'Could not find oldString in the file. Tried 10 matching strategies including fuzzy whitespace, indentation, blank-line-tolerant, and block-anchor matching.' };
+  }
+};
+function fuzzyReplace(content, oldString, newString, replaceAll = false) {
+  if (oldString === newString) {
+    return { error: "No changes: oldString and newString are identical." };
+  }
+  const replacers = [
+    ["exact", SimpleReplacer],
+    ["line-trimmed", LineTrimmedReplacer],
+    ["block-anchor", BlockAnchorReplacer],
+    ["whitespace-normalized", WhitespaceNormalizedReplacer],
+    ["indentation-flexible", IndentationFlexibleReplacer],
+    ["escape-normalized", EscapeNormalizedReplacer],
+    ["trimmed-boundary", TrimmedBoundaryReplacer],
+    ["context-aware", ContextAwareReplacer],
+    ["multi-occurrence", MultiOccurrenceReplacer],
+    ["blank-line-tolerant", BlankLineTolerantReplacer]
+  ];
+  let notFound = true;
+  for (const [name, replacer] of replacers) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search);
+      if (index === -1)
+        continue;
+      notFound = false;
+      if (replaceAll) {
+        return { result: content.replaceAll(search, newString), strategy: name };
+      }
+      const lastIndex = content.lastIndexOf(search);
+      if (index !== lastIndex)
+        continue;
+      return {
+        result: content.substring(0, index) + newString + content.substring(index + search.length),
+        strategy: name
+      };
     }
-    return { error: 'Found multiple matches for oldString. Provide more surrounding context to make the match unique.' };
+  }
+  if (notFound) {
+    return { error: "Could not find oldString in the file. Tried 10 matching strategies including fuzzy whitespace, indentation, blank-line-tolerant, and block-anchor matching." };
+  }
+  return { error: "Found multiple matches for oldString. Provide more surrounding context to make the match unique." };
 }
-// ============================================
-// AUTO-FORMAT — imported from ./format
-// Cascade: Prettier → ESLint --fix
-// (function body lives in src/format.ts)
-// ============================================
-program
-    .name('trace')
-    .description('Trace IDE Bridge — connect your codebase and dev server to the Trace extension')
-    .version(VERSION);
-// ============================================
-// COMMAND: trace dev
-// Starts your dev server AND the IDE bridge in
-// one command. Terminal output is streamed to
-// the extension so Trace agents have live context.
-// ============================================
-program
-    .command('dev')
-    .description('Start dev server + IDE bridge together (recommended)')
-    .argument('[command]', 'Override the dev command (e.g. "npm run start:staging")')
-    .option('-p, --port <port>', 'WebSocket port for IDE bridge', '8765')
-    .action(async (commandOverride, options) => {
-    const port = parseInt(options.port);
-    const projectPath = process.cwd();
-    const { command, pm, script } = detectDevCommand(projectPath, commandOverride);
-    console.log();
-    console.log(chalk.bold.cyan('⚡ Trace Dev'));
-    console.log(chalk.gray('─'.repeat(55)));
-    console.log();
-    console.log(`📁 Project:    ${chalk.green(projectPath)}`);
-    console.log(`📦 Package Mgr: ${chalk.yellow(pm)}`);
-    console.log(`🚀 Dev Command: ${chalk.cyan(command)}`);
-    console.log(`🌐 Bridge Port: ${chalk.cyan(port)}`);
+program.name("trace").description("Trace IDE Bridge \u2014 connect your codebase and dev server to the Trace extension").version(VERSION);
+program.command("dev").description("Start dev server + IDE bridge together (recommended)").argument("[command]", 'Override the dev command (e.g. "npm run start:staging")').option("-p, --port <port>", "WebSocket port for IDE bridge", "8765").action(async (commandOverride, options) => {
+  const port = parseInt(options.port);
+  const projectPath = process.cwd();
+  const { command, pm, script } = detectDevCommand(projectPath, commandOverride);
+  console.log();
+  console.log(chalk.bold.cyan("\u26A1 Trace Dev"));
+  console.log(chalk.gray("\u2500".repeat(55)));
+  console.log();
+  console.log(`\u{1F4C1} Project:    ${chalk.green(projectPath)}`);
+  console.log(`\u{1F4E6} Package Mgr: ${chalk.yellow(pm)}`);
+  console.log(`\u{1F680} Dev Command: ${chalk.cyan(command)}`);
+  console.log(`\u{1F310} Bridge Port: ${chalk.cyan(port)}`);
+  console.log();
+  console.log(chalk.gray("\u2500".repeat(55)));
+  console.log();
+  const connectedClients = /* @__PURE__ */ new Set();
+  const broadcast = (payload) => {
+    const msg = JSON.stringify(payload);
+    for (const client of connectedClients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(msg);
+      }
+    }
+  };
+  console.log(chalk.dim("Starting dev server..."));
+  console.log();
+  const childEnv = { ...process.env, FORCE_COLOR: "1" };
+  delete childEnv.MallocNanoZone;
+  delete childEnv.MallocStackLogging;
+  delete childEnv.MallocScribble;
+  delete childEnv.MallocGuardEdges;
+  delete childEnv.MallocErrorAbort;
+  devProcess = spawn(command, [], {
+    cwd: projectPath,
+    shell: true,
+    env: childEnv
+  });
+  devProcess.stdout?.on("data", (chunk) => {
+    const text = chunk.toString();
+    process.stdout.write(text);
+    globalTerminalBuffer.push(text);
+    broadcast({ type: "STREAM_CHUNK", stream: "stdout", chunk: text });
+  });
+  devProcess.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    process.stderr.write(text);
+    globalTerminalBuffer.push(text);
+    broadcast({ type: "STREAM_CHUNK", stream: "stderr", chunk: text });
+  });
+  devProcess.on("close", (code) => {
+    const msg = `
+[Trace] Dev server exited with code ${code}
+`;
+    process.stdout.write(chalk.yellow(msg));
+    globalTerminalBuffer.push(msg);
+    broadcast({ type: "STREAM_END", exitCode: code });
+    devProcess = null;
+  });
+  devProcess.on("error", (err) => {
+    const msg = `[Trace] Failed to start dev server: ${err.message}
+`;
+    process.stderr.write(chalk.red(msg));
+    console.error(chalk.red("\n\u2717 Could not start dev server."));
+    console.error(chalk.dim(`  Command: ${command}`));
+    console.error(chalk.dim(`  Make sure the script exists in your package.json`));
+  });
+  const wss = new WebSocketServer({ port });
+  let clientCount = 0;
+  wss.on("listening", () => {
     console.log();
-    console.log(chalk.gray('─'.repeat(55)));
+    console.log(chalk.gray("\u2500".repeat(55)));
+    console.log(chalk.green("\u2713") + " IDE Bridge listening on port " + chalk.cyan(port));
+    console.log(chalk.dim("Waiting for Trace extension to connect..."));
+    console.log(chalk.dim("Press Ctrl+C to stop both"));
+    console.log(chalk.gray("\u2500".repeat(55)));
     console.log();
-    // Track all connected WebSocket clients so we can push STREAM_CHUNK events
-    const connectedClients = new Set();
-    const broadcast = (payload) => {
-        const msg = JSON.stringify(payload);
-        for (const client of connectedClients) {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(msg);
-            }
-        }
-    };
-    // ── Start the dev server ──────────────────────────────────
-    console.log(chalk.dim('Starting dev server...'));
-    console.log();
-    devProcess = spawn(command, [], {
-        cwd: projectPath,
-        shell: true,
-        env: { ...process.env, FORCE_COLOR: '1' },
-    });
-    devProcess.stdout?.on('data', (chunk) => {
-        const text = chunk.toString();
-        // Print to terminal so the developer still sees their logs
-        process.stdout.write(text);
-        // Store in rolling buffer (ANSI stripped)
-        globalTerminalBuffer.push(text);
-        // Push raw chunk to extension for live terminal panel
-        broadcast({ type: 'STREAM_CHUNK', stream: 'stdout', chunk: text });
-    });
-    devProcess.stderr?.on('data', (chunk) => {
-        const text = chunk.toString();
-        process.stderr.write(text);
-        globalTerminalBuffer.push(text);
-        broadcast({ type: 'STREAM_CHUNK', stream: 'stderr', chunk: text });
-    });
-    devProcess.on('close', (code) => {
-        const msg = `\n[Trace] Dev server exited with code ${code}\n`;
-        process.stdout.write(chalk.yellow(msg));
-        globalTerminalBuffer.push(msg);
-        broadcast({ type: 'STREAM_END', exitCode: code });
-        devProcess = null;
-    });
-    devProcess.on('error', (err) => {
-        const msg = `[Trace] Failed to start dev server: ${err.message}\n`;
-        process.stderr.write(chalk.red(msg));
-        console.error(chalk.red('\n✗ Could not start dev server.'));
-        console.error(chalk.dim(`  Command: ${command}`));
-        console.error(chalk.dim(`  Make sure the script exists in your package.json`));
+  });
+  wss.on("connection", (ws) => {
+    clientCount++;
+    connectedClients.add(ws);
+    console.log(chalk.green("\u25CF") + ` Extension connected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+    attachMessageHandler(ws, projectPath);
+    const catchup = globalTerminalBuffer.getLast(100);
+    if (catchup.length > 0) {
+      ws.send(JSON.stringify({ type: "TERMINAL_CATCHUP", lines: catchup }));
+    }
+    ws.on("close", () => {
+      clientCount--;
+      connectedClients.delete(ws);
+      console.log(chalk.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
     });
-    // ── Start the WebSocket IDE bridge ────────────────────────
-    const wss = new WebSocketServer({ port });
-    let clientCount = 0;
-    wss.on('listening', () => {
-        console.log();
-        console.log(chalk.gray('─'.repeat(55)));
-        console.log(chalk.green('✓') + ' IDE Bridge listening on port ' + chalk.cyan(port));
-        console.log(chalk.dim('Waiting for Trace extension to connect...'));
-        console.log(chalk.dim('Press Ctrl+C to stop both'));
-        console.log(chalk.gray('─'.repeat(55)));
-        console.log();
+    ws.on("error", (err) => {
+      console.error(chalk.red("WebSocket error:"), err.message);
+      connectedClients.delete(ws);
     });
-    wss.on('connection', (ws) => {
-        clientCount++;
-        connectedClients.add(ws);
-        console.log(chalk.green('●') + ` Extension connected (${clientCount} client${clientCount > 1 ? 's' : ''})`);
-        // Wire up the full IDE bridge protocol (file read/write, detect project, etc.)
-        attachMessageHandler(ws, projectPath);
-        // Send the last 100 lines immediately so the extension has terminal context
-        const catchup = globalTerminalBuffer.getLast(100);
-        if (catchup.length > 0) {
-            ws.send(JSON.stringify({ type: 'TERMINAL_CATCHUP', lines: catchup }));
+  });
+  wss.on("error", (error) => {
+    if (error.code === "EADDRINUSE") {
+      console.error(chalk.red(`\u2717 Port ${port} is already in use. Try: trace dev --port 8766`));
+    } else {
+      console.error(chalk.red("Bridge error:"), error.message);
+    }
+  });
+  const http = await import("http");
+  const browserHttpServer = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url, `http://localhost`);
+    const agentRouteMatch = url.pathname.match(/^\/agent\/([a-z_-]+)$/);
+    if (agentRouteMatch) {
+      const agentName = agentRouteMatch[1];
+      const client2 = [...connectedClients].find((c) => c.readyState === 1);
+      if (!client2) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Trace extension not connected." }));
+        return;
+      }
+      try {
+        let body = {};
+        if (req.method === "POST") {
+          body = await new Promise((resolve3, reject) => {
+            let raw = "";
+            req.on("data", (chunk) => raw += chunk.toString());
+            req.on("end", () => {
+              try {
+                resolve3(JSON.parse(raw || "{}"));
+              } catch {
+                resolve3({});
+              }
+            });
+            req.on("error", reject);
+          });
         }
-        ws.on('close', () => {
-            clientCount--;
-            connectedClients.delete(ws);
-            console.log(chalk.yellow('●') + ` Extension disconnected (${clientCount} client${clientCount > 1 ? 's' : ''})`);
+        const reqId = ++globalBrowserRequestId;
+        client2.send(JSON.stringify({
+          id: reqId,
+          type: "AGENT_INVOKE",
+          agent: agentName,
+          query: body.query || ""
+        }));
+        const result = await new Promise((resolve3, reject) => {
+          const timer = setTimeout(() => {
+            globalBrowserPending.delete(reqId);
+            reject(new Error("Agent timeout (60s). Extension debug agent did not respond."));
+          }, 6e4);
+          globalBrowserPending.set(reqId, { resolve: resolve3, reject, timer });
         });
-        ws.on('error', (err) => {
-            console.error(chalk.red('WebSocket error:'), err.message);
-            connectedClients.delete(ws);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(result, null, 2));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+      return;
+    }
+    const browserQueryRoutes = {
+      "/browser/console": "BROWSER_GET_CONSOLE",
+      "/browser/network": "BROWSER_GET_NETWORK",
+      "/browser/dom": "BROWSER_GET_DOM",
+      "/browser/screenshot": "BROWSER_SCREENSHOT"
+    };
+    const isBrowserRoute = url.pathname in browserQueryRoutes || url.pathname === "/browser/eval";
+    if (!isBrowserRoute) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Available: /browser/{console,network,dom,eval,screenshot}" }));
+      return;
+    }
+    const client = [...connectedClients].find(
+      (c) => c.readyState === 1
+      /* OPEN */
+    );
+    if (!client) {
+      res.writeHead(503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Trace extension not connected. Open the extension and attach to a tab." }));
+      return;
+    }
+    try {
+      let body = {};
+      if (req.method === "POST") {
+        body = await new Promise((resolve3, reject) => {
+          let raw = "";
+          req.on("data", (chunk) => raw += chunk.toString());
+          req.on("end", () => {
+            try {
+              resolve3(JSON.parse(raw || "{}"));
+            } catch {
+              resolve3({});
+            }
+          });
+          req.on("error", reject);
         });
+      }
+      const reqId = ++globalBrowserRequestId;
+      const msgType = browserQueryRoutes[url.pathname] || "BROWSER_EVAL";
+      const wsMsg = { id: reqId, type: msgType };
+      if (url.pathname === "/browser/eval")
+        wsMsg.code = body.code || "";
+      client.send(JSON.stringify(wsMsg));
+      const result = await new Promise((resolve3, reject) => {
+        const timer = setTimeout(() => {
+          globalBrowserPending.delete(reqId);
+          reject(new Error("Browser query timeout (5s). Extension may not be attached to a tab."));
+        }, 5e3);
+        globalBrowserPending.set(reqId, { resolve: resolve3, reject, timer });
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(result, null, 2));
+    } catch (e) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: e.message }));
+    }
+  });
+  const BROWSER_HTTP_PORT = 8767;
+  browserHttpServer.listen(BROWSER_HTTP_PORT, "127.0.0.1", () => {
+    console.log(chalk.green("\u2713") + " Browser Query HTTP server on port " + chalk.cyan(BROWSER_HTTP_PORT));
+    console.log(chalk.dim("  Coding agents can query: curl http://localhost:8767/browser/console"));
+  });
+  browserHttpServer.on("error", (e) => {
+    if (e.code !== "EADDRINUSE")
+      console.warn(chalk.yellow("\u26A0 Browser HTTP server error:"), e.message);
+  });
+  let agentServer = null;
+  try {
+    let agentPath = "@gettrace/agent/dist/node/index.js";
+    if (process.env.TRACE_DEV_MODE) {
+      agentPath = path4.resolve(__dirname, "../../packages/trace-agent/dist/node/index.js");
+      console.log(chalk.magenta("\u2699") + " Dev Mode: Using local trace agent at " + chalk.dim(agentPath));
+    }
+    const { Server } = await import(agentPath);
+    process.env.OPENCODE_EXPERIMENTAL = "1";
+    process.env.OPENCODE_ENABLE_EXA = "1";
+    process.env.OPENCODE_EXPERIMENTAL_LSP_TOOL = "1";
+    process.env.OPENCODE_ENABLE_QUESTION_TOOL = "1";
+    process.env.OPENCODE_CLIENT = "app";
+    process.env.OPENCODE_DISABLE_AUTOUPDATE = "1";
+    process.env.OPENCODE_DISABLE_TERMINAL_TITLE = "1";
+    agentServer = await Server.listen({
+      port: 8766,
+      hostname: "127.0.0.1",
+      cors: ["*"]
     });
-    wss.on('error', (error) => {
-        if (error.code === 'EADDRINUSE') {
-            console.error(chalk.red(`✗ Port ${port} is already in use. Try: trace dev --port 8766`));
-        }
-        else {
-            console.error(chalk.red('Bridge error:'), error.message);
-        }
-    });
-    // ── Graceful shutdown ─────────────────────────────────────
-    const shutdown = () => {
-        console.log();
-        console.log(chalk.yellow('\nShutting down...'));
-        if (devProcess && !devProcess.killed) {
-            devProcess.kill('SIGTERM');
-        }
-        wss.close();
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
+    console.log(chalk.green("\u2713") + " Trace Agent Server listening on port " + chalk.cyan(8766));
+    console.log(chalk.dim("  LSP \xB7 Exa search \xB7 Plan mode \xB7 All tools unlocked"));
+  } catch (e) {
+    console.error(chalk.yellow("\u26A0") + " Failed to start Trace Agent Server:", e.message);
+  }
+  const shutdown = async () => {
+    console.log();
+    console.log(chalk.yellow("\nShutting down..."));
+    if (devProcess && !devProcess.killed) {
+      devProcess.kill("SIGTERM");
+    }
+    if (agentServer) {
+      await agentServer.stop();
+    }
+    wss.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 });
-// ============================================
-// SHARED MESSAGE HANDLER
-// Called by both `trace dev` and `trace connect`.
-// Attaches the full IDE bridge protocol to a WS.
-// ============================================
+var globalBrowserPending = /* @__PURE__ */ new Map();
+var globalBrowserRequestId = 0;
 function attachMessageHandler(ws, projectPath) {
-    // Per-connection undo stack
-    const undoStack = [];
-    // Build project info for GET_PROJECT_INFO responses
-    let projectInfo = { projectPath };
-    try {
-        const pkgPath = path.join(projectPath, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            projectInfo = { ...projectInfo, name: pkg.name, version: pkg.version, description: pkg.description };
-        }
+  const undoStack = [];
+  let projectInfo = { projectPath };
+  try {
+    const pkgPath = path4.join(projectPath, "package.json");
+    if (fs4.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      projectInfo = { ...projectInfo, name: pkg.name, version: pkg.version, description: pkg.description };
     }
-    catch (_) { }
-    ws.on('message', async (data) => {
-        try {
-            const message = JSON.parse(data.toString());
-            const { id, type } = message;
-            let response = { id };
-            switch (type) {
-                case 'GET_PROJECT_INFO':
-                    response.data = projectInfo;
-                    break;
-                case 'READ_FILE':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied';
-                        }
-                        else if (fs.existsSync(filePath)) {
-                            const stat = fs.statSync(filePath);
-                            // Binary file detection (check first 4KB for null bytes)
-                            if (stat.size > 0) {
-                                const fd = fs.openSync(filePath, 'r');
-                                const sample = Buffer.alloc(Math.min(4096, stat.size));
-                                fs.readSync(fd, sample, 0, sample.length, 0);
-                                fs.closeSync(fd);
-                                if (sample.includes(0)) {
-                                    response.error = `Cannot read binary file: ${message.filePath}`;
-                                    break;
-                                }
-                            }
-                            const rawContent = fs.readFileSync(filePath, 'utf-8');
-                            const allLines = rawContent.split('\n');
-                            const offset = message.offset || 1;
-                            const limit = message.limit || 2000;
-                            const startIdx = Math.max(0, offset - 1);
-                            const endIdx = Math.min(allLines.length, startIdx + limit);
-                            const sliced = allLines.slice(startIdx, endIdx);
-                            // Line-number prefixed output (like OpenCode)
-                            const numbered = sliced.map((line, i) => `${startIdx + i + 1}: ${line}`).join('\n');
-                            const truncated = endIdx < allLines.length;
-                            // ── READ TOKEN ───────────────────────────────────────────────
-                            // Agents pass this back in EDIT_FILE / REPLACE_LINES to prove
-                            // the file hasn't changed since they last read it. If the token
-                            // mismatches on a subsequent write, the write is rejected so
-                            // stale line numbers cannot corrupt the file.
-                            const _rtStat = fs.statSync(filePath);
-                            const _readToken = `${Math.round(_rtStat.mtimeMs)}-${_rtStat.size}`;
-                            // ─────────────────────────────────────────────────────────────
-                            response.data = {
-                                content: numbered,
-                                // rawContent intentionally omitted — agents use line-numbered
-                                // content for edits; sending raw doubles context size per read.
-                                exists: true,
-                                path: message.filePath,
-                                totalLines: allLines.length,
-                                showing: { from: offset, to: endIdx, truncated },
-                                readToken: _readToken,
-                            };
-                        }
-                        else {
-                            // Suggest similar files if not found
-                            const dir = path.dirname(filePath);
-                            const base = path.basename(filePath);
-                            let suggestions = [];
-                            try {
-                                suggestions = fs.readdirSync(dir)
-                                    .filter(e => e.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(e.toLowerCase()))
-                                    .slice(0, 3)
-                                    .map(e => path.relative(projectPath, path.join(dir, e)));
-                            }
-                            catch (_) { }
-                            response.data = { exists: false, suggestions };
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'GET_SOURCE':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied';
-                        }
-                        else if (fs.existsSync(filePath)) {
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            const lines = content.split('\n');
-                            const start = Math.max(0, (message.lineStart || 1) - 1);
-                            const end = message.lineEnd ? Math.min(lines.length, message.lineEnd) : lines.length;
-                            response.data = {
-                                lines: lines.slice(start, end),
-                                startLine: start + 1,
-                                endLine: end,
-                                totalLines: lines.length
-                            };
-                        }
-                        else {
-                            response.error = 'File not found';
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'GET_ERROR_CONTEXT':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied';
-                        }
-                        else if (fs.existsSync(filePath)) {
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            const lines = content.split('\n');
-                            const targetLine = message.line || 1;
-                            const contextLines = message.contextLines || 5;
-                            const start = Math.max(0, targetLine - contextLines - 1);
-                            const end = Math.min(lines.length, targetLine + contextLines);
-                            response.data = {
-                                lines: lines.slice(start, end).map((line, i) => ({
-                                    number: start + i + 1,
-                                    content: line,
-                                    isError: start + i + 1 === targetLine
-                                })),
-                                errorLine: targetLine,
-                                filePath: message.filePath
-                            };
-                        }
-                        else {
-                            response.error = 'File not found';
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'GET_FILE_TREE':
-                    try {
-                        const depth = message.depth || 3;
-                        const tree = getFileTree(projectPath, depth);
-                        response.data = { tree };
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'SEARCH_CODE':
-                    try {
-                        const { matches, engine } = await searchCode(projectPath, message.query, {
-                            isRegex: message.isRegex || false,
-                            caseSensitive: message.caseSensitive !== false,
-                            maxResults: message.maxResults || 20,
-                        });
-                        response.data = { matches, engine };
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'FIND_FILES':
-                    try {
-                        const pattern = message.pattern || '';
-                        // Extract the filename from a glob like **/Services.css
-                        const fileName = pattern.split('/').pop().replace(/\*\*/g, '').replace(/\*/g, '');
-                        const maxResults = message.maxResults || 20;
-                        const ignorePatterns = ['node_modules', '.git', 'dist', 'build', '.next', '.cache'];
-                        const found = [];
-                        function findFiles(dir) {
-                            if (found.length >= maxResults)
-                                return;
-                            try {
-                                const items = fs.readdirSync(dir);
-                                for (const item of items) {
-                                    if (found.length >= maxResults)
-                                        break;
-                                    if (ignorePatterns.includes(item) || item.startsWith('.'))
-                                        continue;
-                                    const fullPath = path.join(dir, item);
-                                    try {
-                                        const stat = fs.statSync(fullPath);
-                                        if (stat.isDirectory()) {
-                                            findFiles(fullPath);
-                                        }
-                                        else {
-                                            // Match by filename (with optional wildcard)
-                                            const matchByName = !fileName || item === fileName ||
-                                                (pattern.includes('*') && item.endsWith(fileName));
-                                            if (matchByName) {
-                                                found.push(path.relative(projectPath, fullPath));
-                                            }
-                                        }
-                                    }
-                                    catch (e) { /* skip */ }
-                                }
-                            }
-                            catch (e) { /* skip */ }
-                        }
-                        findFiles(projectPath);
-                        response.data = found;
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                // ========== PROJECT DETECTION (Code Export Pipeline) ==========
-                case 'DETECT_PROJECT':
-                    try {
-                        const pkgPath = path.join(projectPath, 'package.json');
-                        let deps = {};
-                        let devDeps = {};
-                        let pkgName = '';
-                        if (fs.existsSync(pkgPath)) {
-                            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-                            deps = pkg.dependencies || {};
-                            devDeps = pkg.devDependencies || {};
-                            pkgName = pkg.name || '';
-                        }
-                        const allDeps = { ...deps, ...devDeps };
-                        // --- Framework detection ---
-                        let framework = 'html';
-                        if (allDeps['next'])
-                            framework = 'next.js';
-                        else if (allDeps['nuxt'] || allDeps['nuxt3'])
-                            framework = 'nuxt';
-                        else if (allDeps['gatsby'])
-                            framework = 'gatsby';
-                        else if (allDeps['@remix-run/react'])
-                            framework = 'remix';
-                        else if (allDeps['svelte'] || allDeps['@sveltejs/kit'])
-                            framework = 'svelte';
-                        else if (allDeps['vue'])
-                            framework = 'vue';
-                        else if (allDeps['@angular/core'])
-                            framework = 'angular';
-                        else if (allDeps['react'])
-                            framework = 'react';
-                        // --- TypeScript detection ---
-                        const typescript = !!allDeps['typescript'] || fs.existsSync(path.join(projectPath, 'tsconfig.json'));
-                        const ext = typescript ? '.tsx' : '.jsx';
-                        // --- Styling detection ---
-                        let styling = 'plain-css';
-                        if (allDeps['tailwindcss'])
-                            styling = 'tailwind';
-                        else if (allDeps['styled-components'])
-                            styling = 'styled-components';
-                        else if (allDeps['@emotion/react'] || allDeps['@emotion/styled'])
-                            styling = 'emotion';
-                        else if (allDeps['sass'] || allDeps['node-sass'])
-                            styling = 'sass';
-                        // CSS Modules: detected by file presence later
-                        // --- Router detection (Next.js specific) ---
-                        let router = null;
-                        if (framework === 'next.js') {
-                            if (fs.existsSync(path.join(projectPath, 'src/app')) || fs.existsSync(path.join(projectPath, 'app'))) {
-                                router = 'app';
-                            }
-                            else if (fs.existsSync(path.join(projectPath, 'src/pages')) || fs.existsSync(path.join(projectPath, 'pages'))) {
-                                router = 'pages';
-                            }
-                        }
-                        // --- Key file location finder ---
-                        const findFirst = (candidates) => {
-                            for (const c of candidates) {
-                                if (fs.existsSync(path.join(projectPath, c)))
-                                    return c;
-                            }
-                            return null;
-                        };
-                        const layoutFile = findFirst([
-                            'src/app/layout.tsx', 'src/app/layout.jsx', 'src/app/layout.js',
-                            'app/layout.tsx', 'app/layout.jsx', 'app/layout.js',
-                            'src/pages/_app.tsx', 'src/pages/_app.jsx', 'pages/_app.tsx', 'pages/_app.jsx',
-                            'src/App.tsx', 'src/App.jsx', 'src/App.js',
-                            'src/main.tsx', 'src/main.jsx', 'src/main.js',
-                            'index.html'
-                        ]);
-                        const globalStyleFile = findFirst([
-                            'src/app/globals.css', 'src/app/global.css',
-                            'app/globals.css', 'app/global.css',
-                            'src/index.css', 'src/styles/globals.css', 'src/styles/global.css',
-                            'src/App.css', 'src/styles.css',
-                            'styles/globals.css', 'styles/global.css',
-                            'css/style.css', 'css/main.css',
-                            'style.css', 'styles.css'
-                        ]);
-                        // Initial guess via disk — overridden after tree scan with real component count
-                        let componentsDir = findFirst([
-                            'src/components', 'src/app/components', 'components',
-                            'src/ui', 'src/app/ui'
-                        ]);
-                        // --- Tailwind config ---
-                        let tailwindConfig = null;
-                        let tailwindVersion = null;
-                        if (styling === 'tailwind') {
-                            tailwindConfig = findFirst([
-                                'tailwind.config.ts', 'tailwind.config.js', 'tailwind.config.mjs', 'tailwind.config.cjs'
-                            ]);
-                            tailwindVersion = allDeps['tailwindcss'] || null;
-                        }
-                        // --- Detect code conventions from existing components ---
-                        let componentPattern = 'arrow-function';
-                        let exportPattern = 'default';
-                        let sampleComponentFile = null;
-                        let sampleComponentCode = null;
-                        if (componentsDir) {
-                            const compDir = path.join(projectPath, componentsDir);
-                            try {
-                                const files = fs.readdirSync(compDir).filter(f => f.endsWith('.tsx') || f.endsWith('.jsx') || f.endsWith('.js') || f.endsWith('.vue') || f.endsWith('.svelte'));
-                                if (files.length > 0) {
-                                    sampleComponentFile = path.join(componentsDir, files[0]);
-                                    const code = fs.readFileSync(path.join(compDir, files[0]), 'utf-8');
-                                    // Only include first 80 lines as a pattern reference
-                                    sampleComponentCode = code.split('\n').slice(0, 80).join('\n');
-                                    // Detect patterns
-                                    if (/^export default function /m.test(code)) {
-                                        componentPattern = 'function-declaration';
-                                        exportPattern = 'default';
-                                    }
-                                    else if (/^export function /m.test(code)) {
-                                        componentPattern = 'function-declaration';
-                                        exportPattern = 'named';
-                                    }
-                                    else if (/const \w+ = \(/.test(code) || /const \w+ = \(\) =>/.test(code)) {
-                                        componentPattern = 'arrow-function';
-                                    }
-                                    if (/^export default /m.test(code))
-                                        exportPattern = 'default';
-                                    else if (/^export \{/m.test(code) || /^export const/m.test(code))
-                                        exportPattern = 'named';
-                                    // CSS Modules detection from component imports
-                                    if (/import\s+\w+\s+from\s+['"][^'"]+\.module\.(css|scss|sass)['"]/.test(code)) {
-                                        styling = 'css-modules';
-                                    }
-                                }
-                            }
-                            catch (e) { /* skip */ }
-                        }
-                        // --- Also check layout file for CSS Modules if not yet detected ---
-                        if (styling === 'plain-css' && layoutFile) {
-                            try {
-                                const layoutCode = fs.readFileSync(path.join(projectPath, layoutFile), 'utf-8');
-                                if (/import\s+\w+\s+from\s+['"][^'"]+\.module\.(css|scss|sass)['"]/.test(layoutCode)) {
-                                    styling = 'css-modules';
-                                }
-                            }
-                            catch (e) { /* skip */ }
-                        }
-                        // --- Read a snippet of global CSS for context ---
-                        let globalStylePreview = null;
-                        if (globalStyleFile) {
-                            try {
-                                const css = fs.readFileSync(path.join(projectPath, globalStyleFile), 'utf-8');
-                                globalStylePreview = css.split('\n').slice(0, 40).join('\n');
-                            }
-                            catch (e) { /* skip */ }
-                        }
-                        // --- Build filtered scaffolding tree (UI-relevant files only) ---
-                        const SKIP_DIRS = new Set([
-                            'node_modules', '.git', '.next', '.nuxt', '.svelte-kit',
-                            'dist', 'build', '.cache', '.turbo', 'coverage',
-                            '__pycache__', '.vercel', '.output', '.parcel-cache'
-                        ]);
-                        const UI_EXTENSIONS = new Set([
-                            '.tsx', '.jsx', '.js', '.ts', '.vue', '.svelte',
-                            '.css', '.scss', '.sass', '.less', '.module.css', '.module.scss',
-                            '.html', '.astro'
-                        ]);
-                        const treeLines = [];
-                        const MAX_TREE_LINES = 120;
-                        // Track dir → count of Pascal-case component files for smart detection
-                        const dirComponentCount = new Map();
-                        const buildTree = (dir, prefix, depth) => {
-                            if (depth > 4 || treeLines.length >= MAX_TREE_LINES)
-                                return;
-                            try {
-                                const entries = fs.readdirSync(path.join(projectPath, dir), { withFileTypes: true });
-                                // Sort: directories first, then files
-                                const sorted = entries
-                                    .filter(e => !e.name.startsWith('.') || e.name === '.env')
-                                    .sort((a, b) => {
-                                    if (a.isDirectory() && !b.isDirectory())
-                                        return -1;
-                                    if (!a.isDirectory() && b.isDirectory())
-                                        return 1;
-                                    return a.name.localeCompare(b.name);
-                                });
-                                for (let i = 0; i < sorted.length && treeLines.length < MAX_TREE_LINES; i++) {
-                                    const entry = sorted[i];
-                                    const isLast = i === sorted.length - 1;
-                                    const connector = isLast ? '└── ' : '├── ';
-                                    const childPrefix = isLast ? '    ' : '│   ';
-                                    const childPath = dir ? `${dir}/${entry.name}` : entry.name;
-                                    if (entry.isDirectory()) {
-                                        if (SKIP_DIRS.has(entry.name))
-                                            continue;
-                                        treeLines.push(`${prefix}${connector}${entry.name}/`);
-                                        buildTree(childPath, prefix + childPrefix, depth + 1);
-                                    }
-                                    else {
-                                        const ext = path.extname(entry.name).toLowerCase();
-                                        // Count Pascal-case component files per dir (Footer.tsx, Button.tsx, etc.)
-                                        const COMPONENT_EXTS = new Set(['.tsx', '.jsx', '.vue', '.svelte']);
-                                        if (COMPONENT_EXTS.has(ext) && /^[A-Z]/.test(entry.name)) {
-                                            dirComponentCount.set(dir, (dirComponentCount.get(dir) ?? 0) + 1);
-                                        }
-                                        // Include UI-relevant files + config files at root
-                                        if (UI_EXTENSIONS.has(ext) || (depth <= 1 && (entry.name === 'package.json' || entry.name === 'tsconfig.json' ||
-                                            entry.name.startsWith('tailwind.config') || entry.name.startsWith('next.config') ||
-                                            entry.name.startsWith('vite.config')))) {
-                                            treeLines.push(`${prefix}${connector}${entry.name}`);
-                                        }
-                                    }
-                                }
-                            }
-                            catch (e) { /* permission error, skip */ }
-                        };
-                        // Only scan UI-relevant root dirs (not the entire project)
-                        const scanRoots = ['src', 'app', 'pages', 'components', 'styles', 'public', 'lib', 'utils'];
-                        const existingRoots = [];
-                        for (const root of scanRoots) {
-                            if (fs.existsSync(path.join(projectPath, root))) {
-                                existingRoots.push(root);
-                            }
-                        }
-                        // Also add root-level config files
-                        try {
-                            const rootEntries = fs.readdirSync(projectPath, { withFileTypes: true });
-                            for (const entry of rootEntries) {
-                                if (!entry.isDirectory() && (entry.name === 'package.json' || entry.name === 'tsconfig.json' ||
-                                    entry.name.startsWith('tailwind.config') || entry.name.startsWith('next.config') ||
-                                    entry.name.startsWith('vite.config') || entry.name === 'index.html')) {
-                                    treeLines.push(entry.name);
-                                }
-                            }
-                        }
-                        catch (e) { /* skip */ }
-                        // Build tree for each UI root
-                        for (const root of existingRoots) {
-                            treeLines.push(`${root}/`);
-                            buildTree(root, '', 1);
-                        }
-                        const projectTree = treeLines.length > 0 ? treeLines.join('\n') : null;
-                        // --- Override componentsDir with real scan result ---
-                        // Pick the dir with the most Pascal-case component files.
-                        // This beats any hardcoded list: works for src/features, src/modules,
-                        // src/views, src/app/components — whatever the project uses.
-                        if (dirComponentCount.size > 0) {
-                            let bestDir = '';
-                            let bestCount = 0;
-                            for (const [dir, count] of dirComponentCount.entries()) {
-                                if (count > bestCount) {
-                                    bestCount = count;
-                                    bestDir = dir;
-                                }
-                            }
-                            if (bestCount > 0)
-                                componentsDir = bestDir;
-                        }
-                        response.data = {
-                            framework,
-                            typescript,
-                            styling,
-                            router,
-                            ext,
-                            pkgName,
-                            // Key file locations
-                            layoutFile,
-                            globalStyleFile,
-                            componentsDir,
-                            tailwindConfig,
-                            tailwindVersion,
-                            // Code conventions
-                            componentPattern,
-                            exportPattern,
-                            sampleComponentFile,
-                            sampleComponentCode,
-                            // CSS context
-                            globalStylePreview,
-                            // Scaffolding tree
-                            projectTree,
-                        };
-                        console.log(chalk.blue('ℹ') + ` Project detected: ${chalk.yellow(framework)} + ${chalk.cyan(styling)}${typescript ? chalk.dim(' (TS)') : ''}${router ? chalk.dim(` [${router} router]`) : ''}`);
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'BUILD_CLASS_INDEX':
-                    // ────────────────────────────────────────────────────────────────
-                    // Scans all component files (.tsx, .jsx, .vue, .svelte) for
-                    // className attributes and builds a lookup:
-                    //   { classSignature → { file: string, line: number } }
-                    //
-                    // Used by FileResolver in the extension to find which source file
-                    // owns a given DOM element when React Fiber _debugSource is null.
-                    // ────────────────────────────────────────────────────────────────
-                    try {
-                        const COMPONENT_EXTS_IDX = new Set(['.tsx', '.jsx', '.vue', '.svelte', '.js', '.ts']);
-                        const SKIP_DIRS_IDX = new Set(['node_modules', '.git', '.next', '.nuxt', 'dist', 'build', '.cache']);
-                        const index = {};
-                        let filesScanned = 0;
-                        let classesIndexed = 0;
-                        const scanDir = (dir) => {
-                            try {
-                                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                                for (const entry of entries) {
-                                    if (entry.name.startsWith('.'))
-                                        continue;
-                                    const fullPath = path.join(dir, entry.name);
-                                    const relPath = path.relative(projectPath, fullPath).replace(/\\/g, '/');
-                                    if (entry.isDirectory()) {
-                                        if (SKIP_DIRS_IDX.has(entry.name))
-                                            continue;
-                                        scanDir(fullPath);
-                                    }
-                                    else {
-                                        const ext = path.extname(entry.name).toLowerCase();
-                                        if (!COMPONENT_EXTS_IDX.has(ext))
-                                            continue;
-                                        try {
-                                            const content = fs.readFileSync(fullPath, 'utf-8');
-                                            const lines = content.split('\n');
-                                            filesScanned++;
-                                            for (let i = 0; i < lines.length; i++) {
-                                                const line = lines[i];
-                                                // Match className="..." and className={'...'} and class="..."
-                                                const classMatches = line.matchAll(/(?:className|class)\s*=\s*(?:"([^"]+)"|'([^']+)'|\{(?:`([^`]+)`|"([^"]+)"|'([^']+)')\})/g);
-                                                for (const match of classMatches) {
-                                                    const classValue = match[1] || match[2] || match[3] || match[4] || match[5];
-                                                    if (!classValue)
-                                                        continue;
-                                                    const classes = classValue
-                                                        .split(/\s+/)
-                                                        .filter((c) => c.length > 2 &&
-                                                        !c.startsWith('$') &&
-                                                        !c.includes('{') &&
-                                                        !c.includes('}'));
-                                                    if (classes.length === 0)
-                                                        continue;
-                                                    // Full 2-3 class signature as key
-                                                    const sig = classes.slice(0, 3).sort().join(' ');
-                                                    if (sig && !index[sig]) {
-                                                        index[sig] = { file: relPath, line: i + 1 };
-                                                        classesIndexed++;
-                                                    }
-                                                    // Individual distinctive classes
-                                                    for (const cls of classes) {
-                                                        // Skip very common Tailwind utilities that match too many elements
-                                                        if (/^(flex|grid|block|hidden|relative|absolute|fixed|sticky|inline|w-|h-|p-|m-|text-|bg-|border|rounded|flex-|grid-|col-|row-)/.test(cls))
-                                                            continue;
-                                                        if (cls.length > 5 && !index[cls]) {
-                                                            index[cls] = { file: relPath, line: i + 1 };
-                                                            classesIndexed++;
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        catch (e) { /* skip unreadable files */ }
-                                    }
-                                }
-                            }
-                            catch (e) { /* skip unreadable dirs */ }
-                        };
-                        scanDir(projectPath);
-                        response.data = {
-                            index,
-                            filesScanned,
-                            classesIndexed,
-                        };
-                        console.log(chalk.blue('ℹ') + ` Class index built: ${chalk.yellow(classesIndexed)} classes across ${chalk.cyan(filesScanned)} files`);
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                // ========== FILE WRITING (UI Design Export) ==========
-                // --- Undo Stack ---
-                // Snapshots file contents before every write/append/edit.
-                // UNDO_LAST pops the most recent snapshot and restores it.
-                // Max 20 entries to avoid unbounded memory growth.
-                case 'WRITE_FILE':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                        }
-                        else {
-                            // Snapshot before write
-                            const prevContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : null;
-                            undoStack.push({ filePath, prevContent, operation: 'WRITE_FILE', timestamp: Date.now(), relativePath: message.filePath });
-                            if (undoStack.length > 20)
-                                undoStack.shift();
-                            // --- CSS safety: validate balanced braces ---
-                            if (filePath.endsWith('.css')) {
-                                const writeContent = message.content || '';
-                                const opens = (writeContent.match(/\{/g) || []).length;
-                                const closes = (writeContent.match(/\}/g) || []).length;
-                                if (opens !== closes) {
-                                    // Remove snapshot since we're rejecting the write
-                                    undoStack.pop();
-                                    response.error = `CSS validation failed: unbalanced braces (${opens} opening vs ${closes} closing). Fix the CSS before writing.`;
-                                    break;
-                                }
-                            }
-                            const dirPath = path.dirname(filePath);
-                            if (!fs.existsSync(dirPath)) {
-                                fs.mkdirSync(dirPath, { recursive: true });
-                            }
-                            await withFileLock(filePath, async () => {
-                                fs.writeFileSync(filePath, message.content, 'utf-8');
-                                // Auto-format after write
-                                const formatter = await autoFormat(filePath, projectPath);
-                                response.data = { success: true, path: filePath, formatted: formatter, undoAvailable: true };
-                                console.log(chalk.blue('ℹ') + ` Wrote file: ${message.filePath}` + (formatter ? chalk.dim(` (formatted with ${formatter})`) : '') + chalk.dim(' [undo saved]'));
-                            });
-                            // ── LSP: Post-write TypeScript diagnostics ────────────────────
-                            // Runs tsc --noEmit (6s timeout). Never throws. Returns [] for
-                            // non-TS files or projects without tsconfig.json.
-                            const _wLsp = await checkDiagnostics(filePath, projectPath);
-                            if (_wLsp.ran && response.data) {
-                                response.data.lspDiagnostics = _wLsp.diagnostics;
-                                if (_wLsp.summary) {
-                                    response.data.lspSummary = _wLsp.summary;
-                                    if (_wLsp.diagnostics.some(d => d.severity === 'error')) {
-                                        console.log(chalk.yellow('⚠') + ` ${_wLsp.summary}`);
-                                    }
-                                }
-                            }
-                            // ─────────────────────────────────────────────────────────────
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'APPEND_FILE':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                        }
-                        else {
-                            const isCssFile = filePath.endsWith('.css');
-                            const newContent = message.content || '';
-                            // --- CSS safety: validate balanced braces ---
-                            if (isCssFile) {
-                                const opens = (newContent.match(/\{/g) || []).length;
-                                const closes = (newContent.match(/\}/g) || []).length;
-                                if (opens !== closes) {
-                                    response.error = `CSS validation failed: unbalanced braces (${opens} opening vs ${closes} closing). Fix the CSS before appending.`;
-                                    break;
-                                }
-                            }
-                            // Snapshot before append
-                            const prevContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf-8') : null;
-                            undoStack.push({ filePath, prevContent, operation: 'APPEND_FILE', timestamp: Date.now(), relativePath: message.filePath });
-                            if (undoStack.length > 20)
-                                undoStack.shift();
-                            // --- CSS safety: hoist @import/@charset to file top ---
-                            if (isCssFile && prevContent !== null) {
-                                // Extract @import and @charset from the NEW content
-                                const importRegex = /^@(?:import|charset)\s+[^;]+;\s*$/gm;
-                                const newImports = [];
-                                const bodyContent = newContent.replace(importRegex, (match) => {
-                                    newImports.push(match.trim());
-                                    return '';
-                                }).trim();
-                                if (newImports.length > 0) {
-                                    // Find where existing imports end in the original file
-                                    const existingLines = prevContent.split('\n');
-                                    let lastImportLineIdx = -1;
-                                    for (let i = 0; i < existingLines.length; i++) {
-                                        const trimmed = existingLines[i].trim();
-                                        if (trimmed.startsWith('@import') || trimmed.startsWith('@charset')) {
-                                            lastImportLineIdx = i;
-                                        }
-                                        // Stop scanning after first non-import, non-comment, non-empty line
-                                        if (trimmed && !trimmed.startsWith('@import') && !trimmed.startsWith('@charset') && !trimmed.startsWith('/*') && !trimmed.startsWith('*') && !trimmed.startsWith('//')) {
-                                            break;
-                                        }
-                                    }
-                                    // Deduplicate: only add imports that don't already exist
-                                    const dedupedImports = newImports.filter(imp => !prevContent.includes(imp));
-                                    // Build new file: existing imports + new imports + rest of existing + new body
-                                    const insertIdx = lastImportLineIdx + 1;
-                                    const topLines = existingLines.slice(0, insertIdx);
-                                    const restLines = existingLines.slice(insertIdx);
-                                    const merged = [
-                                        ...topLines,
-                                        ...dedupedImports,
-                                        ...restLines,
-                                        '', // separator
-                                        bodyContent
-                                    ].join('\n');
-                                    fs.writeFileSync(filePath, merged, 'utf-8');
-                                    console.log(chalk.blue('ℹ') + ` CSS-safe append: hoisted ${dedupedImports.length} @import(s) to top of ${message.filePath}`);
-                                }
-                                else {
-                                    // No imports in new content — simple append
-                                    fs.appendFileSync(filePath, '\n\n' + newContent, 'utf-8');
-                                }
-                            }
-                            else {
-                                // Non-CSS file or new file — simple append
-                                fs.appendFileSync(filePath, '\n' + newContent, 'utf-8');
-                            }
-                            // Auto-format after append
-                            const formatter = await autoFormat(filePath, projectPath);
-                            response.data = { success: true, path: filePath, formatted: formatter, undoAvailable: true };
-                            console.log(chalk.blue('ℹ') + ` Appended file: ${message.filePath}` + (formatter ? chalk.dim(` (formatted with ${formatter})`) : '') + chalk.dim(' [undo saved]'));
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                // ========== AST-BASED EDITING ==========
-                case 'EDIT_CLASSNAME': {
-                    // ────────────────────────────────────────────────────────
-                    // AST-precise className replacement for JSX/TSX files.
-                    // Survives Prettier reformatting and finds the right element
-                    // even when fuzzy string matching would pick the wrong line.
-                    //
-                    // Required:  filePath, newValue
-                    // Optional:  oldValue (current className to replace)
-                    //            lineHint (from resolvedLine — strongly preferred)
-                    //            readToken (drift guard, same as EDIT_FILE)
-                    // ────────────────────────────────────────────────────────
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                            break;
-                        }
-                        if (!fs.existsSync(filePath)) {
-                            response.error = 'File not found: ' + message.filePath;
-                            break;
-                        }
-                        // Read-token drift guard (same as EDIT_FILE)
-                        if (message.readToken) {
-                            const stat = fs.statSync(filePath);
-                            const token = `${Math.round(stat.mtimeMs)}-${stat.size}`;
-                            if (token !== message.readToken) {
-                                response.error =
-                                    'File has changed since last read (readToken mismatch). ' +
-                                        'Re-read with read_project_file before editing.';
-                                break;
-                            }
-                        }
-                        const source = fs.readFileSync(filePath, 'utf-8');
-                        // Snapshot for undo
-                        undoStack.push({ filePath, prevContent: source, operation: 'EDIT_CLASSNAME', timestamp: Date.now(), relativePath: message.filePath });
-                        if (undoStack.length > 20)
-                            undoStack.shift();
-                        const result = editJSXClassName(source, {
-                            oldValue: message.oldValue,
-                            newValue: message.newValue,
-                            lineHint: message.lineHint,
-                        });
-                        if (!result.success) {
-                            undoStack.pop();
-                            response.error = result.error ?? 'AST edit failed';
-                            break;
-                        }
-                        await withFileLock(filePath, async () => {
-                            fs.writeFileSync(filePath, result.code, 'utf-8');
-                            const formatter = await autoFormat(filePath, projectPath);
-                            response.data = {
-                                success: true,
-                                path: filePath,
-                                strategy: result.strategy,
-                                matchedLine: result.matchedLine,
-                                formatted: formatter,
-                                undoAvailable: true,
-                            };
-                            console.log(chalk.blue('ℹ') +
-                                ` EDIT_CLASSNAME: ${message.filePath}` +
-                                chalk.dim(` [${result.strategy} @ line ${result.matchedLine}]`) +
-                                (formatter ? chalk.dim(` (${formatter})`) : '') +
-                                chalk.dim(' [undo saved]'));
-                        });
-                        // LSP type-check after write
-                        const lsp = await checkDiagnostics(filePath, projectPath);
-                        if (lsp.ran && response.data) {
-                            response.data.lspDiagnostics = lsp.diagnostics;
-                            if (lsp.summary)
-                                response.data.lspSummary = lsp.summary;
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
+  } catch (_) {
+  }
+  ws.on("message", async (data) => {
+    try {
+      const message = JSON.parse(data.toString());
+      const { id, type } = message;
+      let response = { id };
+      switch (type) {
+        case "GET_PROJECT_INFO":
+          response.data = projectInfo;
+          break;
+        case "READ_FILE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied";
+            } else if (fs4.existsSync(filePath)) {
+              const stat = fs4.statSync(filePath);
+              if (stat.size > 0) {
+                const fd = fs4.openSync(filePath, "r");
+                const sample = Buffer.alloc(Math.min(4096, stat.size));
+                fs4.readSync(fd, sample, 0, sample.length, 0);
+                fs4.closeSync(fd);
+                if (sample.includes(0)) {
+                  response.error = `Cannot read binary file: ${message.filePath}`;
+                  break;
                 }
-                case 'EDIT_FILE':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                        }
-                        else if (!fs.existsSync(filePath)) {
-                            // Find similarly-named files to help the LLM self-correct
-                            const requestedBase = path.basename(message.filePath);
-                            const requestedExt = path.extname(requestedBase);
-                            const requestedStem = requestedBase.replace(requestedExt, '');
-                            // Walk shallow project tree to find candidates
-                            const suggestions = [];
-                            const dirsToSearch = ['src/app', 'app', 'src/pages', 'pages', 'src/components', 'components', 'src'];
-                            for (const dir of dirsToSearch) {
-                                const absDir = path.join(projectPath, dir);
-                                if (fs.existsSync(absDir)) {
-                                    try {
-                                        const files = fs.readdirSync(absDir, { recursive: true });
-                                        for (const f of files.slice(0, 100)) {
-                                            const fBase = path.basename(f);
-                                            // Same stem, any extension (page.tsx → page.js, page.jsx)
-                                            if (fBase.startsWith(requestedStem + '.') ||
-                                                fBase === requestedBase) {
-                                                suggestions.push(path.join(dir, f).replace(/\\/g, '/'));
-                                            }
-                                        }
-                                    }
-                                    catch (e) { /* skip unreadable dirs */ }
-                                }
-                            }
-                            const hint = suggestions.length > 0
-                                ? ' Did you mean: ' + suggestions.slice(0, 3).join(' or ') + '?'
-                                : ' Double-check the path against detect_project() output (layoutFile, globalStyleFile) or projectTree.';
-                            response.error = 'File not found: "' + message.filePath + '".' + hint;
-                        }
-                        else {
-                            // ── READ TOKEN DRIFT GUARD ───────────────────────────────────
-                            // If the caller passed readToken from their last READ_FILE,
-                            // validate the file hasn't changed (mtime + size). Stale
-                            // content from a prior read is the #1 cause of silent data
-                            // corruption on multi-step agent edits.
-                            if (message.readToken) {
-                                const _eStat = fs.statSync(filePath);
-                                const _eToken = `${Math.round(_eStat.mtimeMs)}-${_eStat.size}`;
-                                if (_eToken !== message.readToken) {
-                                    response.error =
-                                        'File has changed since last read (readToken mismatch). ' +
-                                            'Re-read the file with read_project_file to get fresh content ' +
-                                            'and line numbers before editing. The file was NOT modified.';
-                                    break;
-                                }
-                            }
-                            // ──────────────────────────────────────────────────────────
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            // Snapshot before edit
-                            undoStack.push({ filePath, prevContent: content, operation: 'EDIT_FILE', timestamp: Date.now(), relativePath: message.filePath });
-                            if (undoStack.length > 20)
-                                undoStack.shift();
-                            // Use the 9-layer fuzzy replacer cascade (ported from OpenCode)
-                            const result = fuzzyReplace(content, message.target, message.replacement, message.replaceAll || false);
-                            if ('error' in result) {
-                                // Edit failed — remove the snapshot we just pushed
-                                undoStack.pop();
-                                response.error = result.error;
-                            }
-                            else {
-                                // ── LAYER 5: JSX content validation (full-file) ──
-                                // Check the RESULTING file for balance, not the replacement
-                                // alone. Agents routinely replace partial JSX blocks where
-                                // the surrounding file provides the closing brackets — checking
-                                // the replacement in isolation caused almost every write to
-                                // fail on first attempt even when the result was valid.
-                                const _jsExts = ['.js', '.jsx', '.tsx', '.ts'];
-                                if (_jsExts.some(ext => filePath.endsWith(ext))) {
-                                    const _resultContent = result.result;
-                                    const _strip = (s) => s
-                                        .replace(/`[^`]*`/g, '``')
-                                        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
-                                        .replace(/\'(?:[^\'\\]|\\.)*\'/g, "''");
-                                    // ── Baseline: measure original file's brace debt ──
-                                    // If the file was already imbalanced (e.g. JSX comment with {,
-                                    // regex literal, or prior agent edit), use that as the floor.
-                                    const _origStripped = _strip(content);
-                                    const _origDebt = (_origStripped.match(/\{/g) || []).length - (_origStripped.match(/\}/g) || []).length;
-                                    const _origPDebt = (_origStripped.match(/\(/g) || []).length - (_origStripped.match(/\)/g) || []).length;
-                                    const _stripped = _strip(_resultContent);
-                                    const _bo = (_stripped.match(/\{/g) || []).length;
-                                    const _bc = (_stripped.match(/\}/g) || []).length;
-                                    const _po = (_stripped.match(/\(/g) || []).length;
-                                    const _pc = (_stripped.match(/\)/g) || []).length;
-                                    const _newDebt = _bo - _bc;
-                                    const _newPDebt = _po - _pc;
-                                    // Only fail if the edit makes the imbalance WORSE than baseline
-                                    if (Math.abs(_newDebt) > Math.abs(_origDebt) || Math.abs(_newPDebt) > Math.abs(_origPDebt)) {
-                                        undoStack.pop();
-                                        response.error = `JSX validation failed: resulting file has unbalanced syntax ` +
-                                            `(braces: ${_bo} open / ${_bc} close, parens: ${_po} open / ${_pc} close). ` +
-                                            `The file was NOT modified. Re-read the file and fix the replacement so the overall file stays balanced.`;
-                                        break;
-                                    }
-                                }
-                                // ─────────────────────────────────────────────────
-                                await withFileLock(filePath, async () => {
-                                    fs.writeFileSync(filePath, result.result, 'utf-8');
-                                    // Auto-format after edit
-                                    const formatter = await autoFormat(filePath, projectPath);
-                                    response.data = {
-                                        success: true,
-                                        path: filePath,
-                                        strategy: result.strategy,
-                                        formatted: formatter,
-                                        undoAvailable: true,
-                                    };
-                                    const strategyLabel = result.strategy === 'exact' ? '' : chalk.dim(` [${result.strategy}]`);
-                                    const formatLabel = formatter ? chalk.dim(` (${formatter})`) : '';
-                                    console.log(chalk.blue('ℹ') + ` Edited file: ${message.filePath}${strategyLabel}${formatLabel}` + chalk.dim(' [undo saved]'));
-                                });
-                                // ── LSP: Post-edit TypeScript diagnostics ─────────────────────
-                                const _eLsp = await checkDiagnostics(filePath, projectPath);
-                                if (_eLsp.ran && response.data) {
-                                    response.data.lspDiagnostics = _eLsp.diagnostics;
-                                    if (_eLsp.summary) {
-                                        response.data.lspSummary = _eLsp.summary;
-                                        if (_eLsp.diagnostics.some(d => d.severity === 'error')) {
-                                            console.log(chalk.yellow('⚠') + ` ${_eLsp.summary}`);
-                                        }
-                                    }
-                                }
-                                // ──────────────────────────────────────────────────────────────
-                            }
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
+              }
+              const rawContent = fs4.readFileSync(filePath, "utf-8");
+              const allLines = rawContent.split("\n");
+              const offset = message.offset || 1;
+              const limit = message.limit || 2e3;
+              const startIdx = Math.max(0, offset - 1);
+              const endIdx = Math.min(allLines.length, startIdx + limit);
+              const sliced = allLines.slice(startIdx, endIdx);
+              const numbered = sliced.map((line, i) => `${startIdx + i + 1}: ${line}`).join("\n");
+              const truncated = endIdx < allLines.length;
+              const _rtStat = fs4.statSync(filePath);
+              const _readToken = `${Math.round(_rtStat.mtimeMs)}-${_rtStat.size}`;
+              response.data = {
+                content: numbered,
+                // rawContent intentionally omitted — agents use line-numbered
+                // content for edits; sending raw doubles context size per read.
+                exists: true,
+                path: message.filePath,
+                totalLines: allLines.length,
+                showing: { from: offset, to: endIdx, truncated },
+                readToken: _readToken
+              };
+            } else {
+              const dir = path4.dirname(filePath);
+              const base = path4.basename(filePath);
+              let suggestions = [];
+              try {
+                suggestions = fs4.readdirSync(dir).filter((e) => e.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(e.toLowerCase())).slice(0, 3).map((e) => path4.relative(projectPath, path4.join(dir, e)));
+              } catch (_) {
+              }
+              response.data = { exists: false, suggestions };
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "GET_SOURCE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied";
+            } else if (fs4.existsSync(filePath)) {
+              const content = fs4.readFileSync(filePath, "utf-8");
+              const lines = content.split("\n");
+              const start = Math.max(0, (message.lineStart || 1) - 1);
+              const end = message.lineEnd ? Math.min(lines.length, message.lineEnd) : lines.length;
+              response.data = {
+                lines: lines.slice(start, end),
+                startLine: start + 1,
+                endLine: end,
+                totalLines: lines.length
+              };
+            } else {
+              response.error = "File not found";
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "GET_ERROR_CONTEXT":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied";
+            } else if (fs4.existsSync(filePath)) {
+              const content = fs4.readFileSync(filePath, "utf-8");
+              const lines = content.split("\n");
+              const targetLine = message.line || 1;
+              const contextLines = message.contextLines || 5;
+              const start = Math.max(0, targetLine - contextLines - 1);
+              const end = Math.min(lines.length, targetLine + contextLines);
+              response.data = {
+                lines: lines.slice(start, end).map((line, i) => ({
+                  number: start + i + 1,
+                  content: line,
+                  isError: start + i + 1 === targetLine
+                })),
+                errorLine: targetLine,
+                filePath: message.filePath
+              };
+            } else {
+              response.error = "File not found";
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "GET_FILE_TREE":
+          try {
+            const depth = message.depth || 3;
+            const tree = getFileTree(projectPath, depth);
+            response.data = { tree };
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "SEARCH_CODE":
+          try {
+            const { matches, engine } = await searchCode(
+              projectPath,
+              message.query,
+              {
+                isRegex: message.isRegex || false,
+                caseSensitive: message.caseSensitive !== false,
+                maxResults: message.maxResults || 20
+              }
+            );
+            response.data = { matches, engine };
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "FIND_FILES":
+          try {
+            let findFiles2 = function(dir) {
+              if (found.length >= maxResults)
+                return;
+              try {
+                const items = fs4.readdirSync(dir);
+                for (const item of items) {
+                  if (found.length >= maxResults)
                     break;
-                case 'REPLACE_LINES':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                        }
-                        else if (!fs.existsSync(filePath)) {
-                            response.error = 'File not found: ' + message.filePath;
-                        }
-                        else {
-                            // ── READ TOKEN DRIFT GUARD ──────────────────────────────────
-                            // Stale line numbers are the primary failure mode of
-                            // REPLACE_LINES. readToken proves the file is exactly
-                            // the version the agent read before computing its range.
-                            if (message.readToken) {
-                                const _rStat = fs.statSync(filePath);
-                                const _rToken = `${Math.round(_rStat.mtimeMs)}-${_rStat.size}`;
-                                if (_rToken !== message.readToken) {
-                                    response.error =
-                                        'File has changed since last read (readToken mismatch). ' +
-                                            'Re-read the file with read_project_file to get fresh line numbers ' +
-                                            'before replacing. The file was NOT modified.';
-                                    break;
-                                }
-                            }
-                            // ────────────────────────────────────────────────────────────
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            const lines = content.split('\n');
-                            const startLine = Math.max(1, message.startLine || 1);
-                            const endLine = Math.min(lines.length, message.endLine || startLine);
-                            if (startLine > lines.length) {
-                                response.error = `Start line ${startLine} is beyond file end (${lines.length} lines)`;
-                            }
-                            else if (startLine > endLine) {
-                                response.error = `Invalid range: start (${startLine}) > end (${endLine})`;
-                            }
-                            else {
-                                // Snapshot for undo
-                                undoStack.push({
-                                    filePath,
-                                    prevContent: content,
-                                    operation: 'REPLACE_LINES',
-                                    timestamp: Date.now(),
-                                    relativePath: message.filePath
-                                });
-                                if (undoStack.length > 20)
-                                    undoStack.shift();
-                                const oldLineCount = endLine - startLine + 1;
-                                const newLines = (message.newContent || '').split('\n');
-                                // ── LAYER 5: JSX content validation (full-file + range hint) ──
-                                // Validates the RESULTING file. If unbalanced because the
-                                // deleted range has unclosed syntax, scans forward to find
-                                // the precise suggested end_line — agent fixes in ONE retry.
-                                const _jsExts2 = ['.js', '.jsx', '.tsx', '.ts'];
-                                if (_jsExts2.some(ext => filePath.endsWith(ext))) {
-                                    const _strip = (s) => s
-                                        .replace(/`[^`]*`/g, '``')
-                                        .replace(/"(?:[^"\\]|\\.)*"/g, '""')
-                                        .replace(/\'(?:[^\'\\]|\\.)*\'/g, "''");
-                                    // ── Baseline: measure original file's brace debt ──
-                                    const _origStripped2 = _strip(content);
-                                    const _origDebt2 = (_origStripped2.match(/\{/g) || []).length - (_origStripped2.match(/\}/g) || []).length;
-                                    const _origPDebt2 = (_origStripped2.match(/\(/g) || []).length - (_origStripped2.match(/\)/g) || []).length;
-                                    const _previewLines = [...lines];
-                                    const _previewNew = (message.newContent || '').split('\n');
-                                    _previewLines.splice(startLine - 1, endLine - startLine + 1, ..._previewNew);
-                                    const _stripped = _strip(_previewLines.join('\n'));
-                                    const _bo = (_stripped.match(/\{/g) || []).length;
-                                    const _bc = (_stripped.match(/\}/g) || []).length;
-                                    const _po = (_stripped.match(/\(/g) || []).length;
-                                    const _pc = (_stripped.match(/\)/g) || []).length;
-                                    const _newDebt2 = _bo - _bc;
-                                    const _newPDebt2 = _po - _pc;
-                                    // Only fail if the edit makes the imbalance WORSE than baseline
-                                    if (Math.abs(_newDebt2) > Math.abs(_origDebt2) || Math.abs(_newPDebt2) > Math.abs(_origPDebt2)) {
-                                        undoStack.pop();
-                                        // Determine if deleted lines are the source of imbalance
-                                        const _deletedBlock = lines.slice(startLine - 1, endLine).join('\n');
-                                        const _ds = _strip(_deletedBlock);
-                                        const _braceDebt = (_ds.match(/\{/g) || []).length - (_ds.match(/\}/g) || []).length;
-                                        const _parenDebt = (_ds.match(/\(/g) || []).length - (_ds.match(/\)/g) || []).length;
-                                        let _hint = '';
-                                        if (_braceDebt > 0 || _parenDebt > 0) {
-                                            // Scan forward line-by-line to find where the debt is repaid
-                                            let _bd = _braceDebt;
-                                            let _pd = _parenDebt;
-                                            let _sugEnd = endLine;
-                                            const _tail = lines.slice(endLine);
-                                            for (let _i = 0; _i < _tail.length; _i++) {
-                                                const _ls = _strip(_tail[_i]);
-                                                _bd -= (_ls.match(/\}/g) || []).length - (_ls.match(/\{/g) || []).length;
-                                                _pd -= (_ls.match(/\)/g) || []).length - (_ls.match(/\(/g) || []).length;
-                                                _sugEnd = endLine + _i + 1;
-                                                if (_bd <= 0 && _pd <= 0)
-                                                    break;
-                                            }
-                                            _hint = ` The range ${startLine}-${endLine} has unclosed syntax.` +
-                                                ` Expand end_line to ~${_sugEnd} to include the closing syntax, then retry.`;
-                                        }
-                                        else {
-                                            _hint = ' Re-read the file and ensure the replacement keeps all JSX balanced.';
-                                        }
-                                        response.error = `JSX validation failed: resulting file has unbalanced syntax ` +
-                                            `(braces: ${_bo} open / ${_bc} close, parens: ${_po} open / ${_pc} close). ` +
-                                            `The file was NOT modified.${_hint}`;
-                                        break;
-                                    }
-                                }
-                                // ──────────────────────────────────────────────────────────────
-                                // splice + write inside lock
-                                await withFileLock(filePath, async () => {
-                                    lines.splice(startLine - 1, oldLineCount, ...newLines);
-                                    const newContent = lines.join('\n');
-                                    fs.writeFileSync(filePath, newContent, 'utf-8');
-                                    // Auto-format
-                                    const formatter = await autoFormat(filePath, projectPath);
-                                    const lineDelta = newLines.length - oldLineCount;
-                                    response.data = {
-                                        success: true,
-                                        path: filePath,
-                                        linesReplaced: `${startLine}-${endLine}`,
-                                        oldLineCount,
-                                        newLineCount: newLines.length,
-                                        lineDelta: lineDelta,
-                                        totalLines: lines.length,
-                                        formatted: formatter,
-                                        undoAvailable: true,
-                                        hint: lineDelta !== 0
-                                            ? `Line count changed by ${lineDelta > 0 ? '+' : ''}${lineDelta}. Adjust subsequent line numbers if making more edits.`
-                                            : null
-                                    };
-                                    const formatLabel = formatter ? chalk.dim(` (${formatter})`) : '';
-                                    console.log(chalk.blue('ℹ') + ` Replaced lines ${startLine}-${endLine} in ${message.filePath} (${oldLineCount}→${newLines.length} lines)${formatLabel}` + chalk.dim(' [undo saved]'));
-                                });
-                                // ── LSP: Post-replace TypeScript diagnostics ──────────────────
-                                const _rLsp = await checkDiagnostics(filePath, projectPath);
-                                if (_rLsp.ran && response.data) {
-                                    response.data.lspDiagnostics = _rLsp.diagnostics;
-                                    if (_rLsp.summary) {
-                                        response.data.lspSummary = _rLsp.summary;
-                                        if (_rLsp.diagnostics.some(d => d.severity === 'error')) {
-                                            console.log(chalk.yellow('⚠') + ` ${_rLsp.summary}`);
-                                        }
-                                    }
-                                }
-                                // ──────────────────────────────────────────────────────────────
-                            }
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
+                  if (ignorePatterns.includes(item) || item.startsWith("."))
+                    continue;
+                  const fullPath = path4.join(dir, item);
+                  try {
+                    const stat = fs4.statSync(fullPath);
+                    if (stat.isDirectory()) {
+                      findFiles2(fullPath);
+                    } else {
+                      const matchByName = !fileName || item === fileName || pattern.includes("*") && item.endsWith(fileName);
+                      if (matchByName) {
+                        found.push(path4.relative(projectPath, fullPath));
+                      }
                     }
-                    break;
-                case 'UNDO_LAST':
-                    try {
-                        if (undoStack.length === 0) {
-                            response.error = 'Nothing to undo — no file changes recorded in this session.';
-                        }
-                        else {
-                            const snapshot = undoStack.pop();
-                            if (snapshot.prevContent === null) {
-                                // File was created from scratch — delete it
-                                if (fs.existsSync(snapshot.filePath)) {
-                                    fs.unlinkSync(snapshot.filePath);
-                                    response.data = {
-                                        success: true,
-                                        undone: snapshot.operation,
-                                        file: snapshot.relativePath,
-                                        action: 'deleted (was new file)',
-                                        remaining: undoStack.length,
-                                    };
-                                    console.log(chalk.yellow('↩') + ` Undo: deleted ${snapshot.relativePath} (was a new file)`);
-                                }
-                                else {
-                                    response.data = {
-                                        success: true,
-                                        undone: snapshot.operation,
-                                        file: snapshot.relativePath,
-                                        action: 'already gone',
-                                        remaining: undoStack.length,
-                                    };
-                                }
-                            }
-                            else {
-                                // Restore previous content
-                                fs.writeFileSync(snapshot.filePath, snapshot.prevContent, 'utf-8');
-                                response.data = {
-                                    success: true,
-                                    undone: snapshot.operation,
-                                    file: snapshot.relativePath,
-                                    action: 'restored',
-                                    remaining: undoStack.length,
-                                };
-                                console.log(chalk.yellow('↩') + ` Undo: restored ${snapshot.relativePath} (reverted ${snapshot.operation})`);
-                            }
-                        }
+                  } catch (e) {
+                  }
+                }
+              } catch (e) {
+              }
+            };
+            var findFiles = findFiles2;
+            const pattern = message.pattern || "";
+            const fileName = pattern.split("/").pop().replace(/\*\*/g, "").replace(/\*/g, "");
+            const maxResults = message.maxResults || 20;
+            const ignorePatterns = ["node_modules", ".git", "dist", "build", ".next", ".cache"];
+            const found = [];
+            findFiles2(projectPath);
+            response.data = found;
+          } catch (e) {
+            response.error = e.message;
+          }
+        case "DETECT_PROJECT":
+          try {
+            const pkgPath = path4.join(projectPath, "package.json");
+            let deps = {};
+            let devDeps = {};
+            let pkgName = "";
+            if (fs4.existsSync(pkgPath)) {
+              const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+              deps = pkg.dependencies || {};
+              devDeps = pkg.devDependencies || {};
+              pkgName = pkg.name || "";
+            }
+            const allDeps = { ...deps, ...devDeps };
+            let framework = "html";
+            if (allDeps["next"])
+              framework = "next.js";
+            else if (allDeps["nuxt"] || allDeps["nuxt3"])
+              framework = "nuxt";
+            else if (allDeps["gatsby"])
+              framework = "gatsby";
+            else if (allDeps["@remix-run/react"])
+              framework = "remix";
+            else if (allDeps["svelte"] || allDeps["@sveltejs/kit"])
+              framework = "svelte";
+            else if (allDeps["vue"])
+              framework = "vue";
+            else if (allDeps["@angular/core"])
+              framework = "angular";
+            else if (allDeps["react"])
+              framework = "react";
+            const typescript = !!allDeps["typescript"] || fs4.existsSync(path4.join(projectPath, "tsconfig.json"));
+            const ext = typescript ? ".tsx" : ".jsx";
+            let styling = "plain-css";
+            if (allDeps["tailwindcss"])
+              styling = "tailwind";
+            else if (allDeps["styled-components"])
+              styling = "styled-components";
+            else if (allDeps["@emotion/react"] || allDeps["@emotion/styled"])
+              styling = "emotion";
+            else if (allDeps["sass"] || allDeps["node-sass"])
+              styling = "sass";
+            let router = null;
+            if (framework === "next.js") {
+              if (fs4.existsSync(path4.join(projectPath, "src/app")) || fs4.existsSync(path4.join(projectPath, "app"))) {
+                router = "app";
+              } else if (fs4.existsSync(path4.join(projectPath, "src/pages")) || fs4.existsSync(path4.join(projectPath, "pages"))) {
+                router = "pages";
+              }
+            }
+            const findFirst = (candidates) => {
+              for (const c of candidates) {
+                if (fs4.existsSync(path4.join(projectPath, c)))
+                  return c;
+              }
+              return null;
+            };
+            const layoutFile = findFirst([
+              "src/app/layout.tsx",
+              "src/app/layout.jsx",
+              "src/app/layout.js",
+              "app/layout.tsx",
+              "app/layout.jsx",
+              "app/layout.js",
+              "src/pages/_app.tsx",
+              "src/pages/_app.jsx",
+              "pages/_app.tsx",
+              "pages/_app.jsx",
+              "src/App.tsx",
+              "src/App.jsx",
+              "src/App.js",
+              "src/main.tsx",
+              "src/main.jsx",
+              "src/main.js",
+              "index.html"
+            ]);
+            const globalStyleFile = findFirst([
+              "src/app/globals.css",
+              "src/app/global.css",
+              "app/globals.css",
+              "app/global.css",
+              "src/index.css",
+              "src/styles/globals.css",
+              "src/styles/global.css",
+              "src/App.css",
+              "src/styles.css",
+              "styles/globals.css",
+              "styles/global.css",
+              "css/style.css",
+              "css/main.css",
+              "style.css",
+              "styles.css"
+            ]);
+            let componentsDir = findFirst([
+              "src/components",
+              "src/app/components",
+              "components",
+              "src/ui",
+              "src/app/ui"
+            ]);
+            let tailwindConfig = null;
+            let tailwindVersion = null;
+            if (styling === "tailwind") {
+              tailwindConfig = findFirst([
+                "tailwind.config.ts",
+                "tailwind.config.js",
+                "tailwind.config.mjs",
+                "tailwind.config.cjs"
+              ]);
+              tailwindVersion = allDeps["tailwindcss"] || null;
+            }
+            let componentPattern = "arrow-function";
+            let exportPattern = "default";
+            let sampleComponentFile = null;
+            let sampleComponentCode = null;
+            if (componentsDir) {
+              const compDir = path4.join(projectPath, componentsDir);
+              try {
+                const files = fs4.readdirSync(compDir).filter(
+                  (f) => f.endsWith(".tsx") || f.endsWith(".jsx") || f.endsWith(".js") || f.endsWith(".vue") || f.endsWith(".svelte")
+                );
+                if (files.length > 0) {
+                  sampleComponentFile = path4.join(componentsDir, files[0]);
+                  const code = fs4.readFileSync(path4.join(compDir, files[0]), "utf-8");
+                  sampleComponentCode = code.split("\n").slice(0, 80).join("\n");
+                  if (/^export default function /m.test(code)) {
+                    componentPattern = "function-declaration";
+                    exportPattern = "default";
+                  } else if (/^export function /m.test(code)) {
+                    componentPattern = "function-declaration";
+                    exportPattern = "named";
+                  } else if (/const \w+ = \(/.test(code) || /const \w+ = \(\) =>/.test(code)) {
+                    componentPattern = "arrow-function";
+                  }
+                  if (/^export default /m.test(code))
+                    exportPattern = "default";
+                  else if (/^export \{/m.test(code) || /^export const/m.test(code))
+                    exportPattern = "named";
+                  if (/import\s+\w+\s+from\s+['"][^'"]+\.module\.(css|scss|sass)['"]/.test(code)) {
+                    styling = "css-modules";
+                  }
+                }
+              } catch (e) {
+              }
+            }
+            if (styling === "plain-css" && layoutFile) {
+              try {
+                const layoutCode = fs4.readFileSync(path4.join(projectPath, layoutFile), "utf-8");
+                if (/import\s+\w+\s+from\s+['"][^'"]+\.module\.(css|scss|sass)['"]/.test(layoutCode)) {
+                  styling = "css-modules";
+                }
+              } catch (e) {
+              }
+            }
+            let globalStylePreview = null;
+            if (globalStyleFile) {
+              try {
+                const css = fs4.readFileSync(path4.join(projectPath, globalStyleFile), "utf-8");
+                globalStylePreview = css.split("\n").slice(0, 40).join("\n");
+              } catch (e) {
+              }
+            }
+            const SKIP_DIRS = /* @__PURE__ */ new Set([
+              "node_modules",
+              ".git",
+              ".next",
+              ".nuxt",
+              ".svelte-kit",
+              "dist",
+              "build",
+              ".cache",
+              ".turbo",
+              "coverage",
+              "__pycache__",
+              ".vercel",
+              ".output",
+              ".parcel-cache"
+            ]);
+            const UI_EXTENSIONS = /* @__PURE__ */ new Set([
+              ".tsx",
+              ".jsx",
+              ".js",
+              ".ts",
+              ".vue",
+              ".svelte",
+              ".css",
+              ".scss",
+              ".sass",
+              ".less",
+              ".module.css",
+              ".module.scss",
+              ".html",
+              ".astro"
+            ]);
+            const treeLines = [];
+            const MAX_TREE_LINES = 120;
+            const dirComponentCount = /* @__PURE__ */ new Map();
+            const buildTree = (dir, prefix, depth) => {
+              if (depth > 4 || treeLines.length >= MAX_TREE_LINES)
+                return;
+              try {
+                const entries = fs4.readdirSync(path4.join(projectPath, dir), { withFileTypes: true });
+                const sorted = entries.filter((e) => !e.name.startsWith(".") || e.name === ".env").sort((a, b) => {
+                  if (a.isDirectory() && !b.isDirectory())
+                    return -1;
+                  if (!a.isDirectory() && b.isDirectory())
+                    return 1;
+                  return a.name.localeCompare(b.name);
+                });
+                for (let i = 0; i < sorted.length && treeLines.length < MAX_TREE_LINES; i++) {
+                  const entry = sorted[i];
+                  const isLast = i === sorted.length - 1;
+                  const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+                  const childPrefix = isLast ? "    " : "\u2502   ";
+                  const childPath = dir ? `${dir}/${entry.name}` : entry.name;
+                  if (entry.isDirectory()) {
+                    if (SKIP_DIRS.has(entry.name))
+                      continue;
+                    treeLines.push(`${prefix}${connector}${entry.name}/`);
+                    buildTree(childPath, prefix + childPrefix, depth + 1);
+                  } else {
+                    const ext2 = path4.extname(entry.name).toLowerCase();
+                    const COMPONENT_EXTS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".vue", ".svelte"]);
+                    if (COMPONENT_EXTS.has(ext2) && /^[A-Z]/.test(entry.name)) {
+                      dirComponentCount.set(dir, (dirComponentCount.get(dir) ?? 0) + 1);
                     }
-                    catch (e) {
-                        response.error = e.message;
+                    if (UI_EXTENSIONS.has(ext2) || depth <= 1 && (entry.name === "package.json" || entry.name === "tsconfig.json" || entry.name.startsWith("tailwind.config") || entry.name.startsWith("next.config") || entry.name.startsWith("vite.config"))) {
+                      treeLines.push(`${prefix}${connector}${entry.name}`);
                     }
-                    break;
-                case 'DELETE_FILE':
+                  }
+                }
+              } catch (e) {
+              }
+            };
+            const scanRoots = ["src", "app", "pages", "components", "styles", "public", "lib", "utils"];
+            const existingRoots = [];
+            for (const root of scanRoots) {
+              if (fs4.existsSync(path4.join(projectPath, root))) {
+                existingRoots.push(root);
+              }
+            }
+            try {
+              const rootEntries = fs4.readdirSync(projectPath, { withFileTypes: true });
+              for (const entry of rootEntries) {
+                if (!entry.isDirectory() && (entry.name === "package.json" || entry.name === "tsconfig.json" || entry.name.startsWith("tailwind.config") || entry.name.startsWith("next.config") || entry.name.startsWith("vite.config") || entry.name === "index.html")) {
+                  treeLines.push(entry.name);
+                }
+              }
+            } catch (e) {
+            }
+            for (const root of existingRoots) {
+              treeLines.push(`${root}/`);
+              buildTree(root, "", 1);
+            }
+            const projectTree = treeLines.length > 0 ? treeLines.join("\n") : null;
+            if (dirComponentCount.size > 0) {
+              let bestDir = "";
+              let bestCount = 0;
+              for (const [dir, count] of dirComponentCount.entries()) {
+                if (count > bestCount) {
+                  bestCount = count;
+                  bestDir = dir;
+                }
+              }
+              if (bestCount > 0)
+                componentsDir = bestDir;
+            }
+            response.data = {
+              framework,
+              typescript,
+              styling,
+              router,
+              ext,
+              pkgName,
+              // Key file locations
+              layoutFile,
+              globalStyleFile,
+              componentsDir,
+              tailwindConfig,
+              tailwindVersion,
+              // Code conventions
+              componentPattern,
+              exportPattern,
+              sampleComponentFile,
+              sampleComponentCode,
+              // CSS context
+              globalStylePreview,
+              // Scaffolding tree
+              projectTree
+            };
+            console.log(chalk.blue("\u2139") + ` Project detected: ${chalk.yellow(framework)} + ${chalk.cyan(styling)}${typescript ? chalk.dim(" (TS)") : ""}${router ? chalk.dim(` [${router} router]`) : ""}`);
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "BUILD_CLASS_INDEX":
+          try {
+            const COMPONENT_EXTS_IDX = /* @__PURE__ */ new Set([".tsx", ".jsx", ".vue", ".svelte", ".js", ".ts"]);
+            const SKIP_DIRS_IDX = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", ".nuxt", "dist", "build", ".cache"]);
+            const index = {};
+            let filesScanned = 0;
+            let classesIndexed = 0;
+            const scanDir = (dir) => {
+              try {
+                const entries = fs4.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                  if (entry.name.startsWith("."))
+                    continue;
+                  const fullPath = path4.join(dir, entry.name);
+                  const relPath = path4.relative(projectPath, fullPath).replace(/\\/g, "/");
+                  if (entry.isDirectory()) {
+                    if (SKIP_DIRS_IDX.has(entry.name))
+                      continue;
+                    scanDir(fullPath);
+                  } else {
+                    const ext = path4.extname(entry.name).toLowerCase();
+                    if (!COMPONENT_EXTS_IDX.has(ext))
+                      continue;
                     try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (!filePath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                            break;
-                        }
-                        if (!fs.existsSync(filePath)) {
-                            response.error = 'File not found: ' + message.filePath;
-                            break;
-                        }
-                        // ── PROTECTED FILES BLOCKLIST ───────────────────────────
-                        // These files are structurally critical to the project.
-                        // The agent is NEVER allowed to delete them, even if asked.
-                        const relPath = message.filePath.replace(/\\/g, '/');
-                        const baseName = path.basename(relPath);
-                        const PROTECTED_PATTERNS = [
-                            // Package & lock files
-                            'package.json', 'package-lock.json', 'yarn.lock',
-                            'pnpm-lock.yaml', 'bun.lockb', 'bun.lock',
-                            // TypeScript / JS config
-                            'tsconfig.json', 'tsconfig.node.json', 'jsconfig.json',
-                            // Framework configs
-                            /^next\.config\./, /^vite\.config\./,
-                            /^nuxt\.config\./, /^svelte\.config\./,
-                            /^remix\.config\./, /^astro\.config\./,
-                            /^webpack\.config\./, /^babel\.config\./,
-                            /^tailwind\.config\./, /^postcss\.config\./,
-                            /^prettier\.config\./, /^eslint\.config\./,
-                            '.eslintrc', '.prettierrc', '.babelrc',
-                            // Env files
-                            '.env', '.env.local', '.env.production',
-                            '.env.development', '.env.staging',
-                            // Next.js/React layout & entry roots
-                            /^layout\.(tsx|jsx|js|ts)$/,
-                            /^_app\.(tsx|jsx|js|ts)$/,
-                            /^_document\.(tsx|jsx|js|ts)$/,
-                            /^App\.(tsx|jsx|js|ts)$/,
-                            /^main\.(tsx|jsx|js|ts)$/,
-                            // Dockerfile & CI
-                            'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
-                            '.gitignore', '.gitattributes',
-                        ];
-                        const isProtected = PROTECTED_PATTERNS.some(p => typeof p === 'string' ? baseName === p || relPath.endsWith('/' + p)
-                            : p.test(baseName));
-                        if (isProtected) {
-                            response.error = `🛡 Protected file: "${message.filePath}" cannot be deleted by the agent. This file is structurally critical to the project. To resolve conflicts involving this file, edit its contents instead of deleting it.`;
-                            break;
-                        }
-                        // ────────────────────────────────────────────────────────
-                        // ── SOFT DELETE → .trace-trash/ ────────────────────────
-                        // Instead of hard-deleting, move the file to .trace-trash/
-                        // with a timestamp prefix. This survives CLI restarts and
-                        // undo-stack evictions — the file is always recoverable
-                        // from the filesystem even after the session ends.
-                        const trashDir = path.join(projectPath, '.trace-trash');
-                        if (!fs.existsSync(trashDir)) {
-                            fs.mkdirSync(trashDir, { recursive: true });
-                            // Add to .gitignore if not already there
-                            const gitignorePath = path.join(projectPath, '.gitignore');
-                            if (fs.existsSync(gitignorePath)) {
-                                const gi = fs.readFileSync(gitignorePath, 'utf-8');
-                                if (!gi.includes('.trace-trash')) {
-                                    fs.appendFileSync(gitignorePath, '\n# Trace soft-delete recovery folder\n.trace-trash/\n');
-                                }
+                      const content = fs4.readFileSync(fullPath, "utf-8");
+                      const lines = content.split("\n");
+                      filesScanned++;
+                      for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        const classMatches = line.matchAll(
+                          /(?:className|class)\s*=\s*(?:"([^"]+)"|'([^']+)'|\{(?:`([^`]+)`|"([^"]+)"|'([^']+)')\})/g
+                        );
+                        for (const match of classMatches) {
+                          const classValue = match[1] || match[2] || match[3] || match[4] || match[5];
+                          if (!classValue)
+                            continue;
+                          const classes = classValue.split(/\s+/).filter(
+                            (c) => c.length > 2 && !c.startsWith("$") && !c.includes("{") && !c.includes("}")
+                          );
+                          if (classes.length === 0)
+                            continue;
+                          const sig = classes.slice(0, 3).sort().join(" ");
+                          if (sig && !index[sig]) {
+                            index[sig] = { file: relPath, line: i + 1 };
+                            classesIndexed++;
+                          }
+                          for (const cls of classes) {
+                            if (/^(flex|grid|block|hidden|relative|absolute|fixed|sticky|inline|w-|h-|p-|m-|text-|bg-|border|rounded|flex-|grid-|col-|row-)/.test(cls))
+                              continue;
+                            if (cls.length > 5 && !index[cls]) {
+                              index[cls] = { file: relPath, line: i + 1 };
+                              classesIndexed++;
                             }
+                          }
                         }
-                        const timestamp = Date.now();
-                        const trashName = `${timestamp}_${baseName}`;
-                        const trashPath = path.join(trashDir, trashName);
-                        // Snapshot for in-session UNDO_LAST restore
-                        const prevContent = fs.readFileSync(filePath, 'utf-8');
-                        undoStack.push({ filePath, prevContent, operation: 'DELETE_FILE', timestamp, relativePath: message.filePath });
-                        if (undoStack.length > 20)
-                            undoStack.shift();
-                        // Move to trash (not hard-delete)
-                        fs.renameSync(filePath, trashPath);
-                        // ────────────────────────────────────────────────────────
-                        response.data = {
-                            success: true,
-                            deleted: message.filePath,
-                            recoveryPath: path.relative(projectPath, trashPath),
-                            undoAvailable: true,
-                            hint: 'File moved to .trace-trash/ — recoverable even after CLI restart. Call UNDO_LAST to restore to original path.'
-                        };
-                        console.log(chalk.yellow('🗑') + ` Soft-deleted: ${message.filePath} → .trace-trash/${trashName}` + chalk.dim(' [recoverable]'));
-                    }
-                    catch (e) {
-                        response.error = e.message;
-                    }
-                    break;
-                case 'RENAME_FILE':
-                    try {
-                        const oldPath = path.resolve(projectPath, message.oldPath);
-                        const newPath = path.resolve(projectPath, message.newPath);
-                        if (!oldPath.startsWith(projectPath) || !newPath.startsWith(projectPath)) {
-                            response.error = 'Access denied: Path outside project';
-                        }
-                        else if (!fs.existsSync(oldPath)) {
-                            response.error = 'File not found: ' + message.oldPath;
-                        }
-                        else if (fs.existsSync(newPath)) {
-                            response.error = 'Target already exists: ' + message.newPath + '. Delete it first or choose a different name.';
-                        }
-                        else {
-                            // Snapshot the content at the old path so UNDO_LAST can restore it
-                            const prevContent = fs.readFileSync(oldPath, 'utf-8');
-                            undoStack.push({ filePath: oldPath, prevContent, operation: 'RENAME_FILE', timestamp: Date.now(), relativePath: message.oldPath });
-                            if (undoStack.length > 20)
-                                undoStack.shift();
-                            // Ensure destination directory exists
-                            const destDir = path.dirname(newPath);
-                            if (!fs.existsSync(destDir))
-                                fs.mkdirSync(destDir, { recursive: true });
-                            fs.renameSync(oldPath, newPath);
-                            response.data = {
-                                success: true,
-                                oldPath: message.oldPath,
-                                newPath: message.newPath,
-                                undoAvailable: true,
-                            };
-                            console.log(chalk.blue('ℹ') + ` Renamed: ${message.oldPath} → ${message.newPath}` + chalk.dim(' [undo saved]'));
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
+                      }
+                    } catch (e) {
                     }
-                    break;
-                // ========== GIT & ENVIRONMENT TOOLS ==========
-                case 'GIT_BLAME':
-                    try {
-                        const filePath = message.filePath;
-                        const line = message.line;
-                        const { stdout } = await execAsync(`git blame -L ${line},${line} --porcelain "${filePath}"`, { cwd: projectPath });
-                        const lines = stdout.split('\n');
-                        const commitHash = lines[0].split(' ')[0];
-                        const author = lines.find((l) => l.startsWith('author '))?.substring(7);
-                        const email = lines.find((l) => l.startsWith('author-mail '))?.substring(12);
-                        const date = lines.find((l) => l.startsWith('author-time '))?.substring(12);
-                        const summary = lines.find((l) => l.startsWith('summary '))?.substring(8);
-                        response.data = {
-                            commit: commitHash,
-                            author,
-                            email,
-                            date: new Date(parseInt(date) * 1000).toISOString().split('T')[0],
-                            message: summary
-                        };
-                    }
-                    catch (e) {
-                        response.error = `Git blame failed: ${e.message}`;
-                    }
-                    break;
-                case 'GIT_RECENT_CHANGES':
-                    try {
-                        const filePath = message.filePath;
-                        const days = message.days || 7;
-                        const { stdout } = await execAsync(`git log -n 10 --since="${days} days ago" --pretty=format:"%h|%an|%ad|%s" --date=short "${filePath}"`, { cwd: projectPath });
-                        response.data = {
-                            history: stdout.split('\n').filter(Boolean).map((line) => {
-                                const [hash, author, date, message] = line.split('|');
-                                return { hash, author, date, message };
-                            })
-                        };
-                    }
-                    catch (e) {
-                        response.error = `Git log failed: ${e.message}`;
+                  }
+                }
+              } catch (e) {
+              }
+            };
+            scanDir(projectPath);
+            response.data = {
+              index,
+              filesScanned,
+              classesIndexed
+            };
+            console.log(chalk.blue("\u2139") + ` Class index built: ${chalk.yellow(classesIndexed)} classes across ${chalk.cyan(filesScanned)} files`);
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "WRITE_FILE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+            } else {
+              const prevContent = fs4.existsSync(filePath) ? fs4.readFileSync(filePath, "utf-8") : null;
+              undoStack.push({ filePath, prevContent, operation: "WRITE_FILE", timestamp: Date.now(), relativePath: message.filePath });
+              if (undoStack.length > 20)
+                undoStack.shift();
+              if (filePath.endsWith(".css")) {
+                const writeContent = message.content || "";
+                const opens = (writeContent.match(/\{/g) || []).length;
+                const closes = (writeContent.match(/\}/g) || []).length;
+                if (opens !== closes) {
+                  undoStack.pop();
+                  response.error = `CSS validation failed: unbalanced braces (${opens} opening vs ${closes} closing). Fix the CSS before writing.`;
+                  break;
+                }
+              }
+              const dirPath = path4.dirname(filePath);
+              if (!fs4.existsSync(dirPath)) {
+                fs4.mkdirSync(dirPath, { recursive: true });
+              }
+              await withFileLock(filePath, async () => {
+                fs4.writeFileSync(filePath, message.content, "utf-8");
+                const formatter = await autoFormat(filePath, projectPath);
+                response.data = { success: true, path: filePath, formatted: formatter, undoAvailable: true };
+                console.log(chalk.blue("\u2139") + ` Wrote file: ${message.filePath}` + (formatter ? chalk.dim(` (formatted with ${formatter})`) : "") + chalk.dim(" [undo saved]"));
+              });
+              const _wLsp = await checkDiagnostics(filePath, projectPath);
+              if (_wLsp.ran && response.data) {
+                response.data.lspDiagnostics = _wLsp.diagnostics;
+                if (_wLsp.summary) {
+                  response.data.lspSummary = _wLsp.summary;
+                  if (_wLsp.diagnostics.some((d) => d.severity === "error")) {
+                    console.log(chalk.yellow("\u26A0") + ` ${_wLsp.summary}`);
+                  }
+                }
+              }
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "APPEND_FILE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+            } else {
+              const isCssFile = filePath.endsWith(".css");
+              const newContent = message.content || "";
+              if (isCssFile) {
+                const opens = (newContent.match(/\{/g) || []).length;
+                const closes = (newContent.match(/\}/g) || []).length;
+                if (opens !== closes) {
+                  response.error = `CSS validation failed: unbalanced braces (${opens} opening vs ${closes} closing). Fix the CSS before appending.`;
+                  break;
+                }
+              }
+              const prevContent = fs4.existsSync(filePath) ? fs4.readFileSync(filePath, "utf-8") : null;
+              undoStack.push({ filePath, prevContent, operation: "APPEND_FILE", timestamp: Date.now(), relativePath: message.filePath });
+              if (undoStack.length > 20)
+                undoStack.shift();
+              if (isCssFile && prevContent !== null) {
+                const importRegex = /^@(?:import|charset)\s+[^;]+;\s*$/gm;
+                const newImports = [];
+                const bodyContent = newContent.replace(importRegex, (match) => {
+                  newImports.push(match.trim());
+                  return "";
+                }).trim();
+                if (newImports.length > 0) {
+                  const existingLines = prevContent.split("\n");
+                  let lastImportLineIdx = -1;
+                  for (let i = 0; i < existingLines.length; i++) {
+                    const trimmed = existingLines[i].trim();
+                    if (trimmed.startsWith("@import") || trimmed.startsWith("@charset")) {
+                      lastImportLineIdx = i;
                     }
-                    break;
-                case 'GET_IMPORTS':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (fs.existsSync(filePath)) {
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            const importRegex = /import\s+(?:[\w*\s{},]*)\s+from\s+['"]([^'"]+)['"]/g;
-                            const imports = [];
-                            let match;
-                            while ((match = importRegex.exec(content)) !== null) {
-                                imports.push(match[1]);
-                            }
-                            response.data = { imports };
-                        }
-                        else {
-                            response.error = 'File not found';
-                        }
+                    if (trimmed && !trimmed.startsWith("@import") && !trimmed.startsWith("@charset") && !trimmed.startsWith("/*") && !trimmed.startsWith("*") && !trimmed.startsWith("//")) {
+                      break;
                     }
-                    catch (e) {
-                        response.error = e.message;
+                  }
+                  const dedupedImports = newImports.filter((imp) => !prevContent.includes(imp));
+                  const insertIdx = lastImportLineIdx + 1;
+                  const topLines = existingLines.slice(0, insertIdx);
+                  const restLines = existingLines.slice(insertIdx);
+                  const merged = [
+                    ...topLines,
+                    ...dedupedImports,
+                    ...restLines,
+                    "",
+                    // separator
+                    bodyContent
+                  ].join("\n");
+                  fs4.writeFileSync(filePath, merged, "utf-8");
+                  console.log(chalk.blue("\u2139") + ` CSS-safe append: hoisted ${dedupedImports.length} @import(s) to top of ${message.filePath}`);
+                } else {
+                  fs4.appendFileSync(filePath, "\n\n" + newContent, "utf-8");
+                }
+              } else {
+                fs4.appendFileSync(filePath, "\n" + newContent, "utf-8");
+              }
+              const formatter = await autoFormat(filePath, projectPath);
+              response.data = { success: true, path: filePath, formatted: formatter, undoAvailable: true };
+              console.log(chalk.blue("\u2139") + ` Appended file: ${message.filePath}` + (formatter ? chalk.dim(` (formatted with ${formatter})`) : "") + chalk.dim(" [undo saved]"));
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "EDIT_CLASSNAME": {
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+              break;
+            }
+            if (!fs4.existsSync(filePath)) {
+              response.error = "File not found: " + message.filePath;
+              break;
+            }
+            if (message.readToken) {
+              const stat = fs4.statSync(filePath);
+              const token = `${Math.round(stat.mtimeMs)}-${stat.size}`;
+              if (token !== message.readToken) {
+                response.error = "File has changed since last read (readToken mismatch). Re-read with read_project_file before editing.";
+                break;
+              }
+            }
+            const source = fs4.readFileSync(filePath, "utf-8");
+            undoStack.push({ filePath, prevContent: source, operation: "EDIT_CLASSNAME", timestamp: Date.now(), relativePath: message.filePath });
+            if (undoStack.length > 20)
+              undoStack.shift();
+            const result = editJSXClassName(source, {
+              oldValue: message.oldValue,
+              newValue: message.newValue,
+              lineHint: message.lineHint
+            });
+            if (!result.success) {
+              undoStack.pop();
+              response.error = result.error ?? "AST edit failed";
+              break;
+            }
+            await withFileLock(filePath, async () => {
+              fs4.writeFileSync(filePath, result.code, "utf-8");
+              const formatter = await autoFormat(filePath, projectPath);
+              response.data = {
+                success: true,
+                path: filePath,
+                strategy: result.strategy,
+                matchedLine: result.matchedLine,
+                formatted: formatter,
+                undoAvailable: true
+              };
+              console.log(
+                chalk.blue("\u2139") + ` EDIT_CLASSNAME: ${message.filePath}` + chalk.dim(` [${result.strategy} @ line ${result.matchedLine}]`) + (formatter ? chalk.dim(` (${formatter})`) : "") + chalk.dim(" [undo saved]")
+              );
+            });
+            const lsp = await checkDiagnostics(filePath, projectPath);
+            if (lsp.ran && response.data) {
+              response.data.lspDiagnostics = lsp.diagnostics;
+              if (lsp.summary)
+                response.data.lspSummary = lsp.summary;
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        }
+        case "EDIT_FILE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+            } else if (!fs4.existsSync(filePath)) {
+              const requestedBase = path4.basename(message.filePath);
+              const requestedExt = path4.extname(requestedBase);
+              const requestedStem = requestedBase.replace(requestedExt, "");
+              const suggestions = [];
+              const dirsToSearch = ["src/app", "app", "src/pages", "pages", "src/components", "components", "src"];
+              for (const dir of dirsToSearch) {
+                const absDir = path4.join(projectPath, dir);
+                if (fs4.existsSync(absDir)) {
+                  try {
+                    const files = fs4.readdirSync(absDir, { recursive: true });
+                    for (const f of files.slice(0, 100)) {
+                      const fBase = path4.basename(f);
+                      if (fBase.startsWith(requestedStem + ".") || fBase === requestedBase) {
+                        suggestions.push(path4.join(dir, f).replace(/\\/g, "/"));
+                      }
                     }
+                  } catch (e) {
+                  }
+                }
+              }
+              const hint = suggestions.length > 0 ? " Did you mean: " + suggestions.slice(0, 3).join(" or ") + "?" : " Double-check the path against detect_project() output (layoutFile, globalStyleFile) or projectTree.";
+              response.error = 'File not found: "' + message.filePath + '".' + hint;
+            } else {
+              if (message.readToken) {
+                const _eStat = fs4.statSync(filePath);
+                const _eToken = `${Math.round(_eStat.mtimeMs)}-${_eStat.size}`;
+                if (_eToken !== message.readToken) {
+                  response.error = "File has changed since last read (readToken mismatch). Re-read the file with read_project_file to get fresh content and line numbers before editing. The file was NOT modified.";
+                  break;
+                }
+              }
+              const content = fs4.readFileSync(filePath, "utf-8");
+              undoStack.push({ filePath, prevContent: content, operation: "EDIT_FILE", timestamp: Date.now(), relativePath: message.filePath });
+              if (undoStack.length > 20)
+                undoStack.shift();
+              const result = fuzzyReplace(content, message.target, message.replacement, message.replaceAll || false);
+              if ("error" in result) {
+                undoStack.pop();
+                response.error = result.error;
+              } else {
+                const _jsExts = [".js", ".jsx", ".tsx", ".ts"];
+                if (_jsExts.some((ext) => filePath.endsWith(ext))) {
+                  const _resultContent = result.result;
+                  const _strip = (s) => s.replace(/`[^`]*`/g, "``").replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/\'(?:[^\'\\]|\\.)*\'/g, "''");
+                  const _origStripped = _strip(content);
+                  const _origDebt = (_origStripped.match(/\{/g) || []).length - (_origStripped.match(/\}/g) || []).length;
+                  const _origPDebt = (_origStripped.match(/\(/g) || []).length - (_origStripped.match(/\)/g) || []).length;
+                  const _stripped = _strip(_resultContent);
+                  const _bo = (_stripped.match(/\{/g) || []).length;
+                  const _bc = (_stripped.match(/\}/g) || []).length;
+                  const _po = (_stripped.match(/\(/g) || []).length;
+                  const _pc = (_stripped.match(/\)/g) || []).length;
+                  const _newDebt = _bo - _bc;
+                  const _newPDebt = _po - _pc;
+                  if (Math.abs(_newDebt) > Math.abs(_origDebt) || Math.abs(_newPDebt) > Math.abs(_origPDebt)) {
+                    undoStack.pop();
+                    response.error = `JSX validation failed: resulting file has unbalanced syntax (braces: ${_bo} open / ${_bc} close, parens: ${_po} open / ${_pc} close). The file was NOT modified. Re-read the file and fix the replacement so the overall file stays balanced.`;
                     break;
-                case 'FIND_USAGES':
-                    try {
-                        const query = message.query;
-                        const { stdout } = await execAsync(`git grep -n "${query}"`, { cwd: projectPath });
-                        response.data = {
-                            usages: stdout.split('\n').filter(Boolean).slice(0, 20).map((line) => {
-                                const parts = line.split(':');
-                                return {
-                                    file: parts[0],
-                                    line: parseInt(parts[1]),
-                                    content: parts.slice(2).join(':').trim()
-                                };
-                            })
-                        };
+                  }
+                }
+                await withFileLock(filePath, async () => {
+                  fs4.writeFileSync(filePath, result.result, "utf-8");
+                  const formatter = await autoFormat(filePath, projectPath);
+                  response.data = {
+                    success: true,
+                    path: filePath,
+                    strategy: result.strategy,
+                    formatted: formatter,
+                    undoAvailable: true
+                  };
+                  const strategyLabel = result.strategy === "exact" ? "" : chalk.dim(` [${result.strategy}]`);
+                  const formatLabel = formatter ? chalk.dim(` (${formatter})`) : "";
+                  console.log(chalk.blue("\u2139") + ` Edited file: ${message.filePath}${strategyLabel}${formatLabel}` + chalk.dim(" [undo saved]"));
+                });
+                const _eLsp = await checkDiagnostics(filePath, projectPath);
+                if (_eLsp.ran && response.data) {
+                  response.data.lspDiagnostics = _eLsp.diagnostics;
+                  if (_eLsp.summary) {
+                    response.data.lspSummary = _eLsp.summary;
+                    if (_eLsp.diagnostics.some((d) => d.severity === "error")) {
+                      console.log(chalk.yellow("\u26A0") + ` ${_eLsp.summary}`);
                     }
-                    catch (e) {
-                        if (e.code === 1)
-                            response.data = { usages: [] };
-                        else
-                            response.error = `Grep failed: ${e.message}`;
+                  }
+                }
+              }
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "REPLACE_LINES":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+            } else if (!fs4.existsSync(filePath)) {
+              response.error = "File not found: " + message.filePath;
+            } else {
+              if (message.readToken) {
+                const _rStat = fs4.statSync(filePath);
+                const _rToken = `${Math.round(_rStat.mtimeMs)}-${_rStat.size}`;
+                if (_rToken !== message.readToken) {
+                  response.error = "File has changed since last read (readToken mismatch). Re-read the file with read_project_file to get fresh line numbers before replacing. The file was NOT modified.";
+                  break;
+                }
+              }
+              const content = fs4.readFileSync(filePath, "utf-8");
+              const lines = content.split("\n");
+              const startLine = Math.max(1, message.startLine || 1);
+              const endLine = Math.min(lines.length, message.endLine || startLine);
+              if (startLine > lines.length) {
+                response.error = `Start line ${startLine} is beyond file end (${lines.length} lines)`;
+              } else if (startLine > endLine) {
+                response.error = `Invalid range: start (${startLine}) > end (${endLine})`;
+              } else {
+                undoStack.push({
+                  filePath,
+                  prevContent: content,
+                  operation: "REPLACE_LINES",
+                  timestamp: Date.now(),
+                  relativePath: message.filePath
+                });
+                if (undoStack.length > 20)
+                  undoStack.shift();
+                const oldLineCount = endLine - startLine + 1;
+                const newLines = (message.newContent || "").split("\n");
+                const _jsExts2 = [".js", ".jsx", ".tsx", ".ts"];
+                if (_jsExts2.some((ext) => filePath.endsWith(ext))) {
+                  const _strip = (s) => s.replace(/`[^`]*`/g, "``").replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/\'(?:[^\'\\]|\\.)*\'/g, "''");
+                  const _origStripped2 = _strip(content);
+                  const _origDebt2 = (_origStripped2.match(/\{/g) || []).length - (_origStripped2.match(/\}/g) || []).length;
+                  const _origPDebt2 = (_origStripped2.match(/\(/g) || []).length - (_origStripped2.match(/\)/g) || []).length;
+                  const _previewLines = [...lines];
+                  const _previewNew = (message.newContent || "").split("\n");
+                  _previewLines.splice(startLine - 1, endLine - startLine + 1, ..._previewNew);
+                  const _stripped = _strip(_previewLines.join("\n"));
+                  const _bo = (_stripped.match(/\{/g) || []).length;
+                  const _bc = (_stripped.match(/\}/g) || []).length;
+                  const _po = (_stripped.match(/\(/g) || []).length;
+                  const _pc = (_stripped.match(/\)/g) || []).length;
+                  const _newDebt2 = _bo - _bc;
+                  const _newPDebt2 = _po - _pc;
+                  if (Math.abs(_newDebt2) > Math.abs(_origDebt2) || Math.abs(_newPDebt2) > Math.abs(_origPDebt2)) {
+                    undoStack.pop();
+                    const _deletedBlock = lines.slice(startLine - 1, endLine).join("\n");
+                    const _ds = _strip(_deletedBlock);
+                    const _braceDebt = (_ds.match(/\{/g) || []).length - (_ds.match(/\}/g) || []).length;
+                    const _parenDebt = (_ds.match(/\(/g) || []).length - (_ds.match(/\)/g) || []).length;
+                    let _hint = "";
+                    if (_braceDebt > 0 || _parenDebt > 0) {
+                      let _bd = _braceDebt;
+                      let _pd = _parenDebt;
+                      let _sugEnd = endLine;
+                      const _tail = lines.slice(endLine);
+                      for (let _i = 0; _i < _tail.length; _i++) {
+                        const _ls = _strip(_tail[_i]);
+                        _bd -= (_ls.match(/\}/g) || []).length - (_ls.match(/\{/g) || []).length;
+                        _pd -= (_ls.match(/\)/g) || []).length - (_ls.match(/\(/g) || []).length;
+                        _sugEnd = endLine + _i + 1;
+                        if (_bd <= 0 && _pd <= 0)
+                          break;
+                      }
+                      _hint = ` The range ${startLine}-${endLine} has unclosed syntax. Expand end_line to ~${_sugEnd} to include the closing syntax, then retry.`;
+                    } else {
+                      _hint = " Re-read the file and ensure the replacement keeps all JSX balanced.";
                     }
+                    response.error = `JSX validation failed: resulting file has unbalanced syntax (braces: ${_bo} open / ${_bc} close, parens: ${_po} open / ${_pc} close). The file was NOT modified.${_hint}`;
                     break;
-                case 'GET_ENV_VARS':
-                    try {
-                        const filePath = path.resolve(projectPath, message.filePath);
-                        if (fs.existsSync(filePath)) {
-                            const content = fs.readFileSync(filePath, 'utf-8');
-                            const envRegex = /(?:process\.env\.|import\.meta\.env\.)([A-Z_][A-Z0-9_]*)/g;
-                            const vars = new Set();
-                            let match;
-                            while ((match = envRegex.exec(content)) !== null) {
-                                vars.add(match[1]);
-                            }
-                            response.data = { envVars: Array.from(vars) };
-                        }
-                        else {
-                            response.error = 'File not found';
-                        }
-                    }
-                    catch (e) {
-                        response.error = e.message;
+                  }
+                }
+                await withFileLock(filePath, async () => {
+                  lines.splice(startLine - 1, oldLineCount, ...newLines);
+                  const newContent = lines.join("\n");
+                  fs4.writeFileSync(filePath, newContent, "utf-8");
+                  const formatter = await autoFormat(filePath, projectPath);
+                  const lineDelta = newLines.length - oldLineCount;
+                  response.data = {
+                    success: true,
+                    path: filePath,
+                    linesReplaced: `${startLine}-${endLine}`,
+                    oldLineCount,
+                    newLineCount: newLines.length,
+                    lineDelta,
+                    totalLines: lines.length,
+                    formatted: formatter,
+                    undoAvailable: true,
+                    hint: lineDelta !== 0 ? `Line count changed by ${lineDelta > 0 ? "+" : ""}${lineDelta}. Adjust subsequent line numbers if making more edits.` : null
+                  };
+                  const formatLabel = formatter ? chalk.dim(` (${formatter})`) : "";
+                  console.log(chalk.blue("\u2139") + ` Replaced lines ${startLine}-${endLine} in ${message.filePath} (${oldLineCount}\u2192${newLines.length} lines)${formatLabel}` + chalk.dim(" [undo saved]"));
+                });
+                const _rLsp = await checkDiagnostics(filePath, projectPath);
+                if (_rLsp.ran && response.data) {
+                  response.data.lspDiagnostics = _rLsp.diagnostics;
+                  if (_rLsp.summary) {
+                    response.data.lspSummary = _rLsp.summary;
+                    if (_rLsp.diagnostics.some((d) => d.severity === "error")) {
+                      console.log(chalk.yellow("\u26A0") + ` ${_rLsp.summary}`);
                     }
-                    break;
-                // ========== TERMINAL BUFFER ACCESS ==========
-                case 'GET_TERMINAL_BUFFER': {
-                    // Returns the last N lines of the dev server terminal output.
-                    // Agents use this to get compiler errors without running a build.
-                    const lines = parseInt(message.lines) || 100;
-                    const buffer = globalTerminalBuffer.getLast(lines);
-                    response.data = {
-                        lines: buffer,
-                        totalLines: globalTerminalBuffer.length,
-                        hasDevProcess: devProcess !== null && !devProcess.killed,
-                    };
-                    break;
+                  }
                 }
-                case 'GET_DEV_STATUS': {
-                    response.data = {
-                        running: devProcess !== null && !devProcess.killed,
-                        pid: devProcess?.pid ?? null,
-                    };
-                    break;
+              }
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "UNDO_LAST":
+          try {
+            if (undoStack.length === 0) {
+              response.error = "Nothing to undo \u2014 no file changes recorded in this session.";
+            } else {
+              const snapshot = undoStack.pop();
+              if (snapshot.prevContent === null) {
+                if (fs4.existsSync(snapshot.filePath)) {
+                  fs4.unlinkSync(snapshot.filePath);
+                  response.data = {
+                    success: true,
+                    undone: snapshot.operation,
+                    file: snapshot.relativePath,
+                    action: "deleted (was new file)",
+                    remaining: undoStack.length
+                  };
+                  console.log(chalk.yellow("\u21A9") + ` Undo: deleted ${snapshot.relativePath} (was a new file)`);
+                } else {
+                  response.data = {
+                    success: true,
+                    undone: snapshot.operation,
+                    file: snapshot.relativePath,
+                    action: "already gone",
+                    remaining: undoStack.length
+                  };
+                }
+              } else {
+                fs4.writeFileSync(snapshot.filePath, snapshot.prevContent, "utf-8");
+                response.data = {
+                  success: true,
+                  undone: snapshot.operation,
+                  file: snapshot.relativePath,
+                  action: "restored",
+                  remaining: undoStack.length
+                };
+                console.log(chalk.yellow("\u21A9") + ` Undo: restored ${snapshot.relativePath} (reverted ${snapshot.operation})`);
+              }
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "DELETE_FILE":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (!filePath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+              break;
+            }
+            if (!fs4.existsSync(filePath)) {
+              response.error = "File not found: " + message.filePath;
+              break;
+            }
+            const relPath = message.filePath.replace(/\\/g, "/");
+            const baseName = path4.basename(relPath);
+            const PROTECTED_PATTERNS = [
+              // Package & lock files
+              "package.json",
+              "package-lock.json",
+              "yarn.lock",
+              "pnpm-lock.yaml",
+              "bun.lockb",
+              "bun.lock",
+              // TypeScript / JS config
+              "tsconfig.json",
+              "tsconfig.node.json",
+              "jsconfig.json",
+              // Framework configs
+              /^next\.config\./,
+              /^vite\.config\./,
+              /^nuxt\.config\./,
+              /^svelte\.config\./,
+              /^remix\.config\./,
+              /^astro\.config\./,
+              /^webpack\.config\./,
+              /^babel\.config\./,
+              /^tailwind\.config\./,
+              /^postcss\.config\./,
+              /^prettier\.config\./,
+              /^eslint\.config\./,
+              ".eslintrc",
+              ".prettierrc",
+              ".babelrc",
+              // Env files
+              ".env",
+              ".env.local",
+              ".env.production",
+              ".env.development",
+              ".env.staging",
+              // Next.js/React layout & entry roots
+              /^layout\.(tsx|jsx|js|ts)$/,
+              /^_app\.(tsx|jsx|js|ts)$/,
+              /^_document\.(tsx|jsx|js|ts)$/,
+              /^App\.(tsx|jsx|js|ts)$/,
+              /^main\.(tsx|jsx|js|ts)$/,
+              // Dockerfile & CI
+              "Dockerfile",
+              "docker-compose.yml",
+              "docker-compose.yaml",
+              ".gitignore",
+              ".gitattributes"
+            ];
+            const isProtected = PROTECTED_PATTERNS.some(
+              (p) => typeof p === "string" ? baseName === p || relPath.endsWith("/" + p) : p.test(baseName)
+            );
+            if (isProtected) {
+              response.error = `\u{1F6E1} Protected file: "${message.filePath}" cannot be deleted by the agent. This file is structurally critical to the project. To resolve conflicts involving this file, edit its contents instead of deleting it.`;
+              break;
+            }
+            const trashDir = path4.join(projectPath, ".trace-trash");
+            if (!fs4.existsSync(trashDir)) {
+              fs4.mkdirSync(trashDir, { recursive: true });
+              const gitignorePath = path4.join(projectPath, ".gitignore");
+              if (fs4.existsSync(gitignorePath)) {
+                const gi = fs4.readFileSync(gitignorePath, "utf-8");
+                if (!gi.includes(".trace-trash")) {
+                  fs4.appendFileSync(gitignorePath, "\n# Trace soft-delete recovery folder\n.trace-trash/\n");
                 }
-                default:
-                    response.error = `Unknown message type: ${type}`;
+              }
+            }
+            const timestamp = Date.now();
+            const trashName = `${timestamp}_${baseName}`;
+            const trashPath = path4.join(trashDir, trashName);
+            const prevContent = fs4.readFileSync(filePath, "utf-8");
+            undoStack.push({ filePath, prevContent, operation: "DELETE_FILE", timestamp, relativePath: message.filePath });
+            if (undoStack.length > 20)
+              undoStack.shift();
+            fs4.renameSync(filePath, trashPath);
+            response.data = {
+              success: true,
+              deleted: message.filePath,
+              recoveryPath: path4.relative(projectPath, trashPath),
+              undoAvailable: true,
+              hint: "File moved to .trace-trash/ \u2014 recoverable even after CLI restart. Call UNDO_LAST to restore to original path."
+            };
+            console.log(chalk.yellow("\u{1F5D1}") + ` Soft-deleted: ${message.filePath} \u2192 .trace-trash/${trashName}` + chalk.dim(" [recoverable]"));
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "RENAME_FILE":
+          try {
+            const oldPath = path4.resolve(projectPath, message.oldPath);
+            const newPath = path4.resolve(projectPath, message.newPath);
+            if (!oldPath.startsWith(projectPath) || !newPath.startsWith(projectPath)) {
+              response.error = "Access denied: Path outside project";
+            } else if (!fs4.existsSync(oldPath)) {
+              response.error = "File not found: " + message.oldPath;
+            } else if (fs4.existsSync(newPath)) {
+              response.error = "Target already exists: " + message.newPath + ". Delete it first or choose a different name.";
+            } else {
+              const prevContent = fs4.readFileSync(oldPath, "utf-8");
+              undoStack.push({ filePath: oldPath, prevContent, operation: "RENAME_FILE", timestamp: Date.now(), relativePath: message.oldPath });
+              if (undoStack.length > 20)
+                undoStack.shift();
+              const destDir = path4.dirname(newPath);
+              if (!fs4.existsSync(destDir))
+                fs4.mkdirSync(destDir, { recursive: true });
+              fs4.renameSync(oldPath, newPath);
+              response.data = {
+                success: true,
+                oldPath: message.oldPath,
+                newPath: message.newPath,
+                undoAvailable: true
+              };
+              console.log(chalk.blue("\u2139") + ` Renamed: ${message.oldPath} \u2192 ${message.newPath}` + chalk.dim(" [undo saved]"));
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "GIT_BLAME":
+          try {
+            const filePath = message.filePath;
+            const line = message.line;
+            const { stdout } = await execAsync3(`git blame -L ${line},${line} --porcelain "${filePath}"`, { cwd: projectPath });
+            const lines = stdout.split("\n");
+            const commitHash = lines[0].split(" ")[0];
+            const author = lines.find((l) => l.startsWith("author "))?.substring(7);
+            const email = lines.find((l) => l.startsWith("author-mail "))?.substring(12);
+            const date = lines.find((l) => l.startsWith("author-time "))?.substring(12);
+            const summary = lines.find((l) => l.startsWith("summary "))?.substring(8);
+            response.data = {
+              commit: commitHash,
+              author,
+              email,
+              date: new Date(parseInt(date) * 1e3).toISOString().split("T")[0],
+              message: summary
+            };
+          } catch (e) {
+            response.error = `Git blame failed: ${e.message}`;
+          }
+          break;
+        case "GIT_RECENT_CHANGES":
+          try {
+            const filePath = message.filePath;
+            const days = message.days || 7;
+            const { stdout } = await execAsync3(`git log -n 10 --since="${days} days ago" --pretty=format:"%h|%an|%ad|%s" --date=short "${filePath}"`, { cwd: projectPath });
+            response.data = {
+              history: stdout.split("\n").filter(Boolean).map((line) => {
+                const [hash, author, date, message2] = line.split("|");
+                return { hash, author, date, message: message2 };
+              })
+            };
+          } catch (e) {
+            response.error = `Git log failed: ${e.message}`;
+          }
+          break;
+        case "GET_IMPORTS":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (fs4.existsSync(filePath)) {
+              const content = fs4.readFileSync(filePath, "utf-8");
+              const importRegex = /import\s+(?:[\w*\s{},]*)\s+from\s+['"]([^'"]+)['"]/g;
+              const imports = [];
+              let match;
+              while ((match = importRegex.exec(content)) !== null) {
+                imports.push(match[1]);
+              }
+              response.data = { imports };
+            } else {
+              response.error = "File not found";
             }
-            ws.send(JSON.stringify(response));
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "FIND_USAGES":
+          try {
+            const query = message.query;
+            const { stdout } = await execAsync3(`git grep -n "${query}"`, { cwd: projectPath });
+            response.data = {
+              usages: stdout.split("\n").filter(Boolean).slice(0, 20).map((line) => {
+                const parts = line.split(":");
+                return {
+                  file: parts[0],
+                  line: parseInt(parts[1]),
+                  content: parts.slice(2).join(":").trim()
+                };
+              })
+            };
+          } catch (e) {
+            if (e.code === 1)
+              response.data = { usages: [] };
+            else
+              response.error = `Grep failed: ${e.message}`;
+          }
+          break;
+        case "GET_ENV_VARS":
+          try {
+            const filePath = path4.resolve(projectPath, message.filePath);
+            if (fs4.existsSync(filePath)) {
+              const content = fs4.readFileSync(filePath, "utf-8");
+              const envRegex = /(?:process\.env\.|import\.meta\.env\.)([A-Z_][A-Z0-9_]*)/g;
+              const vars = /* @__PURE__ */ new Set();
+              let match;
+              while ((match = envRegex.exec(content)) !== null) {
+                vars.add(match[1]);
+              }
+              response.data = { envVars: Array.from(vars) };
+            } else {
+              response.error = "File not found";
+            }
+          } catch (e) {
+            response.error = e.message;
+          }
+          break;
+        case "GET_TERMINAL_BUFFER": {
+          const lines = parseInt(message.lines) || 100;
+          const buffer = globalTerminalBuffer.getLast(lines);
+          response.data = {
+            lines: buffer,
+            totalLines: globalTerminalBuffer.length,
+            hasDevProcess: devProcess !== null && !devProcess.killed
+          };
+          break;
         }
-        catch (e) {
-            console.error(chalk.red('Parse error:'), e.message);
+        case "GET_DEV_STATUS": {
+          response.data = {
+            running: devProcess !== null && !devProcess.killed,
+            pid: devProcess?.pid ?? null
+          };
+          break;
         }
-    });
-}
-// ============================================
-// COMMAND: trace connect (legacy / IDE-only)
-// ============================================
-program
-    .command('connect', { isDefault: true })
-    .alias('c')
-    .description('Start IDE bridge only (use "trace dev" to also start your dev server)')
-    .option('-p, --port <port>', 'WebSocket port', '8765')
-    .action(async (options) => {
-    const port = parseInt(options.port);
-    const projectPath = process.cwd();
-    console.log();
-    console.log(chalk.bold.cyan('🔗 Trace IDE Bridge'));
-    console.log(chalk.gray('─'.repeat(55)));
-    console.log();
-    console.log(`Project: ${chalk.green(projectPath)}`);
-    console.log(`Port: ${chalk.cyan(port)}`);
-    console.log();
+        default:
+          response.error = `Unknown message type: ${type}`;
+      }
+      ws.send(JSON.stringify(response));
+    } catch (e) {
+      console.error(chalk.red("Parse error:"), e.message);
+    }
+  });
+  ws.on("message", (rawData) => {
     try {
-        const pkgPath = path.join(projectPath, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-            console.log(`📦 Package: ${chalk.yellow(pkg.name)} v${pkg.version}`);
-        }
+      const msg = JSON.parse(rawData.toString());
+      if (msg.type === "RESPONSE" && msg.id && globalBrowserPending.has(msg.id)) {
+        const { resolve: resolve3 } = globalBrowserPending.get(msg.id);
+        globalBrowserPending.delete(msg.id);
+        resolve3(msg.error ? { error: msg.error } : msg.data ?? {});
+      }
+    } catch {
     }
-    catch (_) { }
-    const wss = new WebSocketServer({ port });
-    let clientCount = 0;
-    console.log();
-    console.log(chalk.green('✓') + ' WebSocket server started');
-    console.log(chalk.dim('Waiting for extension to connect...'));
-    console.log();
-    console.log(chalk.gray('─'.repeat(55)));
-    console.log(chalk.dim('Press Ctrl+C to stop'));
-    console.log();
-    wss.on('connection', (ws) => {
-        clientCount++;
-        console.log(chalk.green('●') + ` Extension connected (${clientCount} client${clientCount > 1 ? 's' : ''})`);
-        // Wire up the full IDE bridge protocol
-        attachMessageHandler(ws, projectPath);
-        ws.on('close', () => {
-            clientCount--;
-            console.log(chalk.yellow('●') + ` Extension disconnected (${clientCount} client${clientCount > 1 ? 's' : ''})`);
-        });
-        ws.on('error', (error) => {
-            console.error(chalk.red('WebSocket error:'), error.message);
-        });
-    });
-    wss.on('error', (error) => {
-        if (error.code === 'EADDRINUSE') {
-            console.log(chalk.red(`✗ Port ${port} is already in use`));
-            console.log(chalk.dim('Try: trace-connect --port 8766'));
-        }
-        else {
-            console.error(chalk.red('Server error:'), error.message);
-        }
-        process.exit(1);
+  });
+}
+program.command("connect", { isDefault: true }).alias("c").description('Start IDE bridge only (use "trace dev" to also start your dev server)').option("-p, --port <port>", "WebSocket port", "8765").action(async (options) => {
+  const port = parseInt(options.port);
+  const projectPath = process.cwd();
+  console.log();
+  console.log(chalk.bold.cyan("\u{1F517} Trace IDE Bridge"));
+  console.log(chalk.gray("\u2500".repeat(55)));
+  console.log();
+  console.log(`Project: ${chalk.green(projectPath)}`);
+  console.log(`Port: ${chalk.cyan(port)}`);
+  console.log();
+  try {
+    const pkgPath = path4.join(projectPath, "package.json");
+    if (fs4.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      console.log(`\u{1F4E6} Package: ${chalk.yellow(pkg.name)} v${pkg.version}`);
+    }
+  } catch (_) {
+  }
+  const wss = new WebSocketServer({ port });
+  let clientCount = 0;
+  console.log();
+  console.log(chalk.green("\u2713") + " WebSocket server started");
+  console.log(chalk.dim("Waiting for extension to connect..."));
+  console.log();
+  console.log(chalk.gray("\u2500".repeat(55)));
+  console.log(chalk.dim("Press Ctrl+C to stop"));
+  console.log();
+  wss.on("connection", (ws) => {
+    clientCount++;
+    console.log(chalk.green("\u25CF") + ` Extension connected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+    attachMessageHandler(ws, projectPath);
+    ws.on("close", () => {
+      clientCount--;
+      console.log(chalk.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
     });
-    process.on('SIGINT', () => {
-        console.log();
-        console.log(chalk.dim('Stopping...'));
-        wss.close();
-        process.exit(0);
+    ws.on("error", (error) => {
+      console.error(chalk.red("WebSocket error:"), error.message);
     });
+  });
+  wss.on("error", (error) => {
+    if (error.code === "EADDRINUSE") {
+      console.log(chalk.red(`\u2717 Port ${port} is already in use`));
+      console.log(chalk.dim("Try: trace-connect --port 8766"));
+    } else {
+      console.error(chalk.red("Server error:"), error.message);
+    }
+    process.exit(1);
+  });
+  process.on("SIGINT", () => {
+    console.log();
+    console.log(chalk.dim("Stopping..."));
+    wss.close();
+    process.exit(0);
+  });
 });
 program.parse(process.argv);
-// Helper: Get file tree
 function getFileTree(dir, depth, currentDepth = 0) {
-    if (currentDepth >= depth)
-        return null;
-    const result = {};
-    const ignorePatterns = ['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache'];
-    try {
-        const items = fs.readdirSync(dir);
-        for (const item of items.slice(0, 50)) {
-            if (ignorePatterns.includes(item) || item.startsWith('.'))
-                continue;
-            const fullPath = path.join(dir, item);
-            try {
-                const stat = fs.statSync(fullPath);
-                if (stat.isDirectory()) {
-                    result[item] = getFileTree(fullPath, depth, currentDepth + 1);
-                }
-                else {
-                    result[item] = 'file';
-                }
-            }
-            catch (e) {
-                // Skip inaccessible
-            }
-        }
-    }
-    catch (e) {
-        // Skip inaccessible dirs
-    }
-    return result;
-}
-// Helper: Simple search in files
-function searchInFiles(dir, query, maxResults) {
-    const results = [];
-    const extensions = ['.js', '.ts', '.jsx', '.tsx', '.vue', '.svelte', '.css', '.html', '.json'];
-    const ignorePatterns = ['node_modules', '.git', 'dist', 'build', '.next', '.cache'];
-    function searchDir(currentDir) {
-        if (results.length >= maxResults)
-            return;
-        try {
-            const items = fs.readdirSync(currentDir);
-            for (const item of items) {
-                if (results.length >= maxResults)
-                    return;
-                if (ignorePatterns.includes(item) || item.startsWith('.'))
-                    continue;
-                const fullPath = path.join(currentDir, item);
-                try {
-                    const stat = fs.statSync(fullPath);
-                    if (stat.isDirectory()) {
-                        searchDir(fullPath);
-                    }
-                    else if (extensions.some(ext => item.endsWith(ext))) {
-                        const content = fs.readFileSync(fullPath, 'utf-8');
-                        const lines = content.split('\n');
-                        for (let i = 0; i < lines.length && results.length < maxResults; i++) {
-                            if (lines[i].includes(query)) {
-                                results.push({
-                                    file: path.relative(dir, fullPath),
-                                    line: i + 1,
-                                    content: lines[i].trim().substring(0, 200)
-                                });
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    // ignore
-                }
-            }
-        }
-        catch (e) {
-            // ignore
+  if (currentDepth >= depth)
+    return null;
+  const result = {};
+  const ignorePatterns = ["node_modules", ".git", "dist", "build", ".next", "coverage", ".cache"];
+  try {
+    const items = fs4.readdirSync(dir);
+    for (const item of items.slice(0, 50)) {
+      if (ignorePatterns.includes(item) || item.startsWith("."))
+        continue;
+      const fullPath = path4.join(dir, item);
+      try {
+        const stat = fs4.statSync(fullPath);
+        if (stat.isDirectory()) {
+          result[item] = getFileTree(fullPath, depth, currentDepth + 1);
+        } else {
+          result[item] = "file";
         }
+      } catch (e) {
+      }
     }
-    searchDir(dir);
-    return results;
+  } catch (e) {
+  }
+  return result;
 }
-//# sourceMappingURL=index.js.map