@gettrace/cli 1.4.24 → 2.0.1

package/dist/index.js

@@ -2,11 +2,11 @@
 
 // src/index.ts
 import { program } from "commander";
-import chalk from "chalk";
+import chalk2 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 { exec, execFile as execFile3, spawn as spawn2 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { fileURLToPath } from "url";
 
@@ -31,9 +31,9 @@ async function withFileLock(filePath, fn) {
 // src/format.ts
 import * as fs from "fs";
 import * as path from "path";
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import { promisify } from "util";
-var execAsync = promisify(exec);
+var execFileAsync = promisify(execFile);
 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"]);
@@ -53,7 +53,7 @@ async function autoFormat(filePath, projectPath) {
   const prettierBin = path.join(projectPath, "node_modules", ".bin", "prettier");
   if (fs.existsSync(prettierBin)) {
     try {
-      await execAsync(`"${prettierBin}" --write "${filePath}"`, { cwd: projectPath });
+      await execFileAsync(prettierBin, ["--write", filePath], { cwd: projectPath });
       return "prettier";
     } catch {
     }
@@ -62,7 +62,7 @@ async function autoFormat(filePath, projectPath) {
     const eslintBin = path.join(projectPath, "node_modules", ".bin", "eslint");
     if (fs.existsSync(eslintBin)) {
       try {
-        await execAsync(`"${eslintBin}" --fix "${filePath}"`, { cwd: projectPath });
+        await execFileAsync(eslintBin, ["--fix", filePath], { cwd: projectPath });
         return "eslint";
       } catch {
       }
@@ -74,7 +74,7 @@ async function autoFormat(filePath, projectPath) {
 // src/lsp.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-import { exec as exec2 } from "child_process";
+import { spawn } 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"]);
@@ -145,10 +145,9 @@ async function checkDiagnostics(filePath, projectPath) {
 }
 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`;
+  const bin = fs2.existsSync(localTsc) ? localTsc : "tsc";
   try {
-    const raw = await spawnWithTimeout(cmd, projectPath);
+    const raw = await spawnWithTimeout(bin, ["--noEmit", "--pretty", "false"], projectPath);
     return parseTscOutput(raw, projectPath);
   } catch {
     return [];
@@ -174,9 +173,8 @@ function parseTscOutput(output, projectPath) {
   return diagnostics;
 }
 async function runEslint(eslintBin, filePath, projectPath) {
-  const cmd = `"${eslintBin}" --format json "${filePath}"`;
   try {
-    const raw = await spawnWithTimeout(cmd, projectPath);
+    const raw = await spawnWithTimeout(eslintBin, ["--format", "json", filePath], projectPath);
     return parseEslintOutput(raw, projectPath);
   } catch {
     return [];
@@ -210,9 +208,8 @@ function parseEslintOutput(raw, projectPath) {
   return diagnostics;
 }
 async function runStylelint(stylelintBin, filePath, projectPath) {
-  const cmd = `"${stylelintBin}" --formatter json "${filePath}"`;
   try {
-    const raw = await spawnWithTimeout(cmd, projectPath);
+    const raw = await spawnWithTimeout(stylelintBin, ["--formatter", "json", filePath], projectPath);
     return parseStylelintOutput(raw, projectPath);
   } catch {
     return [];
@@ -243,17 +240,36 @@ function parseStylelintOutput(raw, projectPath) {
   }
   return diagnostics;
 }
-function spawnWithTimeout(cmd, cwd) {
+function spawnWithTimeout(bin, args, cwd) {
   return new Promise((resolve3, reject) => {
     let settled = false;
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn(bin, args, { cwd, shell: false });
     const timer = setTimeout(() => {
       if (settled)
         return;
       settled = true;
-      proc.kill("SIGTERM");
-      reject(new Error(`Checker timed out: ${cmd.slice(0, 60)}`));
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      reject(new Error(`Checker timed out: ${bin} ${args.slice(0, 2).join(" ")}`));
     }, CHECKER_TIMEOUT_MS);
-    const proc = exec2(cmd, { cwd }, (_err, stdout, stderr) => {
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString("utf-8");
+    });
+    proc.stderr?.on("data", (d) => {
+      stderr += d.toString("utf-8");
+    });
+    proc.on("error", () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3("");
+    });
+    proc.on("close", () => {
       if (settled)
         return;
       settled = true;
@@ -274,14 +290,14 @@ function tsconfigAllowsJs(tsconfigPath) {
 // src/search.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
-import { exec as exec3 } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec3);
+var execFileAsync2 = promisify2(execFile2);
 async function searchWithRipgrep(projectPath, query, opts) {
-  const flags = [
+  const args = [
     "--json",
     "--line-number",
-    opts.isRegex ? "" : "--fixed-strings",
+    ...opts.isRegex ? [] : ["--fixed-strings"],
     opts.caseSensitive ? "--case-sensitive" : "--ignore-case",
     `--max-count=${opts.maxResults}`,
     // Exclude directories that are never source code
@@ -300,11 +316,13 @@ async function searchWithRipgrep(projectPath, query, opts) {
     "--glob",
     "!.cache/**",
     "--glob",
-    "!.turbo/**"
-  ].filter(Boolean);
-  const escapedQuery = query.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-  const cmd = `rg ${flags.join(" ")} "${escapedQuery}"`;
-  const { stdout } = await execAsync2(cmd, {
+    "!.turbo/**",
+    // `--` ends flags so a query that starts with `-` doesn't get parsed
+    // as a flag by ripgrep itself.
+    "--",
+    query
+  ];
+  const { stdout } = await execFileAsync2("rg", args, {
     cwd: projectPath,
     maxBuffer: 10 * 1024 * 1024
     // 10 MB — generous for large codebases
@@ -539,11 +557,455 @@ function _extractClassNameString(value) {
   return null;
 }
 
+// src/tui.ts
+import chalk from "chalk";
+import * as readline from "readline";
+var CSI = "\x1B[";
+var AGENT_NOISE = [
+  /service=tool\.registry/,
+  /service=permission .* (evaluate|evaluated)$/,
+  /service=permission permission=skill/,
+  /service=bus type=.* (subscribing|publishing)/,
+  /service=server method=GET path=\/(session|global\/event|event)/,
+  /service=server status=(started|completed) .* path=\/(session|global\/event|event)/,
+  /service=server status=(started|completed) duration=\d+ method=GET/,
+  /service=lsp\.client .* path=/,
+  /service=lsp\.server tsserver=/,
+  /service=lsp\.server (downloading|removing|building)/,
+  /service=lsp file=/,
+  /service=snapshot hash=.* tracking/,
+  /service=session\.prompt .* resolveTools/,
+  /service=file\.time/,
+  /service=session\.compaction/,
+  /service=session\.processor/,
+  /service=plugin name=.* loading internal plugin/,
+  /service=provider .* (using bundled provider|getSDK)/,
+  /service=db count=\d+ mode=bundled applying migrations/,
+  /service=db path=.* opening database/,
+  /service=format /,
+  /service=bash-tool /,
+  /service=server-proxy/,
+  /service=project .* fromDirectory/,
+  /service=file init/,
+  /service=lsp serverIds=/,
+  /service=vcs branch=.* initialized/,
+  /service=mcp key=.* found$/,
+  /service=mcp .* startup failed/
+  // pencil mcp ENOENT — pre-existing
+];
+var TraceTUI = class {
+  currentView = "all";
+  logs = [];
+  status;
+  originalStdoutWrite = null;
+  originalStderrWrite = null;
+  headerHeight = 0;
+  // calculated when drawn
+  tabBarRow = 0;
+  scrollTop = 0;
+  // first row of the scroll region (1-indexed)
+  terminalRows = process.stdout.rows || 30;
+  terminalCols = process.stdout.columns || 100;
+  resizeHandler = null;
+  keyHandler = null;
+  rl = null;
+  isShutdown = false;
+  /** Max number of buffered log lines (keeps memory bounded). */
+  MAX_LOGS = 5e3;
+  /** Max number of agent lines per second to display (cheap rate-limit). */
+  agentRateBucket = 0;
+  agentRateResetAt = 0;
+  agentDroppedThisSec = 0;
+  AGENT_RATE_PER_SEC = 60;
+  /**
+   * Per-source partial-line buffer. Node streams hand us chunks that are
+   * sliced at arbitrary byte boundaries, NOT at line boundaries — a single
+   * logical line can arrive split across two chunks. Without buffering,
+   * we'd render the half-lines as if they were complete, producing the
+   * mangled "warning … truncatedry for more info" output the user saw.
+   * Each source gets its own buffer so app/agent/trace streams don't mix.
+   */
+  partialBuffer = /* @__PURE__ */ new Map();
+  constructor(status) {
+    this.status = status;
+  }
+  /** Activate the TUI: install interceptors, draw chrome, capture keys. */
+  start() {
+    this.installInterceptors();
+    this.installResizeHandler();
+    this.installKeyHandler();
+    this.render();
+  }
+  /** Restore terminal state. Idempotent. */
+  shutdown() {
+    if (this.isShutdown)
+      return;
+    for (const [source, buf] of this.partialBuffer) {
+      if (buf)
+        this.pushLine(source, buf);
+    }
+    this.partialBuffer.clear();
+    this.isShutdown = true;
+    if (this.originalStdoutWrite) {
+      process.stdout.write = this.originalStdoutWrite;
+      this.originalStdoutWrite = null;
+    }
+    if (this.originalStderrWrite) {
+      process.stderr.write = this.originalStderrWrite;
+      this.originalStderrWrite = null;
+    }
+    if (this.resizeHandler) {
+      process.stdout.removeListener("resize", this.resizeHandler);
+      this.resizeHandler = null;
+    }
+    if (this.rl) {
+      try {
+        this.rl.close();
+      } catch {
+      }
+      this.rl = null;
+    }
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+      process.stdin.pause();
+    }
+    process.stdout.write(`${CSI}r${CSI}?25h${CSI}${this.terminalRows};1H
+`);
+  }
+  /** Push a line that came from the user's dev server.
+   *
+   * Stream data — Node hands us chunks at arbitrary byte boundaries, so
+   * we run them through the per-source partial-line buffer to reassemble
+   * complete lines before display. */
+  pushApp(text) {
+    this.pushChunk("app", text);
+  }
+  /** Push a CLI status / banner message.
+   *
+   * Internal messages are ALWAYS complete logical lines — `chalk(...)
+   * + chalk(...)` style concatenations, called once per event. They do
+   * NOT go through the chunk buffer; otherwise messages without a
+   * trailing \n accumulate forever and only flush when some other source
+   * produces a newline, glueing many messages onto one rendered row. */
+  pushTrace(line) {
+    const clean = line.replace(/\n+$/, "");
+    for (const part of clean.split("\n")) {
+      this.pushLine("trace", part);
+    }
+  }
+  /** Update status fields and redraw the header in place. */
+  setStatus(updates) {
+    Object.assign(this.status, updates);
+    if (!this.isShutdown)
+      this.drawHeader();
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Internal: input handling
+  // ─────────────────────────────────────────────────────────────────────
+  installKeyHandler() {
+    if (!process.stdin.isTTY)
+      return;
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.setRawMode)
+      process.stdin.setRawMode(true);
+    process.stdin.resume();
+    this.keyHandler = (_str, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && key.name === "c") {
+        process.kill(process.pid, "SIGINT");
+        return;
+      }
+      if (key.name === "q" && !key.ctrl && !key.meta) {
+        process.kill(process.pid, "SIGINT");
+        return;
+      }
+      if (key.name === "1")
+        return this.setView("app");
+      if (key.name === "2")
+        return this.setView("agent");
+      if (key.name === "3")
+        return this.setView("all");
+      if (key.name === "c" && !key.ctrl && !key.meta) {
+        this.clearLogArea();
+        return;
+      }
+    };
+    process.stdin.on("keypress", this.keyHandler);
+  }
+  installResizeHandler() {
+    this.resizeHandler = () => {
+      this.terminalRows = process.stdout.rows || 30;
+      this.terminalCols = process.stdout.columns || 100;
+      this.render();
+    };
+    process.stdout.on("resize", this.resizeHandler);
+  }
+  setView(view) {
+    if (this.currentView === view)
+      return;
+    this.currentView = view;
+    this.drawTabBar();
+    this.replayLogs();
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Internal: stdout/stderr interception
+  //
+  // The trace-agent module is loaded into THIS process via dynamic import
+  // and writes its logs straight to stdout. We replace process.stdout.write
+  // so those lines flow through pushChunk("agent", ...) and get filtered
+  // + tagged before display.
+  // ─────────────────────────────────────────────────────────────────────
+  installInterceptors() {
+    this.originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    this.originalStderrWrite = process.stderr.write.bind(process.stderr);
+    const intercept = (orig) => (chunk, encoding, cb) => {
+      const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString(
+        typeof encoding === "string" ? encoding : "utf8"
+      ) : String(chunk);
+      const trimmed = text.trimStart();
+      const looksLikeAgent = /^(INFO |WARN |ERROR|DEBUG)\s+\d{4}-\d{2}-\d{2}T/.test(trimmed);
+      const source = looksLikeAgent ? "agent" : "trace";
+      this.pushChunk(source, text);
+      if (typeof encoding === "function")
+        encoding();
+      else if (typeof cb === "function")
+        cb();
+      return true;
+    };
+    process.stdout.write = intercept(this.originalStdoutWrite);
+    process.stderr.write = intercept(this.originalStderrWrite);
+  }
+  pushChunk(source, chunk) {
+    const prev = this.partialBuffer.get(source) ?? "";
+    const full = prev + chunk;
+    const parts = full.split("\n");
+    const trailing = parts.pop() ?? "";
+    this.partialBuffer.set(source, trailing);
+    for (const line of parts)
+      this.pushLine(source, line);
+  }
+  pushLine(source, line) {
+    if (source === "agent" && this.isNoise(line))
+      return;
+    if (source === "agent") {
+      const now = Date.now();
+      if (now > this.agentRateResetAt) {
+        if (this.agentDroppedThisSec > 0) {
+          this.appendDisplayLine(this.formatLine({
+            source: "trace",
+            time: now,
+            text: chalk.dim(`(suppressed ${this.agentDroppedThisSec} agent lines this second)`)
+          }));
+          this.agentDroppedThisSec = 0;
+        }
+        this.agentRateBucket = 0;
+        this.agentRateResetAt = now + 1e3;
+      }
+      if (++this.agentRateBucket > this.AGENT_RATE_PER_SEC) {
+        this.agentDroppedThisSec++;
+        return;
+      }
+    }
+    const entry = { source, text: line, time: Date.now() };
+    this.logs.push(entry);
+    if (this.logs.length > this.MAX_LOGS)
+      this.logs.shift();
+    if (this.matchesView(source)) {
+      this.appendDisplayLine(this.formatLine(entry));
+    }
+  }
+  isNoise(line) {
+    if (!line)
+      return true;
+    return AGENT_NOISE.some((re) => re.test(line));
+  }
+  matchesView(source) {
+    if (this.currentView === "all")
+      return true;
+    if (this.currentView === "app")
+      return source === "app";
+    if (this.currentView === "agent")
+      return source !== "app";
+    return true;
+  }
+  formatLine(entry) {
+    const tag = (() => {
+      switch (entry.source) {
+        case "app":
+          return chalk.cyan("app   ");
+        case "agent":
+          return chalk.magenta("agent ");
+        case "trace":
+          return chalk.yellow("trace ");
+      }
+    })();
+    const sep2 = chalk.dim("\u2502");
+    return `  ${tag}${sep2} ${entry.text}`;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Internal: drawing
+  //
+  // We keep header + tab bar fixed at the top via a DECSTBM scroll region.
+  // After the header is drawn, the cursor is parked at the bottom of the
+  // scroll region; logs land there and scroll up naturally.
+  // ─────────────────────────────────────────────────────────────────────
+  /** Full re-render: header + tab bar + scroll region + replay. */
+  render() {
+    if (this.isShutdown)
+      return;
+    this.write(`${CSI}2J${CSI}H${CSI}?25l`);
+    this.drawHeader();
+    this.drawTabBar();
+    this.installScrollRegion();
+    this.replayLogs();
+  }
+  drawHeader() {
+    this.write(`${CSI}s`);
+    this.write(`${CSI}H`);
+    const cyan = chalk.cyan;
+    const cyanBold = chalk.bold.cyan;
+    const dim = chalk.dim;
+    const green = chalk.green;
+    const red = chalk.red;
+    const yellow = chalk.yellow;
+    const mark = [
+      "     \u2572           \u2571     ",
+      "      \u2572         \u2571      ",
+      "       \u2572___ ___\u2571       ",
+      "           \u25CF           ",
+      "          \u2503 \u2503          ",
+      "          \u2503 \u2503          "
+    ];
+    const wordmark = "T R A C E";
+    const lines = [];
+    lines.push("");
+    for (const row of mark)
+      lines.push("  " + cyan(row));
+    lines.push("");
+    lines.push("  " + cyanBold(wordmark) + "   " + dim("v" + this.status.cliVersion));
+    lines.push("");
+    lines.push("  " + dim("\u2500".repeat(Math.max(40, this.terminalCols - 4))));
+    lines.push("");
+    const dot = (ok) => ok ? green("\u25CF") : red("\u25CF");
+    const labelW = 9;
+    const fmt = (label, value) => "    " + dim(label.padEnd(labelW)) + value;
+    const ext = this.status.extConnected;
+    const bridgeStatus = !this.status.bridgeReady ? `${yellow("\u25CB")} starting` : ext ? `${green("\u25CF")} connected ${dim("\xB7")} ${this.status.clientCount} ` + dim(`client${this.status.clientCount === 1 ? "" : "s"}`) : `${dim("\u25CC")} ${dim("ready \xB7 waiting for extension")}`;
+    const agentStatus = !this.status.agentReady ? `${yellow("\u25CB")} starting` : ext ? `${green("\u25CF")} connected` + (this.status.agentExtras ? dim(`   ${this.status.agentExtras}`) : "") : `${dim("\u25CC")} ${dim("ready \xB7 waiting for extension")}` + (this.status.agentExtras ? dim(`   ${this.status.agentExtras}`) : "");
+    const devStatus = !this.status.devReady ? `${yellow("\u25CB")} starting` : `${green("\u25CF")} ready`;
+    const projectShort = this.truncate(this.status.project, this.terminalCols - 18);
+    const cmdLine = `${this.status.devCommand}    ${devStatus}`;
+    const bridgeLine = `ws://localhost:${this.status.bridgePort}        ${bridgeStatus}`;
+    const agentLine = `http://localhost:${this.status.agentPort}      ${agentStatus}`;
+    const browserLine = `http://localhost:${this.status.browserPort}      ${dim("for coding-agent CDP queries")}`;
+    lines.push(fmt("project", projectShort));
+    lines.push(fmt("command", cmdLine));
+    lines.push(fmt("bridge", bridgeLine));
+    lines.push(fmt("agent", agentLine));
+    lines.push(fmt("browser", browserLine));
+    lines.push("");
+    lines.push("  " + dim("\u2500".repeat(Math.max(40, this.terminalCols - 4))));
+    for (const raw of lines) {
+      this.write(this.padToWidth(raw) + "\n");
+    }
+    this.headerHeight = lines.length;
+    this.tabBarRow = this.headerHeight + 1;
+    this.write(`${CSI}u`);
+  }
+  drawTabBar() {
+    if (this.isShutdown)
+      return;
+    this.write(`${CSI}s`);
+    this.write(`${CSI}${this.tabBarRow};1H`);
+    const dim = chalk.dim;
+    const sel = (label, view) => this.currentView === view ? chalk.bold.cyan(label) : chalk.dim(label);
+    const left = "    " + sel("1 App", "app") + "     " + sel("2 Agent", "agent") + "     " + sel("3 All", "all");
+    const right = dim("c clear  \xB7  q quit") + "  ";
+    const stripAnsi = (s) => s.replace(/\x1B\[[0-9;]*m/g, "");
+    const leftLen = stripAnsi(left).length;
+    const rightLen = stripAnsi(right).length;
+    const gap = Math.max(2, this.terminalCols - leftLen - rightLen);
+    const bar = left + " ".repeat(gap) + right;
+    const sep2 = "  " + dim("\u2500".repeat(Math.max(40, this.terminalCols - 4)));
+    this.write(this.padToWidth(bar) + "\n");
+    this.write(this.padToWidth(sep2) + "\n");
+    this.scrollTop = this.tabBarRow + 2;
+    this.write(`${CSI}u`);
+  }
+  installScrollRegion() {
+    this.write(`${CSI}${this.scrollTop};${this.terminalRows}r`);
+    this.write(`${CSI}${this.terminalRows};1H`);
+  }
+  clearLogArea() {
+    this.write(`${CSI}s`);
+    for (let row = this.scrollTop; row <= this.terminalRows; row++) {
+      this.write(`${CSI}${row};1H${CSI}2K`);
+    }
+    this.write(`${CSI}${this.terminalRows};1H`);
+    this.write(`${CSI}u`);
+  }
+  replayLogs() {
+    this.clearLogArea();
+    this.write(`${CSI}${this.terminalRows};1H`);
+    const visibleRows = this.terminalRows - this.scrollTop + 1;
+    const start = Math.max(0, this.logs.length - visibleRows);
+    for (let i = start; i < this.logs.length; i++) {
+      const entry = this.logs[i];
+      if (this.matchesView(entry.source)) {
+        this.appendDisplayLine(this.formatLine(entry));
+      }
+    }
+  }
+  appendDisplayLine(line) {
+    if (this.isShutdown)
+      return;
+    this.write(line + "\n");
+  }
+  /** Direct write that bypasses our interceptor (uses originalStdoutWrite). */
+  write(s) {
+    if (this.originalStdoutWrite) {
+      this.originalStdoutWrite(s);
+    } else {
+      process.stdout.write(s);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Helpers
+  // ─────────────────────────────────────────────────────────────────────
+  truncate(s, width) {
+    if (width <= 3)
+      return s.slice(0, Math.max(0, width));
+    if (s.length <= width)
+      return s;
+    const head = Math.floor((width - 3) * 0.4);
+    const tail = width - 3 - head;
+    return s.slice(0, head) + "..." + s.slice(s.length - tail);
+  }
+  /**
+   * Pad a string out to terminal width so a redraw fully overwrites any
+   * leftover characters from a previous, longer line. Strips ANSI for
+   * length calculation but preserves it in the output.
+   */
+  padToWidth(s) {
+    const visible = s.replace(/\x1B\[[0-9;]*m/g, "");
+    const pad = Math.max(0, this.terminalCols - visible.length);
+    return s + " ".repeat(pad);
+  }
+};
+
 // 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 execAsync = promisify3(exec);
+var execFileAsync3 = promisify3(execFile3);
+function _isInsideProject(projectPath, fullPath) {
+  return fullPath === projectPath || fullPath.startsWith(projectPath + path4.sep);
+}
 var TerminalBuffer = class {
   lines = [];
   MAX_LINES = 500;
@@ -934,21 +1396,53 @@ function fuzzyReplace(content, oldString, newString, replaceAll = false) {
   return { error: "Found multiple matches for oldString. Provide more surrounding context to make the match unique." };
 }
 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) => {
+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").option("--no-ui", "Disable the branded TUI and stream raw logs (useful for piping/CI)").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 useTui = options.ui !== false && process.stdout.isTTY;
+  const tui = useTui ? new TraceTUI({
+    project: projectPath,
+    pm,
+    devCommand: command,
+    bridgePort: port,
+    agentPort: 8766,
+    browserPort: 8767,
+    bridgeReady: false,
+    agentReady: false,
+    devReady: false,
+    extConnected: false,
+    clientCount: 0,
+    agentExtras: "",
+    cliVersion: VERSION
+  }) : null;
+  if (tui)
+    tui.start();
+  const logTrace = (msg) => {
+    if (tui)
+      tui.pushTrace(msg);
+    else
+      console.log(msg);
+  };
+  const logTraceErr = (msg) => {
+    if (tui)
+      tui.pushTrace(chalk2.red(msg));
+    else
+      console.error(msg);
+  };
+  if (!tui) {
+    console.log();
+    console.log(chalk2.bold.cyan("\u26A1 Trace Dev"));
+    console.log(chalk2.gray("\u2500".repeat(55)));
+    console.log();
+    console.log(`\u{1F4C1} Project:    ${chalk2.green(projectPath)}`);
+    console.log(`\u{1F4E6} Package Mgr: ${chalk2.yellow(pm)}`);
+    console.log(`\u{1F680} Dev Command: ${chalk2.cyan(command)}`);
+    console.log(`\u{1F310} Bridge Port: ${chalk2.cyan(port)}`);
+    console.log();
+    console.log(chalk2.gray("\u2500".repeat(55)));
+    console.log();
+  }
   const connectedClients = /* @__PURE__ */ new Set();
   const broadcast = (payload) => {
     const msg = JSON.stringify(payload);
@@ -958,63 +1452,125 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
       }
     }
   };
-  console.log(chalk.dim("Starting dev server..."));
-  console.log();
+  logTrace(chalk2.dim("Starting dev server..."));
   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`));
-  });
+  function hasRunnableDevScript() {
+    const result = _checkPkg(projectPath, commandOverride);
+    if (result.ok)
+      return result;
+    try {
+      const entries = fs4.readdirSync(projectPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+          continue;
+        const sub = path4.join(projectPath, entry.name);
+        const r = _checkPkg(sub, void 0);
+        if (r.ok)
+          return r;
+      }
+    } catch {
+    }
+    return { ok: false };
+  }
+  function _checkPkg(cwd, override) {
+    const pkgPath = path4.join(cwd, "package.json");
+    if (!fs4.existsSync(pkgPath))
+      return { ok: false };
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      const scripts = pkg.scripts || {};
+      const candidates = ["dev", "start", "serve", "preview"];
+      const script2 = candidates.find((c) => !!scripts[c]);
+      if (!script2)
+        return { ok: false };
+      const detected = detectDevCommand(cwd, override);
+      return { ok: true, cmd: detected.command, script: detected.script, cwd };
+    } catch {
+      return { ok: false };
+    }
+  }
+  function spawnDevProcess(cmd, cwd = projectPath) {
+    if (devProcess && !devProcess.killed) {
+      logTrace(chalk2.dim(`[Trace] Dev process already running \u2014 skipping duplicate spawn for ${cwd}`));
+      return;
+    }
+    devProcess = spawn2(cmd, [], {
+      cwd,
+      shell: true,
+      env: childEnv
+    });
+    devProcess.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (tui)
+        tui.pushApp(text);
+      else
+        process.stdout.write(text);
+      globalTerminalBuffer.push(text);
+      broadcast({ type: "STREAM_CHUNK", stream: "stdout", chunk: text });
+      if (tui && /\b(Ready in|ready in|listening on|Local:)\b/i.test(text)) {
+        tui.setStatus({ devReady: true });
+      }
+    });
+    devProcess.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (tui)
+        tui.pushApp(text);
+      else
+        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}`;
+      if (tui)
+        tui.pushTrace(chalk2.yellow(msg));
+      else
+        process.stdout.write(chalk2.yellow(msg) + "\n");
+      globalTerminalBuffer.push(msg);
+      broadcast({ type: "STREAM_END", exitCode: code });
+      if (tui)
+        tui.setStatus({ devReady: false });
+      devProcess = null;
+    });
+    devProcess.on("error", (err) => {
+      const msg = `[Trace] Failed to start dev server: ${err.message}`;
+      logTraceErr(msg);
+      logTraceErr(`\u2717 Could not start dev server. Command: ${cmd}`);
+    });
+  }
   const wss = new WebSocketServer({ port });
   let clientCount = 0;
   wss.on("listening", () => {
-    console.log();
-    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();
+    if (tui) {
+      tui.setStatus({ bridgeReady: true });
+      tui.pushTrace(chalk2.green("\u2713") + ` IDE Bridge listening on port ${port}`);
+      tui.pushTrace(chalk2.dim("Waiting for Trace extension to connect..."));
+    } else {
+      console.log();
+      console.log(chalk2.gray("\u2500".repeat(55)));
+      console.log(chalk2.green("\u2713") + " IDE Bridge listening on port " + chalk2.cyan(port));
+      console.log(chalk2.dim("Waiting for Trace extension to connect..."));
+      console.log(chalk2.dim("Press Ctrl+C to stop both"));
+      console.log(chalk2.gray("\u2500".repeat(55)));
+      console.log();
+    }
   });
   wss.on("connection", (ws) => {
     clientCount++;
     connectedClients.add(ws);
-    console.log(chalk.green("\u25CF") + ` Extension connected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+    if (tui) {
+      tui.setStatus({ extConnected: true, clientCount });
+      tui.pushTrace(chalk2.green("\u25CF") + ` Extension connected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+    } else {
+      console.log(chalk2.green("\u25CF") + ` Extension connected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+    }
     attachMessageHandler(ws, projectPath);
     const catchup = globalTerminalBuffer.getLast(100);
     if (catchup.length > 0) {
@@ -1023,18 +1579,23 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
     ws.on("close", () => {
       clientCount--;
       connectedClients.delete(ws);
-      console.log(chalk.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+      if (tui) {
+        tui.setStatus({ extConnected: clientCount > 0, clientCount });
+        tui.pushTrace(chalk2.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+      } else {
+        console.log(chalk2.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
+      }
     });
     ws.on("error", (err) => {
-      console.error(chalk.red("WebSocket error:"), err.message);
+      console.error(chalk2.red("WebSocket error:"), err.message);
       connectedClients.delete(ws);
     });
   });
   wss.on("error", (error) => {
     if (error.code === "EADDRINUSE") {
-      console.error(chalk.red(`\u2717 Port ${port} is already in use. Try: trace dev --port 8766`));
+      console.error(chalk2.red(`\u2717 Port ${port} is already in use. Try: trace dev --port 8766`));
     } else {
-      console.error(chalk.red("Bridge error:"), error.message);
+      console.error(chalk2.red("Bridge error:"), error.message);
     }
   });
   const http = await import("http");
@@ -1057,9 +1618,9 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
         res.end(JSON.stringify({ error: "Trace extension not connected." }));
         return;
       }
-      try {
-        let body = {};
-        if (req.method === "POST") {
+      let body = {};
+      if (req.method === "POST") {
+        try {
           body = await new Promise((resolve3, reject) => {
             let raw = "";
             req.on("data", (chunk) => raw += chunk.toString());
@@ -1072,39 +1633,88 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
             });
             req.on("error", reject);
           });
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid request body" }));
+          return;
         }
-        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 });
-        });
-        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 }));
       }
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        "Connection": "keep-alive",
+        // Some HTTP layers (proxies, fetch in node) buffer responses
+        // unless we tell them not to.
+        "X-Accel-Buffering": "no"
+      });
+      const writeEvent = (payload) => {
+        try {
+          if (!res.writableEnded) {
+            res.write(`data: ${JSON.stringify(payload)}
+
+`);
+          }
+        } catch {
+        }
+      };
+      writeEvent({ type: "agent_start", agent: agentName });
+      const reqId = ++globalBrowserRequestId;
+      const timer = setTimeout(() => {
+        const pending = globalBrowserPending.get(reqId);
+        if (pending) {
+          globalBrowserPending.delete(reqId);
+          writeEvent({ type: "error", error: "Agent timeout (65s)" });
+          try {
+            res.end();
+          } catch {
+          }
+        }
+      }, 65e3);
+      req.on("close", () => {
+        if (globalBrowserPending.has(reqId)) {
+          clearTimeout(timer);
+          globalBrowserPending.delete(reqId);
+        }
+      });
+      globalBrowserPending.set(reqId, {
+        resolve: (data) => {
+          clearTimeout(timer);
+          writeEvent({ type: "result", data });
+          try {
+            res.end();
+          } catch {
+          }
+        },
+        reject: (e) => {
+          clearTimeout(timer);
+          writeEvent({ type: "error", error: e?.message || String(e) });
+          try {
+            res.end();
+          } catch {
+          }
+        },
+        timer,
+        onProgress: (event) => writeEvent(event)
+      });
+      client2.send(JSON.stringify({
+        id: reqId,
+        type: "AGENT_INVOKE",
+        agent: agentName,
+        query: body.query || ""
+      }));
       return;
     }
     const browserQueryRoutes = {
       "/browser/console": "BROWSER_GET_CONSOLE",
       "/browser/network": "BROWSER_GET_NETWORK",
       "/browser/dom": "BROWSER_GET_DOM",
-      "/browser/screenshot": "BROWSER_SCREENSHOT"
+      "/browser/screenshot": "BROWSER_SCREENSHOT",
+      "/browser/verify-build": "BROWSER_VERIFY_BUILD"
     };
     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}" }));
+      res.end(JSON.stringify({ error: "Not found. Available: /browser/{console,network,dom,eval,screenshot,verify-build}" }));
       return;
     }
     const client = [...connectedClients].find(
@@ -1154,19 +1764,26 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
   });
   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"));
+    if (tui) {
+      tui.pushTrace(chalk2.green("\u2713") + ` Browser Query HTTP server on port ${BROWSER_HTTP_PORT}`);
+    } else {
+      console.log(chalk2.green("\u2713") + " Browser Query HTTP server on port " + chalk2.cyan(BROWSER_HTTP_PORT));
+      console.log(chalk2.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);
+      console.warn(chalk2.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));
+      if (tui)
+        tui.pushTrace(chalk2.magenta("\u2699") + " Dev Mode: Using local trace agent at " + chalk2.dim(agentPath));
+      else
+        console.log(chalk2.magenta("\u2699") + " Dev Mode: Using local trace agent at " + chalk2.dim(agentPath));
     }
     const { Server } = await import(agentPath);
     process.env.OPENCODE_EXPERIMENTAL = "1";
@@ -1181,14 +1798,210 @@ program.command("dev").description("Start dev server + IDE bridge together (reco
       hostname: "127.0.0.1",
       cors: ["*"]
     });
-    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"));
+    if (tui) {
+      tui.setStatus({
+        agentReady: true,
+        agentExtras: "Sonnet 4.5 \xB7 LSP \xB7 Exa \xB7 Plan"
+      });
+      tui.pushTrace(chalk2.green("\u2713") + " Trace Agent Server listening on port 8766");
+    } else {
+      console.log(chalk2.green("\u2713") + " Trace Agent Server listening on port " + chalk2.cyan(8766));
+      console.log(chalk2.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 msg = "\u26A0 Failed to start Trace Agent Server: " + e.message;
+    if (tui)
+      tui.pushTrace(chalk2.yellow(msg));
+    else
+      console.error(chalk2.yellow(msg));
+  }
+  let _devServerId = null;
+  let _devServerOutputSeen = 0;
+  let _devServerPollTimer = null;
+  let _devServerSseAbort = null;
+  function _drainAgentDevOutput(lines) {
+    if (!Array.isArray(lines) || !lines.length)
+      return;
+    if (_devServerOutputSeen >= lines.length) {
+      _devServerOutputSeen = Math.max(0, lines.length - 100);
+    }
+    for (const line of lines.slice(_devServerOutputSeen)) {
+      const text = line + "\n";
+      if (tui)
+        tui.pushApp(text);
+      else
+        process.stdout.write(text);
+      globalTerminalBuffer.push(text);
+      broadcast({ type: "STREAM_CHUNK", stream: "stdout", chunk: text });
+    }
+    _devServerOutputSeen = lines.length;
+  }
+  function _stopAgentDevPoll() {
+    if (_devServerPollTimer) {
+      clearInterval(_devServerPollTimer);
+      _devServerPollTimer = null;
+    }
+  }
+  function _startAgentDevPoll(id) {
+    _stopAgentDevPoll();
+    _devServerPollTimer = setInterval(async () => {
+      try {
+        const res = await fetch(`http://127.0.0.1:8766/dev-server/${encodeURIComponent(id)}`);
+        if (!res.ok)
+          return;
+        const handle = await res.json().catch(() => null);
+        if (!handle)
+          return;
+        _drainAgentDevOutput(handle.output || []);
+        const status = handle.state?.status;
+        if (status === "exited" || status === "stopped" || status === "failed") {
+          _stopAgentDevPoll();
+          if (tui)
+            tui.setStatus({ devReady: false });
+        } else if (status === "ready" && tui) {
+          tui.setStatus({ devReady: true });
+        }
+      } catch {
+      }
+    }, 500);
+  }
+  async function _subscribeAgentDevEvents() {
+    const ctrl = _devServerSseAbort;
+    if (!ctrl)
+      return;
+    while (!ctrl.signal.aborted) {
+      try {
+        const res = await fetch("http://127.0.0.1:8766/global/event", {
+          signal: ctrl.signal,
+          headers: { Accept: "text/event-stream" }
+        });
+        if (!res.ok || !res.body) {
+          await new Promise((r) => setTimeout(r, 1e3));
+          continue;
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        while (!ctrl.signal.aborted) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          buf += decoder.decode(value, { stream: true });
+          let idx;
+          while ((idx = buf.indexOf("\n\n")) !== -1) {
+            const frame = buf.slice(0, idx);
+            buf = buf.slice(idx + 2);
+            const dataLine = frame.split("\n").find((l) => l.startsWith("data:"));
+            if (!dataLine)
+              continue;
+            const dataStr = dataLine.replace(/^data:\s*/, "");
+            try {
+              const parsed = JSON.parse(dataStr);
+              const type = parsed?.payload?.type;
+              const props = parsed?.payload?.properties;
+              if (!type || !props)
+                continue;
+              if (props.id && _devServerId && props.id !== _devServerId)
+                continue;
+              if (type === "dev_server.starting") {
+                if (!_devServerId && props.id) {
+                  _devServerId = props.id;
+                  _startAgentDevPoll(props.id);
+                }
+              } else if (type === "dev_server.ready") {
+                if (tui)
+                  tui.setStatus({ devReady: true });
+              } else if (type === "dev_server.failed" || type === "dev_server.exited") {
+                if (tui)
+                  tui.setStatus({ devReady: false });
+              }
+            } catch {
+            }
+          }
+        }
+      } catch {
+        if (ctrl.signal.aborted)
+          return;
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+  }
+  async function spawnViaAgentServer(cmd, cwd) {
+    if (_devServerId) {
+      logTrace(chalk2.dim(`[Trace] Dev server already managed by agent (id=${_devServerId}) \u2014 skipping duplicate`));
+      return { ok: true };
+    }
+    _devServerSseAbort = new AbortController();
+    void _subscribeAgentDevEvents();
+    let res;
+    try {
+      res = await fetch("http://127.0.0.1:8766/dev-server", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ command: cmd, cwd, timeoutMs: 9e4 })
+      });
+    } catch (e) {
+      return { ok: false, reason: e?.message ?? String(e) };
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return { ok: false, reason: `HTTP ${res.status}: ${text || res.statusText}` };
+    }
+    const handle = await res.json().catch(() => null);
+    if (!handle?.id)
+      return { ok: false, reason: "no_id_returned" };
+    _devServerId = handle.id;
+    _drainAgentDevOutput(handle.output || []);
+    _startAgentDevPoll(handle.id);
+    if (handle.state?.status === "ready") {
+      if (tui)
+        tui.setStatus({ devReady: true });
+      return { ok: true };
+    }
+    return {
+      ok: false,
+      reason: handle.state?.error || `state: ${handle.state?.status ?? "unknown"}`
+    };
+  }
+  const initial = commandOverride ? { ok: true, cmd: command, script: "override", cwd: projectPath } : hasRunnableDevScript();
+  if (initial.ok && initial.cmd) {
+    if (agentServer) {
+      logTrace(chalk2.dim(`Starting dev server via agent: ${initial.cmd}`));
+      const result = await spawnViaAgentServer(initial.cmd, initial.cwd ?? projectPath);
+      if (!result.ok) {
+        logTraceErr(`\u26A0 Agent-routed dev_server failed: ${result.reason}. Falling back to direct spawn.`);
+        spawnDevProcess(initial.cmd, initial.cwd ?? projectPath);
+      }
+    } else {
+      logTrace(chalk2.yellow("\u26A0 Agent server unavailable \u2014 using direct dev spawn (no cross-process dedup)"));
+      spawnDevProcess(initial.cmd, initial.cwd ?? projectPath);
+    }
+  } else {
+    logTrace(chalk2.dim("No dev script at startup \u2014 the agent will start one via dev_server when it scaffolds."));
   }
   const shutdown = async () => {
+    if (tui)
+      tui.shutdown();
     console.log();
-    console.log(chalk.yellow("\nShutting down..."));
+    console.log(chalk2.yellow("Shutting down..."));
+    if (_devServerSseAbort) {
+      try {
+        _devServerSseAbort.abort();
+      } catch {
+      }
+      _devServerSseAbort = null;
+    }
+    _stopAgentDevPoll();
+    if (_devServerId) {
+      try {
+        await fetch(`http://127.0.0.1:8766/dev-server/${encodeURIComponent(_devServerId)}/stop`, {
+          method: "POST",
+          signal: AbortSignal.timeout(3e3)
+        });
+      } catch {
+      }
+      _devServerId = null;
+    }
     if (devProcess && !devProcess.killed) {
       devProcess.kill("SIGTERM");
     }
@@ -1226,7 +2039,7 @@ function attachMessageHandler(ws, projectPath) {
         case "READ_FILE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied";
             } else if (fs4.existsSync(filePath)) {
               const stat = fs4.statSync(filePath);
@@ -1278,7 +2091,7 @@ function attachMessageHandler(ws, projectPath) {
         case "GET_SOURCE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied";
             } else if (fs4.existsSync(filePath)) {
               const content = fs4.readFileSync(filePath, "utf-8");
@@ -1301,7 +2114,7 @@ function attachMessageHandler(ws, projectPath) {
         case "GET_ERROR_CONTEXT":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied";
             } else if (fs4.existsSync(filePath)) {
               const content = fs4.readFileSync(filePath, "utf-8");
@@ -1680,7 +2493,7 @@ function attachMessageHandler(ws, projectPath) {
               // 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]`) : ""}`);
+            console.log(chalk2.blue("\u2139") + ` Project detected: ${chalk2.yellow(framework)} + ${chalk2.cyan(styling)}${typescript ? chalk2.dim(" (TS)") : ""}${router ? chalk2.dim(` [${router} router]`) : ""}`);
           } catch (e) {
             response.error = e.message;
           }
@@ -1754,7 +2567,7 @@ function attachMessageHandler(ws, projectPath) {
               filesScanned,
               classesIndexed
             };
-            console.log(chalk.blue("\u2139") + ` Class index built: ${chalk.yellow(classesIndexed)} classes across ${chalk.cyan(filesScanned)} files`);
+            console.log(chalk2.blue("\u2139") + ` Class index built: ${chalk2.yellow(classesIndexed)} classes across ${chalk2.cyan(filesScanned)} files`);
           } catch (e) {
             response.error = e.message;
           }
@@ -1762,7 +2575,7 @@ function attachMessageHandler(ws, projectPath) {
         case "WRITE_FILE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
             } else {
               const prevContent = fs4.existsSync(filePath) ? fs4.readFileSync(filePath, "utf-8") : null;
@@ -1787,7 +2600,7 @@ function attachMessageHandler(ws, projectPath) {
                 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]"));
+                console.log(chalk2.blue("\u2139") + ` Wrote file: ${message.filePath}` + (formatter ? chalk2.dim(` (formatted with ${formatter})`) : "") + chalk2.dim(" [undo saved]"));
               });
               const _wLsp = await checkDiagnostics(filePath, projectPath);
               if (_wLsp.ran && response.data) {
@@ -1795,7 +2608,7 @@ function attachMessageHandler(ws, projectPath) {
                 if (_wLsp.summary) {
                   response.data.lspSummary = _wLsp.summary;
                   if (_wLsp.diagnostics.some((d) => d.severity === "error")) {
-                    console.log(chalk.yellow("\u26A0") + ` ${_wLsp.summary}`);
+                    console.log(chalk2.yellow("\u26A0") + ` ${_wLsp.summary}`);
                   }
                 }
               }
@@ -1807,7 +2620,7 @@ function attachMessageHandler(ws, projectPath) {
         case "APPEND_FILE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
             } else {
               const isCssFile = filePath.endsWith(".css");
@@ -1856,7 +2669,7 @@ function attachMessageHandler(ws, projectPath) {
                     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}`);
+                  console.log(chalk2.blue("\u2139") + ` CSS-safe append: hoisted ${dedupedImports.length} @import(s) to top of ${message.filePath}`);
                 } else {
                   fs4.appendFileSync(filePath, "\n\n" + newContent, "utf-8");
                 }
@@ -1865,7 +2678,7 @@ function attachMessageHandler(ws, projectPath) {
               }
               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]"));
+              console.log(chalk2.blue("\u2139") + ` Appended file: ${message.filePath}` + (formatter ? chalk2.dim(` (formatted with ${formatter})`) : "") + chalk2.dim(" [undo saved]"));
             }
           } catch (e) {
             response.error = e.message;
@@ -1874,7 +2687,7 @@ function attachMessageHandler(ws, projectPath) {
         case "EDIT_CLASSNAME": {
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
               break;
             }
@@ -1916,7 +2729,7 @@ function attachMessageHandler(ws, projectPath) {
                 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]")
+                chalk2.blue("\u2139") + ` EDIT_CLASSNAME: ${message.filePath}` + chalk2.dim(` [${result.strategy} @ line ${result.matchedLine}]`) + (formatter ? chalk2.dim(` (${formatter})`) : "") + chalk2.dim(" [undo saved]")
               );
             });
             const lsp = await checkDiagnostics(filePath, projectPath);
@@ -1933,7 +2746,7 @@ function attachMessageHandler(ws, projectPath) {
         case "EDIT_FILE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
             } else if (!fs4.existsSync(filePath)) {
               const requestedBase = path4.basename(message.filePath);
@@ -2006,9 +2819,9 @@ function attachMessageHandler(ws, projectPath) {
                     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 strategyLabel = result.strategy === "exact" ? "" : chalk2.dim(` [${result.strategy}]`);
+                  const formatLabel = formatter ? chalk2.dim(` (${formatter})`) : "";
+                  console.log(chalk2.blue("\u2139") + ` Edited file: ${message.filePath}${strategyLabel}${formatLabel}` + chalk2.dim(" [undo saved]"));
                 });
                 const _eLsp = await checkDiagnostics(filePath, projectPath);
                 if (_eLsp.ran && response.data) {
@@ -2016,7 +2829,7 @@ function attachMessageHandler(ws, projectPath) {
                   if (_eLsp.summary) {
                     response.data.lspSummary = _eLsp.summary;
                     if (_eLsp.diagnostics.some((d) => d.severity === "error")) {
-                      console.log(chalk.yellow("\u26A0") + ` ${_eLsp.summary}`);
+                      console.log(chalk2.yellow("\u26A0") + ` ${_eLsp.summary}`);
                     }
                   }
                 }
@@ -2029,7 +2842,7 @@ function attachMessageHandler(ws, projectPath) {
         case "REPLACE_LINES":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
             } else if (!fs4.existsSync(filePath)) {
               response.error = "File not found: " + message.filePath;
@@ -2124,8 +2937,8 @@ function attachMessageHandler(ws, projectPath) {
                     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 formatLabel = formatter ? chalk2.dim(` (${formatter})`) : "";
+                  console.log(chalk2.blue("\u2139") + ` Replaced lines ${startLine}-${endLine} in ${message.filePath} (${oldLineCount}\u2192${newLines.length} lines)${formatLabel}` + chalk2.dim(" [undo saved]"));
                 });
                 const _rLsp = await checkDiagnostics(filePath, projectPath);
                 if (_rLsp.ran && response.data) {
@@ -2133,7 +2946,7 @@ function attachMessageHandler(ws, projectPath) {
                   if (_rLsp.summary) {
                     response.data.lspSummary = _rLsp.summary;
                     if (_rLsp.diagnostics.some((d) => d.severity === "error")) {
-                      console.log(chalk.yellow("\u26A0") + ` ${_rLsp.summary}`);
+                      console.log(chalk2.yellow("\u26A0") + ` ${_rLsp.summary}`);
                     }
                   }
                 }
@@ -2159,7 +2972,7 @@ function attachMessageHandler(ws, projectPath) {
                     action: "deleted (was new file)",
                     remaining: undoStack.length
                   };
-                  console.log(chalk.yellow("\u21A9") + ` Undo: deleted ${snapshot.relativePath} (was a new file)`);
+                  console.log(chalk2.yellow("\u21A9") + ` Undo: deleted ${snapshot.relativePath} (was a new file)`);
                 } else {
                   response.data = {
                     success: true,
@@ -2178,7 +2991,7 @@ function attachMessageHandler(ws, projectPath) {
                   action: "restored",
                   remaining: undoStack.length
                 };
-                console.log(chalk.yellow("\u21A9") + ` Undo: restored ${snapshot.relativePath} (reverted ${snapshot.operation})`);
+                console.log(chalk2.yellow("\u21A9") + ` Undo: restored ${snapshot.relativePath} (reverted ${snapshot.operation})`);
               }
             }
           } catch (e) {
@@ -2188,7 +3001,7 @@ function attachMessageHandler(ws, projectPath) {
         case "DELETE_FILE":
           try {
             const filePath = path4.resolve(projectPath, message.filePath);
-            if (!filePath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, filePath)) {
               response.error = "Access denied: Path outside project";
               break;
             }
@@ -2278,7 +3091,7 @@ function attachMessageHandler(ws, projectPath) {
               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]"));
+            console.log(chalk2.yellow("\u{1F5D1}") + ` Soft-deleted: ${message.filePath} \u2192 .trace-trash/${trashName}` + chalk2.dim(" [recoverable]"));
           } catch (e) {
             response.error = e.message;
           }
@@ -2287,7 +3100,7 @@ function attachMessageHandler(ws, projectPath) {
           try {
             const oldPath = path4.resolve(projectPath, message.oldPath);
             const newPath = path4.resolve(projectPath, message.newPath);
-            if (!oldPath.startsWith(projectPath) || !newPath.startsWith(projectPath)) {
+            if (!_isInsideProject(projectPath, oldPath) || !_isInsideProject(projectPath, newPath)) {
               response.error = "Access denied: Path outside project";
             } else if (!fs4.existsSync(oldPath)) {
               response.error = "File not found: " + message.oldPath;
@@ -2308,7 +3121,7 @@ function attachMessageHandler(ws, projectPath) {
                 newPath: message.newPath,
                 undoAvailable: true
               };
-              console.log(chalk.blue("\u2139") + ` Renamed: ${message.oldPath} \u2192 ${message.newPath}` + chalk.dim(" [undo saved]"));
+              console.log(chalk2.blue("\u2139") + ` Renamed: ${message.oldPath} \u2192 ${message.newPath}` + chalk2.dim(" [undo saved]"));
             }
           } catch (e) {
             response.error = e.message;
@@ -2316,9 +3129,23 @@ function attachMessageHandler(ws, projectPath) {
           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 filePath = path4.resolve(projectPath, message.filePath || "");
+            if (!_isInsideProject(projectPath, filePath)) {
+              response.error = "Access denied: Path outside project";
+              break;
+            }
+            const lineNum = parseInt(message.line, 10);
+            if (!Number.isFinite(lineNum) || lineNum < 1) {
+              response.error = "Invalid line number";
+              break;
+            }
+            const { stdout } = await execFileAsync3("git", [
+              "blame",
+              "-L",
+              `${lineNum},${lineNum}`,
+              "--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);
@@ -2338,9 +3165,23 @@ function attachMessageHandler(ws, projectPath) {
           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 });
+            const filePath = path4.resolve(projectPath, message.filePath || "");
+            if (!_isInsideProject(projectPath, filePath)) {
+              response.error = "Access denied: Path outside project";
+              break;
+            }
+            const days = Number.isFinite(message.days) && message.days > 0 ? Math.floor(message.days) : 7;
+            const { stdout } = await execFileAsync3("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("|");
@@ -2353,8 +3194,10 @@ function attachMessageHandler(ws, projectPath) {
           break;
         case "GET_IMPORTS":
           try {
-            const filePath = path4.resolve(projectPath, message.filePath);
-            if (fs4.existsSync(filePath)) {
+            const filePath = path4.resolve(projectPath, message.filePath || "");
+            if (!_isInsideProject(projectPath, filePath)) {
+              response.error = "Access denied: Path outside project";
+            } else if (fs4.existsSync(filePath)) {
               const content = fs4.readFileSync(filePath, "utf-8");
               const importRegex = /import\s+(?:[\w*\s{},]*)\s+from\s+['"]([^'"]+)['"]/g;
               const imports = [];
@@ -2372,8 +3215,17 @@ function attachMessageHandler(ws, projectPath) {
           break;
         case "FIND_USAGES":
           try {
-            const query = message.query;
-            const { stdout } = await execAsync3(`git grep -n "${query}"`, { cwd: projectPath });
+            const query = typeof message.query === "string" ? message.query : "";
+            if (!query) {
+              response.error = "Empty query";
+              break;
+            }
+            const { stdout } = await execFileAsync3("git", [
+              "grep",
+              "-n",
+              "--",
+              query
+            ], { cwd: projectPath });
             response.data = {
               usages: stdout.split("\n").filter(Boolean).slice(0, 20).map((line) => {
                 const parts = line.split(":");
@@ -2393,8 +3245,10 @@ function attachMessageHandler(ws, projectPath) {
           break;
         case "GET_ENV_VARS":
           try {
-            const filePath = path4.resolve(projectPath, message.filePath);
-            if (fs4.existsSync(filePath)) {
+            const filePath = path4.resolve(projectPath, message.filePath || "");
+            if (!_isInsideProject(projectPath, filePath)) {
+              response.error = "Access denied: Path outside project";
+            } else 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();
@@ -2432,7 +3286,7 @@ function attachMessageHandler(ws, projectPath) {
       }
       ws.send(JSON.stringify(response));
     } catch (e) {
-      console.error(chalk.red("Parse error:"), e.message);
+      console.error(chalk2.red("Parse error:"), e.message);
     }
   });
   ws.on("message", (rawData) => {
@@ -2442,6 +3296,14 @@ function attachMessageHandler(ws, projectPath) {
         const { resolve: resolve3 } = globalBrowserPending.get(msg.id);
         globalBrowserPending.delete(msg.id);
         resolve3(msg.error ? { error: msg.error } : msg.data ?? {});
+      } else if (msg.type === "AGENT_PROGRESS" && msg.id && globalBrowserPending.has(msg.id)) {
+        const pending = globalBrowserPending.get(msg.id);
+        if (pending.onProgress) {
+          try {
+            pending.onProgress(msg.event);
+          } catch {
+          }
+        }
       }
     } catch {
     }
@@ -2451,53 +3313,53 @@ program.command("connect", { isDefault: true }).alias("c").description('Start ID
   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(chalk2.bold.cyan("\u{1F517} Trace IDE Bridge"));
+  console.log(chalk2.gray("\u2500".repeat(55)));
   console.log();
-  console.log(`Project: ${chalk.green(projectPath)}`);
-  console.log(`Port: ${chalk.cyan(port)}`);
+  console.log(`Project: ${chalk2.green(projectPath)}`);
+  console.log(`Port: ${chalk2.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}`);
+      console.log(`\u{1F4E6} Package: ${chalk2.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(chalk2.green("\u2713") + " WebSocket server started");
+  console.log(chalk2.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(chalk2.gray("\u2500".repeat(55)));
+  console.log(chalk2.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" : ""})`);
+    console.log(chalk2.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" : ""})`);
+      console.log(chalk2.yellow("\u25CF") + ` Extension disconnected (${clientCount} client${clientCount > 1 ? "s" : ""})`);
     });
     ws.on("error", (error) => {
-      console.error(chalk.red("WebSocket error:"), error.message);
+      console.error(chalk2.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"));
+      console.log(chalk2.red(`\u2717 Port ${port} is already in use`));
+      console.log(chalk2.dim("Try: trace-connect --port 8766"));
     } else {
-      console.error(chalk.red("Server error:"), error.message);
+      console.error(chalk2.red("Server error:"), error.message);
     }
     process.exit(1);
   });
   process.on("SIGINT", () => {
     console.log();
-    console.log(chalk.dim("Stopping..."));
+    console.log(chalk2.dim("Stopping..."));
     wss.close();
     process.exit(0);
   });