@freesyntax/notch-cli 0.4.8 → 0.5.0

package/dist/index.js

@@ -14,8 +14,8 @@ import {
 
 // src/index.ts
 import { Command } from "commander";
-import chalk9 from "chalk";
-import ora from "ora";
+import chalk26 from "chalk";
+import ora4 from "ora";
 import * as readline from "readline";
 import * as nodePath from "path";
 
@@ -866,7 +866,7 @@ var GITHUB_API = "https://api.github.com";
 function getToken() {
   return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
 }
-async function ghFetch(path19, opts2 = {}) {
+async function ghFetch(path25, opts2 = {}) {
   const token = getToken();
   const headers = {
     "Accept": "application/vnd.github+json",
@@ -874,7 +874,7 @@ async function ghFetch(path19, opts2 = {}) {
     ...opts2.headers ?? {}
   };
   if (token) headers["Authorization"] = `Bearer ${token}`;
-  return fetch(`${GITHUB_API}${path19}`, { ...opts2, headers });
+  return fetch(`${GITHUB_API}${path25}`, { ...opts2, headers });
 }
 var parameters9 = z9.object({
   action: z9.enum([
@@ -1031,24 +1031,516 @@ var githubTool = {
   execute
 };
 
+// src/tools/lsp.ts
+import { execSync as execSync3, execFileSync } from "child_process";
+import fs6 from "fs/promises";
+import path7 from "path";
+import { z as z10 } from "zod";
+var parameters10 = z10.object({
+  action: z10.enum(["definition", "references", "diagnostics", "hover"]).describe("LSP action: definition (go-to-def), references (find usages), diagnostics (type errors), hover (type info)"),
+  file: z10.string().describe("File path (relative or absolute)"),
+  line: z10.number().optional().describe("Line number (1-based) \u2014 required for definition, references, hover"),
+  character: z10.number().optional().describe("Column number (0-based) \u2014 required for definition, references, hover"),
+  symbol: z10.string().optional().describe("Symbol name to search for (alternative to line/character)")
+});
+function detectLanguage(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return { lang: "typescript", server: "typescript-language-server", tsconfig: true };
+    case ".py":
+      return { lang: "python", server: "pyright", tsconfig: false };
+    case ".go":
+      return { lang: "go", server: "gopls", tsconfig: false };
+    case ".rs":
+      return { lang: "rust", server: "rust-analyzer", tsconfig: false };
+    default:
+      return { lang: "unknown", server: null, tsconfig: false };
+  }
+}
+function isAvailable(cmd) {
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    execFileSync(which, [cmd], { stdio: "pipe", timeout: 3e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function tsDiagnostics(filePath, cwd) {
+  try {
+    const result = execSync3(
+      `npx tsc --noEmit --pretty false "${filePath}" 2>&1`,
+      { cwd, encoding: "utf-8", timeout: 3e4 }
+    );
+    return result.trim() || "No type errors found.";
+  } catch (err) {
+    const output = err.stdout || err.stderr || "";
+    if (output.includes("error TS")) {
+      const lines = output.split("\n").filter((l) => l.includes("error TS"));
+      return lines.slice(0, 20).join("\n") || "No type errors found.";
+    }
+    try {
+      const result = execSync3(
+        `npx tsc --noEmit --pretty false 2>&1 | head -30`,
+        { cwd, encoding: "utf-8", timeout: 3e4, shell: true }
+      );
+      return result.trim() || "No type errors found.";
+    } catch (err2) {
+      const out = err2.stdout || err2.stderr || "";
+      const errLines = out.split("\n").filter((l) => l.includes("error TS"));
+      return errLines.slice(0, 20).join("\n") || "Could not run type checker.";
+    }
+  }
+}
+async function findDefinition(symbol, cwd) {
+  const patterns = [
+    `(function|const|let|var|class|interface|type|enum)\\s+${symbol}\\b`,
+    `export\\s+(default\\s+)?(function|const|let|var|class|interface|type|enum)\\s+${symbol}\\b`,
+    `def\\s+${symbol}\\s*\\(`,
+    // Python
+    `func\\s+${symbol}\\s*\\(`,
+    // Go
+    `fn\\s+${symbol}\\s*[<(]`
+    // Rust
+  ];
+  const combinedPattern = patterns.join("|");
+  try {
+    const result = execSync3(
+      `rg --no-heading --line-number -e "${combinedPattern}" --type-add "code:*.{ts,tsx,js,jsx,py,go,rs}" --type code -m 10`,
+      { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 }
+    );
+    return result.trim() || `No definition found for "${symbol}"`;
+  } catch {
+    try {
+      const result = execSync3(
+        `grep -rn -E "${combinedPattern}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.py" --include="*.go" --include="*.rs" . | head -10`,
+        { cwd, encoding: "utf-8", timeout: 1e4, shell: true, maxBuffer: 1024 * 1024 }
+      );
+      return result.trim() || `No definition found for "${symbol}"`;
+    } catch {
+      return `No definition found for "${symbol}"`;
+    }
+  }
+}
+async function findReferences(symbol, cwd) {
+  try {
+    const result = execSync3(
+      `rg --no-heading --line-number -w "${symbol}" --type-add "code:*.{ts,tsx,js,jsx,py,go,rs}" --type code -m 30`,
+      { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 }
+    );
+    const lines = result.trim().split("\n");
+    return `Found ${lines.length} reference(s) for "${symbol}":
+
+${lines.join("\n")}`;
+  } catch {
+    try {
+      const result = execSync3(
+        `grep -rn -w "${symbol}" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.py" --include="*.go" --include="*.rs" . | head -30`,
+        { cwd, encoding: "utf-8", timeout: 1e4, shell: true, maxBuffer: 1024 * 1024 }
+      );
+      const lines = result.trim().split("\n");
+      return `Found ${lines.length} reference(s) for "${symbol}":
+
+${lines.join("\n")}`;
+    } catch {
+      return `No references found for "${symbol}"`;
+    }
+  }
+}
+async function getHoverInfo(symbol, filePath, line, cwd) {
+  try {
+    const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+    const content = await fs6.readFile(absPath, "utf-8");
+    const lines = content.split("\n");
+    const startLine = Math.max(0, line - 3);
+    const endLine = Math.min(lines.length, line + 2);
+    const context = lines.slice(startLine, endLine).map((l, i) => `${startLine + i + 1}: ${l}`).join("\n");
+    const def = await findDefinition(symbol, cwd);
+    return `## Context at ${filePath}:${line}
+\`\`\`
+${context}
+\`\`\`
+
+## Definition
+${def}`;
+  } catch (err) {
+    return `Could not get hover info: ${err.message}`;
+  }
+}
+async function getDiagnostics(filePath, cwd) {
+  const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+  const { lang } = detectLanguage(absPath);
+  switch (lang) {
+    case "typescript":
+      return tsDiagnostics(absPath, cwd);
+    case "python": {
+      if (isAvailable("pyright")) {
+        try {
+          const result = execFileSync("pyright", [absPath], {
+            cwd,
+            encoding: "utf-8",
+            timeout: 3e4
+          });
+          return result.trim() || "No errors found.";
+        } catch (err) {
+          return err.stdout || err.stderr || "Pyright check failed.";
+        }
+      }
+      try {
+        execFileSync("python", ["-m", "py_compile", absPath], {
+          cwd,
+          encoding: "utf-8",
+          timeout: 1e4
+        });
+        return "No syntax errors found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Syntax check failed.";
+      }
+    }
+    case "go": {
+      try {
+        const result = execFileSync("go", ["vet", absPath], {
+          cwd,
+          encoding: "utf-8",
+          timeout: 15e3
+        });
+        return result.trim() || "No issues found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Go vet failed.";
+      }
+    }
+    case "rust": {
+      try {
+        const result = execSync3(`cargo check --message-format short 2>&1 | head -30`, {
+          cwd,
+          encoding: "utf-8",
+          timeout: 6e4,
+          shell: true
+        });
+        return result.trim() || "No issues found.";
+      } catch (err) {
+        return err.stderr || err.stdout || "Cargo check failed.";
+      }
+    }
+    default:
+      return `No language server available for ${lang} files. Use grep to search for symbols.`;
+  }
+}
+var lspTool = {
+  name: "lsp",
+  description: "Code intelligence: find definitions, references, type errors, and hover info. Uses TypeScript compiler, pyright, gopls, or grep-based heuristics. Actions: definition (go-to-def), references (find usages), diagnostics (type errors), hover (type info). Provide either line/character position or a symbol name.",
+  parameters: parameters10,
+  async execute(params, ctx) {
+    const filePath = params.file;
+    const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(ctx.cwd, filePath);
+    try {
+      switch (params.action) {
+        case "definition": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await findDefinition(symbol, ctx.cwd);
+          return { content: result };
+        }
+        case "references": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await findReferences(symbol, ctx.cwd);
+          return { content: result };
+        }
+        case "diagnostics": {
+          const result = await getDiagnostics(filePath, ctx.cwd);
+          return { content: result };
+        }
+        case "hover": {
+          const symbol = params.symbol || await extractSymbol(absPath, params.line, params.character);
+          if (!symbol) {
+            return { content: "Provide a symbol name or line/character position.", isError: true };
+          }
+          const result = await getHoverInfo(symbol, filePath, params.line ?? 1, ctx.cwd);
+          return { content: result };
+        }
+        default:
+          return { content: `Unknown action: ${params.action}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `LSP error: ${err.message}`, isError: true };
+    }
+  }
+};
+async function extractSymbol(filePath, line, character) {
+  if (!line) return null;
+  try {
+    const content = await fs6.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const lineText = lines[line - 1];
+    if (!lineText) return null;
+    const col = character ?? 0;
+    const wordRegex = /[a-zA-Z_$][a-zA-Z0-9_$]*/g;
+    let match;
+    while ((match = wordRegex.exec(lineText)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (col >= start && col <= end) {
+        return match[0];
+      }
+    }
+    const firstMatch = lineText.match(/[a-zA-Z_$][a-zA-Z0-9_$]*/);
+    return firstMatch?.[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/notebook.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+import { z as z11 } from "zod";
+var parameters11 = z11.object({
+  action: z11.enum(["read", "edit", "add", "remove"]).describe("Action: read (view cells), edit (modify cell source), add (insert new cell), remove (delete cell)"),
+  path: z11.string().describe("Path to the .ipynb notebook file"),
+  cell_index: z11.number().optional().describe("Cell index (0-based) \u2014 for edit/remove actions"),
+  cell_type: z11.enum(["code", "markdown", "raw"]).optional().describe("Cell type \u2014 for add action"),
+  content: z11.string().optional().describe("New cell content \u2014 for edit/add actions"),
+  insert_after: z11.number().optional().describe("Insert after this cell index \u2014 for add action (-1 for beginning)")
+});
+function formatNotebook(nb, filePath) {
+  const parts = [
+    `# ${path8.basename(filePath)}`,
+    `# ${nb.cells.length} cells | nbformat ${nb.nbformat}.${nb.nbformat_minor}`,
+    ""
+  ];
+  for (let i = 0; i < nb.cells.length; i++) {
+    const cell = nb.cells[i];
+    const source = cell.source.join("");
+    const header = cell.cell_type === "code" ? `[${i}] Code (exec: ${cell.execution_count ?? "-"})` : `[${i}] ${cell.cell_type.charAt(0).toUpperCase() + cell.cell_type.slice(1)}`;
+    parts.push(`--- ${header} ---`);
+    parts.push(source);
+    if (cell.cell_type === "code" && cell.outputs && cell.outputs.length > 0) {
+      parts.push("  Output:");
+      for (const output of cell.outputs) {
+        if (output.text) {
+          parts.push("  " + output.text.join("").slice(0, 500));
+        } else if (output.data?.["text/plain"]) {
+          parts.push("  " + output.data["text/plain"].join("").slice(0, 500));
+        } else if (output.ename) {
+          parts.push(`  Error: ${output.ename}: ${output.evalue}`);
+        }
+      }
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+var notebookTool = {
+  name: "notebook",
+  description: "Read and edit Jupyter .ipynb notebook files. Actions: read (view all cells with outputs), edit (modify a cell), add (insert a new cell), remove (delete a cell).",
+  parameters: parameters11,
+  async execute(params, ctx) {
+    const filePath = path8.isAbsolute(params.path) ? params.path : path8.resolve(ctx.cwd, params.path);
+    try {
+      switch (params.action) {
+        case "read": {
+          const raw = await fs7.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          return { content: formatNotebook(nb, filePath) };
+        }
+        case "edit": {
+          if (params.cell_index === void 0) {
+            return { content: "cell_index is required for edit action.", isError: true };
+          }
+          if (params.content === void 0) {
+            return { content: "content is required for edit action.", isError: true };
+          }
+          const raw = await fs7.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          if (params.cell_index < 0 || params.cell_index >= nb.cells.length) {
+            return { content: `Cell index ${params.cell_index} out of range (0-${nb.cells.length - 1}).`, isError: true };
+          }
+          const lines = params.content.split("\n").map(
+            (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
+          );
+          nb.cells[params.cell_index].source = lines;
+          await fs7.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Cell [${params.cell_index}] updated in ${path8.basename(filePath)}.` };
+        }
+        case "add": {
+          if (params.content === void 0) {
+            return { content: "content is required for add action.", isError: true };
+          }
+          const raw = await fs7.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          const cellType = params.cell_type ?? "code";
+          const lines = params.content.split("\n").map(
+            (l, i, arr) => i < arr.length - 1 ? l + "\n" : l
+          );
+          const newCell = {
+            cell_type: cellType,
+            source: lines,
+            metadata: {},
+            ...cellType === "code" ? { outputs: [], execution_count: null } : {}
+          };
+          const insertIdx = params.insert_after !== void 0 ? params.insert_after + 1 : nb.cells.length;
+          nb.cells.splice(insertIdx, 0, newCell);
+          await fs7.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Added ${cellType} cell at index [${insertIdx}] in ${path8.basename(filePath)}.` };
+        }
+        case "remove": {
+          if (params.cell_index === void 0) {
+            return { content: "cell_index is required for remove action.", isError: true };
+          }
+          const raw = await fs7.readFile(filePath, "utf-8");
+          const nb = JSON.parse(raw);
+          if (params.cell_index < 0 || params.cell_index >= nb.cells.length) {
+            return { content: `Cell index ${params.cell_index} out of range (0-${nb.cells.length - 1}).`, isError: true };
+          }
+          const removed = nb.cells.splice(params.cell_index, 1)[0];
+          await fs7.writeFile(filePath, JSON.stringify(nb, null, 1) + "\n");
+          return { content: `Removed ${removed.cell_type} cell [${params.cell_index}] from ${path8.basename(filePath)}. ${nb.cells.length} cells remaining.` };
+        }
+        default:
+          return { content: `Unknown action: ${params.action}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `Notebook error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/task.ts
+import { z as z12 } from "zod";
+import chalk from "chalk";
+var tasks = [];
+var nextId = 1;
+var parameters12 = z12.object({
+  action: z12.enum(["create", "update", "list", "get"]).describe("Action: create (new task), update (change status/subject), list (show all), get (show one)"),
+  subject: z12.string().optional().describe("Task title \u2014 for create action"),
+  description: z12.string().optional().describe("Task details \u2014 for create action"),
+  task_id: z12.number().int().positive().optional().describe("Task ID \u2014 for update/get actions"),
+  status: z12.enum(["pending", "in_progress", "completed", "failed"]).optional().describe("New status \u2014 for update action")
+});
+function formatTask(t) {
+  const icons = {
+    pending: "\u25CB",
+    in_progress: "\u25D0",
+    completed: "\u25CF",
+    failed: "\u2717"
+  };
+  const colors = {
+    pending: chalk.gray,
+    in_progress: chalk.yellow,
+    completed: chalk.green,
+    failed: chalk.red
+  };
+  return `${colors[t.status](icons[t.status])} #${t.id} ${colors[t.status](t.subject)} [${t.status}]`;
+}
+function formatTaskList() {
+  if (tasks.length === 0) return "No tasks.";
+  return tasks.map(formatTask).join("\n");
+}
+var taskTool = {
+  name: "task",
+  description: "Manage tasks within the current session. Use this to break complex work into tracked steps. Actions: create (new task), update (change status), list (show all tasks), get (show one task). Mark tasks as in_progress when starting and completed when done.",
+  parameters: parameters12,
+  async execute(params, _ctx) {
+    switch (params.action) {
+      case "create": {
+        if (!params.subject) {
+          return { content: "subject is required for create action.", isError: true };
+        }
+        const task = {
+          id: nextId++,
+          subject: params.subject,
+          description: params.description,
+          status: "pending",
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        tasks.push(task);
+        console.log(chalk.gray(`  ${formatTask(task)}`));
+        return { content: `Task #${task.id} created: ${task.subject}` };
+      }
+      case "update": {
+        if (params.task_id === void 0) {
+          return { content: "task_id is required for update action.", isError: true };
+        }
+        const task = tasks.find((t) => t.id === params.task_id);
+        if (!task) {
+          return { content: `Task #${params.task_id} not found.`, isError: true };
+        }
+        if (params.status) task.status = params.status;
+        if (params.subject) task.subject = params.subject;
+        task.updatedAt = Date.now();
+        console.log(chalk.gray(`  ${formatTask(task)}`));
+        return { content: `Task #${task.id} updated: ${task.subject} [${task.status}]` };
+      }
+      case "list": {
+        const output = formatTaskList();
+        return { content: output };
+      }
+      case "get": {
+        if (params.task_id === void 0) {
+          return { content: "task_id is required for get action.", isError: true };
+        }
+        const task = tasks.find((t) => t.id === params.task_id);
+        if (!task) {
+          return { content: `Task #${params.task_id} not found.`, isError: true };
+        }
+        const details = [
+          formatTask(task),
+          task.description ? `  ${task.description}` : "",
+          `  Created: ${new Date(task.createdAt).toLocaleTimeString()}`,
+          `  Updated: ${new Date(task.updatedAt).toLocaleTimeString()}`
+        ].filter(Boolean).join("\n");
+        return { content: details };
+      }
+      default:
+        return { content: `Unknown action: ${params.action}`, isError: true };
+    }
+  }
+};
+function getAllTasks() {
+  return [...tasks];
+}
+function formatTasksDisplay() {
+  return formatTaskList();
+}
+
 // src/mcp/client.ts
+import { z as z13 } from "zod";
+
+// src/mcp/transport.ts
+function detectTransport(config) {
+  if (config.transport) return config.transport;
+  if (config.url) return "http";
+  return "stdio";
+}
+
+// src/mcp/stdio-transport.ts
 import { spawn } from "child_process";
-import { z as z10 } from "zod";
-var MCPClient = class {
-  constructor(config, serverName) {
+var StdioTransport = class {
+  constructor(config, name) {
     this.config = config;
-    this.serverName = serverName;
+    this.name = name;
   }
   process = null;
   requestId = 0;
   pendingRequests = /* @__PURE__ */ new Map();
   buffer = "";
-  serverName;
-  _tools = [];
-  /**
-   * Start the MCP server and initialize the connection.
-   */
+  name;
   async connect() {
+    if (!this.config.command) {
+      throw new Error(`Stdio transport requires 'command' in config for server ${this.name}`);
+    }
     this.process = spawn(this.config.command, this.config.args ?? [], {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...this.config.env },
@@ -1061,54 +1553,17 @@ var MCPClient = class {
     });
     this.process.on("error", (err) => {
       for (const [id, pending] of this.pendingRequests) {
-        pending.reject(new Error(`MCP server ${this.serverName} error: ${err.message}`));
+        pending.reject(new Error(`MCP server ${this.name} error: ${err.message}`));
         this.pendingRequests.delete(id);
       }
     });
     this.process.on("exit", (code) => {
       for (const [id, pending] of this.pendingRequests) {
-        pending.reject(new Error(`MCP server ${this.serverName} exited with code ${code}`));
+        pending.reject(new Error(`MCP server ${this.name} exited with code ${code}`));
         this.pendingRequests.delete(id);
       }
     });
-    await this.sendRequest("initialize", {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: { name: "notch-cli", version: "0.3.0" }
-    });
-    this.sendNotification("notifications/initialized", {});
-    const result = await this.sendRequest("tools/list", {});
-    this._tools = result.tools ?? [];
-  }
-  /**
-   * Get discovered tools from this server.
-   */
-  get tools() {
-    return this._tools;
-  }
-  /**
-   * Check if the MCP server process is still alive.
-   */
-  get isAlive() {
-    return this.process !== null && this.process.exitCode === null && !this.process.killed;
-  }
-  /**
-   * Call a tool on the MCP server. Auto-reconnects if the server has crashed.
-   */
-  async callTool(name, args) {
-    if (!this.isAlive) {
-      try {
-        await this.connect();
-      } catch (err) {
-        throw new Error(`MCP server ${this.serverName} is down and could not reconnect: ${err.message}`);
-      }
-    }
-    const result = await this.sendRequest("tools/call", { name, arguments: args });
-    return result;
   }
-  /**
-   * Disconnect from the MCP server.
-   */
   disconnect() {
     if (this.process) {
       this.process.stdin?.end();
@@ -1117,15 +1572,13 @@ var MCPClient = class {
     }
     this.pendingRequests.clear();
   }
+  get isAlive() {
+    return this.process !== null && this.process.exitCode === null && !this.process.killed;
+  }
   sendRequest(method, params) {
     return new Promise((resolve2, reject) => {
       const id = ++this.requestId;
-      const msg = {
-        jsonrpc: "2.0",
-        id,
-        method,
-        params
-      };
+      const msg = { jsonrpc: "2.0", id, method, params };
       this.pendingRequests.set(id, { resolve: resolve2, reject });
       const data = JSON.stringify(msg);
       const header = `Content-Length: ${Buffer.byteLength(data)}\r
@@ -1141,11 +1594,7 @@ var MCPClient = class {
     });
   }
   sendNotification(method, params) {
-    const msg = {
-      jsonrpc: "2.0",
-      method,
-      params
-    };
+    const msg = { jsonrpc: "2.0", method, params };
     const data = JSON.stringify(msg);
     const header = `Content-Length: ${Buffer.byteLength(data)}\r
 \r
@@ -1190,41 +1639,500 @@ var MCPClient = class {
     }
   }
 };
-function parseMCPConfig(config) {
-  const servers = config?.mcpServers;
-  if (!servers || typeof servers !== "object") return {};
-  const result = {};
-  for (const [name, cfg] of Object.entries(servers)) {
-    const c = cfg;
-    if (c?.command) {
-      result[name] = {
-        command: c.command,
-        args: c.args,
-        env: c.env,
-        cwd: c.cwd
-      };
+
+// src/mcp/http-transport.ts
+var HttpTransport = class {
+  requestId = 0;
+  connected = false;
+  name;
+  baseUrl;
+  headers;
+  constructor(config, name) {
+    this.name = name;
+    if (!config.url) {
+      throw new Error(`HTTP transport requires 'url' in config for server ${name}`);
+    }
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+  }
+  async connect() {
+    try {
+      const response = await fetch(`${this.baseUrl}`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: ++this.requestId,
+          method: "initialize",
+          params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "notch-cli", version: "0.4.8" }
+          }
+        }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      this.sendNotification("notifications/initialized", {});
+      this.connected = true;
+    } catch (err) {
+      throw new Error(`MCP HTTP server ${this.name} unreachable: ${err.message}`);
     }
   }
-  return result;
-}
+  disconnect() {
+    this.connected = false;
+  }
+  get isAlive() {
+    return this.connected;
+  }
+  async sendRequest(method, params) {
+    const id = ++this.requestId;
+    const body = { jsonrpc: "2.0", id, method, params };
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      throw new Error(`MCP HTTP error (${this.name}): ${response.status} ${response.statusText}`);
+    }
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(`MCP error (${this.name}): ${json.error.message}`);
+    }
+    return json.result;
+  }
+  sendNotification(method, params) {
+    void fetch(this.baseUrl, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => {
+    });
+  }
+};
 
-// src/tools/index.ts
-var BUILTIN_TOOLS = [
-  readTool,
-  writeTool,
-  editTool,
-  shellTool,
-  gitTool,
-  githubTool,
-  grepTool,
-  globTool,
-  webFetchTool
-];
-var mcpTools = [];
-function getAllTools() {
-  return [...BUILTIN_TOOLS, ...mcpTools];
-}
-function buildToolMap(ctx) {
+// src/mcp/sse-transport.ts
+var SSETransport = class {
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  abortController = null;
+  connected = false;
+  name;
+  baseUrl;
+  messageEndpoint;
+  sseEndpoint;
+  headers;
+  constructor(config, name) {
+    this.name = name;
+    if (!config.url) {
+      throw new Error(`SSE transport requires 'url' in config for server ${name}`);
+    }
+    this.baseUrl = config.url.replace(/\/$/, "");
+    this.sseEndpoint = `${this.baseUrl}/sse`;
+    this.messageEndpoint = `${this.baseUrl}/message`;
+    this.headers = {
+      "Content-Type": "application/json",
+      ...config.headers
+    };
+  }
+  async connect() {
+    this.abortController = new AbortController();
+    const ssePromise = this.startSSEListener();
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
+    const initResult = await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "notch-cli", version: "0.4.8" }
+    });
+    if (!initResult) {
+      throw new Error(`MCP SSE server ${this.name} failed to initialize`);
+    }
+    this.sendNotification("notifications/initialized", {});
+    this.connected = true;
+    ssePromise.catch(() => {
+      this.connected = false;
+    });
+  }
+  disconnect() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.connected = false;
+    for (const [id, pending] of this.pendingRequests) {
+      pending.reject(new Error(`MCP SSE transport disconnected`));
+      this.pendingRequests.delete(id);
+    }
+  }
+  get isAlive() {
+    return this.connected;
+  }
+  async sendRequest(method, params) {
+    const id = ++this.requestId;
+    const body = { jsonrpc: "2.0", id, method, params };
+    const resultPromise = new Promise((resolve2, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve2, reject });
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`MCP SSE request ${method} timed out`));
+        }
+      }, 3e4);
+    });
+    const response = await fetch(this.messageEndpoint, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      this.pendingRequests.delete(id);
+      throw new Error(`MCP SSE POST error (${this.name}): ${response.status} ${response.statusText}`);
+    }
+    return resultPromise;
+  }
+  sendNotification(method, params) {
+    const body = { jsonrpc: "2.0", method, params };
+    void fetch(this.messageEndpoint, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(1e4)
+    }).catch(() => {
+    });
+  }
+  /**
+   * Start listening for Server-Sent Events.
+   * Parses the SSE stream and resolves pending requests.
+   */
+  async startSSEListener() {
+    const response = await fetch(this.sseEndpoint, {
+      headers: {
+        Accept: "text/event-stream",
+        ...this.headers
+      },
+      signal: this.abortController?.signal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`SSE connection failed: ${response.status}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const events = buffer.split("\n\n");
+        buffer = events.pop() ?? "";
+        for (const event of events) {
+          const lines = event.split("\n");
+          let data = "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              data += line.slice(6);
+            }
+          }
+          if (data) {
+            this.handleSSEMessage(data);
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        this.connected = false;
+      }
+    }
+  }
+  handleSSEMessage(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.id !== void 0 && this.pendingRequests.has(msg.id)) {
+        const pending = this.pendingRequests.get(msg.id);
+        this.pendingRequests.delete(msg.id);
+        if (msg.error) {
+          pending.reject(new Error(`MCP SSE error: ${msg.error.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/mcp/client.ts
+function createTransport(config, name) {
+  const type = detectTransport(config);
+  switch (type) {
+    case "http":
+      return new HttpTransport(config, name);
+    case "sse":
+      return new SSETransport(config, name);
+    case "stdio":
+    default:
+      return new StdioTransport(config, name);
+  }
+}
+var MCPClient = class {
+  transport;
+  serverName;
+  _tools = [];
+  constructor(config, serverName) {
+    this.serverName = serverName;
+    this.transport = createTransport(config, serverName);
+  }
+  /**
+   * Start the MCP server and initialize the connection.
+   */
+  async connect() {
+    await this.transport.connect();
+    await this.transport.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "notch-cli", version: "0.4.8" }
+    });
+    this.transport.sendNotification("notifications/initialized", {});
+    const result = await this.transport.sendRequest("tools/list", {});
+    this._tools = result.tools ?? [];
+  }
+  /**
+   * Get discovered tools from this server.
+   */
+  get tools() {
+    return this._tools;
+  }
+  /**
+   * Check if the MCP server is still alive.
+   */
+  get isAlive() {
+    return this.transport.isAlive;
+  }
+  /**
+   * Call a tool on the MCP server. Auto-reconnects if the server has crashed.
+   */
+  async callTool(name, args) {
+    if (!this.isAlive) {
+      try {
+        await this.transport.connect();
+      } catch (err) {
+        throw new Error(`MCP server ${this.serverName} is down and could not reconnect: ${err.message}`);
+      }
+    }
+    return this.transport.sendRequest("tools/call", { name, arguments: args });
+  }
+  /**
+   * Disconnect from the MCP server.
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+};
+function parseMCPConfig(config) {
+  const servers = config?.mcpServers;
+  if (!servers || typeof servers !== "object") return {};
+  const result = {};
+  for (const [name, cfg] of Object.entries(servers)) {
+    const c = cfg;
+    if (c?.command || c?.url) {
+      result[name] = {
+        command: c.command,
+        args: c.args,
+        env: c.env,
+        cwd: c.cwd,
+        transport: c.transport,
+        url: c.url,
+        headers: c.headers
+      };
+    }
+  }
+  return result;
+}
+
+// src/plugins/discovery.ts
+import fs8 from "fs/promises";
+import path9 from "path";
+import os from "os";
+async function discoverPlugins(projectRoot) {
+  const globalDir = path9.join(os.homedir(), ".notch", "plugins");
+  const projectDir = path9.join(projectRoot, ".notch", "plugins");
+  const plugins = /* @__PURE__ */ new Map();
+  for (const plugin of await scanDirectory(globalDir)) {
+    plugins.set(plugin.name, plugin);
+  }
+  for (const plugin of await scanDirectory(projectDir)) {
+    plugins.set(plugin.name, plugin);
+  }
+  return [...plugins.values()];
+}
+async function scanDirectory(dir) {
+  const results = [];
+  try {
+    const entries = await fs8.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginDir = path9.join(dir, entry.name);
+      const pkgPath = path9.join(pluginDir, "package.json");
+      try {
+        const raw = await fs8.readFile(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg["notch-plugin"] && pkg.name) {
+          results.push({
+            name: pkg.name,
+            version: pkg.version ?? "0.0.0",
+            description: pkg.description ?? "",
+            path: pluginDir,
+            manifest: pkg["notch-plugin"]
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/plugins/loader.ts
+import path10 from "path";
+import { pathToFileURL } from "url";
+
+// src/commands/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerCommand(name, handler) {
+  registry.set(name, handler);
+}
+async function dispatchCommand(input, ctx) {
+  for (const [name, handler] of registry) {
+    if (input === name || input.startsWith(name + " ")) {
+      const args = input.slice(name.length).trim();
+      await handler(args, ctx);
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/plugins/loader.ts
+async function loadPlugin(discovered, projectRoot, log) {
+  const entryPath = path10.resolve(discovered.path, discovered.manifest.main);
+  const tools = [];
+  const hooks = [];
+  const ctx = {
+    cwd: projectRoot,
+    log,
+    registerTool(tool2) {
+      tools.push(tool2);
+    },
+    registerCommand(name, handler) {
+      registerCommand(name, handler);
+    },
+    registerHook(hook) {
+      hooks.push(hook);
+    }
+  };
+  try {
+    const moduleUrl = pathToFileURL(entryPath).href;
+    const mod = await import(moduleUrl);
+    const plugin = mod.default ?? mod;
+    if (typeof plugin.activate !== "function") {
+      log(`Plugin ${discovered.name}: no activate() function \u2014 skipping`);
+      return null;
+    }
+    await plugin.activate(ctx);
+    return {
+      name: discovered.name,
+      version: discovered.version,
+      description: discovered.description,
+      path: discovered.path,
+      instance: plugin,
+      tools,
+      hooks
+    };
+  } catch (err) {
+    log(`Plugin ${discovered.name} failed to load: ${err.message}`);
+    return null;
+  }
+}
+
+// src/plugins/index.ts
+var PluginManager = class {
+  plugins = [];
+  initialized = false;
+  /**
+   * Discover and load all plugins. Call once at startup.
+   */
+  async init(projectRoot, log) {
+    if (this.initialized) return this.plugins.length;
+    const discovered = await discoverPlugins(projectRoot);
+    if (discovered.length === 0) {
+      this.initialized = true;
+      return 0;
+    }
+    for (const d of discovered) {
+      const loaded = await loadPlugin(d, projectRoot, log);
+      if (loaded) {
+        this.plugins.push(loaded);
+      }
+    }
+    this.initialized = true;
+    return this.plugins.length;
+  }
+  /** All tools registered by plugins */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getTools() {
+    return this.plugins.flatMap((p) => p.tools);
+  }
+  /** All hooks registered by plugins */
+  getHooks() {
+    return this.plugins.flatMap((p) => p.hooks);
+  }
+  /** List all loaded plugins */
+  list() {
+    return [...this.plugins];
+  }
+  /** Shut down all plugins gracefully */
+  async shutdown() {
+    for (const p of this.plugins) {
+      try {
+        await p.instance.deactivate?.();
+      } catch (err) {
+        console.warn(`  Plugin ${p.name} deactivation failed: ${err.message}`);
+      }
+    }
+    this.plugins = [];
+    this.initialized = false;
+  }
+};
+var pluginManager = new PluginManager();
+
+// src/tools/index.ts
+var BUILTIN_TOOLS = [
+  readTool,
+  writeTool,
+  editTool,
+  shellTool,
+  gitTool,
+  githubTool,
+  grepTool,
+  globTool,
+  webFetchTool,
+  lspTool,
+  notebookTool,
+  taskTool
+];
+var mcpTools = [];
+function getAllTools() {
+  return [...BUILTIN_TOOLS, ...mcpTools, ...pluginManager.getTools()];
+}
+function buildToolMap(ctx) {
   const map = {};
   for (const t of getAllTools()) {
     map[t.name] = tool({
@@ -1232,8 +2140,10 @@ function buildToolMap(ctx) {
       parameters: t.parameters,
       execute: async (params) => {
         if (ctx.checkPermission) {
+          await ctx.runHook?.("permission-request", { tool: t.name, args: params });
           const level = ctx.checkPermission(t.name, params);
           if (level === "deny") {
+            await ctx.runHook?.("permission-denied", { tool: t.name, args: params, reason: "denied-by-config" });
             return {
               content: `Permission denied: ${t.name} is not allowed by your permission config.`,
               isError: true
@@ -1245,6 +2155,7 @@ function buildToolMap(ctx) {
               `Tool ${t.name}(${paramSummary}) requires approval. Proceed?`
             );
             if (!confirmed) {
+              await ctx.runHook?.("permission-denied", { tool: t.name, args: params, reason: "cancelled-by-user" });
               return { content: "Cancelled by user.", isError: true };
             }
           }
@@ -1277,15 +2188,15 @@ function describeTools() {
 }
 
 // src/context/project-instructions.ts
-import fs6 from "fs/promises";
-import path7 from "path";
-import os from "os";
+import fs9 from "fs/promises";
+import path11 from "path";
+import os2 from "os";
 var INSTRUCTION_FILES = [".notch.md", "NOTCH.md", ".notch/instructions.md"];
 async function loadProjectInstructions(projectRoot) {
   const sources = [];
-  const homeDir = os.homedir();
+  const homeDir = os2.homedir();
   for (const file of INSTRUCTION_FILES) {
-    const globalPath = path7.join(homeDir, file);
+    const globalPath = path11.join(homeDir, file);
     const content = await safeRead(globalPath);
     if (content) {
       sources.push({ path: globalPath, content, scope: "global" });
@@ -1293,7 +2204,7 @@ async function loadProjectInstructions(projectRoot) {
     }
   }
   for (const file of INSTRUCTION_FILES) {
-    const projectPath = path7.join(projectRoot, file);
+    const projectPath = path11.join(projectRoot, file);
     const content = await safeRead(projectPath);
     if (content) {
       sources.push({ path: projectPath, content, scope: "project" });
@@ -1315,7 +2226,7 @@ ${sections.join("\n\n")}`;
 }
 async function safeRead(filePath) {
   try {
-    const content = await fs6.readFile(filePath, "utf-8");
+    const content = await fs9.readFile(filePath, "utf-8");
     return content.trim() || null;
   } catch {
     return null;
@@ -1323,19 +2234,19 @@ async function safeRead(filePath) {
 }
 
 // src/memory/store.ts
-import fs7 from "fs/promises";
-import path8 from "path";
-import os2 from "os";
-var MEMORY_DIR = path8.join(os2.homedir(), ".notch", "memory");
-var INDEX_FILE = path8.join(MEMORY_DIR, "MEMORY.md");
+import fs10 from "fs/promises";
+import path12 from "path";
+import os3 from "os";
+var MEMORY_DIR = path12.join(os3.homedir(), ".notch", "memory");
+var INDEX_FILE = path12.join(MEMORY_DIR, "MEMORY.md");
 async function ensureDir() {
-  await fs7.mkdir(MEMORY_DIR, { recursive: true });
+  await fs10.mkdir(MEMORY_DIR, { recursive: true });
 }
 async function saveMemory(memory) {
   await ensureDir();
   const slug = memory.name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   const filename = `${memory.type}_${slug}.md`;
-  const filePath = path8.join(MEMORY_DIR, filename);
+  const filePath = path12.join(MEMORY_DIR, filename);
   const fileContent = [
     "---",
     `name: ${memory.name}`,
@@ -1346,18 +2257,18 @@ async function saveMemory(memory) {
     "",
     memory.content
   ].join("\n");
-  await fs7.writeFile(filePath, fileContent, "utf-8");
+  await fs10.writeFile(filePath, fileContent, "utf-8");
   await updateIndex();
   return filename;
 }
 async function loadMemories() {
   await ensureDir();
-  const files = await fs7.readdir(MEMORY_DIR);
+  const files = await fs10.readdir(MEMORY_DIR);
   const memories = [];
   for (const file of files) {
     if (!file.endsWith(".md") || file === "MEMORY.md") continue;
     try {
-      const content = await fs7.readFile(path8.join(MEMORY_DIR, file), "utf-8");
+      const content = await fs10.readFile(path12.join(MEMORY_DIR, file), "utf-8");
       const memory = parseMemoryFile(content, file);
       if (memory) memories.push(memory);
     } catch {
@@ -1367,7 +2278,7 @@ async function loadMemories() {
 }
 async function deleteMemory(filename) {
   try {
-    await fs7.unlink(path8.join(MEMORY_DIR, filename));
+    await fs10.unlink(path12.join(MEMORY_DIR, filename));
     await updateIndex();
     return true;
   } catch {
@@ -1443,7 +2354,7 @@ async function updateIndex() {
     }
     lines.push("");
   }
-  await fs7.writeFile(INDEX_FILE, lines.join("\n"), "utf-8");
+  await fs10.writeFile(INDEX_FILE, lines.join("\n"), "utf-8");
 }
 
 // src/agent/loop.ts
@@ -1462,10 +2373,14 @@ async function runAgentLoop(messages, config) {
   let totalCompletionTokens = 0;
   let wasCompressed = false;
   let history = [...messages];
+  await config.toolContext.runHook?.("pre-compact", { messageCount: history.length });
   history = await autoCompress(history, config.model, contextWindow, () => {
     wasCompressed = true;
     config.onCompress?.();
   });
+  if (wasCompressed) {
+    await config.toolContext.runHook?.("post-compact", { messageCount: history.length });
+  }
   while (iterations < maxIter) {
     iterations++;
     const result = streamText({
@@ -1537,10 +2452,15 @@ async function runAgentLoop(messages, config) {
         }))
       });
       if (iterations % 5 === 0) {
+        const prevLen = history.length;
+        await config.toolContext.runHook?.("pre-compact", { messageCount: prevLen });
         history = await autoCompress(history, config.model, contextWindow, () => {
           wasCompressed = true;
           config.onCompress?.();
         });
+        if (history.length < prevLen) {
+          await config.toolContext.runHook?.("post-compact", { messageCount: history.length });
+        }
       }
       continue;
     }
@@ -1623,8 +2543,8 @@ async function buildSystemPrompt(projectRoot, modelId) {
 }
 
 // src/agent/checkpoints.ts
-import fs8 from "fs/promises";
-import path9 from "path";
+import fs11 from "fs/promises";
+import path13 from "path";
 var CheckpointManager = class {
   checkpoints = [];
   nextId = 1;
@@ -1633,7 +2553,7 @@ var CheckpointManager = class {
   async recordBefore(filePath) {
     if (this.pendingFiles.has(filePath)) return;
     try {
-      const content = await fs8.readFile(filePath, "utf-8");
+      const content = await fs11.readFile(filePath, "utf-8");
       this.pendingFiles.set(filePath, content);
     } catch {
       this.pendingFiles.set(filePath, null);
@@ -1645,7 +2565,7 @@ var CheckpointManager = class {
     for (const [filePath, before] of this.pendingFiles) {
       let after = null;
       try {
-        after = await fs8.readFile(filePath, "utf-8");
+        after = await fs11.readFile(filePath, "utf-8");
       } catch {
       }
       files.push({ path: filePath, before, after });
@@ -1667,12 +2587,12 @@ var CheckpointManager = class {
     for (const snap of checkpoint.files) {
       if (snap.before === null) {
         try {
-          await fs8.unlink(snap.path);
+          await fs11.unlink(snap.path);
         } catch {
         }
       } else {
-        await fs8.mkdir(path9.dirname(snap.path), { recursive: true });
-        await fs8.writeFile(snap.path, snap.before, "utf-8");
+        await fs11.mkdir(path13.dirname(snap.path), { recursive: true });
+        await fs11.writeFile(snap.path, snap.before, "utf-8");
       }
     }
     return checkpoint;
@@ -1704,8 +2624,8 @@ var CheckpointManager = class {
         }
       }
     }
-    return Array.from(fileMap.entries()).map(([path19, { before, after }]) => ({
-      path: path19,
+    return Array.from(fileMap.entries()).map(([path25, { before, after }]) => ({
+      path: path25,
       before,
       after
     }));
@@ -1713,7 +2633,7 @@ var CheckpointManager = class {
 };
 
 // src/agent/usage.ts
-import chalk from "chalk";
+import chalk2 from "chalk";
 var UsageTracker = class {
   turns = [];
   record(usage) {
@@ -1738,18 +2658,18 @@ var UsageTracker = class {
     const last = this.turns[this.turns.length - 1];
     if (!last) return "";
     const t = last.totalTokens;
-    const label = t > 1e4 ? chalk.yellow(`${(t / 1e3).toFixed(1)}K`) : chalk.gray(`${t}`);
-    return chalk.gray(`  [${label} tokens, ${last.toolCalls} tool calls, ${last.iterations} rounds]`);
+    const label = t > 1e4 ? chalk2.yellow(`${(t / 1e3).toFixed(1)}K`) : chalk2.gray(`${t}`);
+    return chalk2.gray(`  [${label} tokens, ${last.toolCalls} tool calls, ${last.iterations} rounds]`);
   }
   formatSession() {
     const total = this.sessionTotal;
     return [
-      chalk.gray(`
+      chalk2.gray(`
   Session usage (${this.turnCount} turns):`),
-      chalk.gray(`    Prompt:     ${total.promptTokens.toLocaleString()} tokens`),
-      chalk.gray(`    Completion: ${total.completionTokens.toLocaleString()} tokens`),
-      chalk.gray(`    Total:      ${total.totalTokens.toLocaleString()} tokens`),
-      chalk.gray(`    Tool calls: ${total.toolCalls}`)
+      chalk2.gray(`    Prompt:     ${total.promptTokens.toLocaleString()} tokens`),
+      chalk2.gray(`    Completion: ${total.completionTokens.toLocaleString()} tokens`),
+      chalk2.gray(`    Total:      ${total.totalTokens.toLocaleString()} tokens`),
+      chalk2.gray(`    Tool calls: ${total.toolCalls}`)
     ].join("\n");
   }
 };
@@ -1945,7 +2865,7 @@ function nextSubagentId(type) {
 
 // src/agent/planner.ts
 import { generateText as generateText2 } from "ai";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var PLAN_SYSTEM_PROMPT = `You are a planning assistant. Given a task, produce a structured implementation plan.
 
 Respond in EXACTLY this format (no other text):
@@ -2037,25 +2957,25 @@ function parsePlan(text) {
 function formatPlan(plan) {
   const lines = [];
   lines.push("");
-  lines.push(chalk2.bold.white(`  Plan: ${plan.summary}`));
+  lines.push(chalk3.bold.white(`  Plan: ${plan.summary}`));
   lines.push("");
   for (const step of plan.steps) {
-    const icon = step.status === "done" ? chalk2.green("\u2713") : step.status === "in_progress" ? chalk2.yellow("\u25B6") : step.status === "failed" ? chalk2.red("\u2717") : step.status === "skipped" ? chalk2.gray("\u2013") : chalk2.gray("\u25CB");
-    const num = chalk2.gray(`${step.index + 1}.`);
-    const action = step.status === "done" ? chalk2.gray(step.action) : chalk2.white(step.action);
-    const files = step.files.length > 0 ? chalk2.cyan(` [${step.files.join(", ")}]`) : "";
+    const icon = step.status === "done" ? chalk3.green("\u2713") : step.status === "in_progress" ? chalk3.yellow("\u25B6") : step.status === "failed" ? chalk3.red("\u2717") : step.status === "skipped" ? chalk3.gray("\u2013") : chalk3.gray("\u25CB");
+    const num = chalk3.gray(`${step.index + 1}.`);
+    const action = step.status === "done" ? chalk3.gray(step.action) : chalk3.white(step.action);
+    const files = step.files.length > 0 ? chalk3.cyan(` [${step.files.join(", ")}]`) : "";
     lines.push(`  ${icon} ${num} ${action}${files}`);
   }
   if (plan.risks.length > 0) {
     lines.push("");
-    lines.push(chalk2.yellow("  Risks:"));
+    lines.push(chalk3.yellow("  Risks:"));
     for (const risk of plan.risks) {
-      lines.push(chalk2.yellow(`    \u26A0 ${risk}`));
+      lines.push(chalk3.yellow(`    \u26A0 ${risk}`));
     }
   }
   lines.push("");
   if (!plan.approved) {
-    lines.push(chalk2.gray("  Approve: /plan approve  |  Modify: /plan edit  |  Cancel: /plan cancel"));
+    lines.push(chalk3.gray("  Approve: /plan approve  |  Modify: /plan edit  |  Cancel: /plan cancel"));
   }
   lines.push("");
   return lines.join("\n");
@@ -2086,7 +3006,7 @@ function isPlanComplete(plan) {
 }
 
 // src/agent/cost.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var MODEL_COSTS = {
   "notch-cinder": { input: 0.05, output: 0.15 },
   // L4 — cheapest
@@ -2129,19 +3049,19 @@ var CostTracker = class {
   formatLastCost() {
     const last = this.entries[this.entries.length - 1];
     if (!last) return "";
-    return chalk3.gray(`$${last.cost.toFixed(4)}`);
+    return chalk4.gray(`$${last.cost.toFixed(4)}`);
   }
   formatSession() {
-    if (this.entries.length === 0) return chalk3.gray("  No cost data.");
+    if (this.entries.length === 0) return chalk4.gray("  No cost data.");
     const total = this.totalCost;
     const tokens = this.totalTokens;
     return [
-      chalk3.gray(`
+      chalk4.gray(`
   Session cost estimate:`),
-      chalk3.gray(`    Input:      ${tokens.prompt.toLocaleString()} tokens`),
-      chalk3.gray(`    Output:     ${tokens.completion.toLocaleString()} tokens`),
-      chalk3.gray(`    Est. cost:  `) + chalk3.white(`$${total.toFixed(4)}`),
-      chalk3.gray(`    (${this.entries.length} turns)`)
+      chalk4.gray(`    Input:      ${tokens.prompt.toLocaleString()} tokens`),
+      chalk4.gray(`    Output:     ${tokens.completion.toLocaleString()} tokens`),
+      chalk4.gray(`    Est. cost:  `) + chalk4.white(`$${total.toFixed(4)}`),
+      chalk4.gray(`    (${this.entries.length} turns)`)
     ].join("\n");
   }
   /** Alias for formatSession */
@@ -2160,10 +3080,10 @@ var CostTracker = class {
       existing.turns += 1;
       byModel.set(e.model, existing);
     }
-    const lines = [chalk3.gray("\n  Cost by model:")];
+    const lines = [chalk4.gray("\n  Cost by model:")];
     for (const [modelId, data] of byModel) {
       lines.push(
-        chalk3.gray(`    ${modelId.padEnd(14)} ${data.turns} turns  `) + chalk3.white(`$${data.cost.toFixed(4)}`) + chalk3.gray(` (${(data.prompt + data.completion).toLocaleString()} tokens)`)
+        chalk4.gray(`    ${modelId.padEnd(14)} ${data.turns} turns  `) + chalk4.white(`$${data.cost.toFixed(4)}`) + chalk4.gray(` (${(data.prompt + data.completion).toLocaleString()} tokens)`)
       );
     }
     return lines.join("\n");
@@ -2171,14 +3091,14 @@ var CostTracker = class {
 };
 
 // src/agent/ralph.ts
-import fs10 from "fs/promises";
-import path11 from "path";
-import chalk4 from "chalk";
+import fs13 from "fs/promises";
+import path15 from "path";
+import chalk5 from "chalk";
 import { generateText as generateText3, streamText as streamText3 } from "ai";
 
 // src/context/repo-map.ts
-import fs9 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path14 from "path";
 import { glob } from "glob";
 var PATTERNS = {
   ts: [
@@ -2209,7 +3129,7 @@ var PATTERNS = {
 };
 var IMPORT_PATTERN = /(?:import|from)\s+['"]([^'"]+)['"]/g;
 function getPatterns(filePath) {
-  const ext = path10.extname(filePath).slice(1);
+  const ext = path14.extname(filePath).slice(1);
   if (["ts", "tsx", "mts", "cts"].includes(ext)) return PATTERNS.ts;
   if (["js", "jsx", "mjs", "cjs"].includes(ext)) return PATTERNS.js;
   if (ext === "py") return PATTERNS.py;
@@ -2260,9 +3180,9 @@ async function buildRepoMap(root) {
   });
   const entries = [];
   for (const file of files.slice(0, 500)) {
-    const fullPath = path10.resolve(root, file);
+    const fullPath = path14.resolve(root, file);
     try {
-      const content = await fs9.readFile(fullPath, "utf-8");
+      const content = await fs12.readFile(fullPath, "utf-8");
       const lines = content.split("\n").length;
       const patterns = getPatterns(file);
       const symbols = extractSymbols(content, patterns);
@@ -2364,11 +3284,11 @@ ${repoContext || "(empty project)"}`;
 async function savePlan(plan, cwd) {
   plan.updated = (/* @__PURE__ */ new Date()).toISOString();
   plan.completedCount = plan.tasks.filter((t) => t.status === "done").length;
-  await fs10.writeFile(path11.join(cwd, PLAN_FILE), JSON.stringify(plan, null, 2), "utf-8");
+  await fs13.writeFile(path15.join(cwd, PLAN_FILE), JSON.stringify(plan, null, 2), "utf-8");
 }
 async function loadPlan(cwd) {
   try {
-    const raw = await fs10.readFile(path11.join(cwd, PLAN_FILE), "utf-8");
+    const raw = await fs13.readFile(path15.join(cwd, PLAN_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2376,7 +3296,7 @@ async function loadPlan(cwd) {
 }
 async function deletePlan(cwd) {
   try {
-    await fs10.unlink(path11.join(cwd, PLAN_FILE));
+    await fs13.unlink(path15.join(cwd, PLAN_FILE));
   } catch {
   }
 }
@@ -2540,27 +3460,27 @@ function formatRalphStatus(plan) {
   const progress = plan.totalCount > 0 ? Math.round(done / plan.totalCount * 100) : 0;
   const barWidth = 25;
   const filled = Math.round(done / plan.totalCount * barWidth);
-  const bar = chalk4.green("\u2588".repeat(filled)) + chalk4.gray("\u2591".repeat(barWidth - filled));
+  const bar = chalk5.green("\u2588".repeat(filled)) + chalk5.gray("\u2591".repeat(barWidth - filled));
   lines.push("");
-  lines.push(chalk4.bold.white(`  Ralph Mode: ${plan.goal}`));
+  lines.push(chalk5.bold.white(`  Ralph Mode: ${plan.goal}`));
   lines.push(`  [${bar}] ${progress}% (${done}/${plan.totalCount} tasks)`);
-  if (failed > 0) lines.push(chalk4.red(`  ${failed} failed`));
+  if (failed > 0) lines.push(chalk5.red(`  ${failed} failed`));
   lines.push("");
   for (const task of plan.tasks) {
-    const icon = task.status === "done" ? chalk4.green("\u2713") : task.status === "failed" ? chalk4.red("\u2717") : task.status === "in_progress" ? chalk4.yellow("\u25B6") : task.status === "skipped" ? chalk4.gray("\u2013") : chalk4.gray("\u25CB");
-    const title = task.status === "done" ? chalk4.gray(task.title) : task.status === "failed" ? chalk4.red(task.title) : chalk4.white(task.title);
-    const files = task.files.length > 0 ? chalk4.cyan(` [${task.files.join(", ")}]`) : "";
-    const err = task.error ? chalk4.red(` \u2014 ${task.error.slice(0, 60)}`) : "";
-    const attempts = task.attempts > 1 ? chalk4.yellow(` (${task.attempts} attempts)`) : "";
-    lines.push(`  ${icon} ${chalk4.gray(`${task.id}.`)} ${title}${files}${attempts}${err}`);
+    const icon = task.status === "done" ? chalk5.green("\u2713") : task.status === "failed" ? chalk5.red("\u2717") : task.status === "in_progress" ? chalk5.yellow("\u25B6") : task.status === "skipped" ? chalk5.gray("\u2013") : chalk5.gray("\u25CB");
+    const title = task.status === "done" ? chalk5.gray(task.title) : task.status === "failed" ? chalk5.red(task.title) : chalk5.white(task.title);
+    const files = task.files.length > 0 ? chalk5.cyan(` [${task.files.join(", ")}]`) : "";
+    const err = task.error ? chalk5.red(` \u2014 ${task.error.slice(0, 60)}`) : "";
+    const attempts = task.attempts > 1 ? chalk5.yellow(` (${task.attempts} attempts)`) : "";
+    lines.push(`  ${icon} ${chalk5.gray(`${task.id}.`)} ${title}${files}${attempts}${err}`);
   }
   lines.push("");
   return lines.join("\n");
 }
 
 // src/context/references.ts
-import fs11 from "fs/promises";
-import path12 from "path";
+import fs14 from "fs/promises";
+import path16 from "path";
 import { glob as glob2 } from "glob";
 async function resolveReferences(input, cwd) {
   const references = [];
@@ -2603,9 +3523,9 @@ ${truncated}
   return sections.join("\n\n") + "\n\n";
 }
 async function resolveFile(ref, cwd) {
-  const filePath = path12.isAbsolute(ref) ? ref : path12.resolve(cwd, ref);
+  const filePath = path16.isAbsolute(ref) ? ref : path16.resolve(cwd, ref);
   try {
-    const content = await fs11.readFile(filePath, "utf-8");
+    const content = await fs14.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const numbered = lines.map((line, i) => `${String(i + 1).padStart(4)} | ${line}`).join("\n");
     return {
@@ -2701,448 +3621,448 @@ async function resolveGlob(pattern, cwd) {
 }
 
 // src/ui/banner.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/ui/themes.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 var defaultTheme = {
   name: "Default",
   description: "FreeSyntax \u2014 silver, white, monochrome",
-  brand: chalk5.hex("#D4D4D4"),
+  brand: chalk6.hex("#D4D4D4"),
   // silver (banner uses gradient override)
-  mascot: chalk5.hex("#AAAAAA"),
+  mascot: chalk6.hex("#AAAAAA"),
   // medium gray mantis
-  mascotAccent: chalk5.hex("#FFFFFF"),
+  mascotAccent: chalk6.hex("#FFFFFF"),
   // white eyes
-  tagline: chalk5.hex("#777777"),
+  tagline: chalk6.hex("#777777"),
   // muted gray
-  prompt: chalk5.hex("#CCCCCC"),
+  prompt: chalk6.hex("#CCCCCC"),
   // silver prompt
-  border: chalk5.hex("#444444"),
+  border: chalk6.hex("#444444"),
   // dark border
-  dim: chalk5.hex("#666666"),
+  dim: chalk6.hex("#666666"),
   // muted text
-  text: chalk5.hex("#D4D4D4"),
+  text: chalk6.hex("#D4D4D4"),
   // silver body text
-  bold: chalk5.hex("#FFFFFF").bold,
+  bold: chalk6.hex("#FFFFFF").bold,
   // pure white emphasis
-  success: chalk5.green,
-  warning: chalk5.yellow,
-  error: chalk5.red,
-  info: chalk5.hex("#BBBBBB"),
+  success: chalk6.green,
+  warning: chalk6.yellow,
+  error: chalk6.red,
+  info: chalk6.hex("#BBBBBB"),
   // light gray info
-  toolName: chalk5.hex("#AAAAAA"),
-  toolArgs: chalk5.hex("#777777"),
-  toolResult: chalk5.hex("#555555"),
-  diffAdd: chalk5.green,
-  diffRemove: chalk5.red,
-  diffHeader: chalk5.hex("#CCCCCC"),
-  mdH1: chalk5.hex("#FFFFFF").bold,
-  mdH2: chalk5.hex("#D4D4D4"),
-  mdH3: chalk5.hex("#AAAAAA"),
-  mdCode: chalk5.hex("#BBBBBB"),
-  mdInlineCode: chalk5.hex("#CCCCCC"),
-  mdLink: chalk5.hex("#D4D4D4").underline,
-  meterLow: chalk5.green,
-  meterMid: chalk5.yellow,
-  meterHigh: chalk5.red
+  toolName: chalk6.hex("#AAAAAA"),
+  toolArgs: chalk6.hex("#777777"),
+  toolResult: chalk6.hex("#555555"),
+  diffAdd: chalk6.green,
+  diffRemove: chalk6.red,
+  diffHeader: chalk6.hex("#CCCCCC"),
+  mdH1: chalk6.hex("#FFFFFF").bold,
+  mdH2: chalk6.hex("#D4D4D4"),
+  mdH3: chalk6.hex("#AAAAAA"),
+  mdCode: chalk6.hex("#BBBBBB"),
+  mdInlineCode: chalk6.hex("#CCCCCC"),
+  mdLink: chalk6.hex("#D4D4D4").underline,
+  meterLow: chalk6.green,
+  meterMid: chalk6.yellow,
+  meterHigh: chalk6.red
 };
 var interstellarTheme = {
   name: "Interstellar",
   description: "Deep space amber \u2014 Endurance control panels",
-  brand: chalk5.hex("#FFB347"),
+  brand: chalk6.hex("#FFB347"),
   // warm amber (instrument readout)
-  mascot: chalk5.hex("#4A90D9"),
+  mascot: chalk6.hex("#4A90D9"),
   // pale blue (frozen clouds)
-  mascotAccent: chalk5.hex("#FFD700"),
+  mascotAccent: chalk6.hex("#FFD700"),
   // gold (Gargantua light)
-  tagline: chalk5.hex("#708090"),
+  tagline: chalk6.hex("#708090"),
   // slate gray (ship hull)
-  prompt: chalk5.hex("#FFB347"),
-  border: chalk5.hex("#3A3A3A"),
+  prompt: chalk6.hex("#FFB347"),
+  border: chalk6.hex("#3A3A3A"),
   // dark hull metal
-  dim: chalk5.hex("#5C5C5C"),
-  text: chalk5.hex("#D4D4D4"),
+  dim: chalk6.hex("#5C5C5C"),
+  text: chalk6.hex("#D4D4D4"),
   // cool white (display text)
-  bold: chalk5.hex("#FFFFFF").bold,
-  success: chalk5.hex("#7CFC00"),
+  bold: chalk6.hex("#FFFFFF").bold,
+  success: chalk6.hex("#7CFC00"),
   // "CASE: All systems nominal"
-  warning: chalk5.hex("#FFB347"),
+  warning: chalk6.hex("#FFB347"),
   // amber warning
-  error: chalk5.hex("#FF4444"),
+  error: chalk6.hex("#FF4444"),
   // critical alert
-  info: chalk5.hex("#4A90D9"),
+  info: chalk6.hex("#4A90D9"),
   // blue data readout
-  toolName: chalk5.hex("#FFB347"),
-  toolArgs: chalk5.hex("#708090"),
-  toolResult: chalk5.hex("#5C5C5C"),
-  diffAdd: chalk5.hex("#7CFC00"),
-  diffRemove: chalk5.hex("#FF4444"),
-  diffHeader: chalk5.hex("#FFB347"),
-  mdH1: chalk5.hex("#FFB347").bold,
-  mdH2: chalk5.hex("#4A90D9"),
-  mdH3: chalk5.hex("#708090"),
-  mdCode: chalk5.hex("#FFD700"),
-  mdInlineCode: chalk5.hex("#FFB347"),
-  mdLink: chalk5.hex("#4A90D9").underline,
-  meterLow: chalk5.hex("#4A90D9"),
-  meterMid: chalk5.hex("#FFB347"),
-  meterHigh: chalk5.hex("#FF4444")
+  toolName: chalk6.hex("#FFB347"),
+  toolArgs: chalk6.hex("#708090"),
+  toolResult: chalk6.hex("#5C5C5C"),
+  diffAdd: chalk6.hex("#7CFC00"),
+  diffRemove: chalk6.hex("#FF4444"),
+  diffHeader: chalk6.hex("#FFB347"),
+  mdH1: chalk6.hex("#FFB347").bold,
+  mdH2: chalk6.hex("#4A90D9"),
+  mdH3: chalk6.hex("#708090"),
+  mdCode: chalk6.hex("#FFD700"),
+  mdInlineCode: chalk6.hex("#FFB347"),
+  mdLink: chalk6.hex("#4A90D9").underline,
+  meterLow: chalk6.hex("#4A90D9"),
+  meterMid: chalk6.hex("#FFB347"),
+  meterHigh: chalk6.hex("#FF4444")
 };
 var spaceGrayTheme = {
   name: "Space Gray",
   description: "Apple minimalism \u2014 silver, cool gray, ice blue",
-  brand: chalk5.hex("#A2AAAD"),
+  brand: chalk6.hex("#A2AAAD"),
   // apple silver
-  mascot: chalk5.hex("#86868B"),
+  mascot: chalk6.hex("#86868B"),
   // space gray
-  mascotAccent: chalk5.hex("#0071E3"),
+  mascotAccent: chalk6.hex("#0071E3"),
   // apple blue
-  tagline: chalk5.hex("#6E6E73"),
+  tagline: chalk6.hex("#6E6E73"),
   // secondary gray
-  prompt: chalk5.hex("#A2AAAD"),
-  border: chalk5.hex("#3A3A3C"),
+  prompt: chalk6.hex("#A2AAAD"),
+  border: chalk6.hex("#3A3A3C"),
   // dark separator
-  dim: chalk5.hex("#6E6E73"),
-  text: chalk5.hex("#E5E5EA"),
+  dim: chalk6.hex("#6E6E73"),
+  text: chalk6.hex("#E5E5EA"),
   // system gray 6
-  bold: chalk5.hex("#F5F5F7").bold,
+  bold: chalk6.hex("#F5F5F7").bold,
   // near white
-  success: chalk5.hex("#30D158"),
+  success: chalk6.hex("#30D158"),
   // apple green
-  warning: chalk5.hex("#FFD60A"),
+  warning: chalk6.hex("#FFD60A"),
   // apple yellow
-  error: chalk5.hex("#FF453A"),
+  error: chalk6.hex("#FF453A"),
   // apple red
-  info: chalk5.hex("#0A84FF"),
+  info: chalk6.hex("#0A84FF"),
   // apple blue
-  toolName: chalk5.hex("#A2AAAD"),
-  toolArgs: chalk5.hex("#6E6E73"),
-  toolResult: chalk5.hex("#48484A"),
-  diffAdd: chalk5.hex("#30D158"),
-  diffRemove: chalk5.hex("#FF453A"),
-  diffHeader: chalk5.hex("#0A84FF"),
-  mdH1: chalk5.hex("#F5F5F7").bold,
-  mdH2: chalk5.hex("#0A84FF"),
-  mdH3: chalk5.hex("#A2AAAD"),
-  mdCode: chalk5.hex("#BF5AF2"),
+  toolName: chalk6.hex("#A2AAAD"),
+  toolArgs: chalk6.hex("#6E6E73"),
+  toolResult: chalk6.hex("#48484A"),
+  diffAdd: chalk6.hex("#30D158"),
+  diffRemove: chalk6.hex("#FF453A"),
+  diffHeader: chalk6.hex("#0A84FF"),
+  mdH1: chalk6.hex("#F5F5F7").bold,
+  mdH2: chalk6.hex("#0A84FF"),
+  mdH3: chalk6.hex("#A2AAAD"),
+  mdCode: chalk6.hex("#BF5AF2"),
   // apple purple for code
-  mdInlineCode: chalk5.hex("#BF5AF2"),
-  mdLink: chalk5.hex("#0A84FF").underline,
-  meterLow: chalk5.hex("#30D158"),
-  meterMid: chalk5.hex("#FFD60A"),
-  meterHigh: chalk5.hex("#FF453A")
+  mdInlineCode: chalk6.hex("#BF5AF2"),
+  mdLink: chalk6.hex("#0A84FF").underline,
+  meterLow: chalk6.hex("#30D158"),
+  meterMid: chalk6.hex("#FFD60A"),
+  meterHigh: chalk6.hex("#FF453A")
 };
 var cyberpunkTheme = {
   name: "Cyberpunk",
   description: "Neon pink & cyan \u2014 Night City terminal",
-  brand: chalk5.hex("#FF2079"),
+  brand: chalk6.hex("#FF2079"),
   // hot pink
-  mascot: chalk5.hex("#00FFFF"),
+  mascot: chalk6.hex("#00FFFF"),
   // electric cyan
-  mascotAccent: chalk5.hex("#FF2079"),
+  mascotAccent: chalk6.hex("#FF2079"),
   // hot pink eyes
-  tagline: chalk5.hex("#9D00FF"),
+  tagline: chalk6.hex("#9D00FF"),
   // deep violet
-  prompt: chalk5.hex("#FF2079"),
-  border: chalk5.hex("#1A1A2E"),
-  dim: chalk5.hex("#4A4A6A"),
-  text: chalk5.hex("#E0E0FF"),
-  bold: chalk5.hex("#FFFFFF").bold,
-  success: chalk5.hex("#00FF41"),
+  prompt: chalk6.hex("#FF2079"),
+  border: chalk6.hex("#1A1A2E"),
+  dim: chalk6.hex("#4A4A6A"),
+  text: chalk6.hex("#E0E0FF"),
+  bold: chalk6.hex("#FFFFFF").bold,
+  success: chalk6.hex("#00FF41"),
   // matrix green
-  warning: chalk5.hex("#FFFF00"),
+  warning: chalk6.hex("#FFFF00"),
   // neon yellow
-  error: chalk5.hex("#FF0000"),
-  info: chalk5.hex("#00FFFF"),
-  toolName: chalk5.hex("#FF2079"),
-  toolArgs: chalk5.hex("#9D00FF"),
-  toolResult: chalk5.hex("#4A4A6A"),
-  diffAdd: chalk5.hex("#00FF41"),
-  diffRemove: chalk5.hex("#FF0000"),
-  diffHeader: chalk5.hex("#FF2079"),
-  mdH1: chalk5.hex("#FF2079").bold,
-  mdH2: chalk5.hex("#00FFFF"),
-  mdH3: chalk5.hex("#9D00FF"),
-  mdCode: chalk5.hex("#00FF41"),
-  mdInlineCode: chalk5.hex("#00FFFF"),
-  mdLink: chalk5.hex("#9D00FF").underline,
-  meterLow: chalk5.hex("#00FF41"),
-  meterMid: chalk5.hex("#FFFF00"),
-  meterHigh: chalk5.hex("#FF0000")
+  error: chalk6.hex("#FF0000"),
+  info: chalk6.hex("#00FFFF"),
+  toolName: chalk6.hex("#FF2079"),
+  toolArgs: chalk6.hex("#9D00FF"),
+  toolResult: chalk6.hex("#4A4A6A"),
+  diffAdd: chalk6.hex("#00FF41"),
+  diffRemove: chalk6.hex("#FF0000"),
+  diffHeader: chalk6.hex("#FF2079"),
+  mdH1: chalk6.hex("#FF2079").bold,
+  mdH2: chalk6.hex("#00FFFF"),
+  mdH3: chalk6.hex("#9D00FF"),
+  mdCode: chalk6.hex("#00FF41"),
+  mdInlineCode: chalk6.hex("#00FFFF"),
+  mdLink: chalk6.hex("#9D00FF").underline,
+  meterLow: chalk6.hex("#00FF41"),
+  meterMid: chalk6.hex("#FFFF00"),
+  meterHigh: chalk6.hex("#FF0000")
 };
 var auroraTheme = {
   name: "Aurora",
   description: "Northern lights \u2014 teal, violet, polar green",
-  brand: chalk5.hex("#7FFFD4"),
+  brand: chalk6.hex("#7FFFD4"),
   // aquamarine
-  mascot: chalk5.hex("#00CED1"),
+  mascot: chalk6.hex("#00CED1"),
   // dark turquoise
-  mascotAccent: chalk5.hex("#DA70D6"),
+  mascotAccent: chalk6.hex("#DA70D6"),
   // orchid
-  tagline: chalk5.hex("#9370DB"),
+  tagline: chalk6.hex("#9370DB"),
   // medium purple
-  prompt: chalk5.hex("#7FFFD4"),
-  border: chalk5.hex("#2F4F4F"),
+  prompt: chalk6.hex("#7FFFD4"),
+  border: chalk6.hex("#2F4F4F"),
   // dark slate
-  dim: chalk5.hex("#5F9EA0"),
+  dim: chalk6.hex("#5F9EA0"),
   // cadet blue
-  text: chalk5.hex("#E0FFFF"),
+  text: chalk6.hex("#E0FFFF"),
   // light cyan
-  bold: chalk5.hex("#F0FFFF").bold,
-  success: chalk5.hex("#00FA9A"),
+  bold: chalk6.hex("#F0FFFF").bold,
+  success: chalk6.hex("#00FA9A"),
   // medium spring green
-  warning: chalk5.hex("#DDA0DD"),
+  warning: chalk6.hex("#DDA0DD"),
   // plum
-  error: chalk5.hex("#FF6B6B"),
-  info: chalk5.hex("#87CEEB"),
+  error: chalk6.hex("#FF6B6B"),
+  info: chalk6.hex("#87CEEB"),
   // sky blue
-  toolName: chalk5.hex("#7FFFD4"),
-  toolArgs: chalk5.hex("#5F9EA0"),
-  toolResult: chalk5.hex("#2F4F4F"),
-  diffAdd: chalk5.hex("#00FA9A"),
-  diffRemove: chalk5.hex("#FF6B6B"),
-  diffHeader: chalk5.hex("#DA70D6"),
-  mdH1: chalk5.hex("#7FFFD4").bold,
-  mdH2: chalk5.hex("#DA70D6"),
-  mdH3: chalk5.hex("#87CEEB"),
-  mdCode: chalk5.hex("#00CED1"),
-  mdInlineCode: chalk5.hex("#7FFFD4"),
-  mdLink: chalk5.hex("#DA70D6").underline,
-  meterLow: chalk5.hex("#00FA9A"),
-  meterMid: chalk5.hex("#DDA0DD"),
-  meterHigh: chalk5.hex("#FF6B6B")
+  toolName: chalk6.hex("#7FFFD4"),
+  toolArgs: chalk6.hex("#5F9EA0"),
+  toolResult: chalk6.hex("#2F4F4F"),
+  diffAdd: chalk6.hex("#00FA9A"),
+  diffRemove: chalk6.hex("#FF6B6B"),
+  diffHeader: chalk6.hex("#DA70D6"),
+  mdH1: chalk6.hex("#7FFFD4").bold,
+  mdH2: chalk6.hex("#DA70D6"),
+  mdH3: chalk6.hex("#87CEEB"),
+  mdCode: chalk6.hex("#00CED1"),
+  mdInlineCode: chalk6.hex("#7FFFD4"),
+  mdLink: chalk6.hex("#DA70D6").underline,
+  meterLow: chalk6.hex("#00FA9A"),
+  meterMid: chalk6.hex("#DDA0DD"),
+  meterHigh: chalk6.hex("#FF6B6B")
 };
 var solarizedTheme = {
   name: "Solarized",
   description: "Solarized Dark \u2014 warm, precise, classic dev palette",
-  brand: chalk5.hex("#268BD2"),
+  brand: chalk6.hex("#268BD2"),
   // blue
-  mascot: chalk5.hex("#859900"),
+  mascot: chalk6.hex("#859900"),
   // green
-  mascotAccent: chalk5.hex("#B58900"),
+  mascotAccent: chalk6.hex("#B58900"),
   // yellow
-  tagline: chalk5.hex("#2AA198"),
+  tagline: chalk6.hex("#2AA198"),
   // cyan
-  prompt: chalk5.hex("#268BD2"),
-  border: chalk5.hex("#073642"),
+  prompt: chalk6.hex("#268BD2"),
+  border: chalk6.hex("#073642"),
   // base02
-  dim: chalk5.hex("#586E75"),
+  dim: chalk6.hex("#586E75"),
   // base01
-  text: chalk5.hex("#839496"),
+  text: chalk6.hex("#839496"),
   // base0
-  bold: chalk5.hex("#93A1A1").bold,
+  bold: chalk6.hex("#93A1A1").bold,
   // base1
-  success: chalk5.hex("#859900"),
-  warning: chalk5.hex("#B58900"),
-  error: chalk5.hex("#DC322F"),
-  info: chalk5.hex("#2AA198"),
-  toolName: chalk5.hex("#268BD2"),
-  toolArgs: chalk5.hex("#586E75"),
-  toolResult: chalk5.hex("#073642"),
-  diffAdd: chalk5.hex("#859900"),
-  diffRemove: chalk5.hex("#DC322F"),
-  diffHeader: chalk5.hex("#268BD2"),
-  mdH1: chalk5.hex("#93A1A1").bold,
-  mdH2: chalk5.hex("#268BD2"),
-  mdH3: chalk5.hex("#2AA198"),
-  mdCode: chalk5.hex("#859900"),
-  mdInlineCode: chalk5.hex("#2AA198"),
-  mdLink: chalk5.hex("#268BD2").underline,
-  meterLow: chalk5.hex("#859900"),
-  meterMid: chalk5.hex("#B58900"),
-  meterHigh: chalk5.hex("#DC322F")
+  success: chalk6.hex("#859900"),
+  warning: chalk6.hex("#B58900"),
+  error: chalk6.hex("#DC322F"),
+  info: chalk6.hex("#2AA198"),
+  toolName: chalk6.hex("#268BD2"),
+  toolArgs: chalk6.hex("#586E75"),
+  toolResult: chalk6.hex("#073642"),
+  diffAdd: chalk6.hex("#859900"),
+  diffRemove: chalk6.hex("#DC322F"),
+  diffHeader: chalk6.hex("#268BD2"),
+  mdH1: chalk6.hex("#93A1A1").bold,
+  mdH2: chalk6.hex("#268BD2"),
+  mdH3: chalk6.hex("#2AA198"),
+  mdCode: chalk6.hex("#859900"),
+  mdInlineCode: chalk6.hex("#2AA198"),
+  mdLink: chalk6.hex("#268BD2").underline,
+  meterLow: chalk6.hex("#859900"),
+  meterMid: chalk6.hex("#B58900"),
+  meterHigh: chalk6.hex("#DC322F")
 };
 var draculaTheme = {
   name: "Dracula",
   description: "Dracula \u2014 purple, pink, green on charcoal",
-  brand: chalk5.hex("#BD93F9"),
+  brand: chalk6.hex("#BD93F9"),
   // purple
-  mascot: chalk5.hex("#50FA7B"),
+  mascot: chalk6.hex("#50FA7B"),
   // green
-  mascotAccent: chalk5.hex("#FF79C6"),
+  mascotAccent: chalk6.hex("#FF79C6"),
   // pink
-  tagline: chalk5.hex("#6272A4"),
+  tagline: chalk6.hex("#6272A4"),
   // comment gray
-  prompt: chalk5.hex("#BD93F9"),
-  border: chalk5.hex("#44475A"),
+  prompt: chalk6.hex("#BD93F9"),
+  border: chalk6.hex("#44475A"),
   // current line
-  dim: chalk5.hex("#6272A4"),
+  dim: chalk6.hex("#6272A4"),
   // comment
-  text: chalk5.hex("#F8F8F2"),
+  text: chalk6.hex("#F8F8F2"),
   // foreground
-  bold: chalk5.hex("#F8F8F2").bold,
-  success: chalk5.hex("#50FA7B"),
-  warning: chalk5.hex("#F1FA8C"),
+  bold: chalk6.hex("#F8F8F2").bold,
+  success: chalk6.hex("#50FA7B"),
+  warning: chalk6.hex("#F1FA8C"),
   // yellow
-  error: chalk5.hex("#FF5555"),
-  info: chalk5.hex("#8BE9FD"),
+  error: chalk6.hex("#FF5555"),
+  info: chalk6.hex("#8BE9FD"),
   // cyan
-  toolName: chalk5.hex("#BD93F9"),
-  toolArgs: chalk5.hex("#6272A4"),
-  toolResult: chalk5.hex("#44475A"),
-  diffAdd: chalk5.hex("#50FA7B"),
-  diffRemove: chalk5.hex("#FF5555"),
-  diffHeader: chalk5.hex("#FF79C6"),
-  mdH1: chalk5.hex("#FF79C6").bold,
-  mdH2: chalk5.hex("#BD93F9"),
-  mdH3: chalk5.hex("#8BE9FD"),
-  mdCode: chalk5.hex("#50FA7B"),
-  mdInlineCode: chalk5.hex("#F1FA8C"),
-  mdLink: chalk5.hex("#8BE9FD").underline,
-  meterLow: chalk5.hex("#50FA7B"),
-  meterMid: chalk5.hex("#F1FA8C"),
-  meterHigh: chalk5.hex("#FF5555")
+  toolName: chalk6.hex("#BD93F9"),
+  toolArgs: chalk6.hex("#6272A4"),
+  toolResult: chalk6.hex("#44475A"),
+  diffAdd: chalk6.hex("#50FA7B"),
+  diffRemove: chalk6.hex("#FF5555"),
+  diffHeader: chalk6.hex("#FF79C6"),
+  mdH1: chalk6.hex("#FF79C6").bold,
+  mdH2: chalk6.hex("#BD93F9"),
+  mdH3: chalk6.hex("#8BE9FD"),
+  mdCode: chalk6.hex("#50FA7B"),
+  mdInlineCode: chalk6.hex("#F1FA8C"),
+  mdLink: chalk6.hex("#8BE9FD").underline,
+  meterLow: chalk6.hex("#50FA7B"),
+  meterMid: chalk6.hex("#F1FA8C"),
+  meterHigh: chalk6.hex("#FF5555")
 };
 var monokaiTheme = {
   name: "Monokai",
   description: "Monokai Pro \u2014 vivid on dark, a classic",
-  brand: chalk5.hex("#A6E22E"),
+  brand: chalk6.hex("#A6E22E"),
   // green
-  mascot: chalk5.hex("#66D9EF"),
+  mascot: chalk6.hex("#66D9EF"),
   // blue
-  mascotAccent: chalk5.hex("#F92672"),
+  mascotAccent: chalk6.hex("#F92672"),
   // pink
-  tagline: chalk5.hex("#75715E"),
+  tagline: chalk6.hex("#75715E"),
   // comment
-  prompt: chalk5.hex("#A6E22E"),
-  border: chalk5.hex("#3E3D32"),
-  dim: chalk5.hex("#75715E"),
-  text: chalk5.hex("#F8F8F2"),
-  bold: chalk5.hex("#F8F8F2").bold,
-  success: chalk5.hex("#A6E22E"),
-  warning: chalk5.hex("#E6DB74"),
+  prompt: chalk6.hex("#A6E22E"),
+  border: chalk6.hex("#3E3D32"),
+  dim: chalk6.hex("#75715E"),
+  text: chalk6.hex("#F8F8F2"),
+  bold: chalk6.hex("#F8F8F2").bold,
+  success: chalk6.hex("#A6E22E"),
+  warning: chalk6.hex("#E6DB74"),
   // yellow
-  error: chalk5.hex("#F92672"),
-  info: chalk5.hex("#66D9EF"),
-  toolName: chalk5.hex("#A6E22E"),
-  toolArgs: chalk5.hex("#75715E"),
-  toolResult: chalk5.hex("#3E3D32"),
-  diffAdd: chalk5.hex("#A6E22E"),
-  diffRemove: chalk5.hex("#F92672"),
-  diffHeader: chalk5.hex("#66D9EF"),
-  mdH1: chalk5.hex("#F92672").bold,
-  mdH2: chalk5.hex("#A6E22E"),
-  mdH3: chalk5.hex("#66D9EF"),
-  mdCode: chalk5.hex("#E6DB74"),
-  mdInlineCode: chalk5.hex("#A6E22E"),
-  mdLink: chalk5.hex("#66D9EF").underline,
-  meterLow: chalk5.hex("#A6E22E"),
-  meterMid: chalk5.hex("#E6DB74"),
-  meterHigh: chalk5.hex("#F92672")
+  error: chalk6.hex("#F92672"),
+  info: chalk6.hex("#66D9EF"),
+  toolName: chalk6.hex("#A6E22E"),
+  toolArgs: chalk6.hex("#75715E"),
+  toolResult: chalk6.hex("#3E3D32"),
+  diffAdd: chalk6.hex("#A6E22E"),
+  diffRemove: chalk6.hex("#F92672"),
+  diffHeader: chalk6.hex("#66D9EF"),
+  mdH1: chalk6.hex("#F92672").bold,
+  mdH2: chalk6.hex("#A6E22E"),
+  mdH3: chalk6.hex("#66D9EF"),
+  mdCode: chalk6.hex("#E6DB74"),
+  mdInlineCode: chalk6.hex("#A6E22E"),
+  mdLink: chalk6.hex("#66D9EF").underline,
+  meterLow: chalk6.hex("#A6E22E"),
+  meterMid: chalk6.hex("#E6DB74"),
+  meterHigh: chalk6.hex("#F92672")
 };
 var oceanTheme = {
   name: "Ocean",
   description: "Deep sea \u2014 midnight blue, bioluminescent glow",
-  brand: chalk5.hex("#00B4D8"),
+  brand: chalk6.hex("#00B4D8"),
   // cerulean
-  mascot: chalk5.hex("#0077B6"),
+  mascot: chalk6.hex("#0077B6"),
   // deep blue
-  mascotAccent: chalk5.hex("#90E0EF"),
+  mascotAccent: chalk6.hex("#90E0EF"),
   // light blue (bioluminescent)
-  tagline: chalk5.hex("#023E8A"),
+  tagline: chalk6.hex("#023E8A"),
   // navy
-  prompt: chalk5.hex("#00B4D8"),
-  border: chalk5.hex("#03045E"),
+  prompt: chalk6.hex("#00B4D8"),
+  border: chalk6.hex("#03045E"),
   // deep navy
-  dim: chalk5.hex("#0077B6"),
-  text: chalk5.hex("#CAF0F8"),
+  dim: chalk6.hex("#0077B6"),
+  text: chalk6.hex("#CAF0F8"),
   // lightest blue
-  bold: chalk5.hex("#CAF0F8").bold,
-  success: chalk5.hex("#2DC653"),
+  bold: chalk6.hex("#CAF0F8").bold,
+  success: chalk6.hex("#2DC653"),
   // kelp green
-  warning: chalk5.hex("#F4A261"),
+  warning: chalk6.hex("#F4A261"),
   // sandy
-  error: chalk5.hex("#E76F51"),
+  error: chalk6.hex("#E76F51"),
   // coral
-  info: chalk5.hex("#90E0EF"),
-  toolName: chalk5.hex("#00B4D8"),
-  toolArgs: chalk5.hex("#0077B6"),
-  toolResult: chalk5.hex("#03045E"),
-  diffAdd: chalk5.hex("#2DC653"),
-  diffRemove: chalk5.hex("#E76F51"),
-  diffHeader: chalk5.hex("#00B4D8"),
-  mdH1: chalk5.hex("#90E0EF").bold,
-  mdH2: chalk5.hex("#00B4D8"),
-  mdH3: chalk5.hex("#0077B6"),
-  mdCode: chalk5.hex("#90E0EF"),
-  mdInlineCode: chalk5.hex("#00B4D8"),
-  mdLink: chalk5.hex("#90E0EF").underline,
-  meterLow: chalk5.hex("#00B4D8"),
-  meterMid: chalk5.hex("#F4A261"),
-  meterHigh: chalk5.hex("#E76F51")
+  info: chalk6.hex("#90E0EF"),
+  toolName: chalk6.hex("#00B4D8"),
+  toolArgs: chalk6.hex("#0077B6"),
+  toolResult: chalk6.hex("#03045E"),
+  diffAdd: chalk6.hex("#2DC653"),
+  diffRemove: chalk6.hex("#E76F51"),
+  diffHeader: chalk6.hex("#00B4D8"),
+  mdH1: chalk6.hex("#90E0EF").bold,
+  mdH2: chalk6.hex("#00B4D8"),
+  mdH3: chalk6.hex("#0077B6"),
+  mdCode: chalk6.hex("#90E0EF"),
+  mdInlineCode: chalk6.hex("#00B4D8"),
+  mdLink: chalk6.hex("#90E0EF").underline,
+  meterLow: chalk6.hex("#00B4D8"),
+  meterMid: chalk6.hex("#F4A261"),
+  meterHigh: chalk6.hex("#E76F51")
 };
 var emberTheme = {
   name: "Ember",
   description: "Fire forged \u2014 charcoal, ember orange, flame red",
-  brand: chalk5.hex("#FF6B35"),
+  brand: chalk6.hex("#FF6B35"),
   // flame orange
-  mascot: chalk5.hex("#D62828"),
+  mascot: chalk6.hex("#D62828"),
   // deep red
-  mascotAccent: chalk5.hex("#FFD166"),
+  mascotAccent: chalk6.hex("#FFD166"),
   // bright flame
-  tagline: chalk5.hex("#8B4513"),
+  tagline: chalk6.hex("#8B4513"),
   // saddle brown
-  prompt: chalk5.hex("#FF6B35"),
-  border: chalk5.hex("#2B2B2B"),
+  prompt: chalk6.hex("#FF6B35"),
+  border: chalk6.hex("#2B2B2B"),
   // charcoal
-  dim: chalk5.hex("#6B3A2A"),
-  text: chalk5.hex("#F4E4C1"),
+  dim: chalk6.hex("#6B3A2A"),
+  text: chalk6.hex("#F4E4C1"),
   // warm parchment
-  bold: chalk5.hex("#FFF5E1").bold,
-  success: chalk5.hex("#FFD166"),
+  bold: chalk6.hex("#FFF5E1").bold,
+  success: chalk6.hex("#FFD166"),
   // bright flame = success
-  warning: chalk5.hex("#FF6B35"),
-  error: chalk5.hex("#D62828"),
-  info: chalk5.hex("#F4845F"),
+  warning: chalk6.hex("#FF6B35"),
+  error: chalk6.hex("#D62828"),
+  info: chalk6.hex("#F4845F"),
   // soft coral
-  toolName: chalk5.hex("#FF6B35"),
-  toolArgs: chalk5.hex("#6B3A2A"),
-  toolResult: chalk5.hex("#2B2B2B"),
-  diffAdd: chalk5.hex("#FFD166"),
-  diffRemove: chalk5.hex("#D62828"),
-  diffHeader: chalk5.hex("#FF6B35"),
-  mdH1: chalk5.hex("#FF6B35").bold,
-  mdH2: chalk5.hex("#F4845F"),
-  mdH3: chalk5.hex("#8B4513"),
-  mdCode: chalk5.hex("#FFD166"),
-  mdInlineCode: chalk5.hex("#FF6B35"),
-  mdLink: chalk5.hex("#F4845F").underline,
-  meterLow: chalk5.hex("#FFD166"),
-  meterMid: chalk5.hex("#FF6B35"),
-  meterHigh: chalk5.hex("#D62828")
+  toolName: chalk6.hex("#FF6B35"),
+  toolArgs: chalk6.hex("#6B3A2A"),
+  toolResult: chalk6.hex("#2B2B2B"),
+  diffAdd: chalk6.hex("#FFD166"),
+  diffRemove: chalk6.hex("#D62828"),
+  diffHeader: chalk6.hex("#FF6B35"),
+  mdH1: chalk6.hex("#FF6B35").bold,
+  mdH2: chalk6.hex("#F4845F"),
+  mdH3: chalk6.hex("#8B4513"),
+  mdCode: chalk6.hex("#FFD166"),
+  mdInlineCode: chalk6.hex("#FF6B35"),
+  mdLink: chalk6.hex("#F4845F").underline,
+  meterLow: chalk6.hex("#FFD166"),
+  meterMid: chalk6.hex("#FF6B35"),
+  meterHigh: chalk6.hex("#D62828")
 };
 var ghostTheme = {
   name: "Ghost",
   description: "Monochrome \u2014 pure grayscale minimalism",
-  brand: chalk5.hex("#E0E0E0"),
-  mascot: chalk5.hex("#AAAAAA"),
-  mascotAccent: chalk5.hex("#FFFFFF"),
-  tagline: chalk5.hex("#666666"),
-  prompt: chalk5.hex("#CCCCCC"),
-  border: chalk5.hex("#333333"),
-  dim: chalk5.hex("#555555"),
-  text: chalk5.hex("#CCCCCC"),
-  bold: chalk5.hex("#FFFFFF").bold,
-  success: chalk5.hex("#AAAAAA"),
-  warning: chalk5.hex("#CCCCCC"),
-  error: chalk5.hex("#FFFFFF"),
-  info: chalk5.hex("#999999"),
-  toolName: chalk5.hex("#AAAAAA"),
-  toolArgs: chalk5.hex("#666666"),
-  toolResult: chalk5.hex("#444444"),
-  diffAdd: chalk5.hex("#CCCCCC"),
-  diffRemove: chalk5.hex("#777777").strikethrough,
-  diffHeader: chalk5.hex("#E0E0E0"),
-  mdH1: chalk5.hex("#FFFFFF").bold,
-  mdH2: chalk5.hex("#CCCCCC"),
-  mdH3: chalk5.hex("#AAAAAA"),
-  mdCode: chalk5.hex("#BBBBBB"),
-  mdInlineCode: chalk5.hex("#CCCCCC"),
-  mdLink: chalk5.hex("#E0E0E0").underline,
-  meterLow: chalk5.hex("#AAAAAA"),
-  meterMid: chalk5.hex("#CCCCCC"),
-  meterHigh: chalk5.hex("#FFFFFF")
+  brand: chalk6.hex("#E0E0E0"),
+  mascot: chalk6.hex("#AAAAAA"),
+  mascotAccent: chalk6.hex("#FFFFFF"),
+  tagline: chalk6.hex("#666666"),
+  prompt: chalk6.hex("#CCCCCC"),
+  border: chalk6.hex("#333333"),
+  dim: chalk6.hex("#555555"),
+  text: chalk6.hex("#CCCCCC"),
+  bold: chalk6.hex("#FFFFFF").bold,
+  success: chalk6.hex("#AAAAAA"),
+  warning: chalk6.hex("#CCCCCC"),
+  error: chalk6.hex("#FFFFFF"),
+  info: chalk6.hex("#999999"),
+  toolName: chalk6.hex("#AAAAAA"),
+  toolArgs: chalk6.hex("#666666"),
+  toolResult: chalk6.hex("#444444"),
+  diffAdd: chalk6.hex("#CCCCCC"),
+  diffRemove: chalk6.hex("#777777").strikethrough,
+  diffHeader: chalk6.hex("#E0E0E0"),
+  mdH1: chalk6.hex("#FFFFFF").bold,
+  mdH2: chalk6.hex("#CCCCCC"),
+  mdH3: chalk6.hex("#AAAAAA"),
+  mdCode: chalk6.hex("#BBBBBB"),
+  mdInlineCode: chalk6.hex("#CCCCCC"),
+  mdLink: chalk6.hex("#E0E0E0").underline,
+  meterLow: chalk6.hex("#AAAAAA"),
+  meterMid: chalk6.hex("#CCCCCC"),
+  meterHigh: chalk6.hex("#FFFFFF")
 };
 var THEME_CATALOG = {
   "default": defaultTheme,
@@ -3181,11 +4101,11 @@ function formatThemeList(activeId) {
   for (const id of THEME_IDS) {
     const t = THEME_CATALOG[id];
     const active = id === activeId ? t.success(" \u25CF") : "  ";
-    const name = id === activeId ? t.bold(t.name) : chalk5.gray(t.name);
-    const desc = chalk5.gray(t.description);
-    lines.push(`  ${active} ${chalk5.hex("#888")(id.padEnd(14))} ${name}  ${desc}`);
+    const name = id === activeId ? t.bold(t.name) : chalk6.gray(t.name);
+    const desc = chalk6.gray(t.description);
+    lines.push(`  ${active} ${chalk6.hex("#888")(id.padEnd(14))} ${name}  ${desc}`);
   }
-  lines.push(chalk5.gray(`
+  lines.push(chalk6.gray(`
   Switch with: /theme <name>
 `));
   return lines.join("\n");
@@ -3223,7 +4143,7 @@ function colorBannerLine(line, rowIndex) {
     return t.brand(line);
   }
   const color = ROW_COLORS[rowIndex] ?? "#CCCCCC";
-  return chalk6.hex(color)(line);
+  return chalk7.hex(color)(line);
 }
 var MANTIS = [
   "  \u2571\u25C9\u25C9\u2572",
@@ -3329,12 +4249,12 @@ function formatTokens(n) {
 }
 
 // src/ui/update-checker.ts
-import fs12 from "fs/promises";
-import path13 from "path";
-import os3 from "os";
-import { execSync as execSync3 } from "child_process";
-import chalk7 from "chalk";
-var CACHE_FILE = path13.join(os3.homedir(), ".notch", "update-check.json");
+import fs15 from "fs/promises";
+import path17 from "path";
+import os4 from "os";
+import { execSync as execSync4 } from "child_process";
+import chalk8 from "chalk";
+var CACHE_FILE = path17.join(os4.homedir(), ".notch", "update-check.json");
 var CHECK_INTERVAL = 60 * 60 * 1e3;
 var PACKAGE_NAME = "@freesyntax/notch-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
@@ -3367,15 +4287,15 @@ async function checkForUpdates(currentVersion) {
   }
 }
 function autoUpdate(current, latest) {
-  console.log(chalk7.cyan(`
+  console.log(chalk8.cyan(`
   \u2B06 Updating Notch CLI: ${current} \u2192 ${latest}...
 `));
   try {
-    execSync3(`npm install -g ${PACKAGE_NAME}@${latest}`, {
+    execSync4(`npm install -g ${PACKAGE_NAME}@${latest}`, {
       stdio: "inherit",
       timeout: 6e4
     });
-    console.log(chalk7.green(`
+    console.log(chalk8.green(`
   \u2713 Updated to v${latest}. Restarting...
 `));
     const args = process.argv.slice(2);
@@ -3383,7 +4303,7 @@ function autoUpdate(current, latest) {
     const result = spawnSync("notch", args, { stdio: "inherit" });
     process.exit(result.status ?? 0);
   } catch {
-    return chalk7.yellow(`  Update available: ${current} \u2192 ${latest}. Run: npm install -g ${PACKAGE_NAME}@latest
+    return chalk8.yellow(`  Update available: ${current} \u2192 ${latest}. Run: npm install -g ${PACKAGE_NAME}@latest
 `);
   }
 }
@@ -3398,7 +4318,7 @@ function isNewer(latest, current) {
 }
 async function loadCache() {
   try {
-    const raw = await fs12.readFile(CACHE_FILE, "utf-8");
+    const raw = await fs15.readFile(CACHE_FILE, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3406,16 +4326,16 @@ async function loadCache() {
 }
 async function saveCache(cache) {
   try {
-    await fs12.mkdir(path13.dirname(CACHE_FILE), { recursive: true });
-    await fs12.writeFile(CACHE_FILE, JSON.stringify(cache), "utf-8");
+    await fs15.mkdir(path17.dirname(CACHE_FILE), { recursive: true });
+    await fs15.writeFile(CACHE_FILE, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 
 // src/permissions/index.ts
-import fs13 from "fs/promises";
-import path14 from "path";
-import os4 from "os";
+import fs16 from "fs/promises";
+import path18 from "path";
+import os5 from "os";
 var DEFAULT_PERMISSIONS = {
   default: "prompt",
   rules: [
@@ -3432,11 +4352,11 @@ var DEFAULT_PERMISSIONS = {
   ]
 };
 async function loadPermissions(projectRoot) {
-  const projectPath = path14.join(projectRoot, ".notch.json");
-  const globalPath = path14.join(os4.homedir(), ".notch", "permissions.json");
+  const projectPath = path18.join(projectRoot, ".notch.json");
+  const globalPath = path18.join(os5.homedir(), ".notch", "permissions.json");
   let config = { ...DEFAULT_PERMISSIONS };
   try {
-    const raw = await fs13.readFile(globalPath, "utf-8");
+    const raw = await fs16.readFile(globalPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.permissions) {
       config = mergePermissions(config, parsed.permissions);
@@ -3444,7 +4364,7 @@ async function loadPermissions(projectRoot) {
   } catch {
   }
   try {
-    const raw = await fs13.readFile(projectPath, "utf-8");
+    const raw = await fs16.readFile(projectPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.permissions) {
       config = mergePermissions(config, parsed.permissions);
@@ -3490,17 +4410,18 @@ function mergePermissions(base, override) {
 }
 
 // src/hooks/index.ts
-import { execSync as execSync4 } from "child_process";
-import fs14 from "fs/promises";
-import path15 from "path";
-import os5 from "os";
+import { execSync as execSync5 } from "child_process";
+import fs17 from "fs/promises";
+import { watch } from "fs";
+import path19 from "path";
+import os6 from "os";
 import crypto from "crypto";
-var TRUST_STORE_PATH = path15.join(os5.homedir(), ".notch", "trusted-projects.json");
+var TRUST_STORE_PATH = path19.join(os6.homedir(), ".notch", "trusted-projects.json");
 async function isTrustedProject(projectRoot, raw) {
   const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
-  const key = path15.resolve(projectRoot);
+  const key = path19.resolve(projectRoot);
   try {
-    const store = JSON.parse(await fs14.readFile(TRUST_STORE_PATH, "utf-8"));
+    const store = JSON.parse(await fs17.readFile(TRUST_STORE_PATH, "utf-8"));
     return store[key] === fingerprint;
   } catch {
     return false;
@@ -3508,30 +4429,30 @@ async function isTrustedProject(projectRoot, raw) {
 }
 async function trustProject(projectRoot, raw) {
   const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
-  const key = path15.resolve(projectRoot);
+  const key = path19.resolve(projectRoot);
   let store = {};
   try {
-    store = JSON.parse(await fs14.readFile(TRUST_STORE_PATH, "utf-8"));
+    store = JSON.parse(await fs17.readFile(TRUST_STORE_PATH, "utf-8"));
   } catch {
   }
   store[key] = fingerprint;
-  await fs14.mkdir(path15.dirname(TRUST_STORE_PATH), { recursive: true });
-  await fs14.writeFile(TRUST_STORE_PATH, JSON.stringify(store, null, 2));
+  await fs17.mkdir(path19.dirname(TRUST_STORE_PATH), { recursive: true });
+  await fs17.writeFile(TRUST_STORE_PATH, JSON.stringify(store, null, 2));
 }
 async function loadHooks(projectRoot, promptTrust) {
   const hooks = [];
-  const globalPath = path15.join(os5.homedir(), ".notch", "hooks.json");
+  const globalPath = path19.join(os6.homedir(), ".notch", "hooks.json");
   try {
-    const raw = await fs14.readFile(globalPath, "utf-8");
+    const raw = await fs17.readFile(globalPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed.hooks)) {
       hooks.push(...parsed.hooks);
     }
   } catch {
   }
-  const projectPath = path15.join(projectRoot, ".notch.json");
+  const projectPath = path19.join(projectRoot, ".notch.json");
   try {
-    const raw = await fs14.readFile(projectPath, "utf-8");
+    const raw = await fs17.readFile(projectPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed.hooks) && parsed.hooks.length > 0) {
       const alreadyTrusted = await isTrustedProject(projectRoot, raw);
@@ -3553,7 +4474,8 @@ async function loadHooks(projectRoot, promptTrust) {
   return { hooks };
 }
 async function runHooks(config, event, context) {
-  const matching = config.hooks.filter((h) => {
+  const allHooks = [...config.hooks, ...pluginManager.getHooks()];
+  const matching = allHooks.filter((h) => {
     if (h.event !== event) return false;
     if (h.tool && h.tool !== context.tool) return false;
     if (h.pattern && context.file && !context.file.includes(h.pattern)) return false;
@@ -3596,7 +4518,7 @@ async function executeHook(hook, context) {
     NOTCH_CWD: context.cwd
   };
   try {
-    const output = execSync4(hook.command, {
+    const output = execSync5(hook.command, {
       cwd: context.cwd,
       encoding: "utf-8",
       timeout: hook.timeout ?? 1e4,
@@ -3613,18 +4535,48 @@ async function executeHook(hook, context) {
     };
   }
 }
+function startFileWatcher(projectRoot, hookConfig, onHookResult) {
+  const debounceMs = 150;
+  const pending = /* @__PURE__ */ new Map();
+  let watcher = null;
+  try {
+    watcher = watch(projectRoot, { recursive: true }, (_eventType, filename) => {
+      if (!filename) return;
+      if (filename.startsWith(".git/") || filename.startsWith(".git\\") || filename.includes("node_modules") || filename.startsWith("dist/") || filename.startsWith("dist\\")) return;
+      const existing = pending.get(filename);
+      if (existing) clearTimeout(existing);
+      pending.set(filename, setTimeout(async () => {
+        pending.delete(filename);
+        const filePath = path19.join(projectRoot, filename);
+        const context = { cwd: projectRoot, file: filePath };
+        const { results } = await runHooks(hookConfig, "file-changed", context);
+        onHookResult?.("file-changed", results);
+        if (filename === ".notch.json") {
+          const { results: cfgResults } = await runHooks(hookConfig, "config-change", context);
+          onHookResult?.("config-change", cfgResults);
+        }
+      }, debounceMs));
+    });
+  } catch {
+  }
+  return () => {
+    watcher?.close();
+    for (const timer of pending.values()) clearTimeout(timer);
+    pending.clear();
+  };
+}
 
 // src/session/index.ts
-import fs15 from "fs/promises";
-import path16 from "path";
-import os6 from "os";
-var SESSION_DIR = path16.join(os6.homedir(), ".notch", "sessions");
+import fs18 from "fs/promises";
+import path20 from "path";
+import os7 from "os";
+var SESSION_DIR = path20.join(os7.homedir(), ".notch", "sessions");
 var MAX_SESSIONS = 20;
 async function ensureDir2() {
-  await fs15.mkdir(SESSION_DIR, { recursive: true });
+  await fs18.mkdir(SESSION_DIR, { recursive: true });
 }
 function sessionPath(id) {
-  return path16.join(SESSION_DIR, `${id}.json`);
+  return path20.join(SESSION_DIR, `${id}.json`);
 }
 function generateId() {
   const now = /* @__PURE__ */ new Date();
@@ -3651,13 +4603,13 @@ async function saveSession(messages, project, model, existingId) {
     },
     messages
   };
-  await fs15.writeFile(sessionPath(id), JSON.stringify(session, null, 2), "utf-8");
+  await fs18.writeFile(sessionPath(id), JSON.stringify(session, null, 2), "utf-8");
   await pruneOldSessions();
   return id;
 }
 async function loadSession(id) {
   try {
-    const raw = await fs15.readFile(sessionPath(id), "utf-8");
+    const raw = await fs18.readFile(sessionPath(id), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3665,12 +4617,12 @@ async function loadSession(id) {
 }
 async function listSessions() {
   await ensureDir2();
-  const files = await fs15.readdir(SESSION_DIR);
+  const files = await fs18.readdir(SESSION_DIR);
   const sessions = [];
   for (const file of files) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = await fs15.readFile(path16.join(SESSION_DIR, file), "utf-8");
+      const raw = await fs18.readFile(path20.join(SESSION_DIR, file), "utf-8");
       const session = JSON.parse(raw);
       sessions.push(session.meta);
     } catch {
@@ -3686,7 +4638,7 @@ async function loadLastSession(project) {
 }
 async function deleteSession(id) {
   try {
-    await fs15.unlink(sessionPath(id));
+    await fs18.unlink(sessionPath(id));
     return true;
   } catch {
     return false;
@@ -3740,14 +4692,14 @@ async function exportSession(messages, outputPath, meta) {
       lines.push("");
     }
   }
-  await fs15.writeFile(outputPath, lines.join("\n"), "utf-8");
+  await fs18.writeFile(outputPath, lines.join("\n"), "utf-8");
   return outputPath;
 }
 
 // src/init.ts
-import fs16 from "fs/promises";
-import path17 from "path";
-import chalk8 from "chalk";
+import fs19 from "fs/promises";
+import path21 from "path";
+import chalk9 from "chalk";
 var DEFAULT_CONFIG = {
   model: "notch-forge",
   temperature: 0.3,
@@ -3778,47 +4730,47 @@ var DEFAULT_INSTRUCTIONS = `# Project Instructions for Notch
 <!-- Files or areas Notch should NOT modify -->
 `;
 async function initProject(projectRoot) {
-  const configPath = path17.join(projectRoot, ".notch.json");
-  const instructionsPath = path17.join(projectRoot, ".notch.md");
+  const configPath = path21.join(projectRoot, ".notch.json");
+  const instructionsPath = path21.join(projectRoot, ".notch.md");
   let configExists = false;
   let instructionsExist = false;
   try {
-    await fs16.access(configPath);
+    await fs19.access(configPath);
     configExists = true;
   } catch {
   }
   try {
-    await fs16.access(instructionsPath);
+    await fs19.access(instructionsPath);
     instructionsExist = true;
   } catch {
   }
   if (!configExists) {
-    await fs16.writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf-8");
-    console.log(chalk8.green(`  Created ${configPath}`));
+    await fs19.writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf-8");
+    console.log(chalk9.green(`  Created ${configPath}`));
   } else {
-    console.log(chalk8.gray(`  Skipped ${configPath} (already exists)`));
+    console.log(chalk9.gray(`  Skipped ${configPath} (already exists)`));
   }
   if (!instructionsExist) {
-    await fs16.writeFile(instructionsPath, DEFAULT_INSTRUCTIONS, "utf-8");
-    console.log(chalk8.green(`  Created ${instructionsPath}`));
+    await fs19.writeFile(instructionsPath, DEFAULT_INSTRUCTIONS, "utf-8");
+    console.log(chalk9.green(`  Created ${instructionsPath}`));
   } else {
-    console.log(chalk8.gray(`  Skipped ${instructionsPath} (already exists)`));
+    console.log(chalk9.gray(`  Skipped ${instructionsPath} (already exists)`));
   }
-  const gitignorePath = path17.join(projectRoot, ".gitignore");
+  const gitignorePath = path21.join(projectRoot, ".gitignore");
   try {
-    const gitignore = await fs16.readFile(gitignorePath, "utf-8");
+    const gitignore = await fs19.readFile(gitignorePath, "utf-8");
     const additions = [];
     if (!gitignore.includes(".notch.json")) additions.push(".notch.json");
     if (additions.length > 0) {
       const append = "\n# Notch CLI\n" + additions.join("\n") + "\n";
-      await fs16.appendFile(gitignorePath, append, "utf-8");
-      console.log(chalk8.green(`  Updated .gitignore`));
+      await fs19.appendFile(gitignorePath, append, "utf-8");
+      console.log(chalk9.green(`  Updated .gitignore`));
     }
   } catch {
   }
   console.log("");
-  console.log(chalk8.cyan("  Notch initialized! Edit .notch.md to customize behavior."));
-  console.log(chalk8.gray('  Run "notch" to start.\n'));
+  console.log(chalk9.cyan("  Notch initialized! Edit .notch.md to customize behavior."));
+  console.log(chalk9.gray('  Run "notch" to start.\n'));
 }
 
 // src/tools/diff-preview.ts
@@ -3937,9 +4889,1198 @@ function findSync(oldLines, newLines, oi, ni, lookAhead) {
   return null;
 }
 
+// src/commands/doctor.ts
+import { execSync as execSync6 } from "child_process";
+import fs20 from "fs/promises";
+import path22 from "path";
+import os8 from "os";
+import chalk10 from "chalk";
+async function runDiagnostics(cwd) {
+  const results = [];
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split(".")[0], 10);
+  if (major >= 20) {
+    results.push({ name: "Node.js", status: "ok", message: `v${nodeVersion}` });
+  } else if (major >= 18) {
+    results.push({ name: "Node.js", status: "warn", message: `v${nodeVersion} (recommend >= 20)` });
+  } else {
+    results.push({ name: "Node.js", status: "fail", message: `v${nodeVersion} (requires >= 18)` });
+  }
+  try {
+    const gitVersion = execSync6("git --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+    results.push({ name: "Git", status: "ok", message: gitVersion });
+  } catch {
+    results.push({ name: "Git", status: "fail", message: "Not found. Install git to use git tools." });
+  }
+  try {
+    const config = await loadConfig({ projectRoot: cwd });
+    const apiKey = config.models.chat.apiKey;
+    if (apiKey) {
+      results.push({ name: "API Key", status: "ok", message: `Set (${apiKey.slice(0, 8)}...)` });
+    } else {
+      results.push({ name: "API Key", status: "fail", message: "Not set. Run: notch login" });
+    }
+    try {
+      const check = await validateConfig(config.models.chat);
+      if (check.ok) {
+        results.push({ name: "API Endpoint", status: "ok", message: `${config.models.chat.model} reachable` });
+      } else {
+        results.push({ name: "API Endpoint", status: "fail", message: check.error ?? "Unreachable" });
+      }
+    } catch (err) {
+      results.push({ name: "API Endpoint", status: "fail", message: err.message });
+    }
+  } catch (err) {
+    results.push({ name: "Config", status: "fail", message: `Could not load: ${err.message}` });
+  }
+  try {
+    await fs20.access(path22.join(cwd, ".notch.json"));
+    results.push({ name: ".notch.json", status: "ok", message: "Found" });
+  } catch {
+    results.push({ name: ".notch.json", status: "warn", message: "Not found. Run: notch init" });
+  }
+  const notchDir = path22.join(os8.homedir(), ".notch");
+  try {
+    await fs20.access(notchDir);
+    results.push({ name: "~/.notch/", status: "ok", message: "Exists" });
+  } catch {
+    results.push({ name: "~/.notch/", status: "warn", message: "Not found (will be created on first use)" });
+  }
+  try {
+    await fs20.access(path22.join(cwd, ".notch.md"));
+    results.push({ name: ".notch.md", status: "ok", message: "Found" });
+  } catch {
+    results.push({ name: ".notch.md", status: "warn", message: "Not found. Run: notch init" });
+  }
+  try {
+    const configRaw = await fs20.readFile(path22.join(cwd, ".notch.json"), "utf-8").catch(() => "{}");
+    const mcpConfigs = parseMCPConfig(JSON.parse(configRaw));
+    const serverNames = Object.keys(mcpConfigs);
+    if (serverNames.length === 0) {
+      results.push({ name: "MCP Servers", status: "ok", message: "None configured" });
+    } else {
+      for (const name of serverNames) {
+        try {
+          const client = new MCPClient(mcpConfigs[name], name);
+          await client.connect();
+          results.push({ name: `MCP: ${name}`, status: "ok", message: `${client.tools.length} tools` });
+          client.disconnect();
+        } catch (err) {
+          results.push({ name: `MCP: ${name}`, status: "fail", message: err.message });
+        }
+      }
+    }
+  } catch {
+    results.push({ name: "MCP Servers", status: "ok", message: "No config to check" });
+  }
+  try {
+    const sessionsDir = path22.join(notchDir, "sessions");
+    const entries = await fs20.readdir(sessionsDir).catch(() => []);
+    results.push({ name: "Sessions", status: "ok", message: `${entries.length} saved` });
+  } catch {
+    results.push({ name: "Sessions", status: "ok", message: "0 saved" });
+  }
+  return results;
+}
+function formatDiagnostics(results) {
+  const icons = { ok: chalk10.green("\u2713"), warn: chalk10.yellow("!"), fail: chalk10.red("\u2717") };
+  const lines = results.map((r) => {
+    const icon = icons[r.status];
+    const name = r.name.padEnd(16);
+    return `  ${icon} ${name} ${chalk10.gray(r.message)}`;
+  });
+  return "\n" + lines.join("\n") + "\n";
+}
+registerCommand("/doctor", async (_args, ctx) => {
+  ctx.log("Running diagnostics...");
+  const results = await runDiagnostics(ctx.cwd);
+  console.log(formatDiagnostics(results));
+  const failCount = results.filter((r) => r.status === "fail").length;
+  const warnCount = results.filter((r) => r.status === "warn").length;
+  if (failCount > 0) {
+    console.log(chalk10.red(`  ${failCount} issue(s) need attention.
+`));
+  } else if (warnCount > 0) {
+    console.log(chalk10.yellow(`  All clear with ${warnCount} suggestion(s).
+`));
+  } else {
+    console.log(chalk10.green("  Everything looks good!\n"));
+  }
+});
+
+// src/commands/copy.ts
+import { execSync as execSync7 } from "child_process";
+import chalk11 from "chalk";
+function copyToClipboard(text) {
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      execSync7("clip.exe", { input: text, timeout: 5e3 });
+    } else if (platform === "darwin") {
+      execSync7("pbcopy", { input: text, timeout: 5e3 });
+    } else {
+      try {
+        execSync7("xclip -selection clipboard", { input: text, timeout: 5e3 });
+      } catch {
+        try {
+          execSync7("xsel --clipboard --input", { input: text, timeout: 5e3 });
+        } catch {
+          execSync7("wl-copy", { input: text, timeout: 5e3 });
+        }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+registerCommand("/copy", async (_args, ctx) => {
+  if (!ctx.lastResponse) {
+    console.log(chalk11.gray("  Nothing to copy yet.\n"));
+    return;
+  }
+  if (copyToClipboard(ctx.lastResponse)) {
+    const preview = ctx.lastResponse.slice(0, 60).replace(/\n/g, " ");
+    console.log(chalk11.green(`  \u2713 Copied to clipboard`) + chalk11.gray(` (${ctx.lastResponse.length} chars)`));
+    console.log(chalk11.gray(`    "${preview}${ctx.lastResponse.length > 60 ? "..." : ""}"
+`));
+  } else {
+    console.log(chalk11.red("  Clipboard not available."));
+    console.log(chalk11.gray("  Install xclip (Linux) or ensure clip.exe/pbcopy is available.\n"));
+  }
+});
+
+// src/commands/btw.ts
+import chalk12 from "chalk";
+registerCommand("/btw", async (args, ctx) => {
+  if (!args) {
+    console.log(chalk12.gray("  Usage: /btw <question>\n"));
+    return;
+  }
+  console.log(chalk12.gray("  (Side question \u2014 won't affect main conversation)\n"));
+  const tempMessages = [
+    { role: "user", content: args }
+  ];
+  try {
+    await ctx.runPrompt(args, tempMessages);
+    console.log(chalk12.gray("\n  (Side question complete \u2014 context unchanged)\n"));
+  } catch (err) {
+    console.log(chalk12.red(`  Side question failed: ${err.message}
+`));
+  }
+});
+
+// src/commands/security-review.ts
+import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
+import chalk13 from "chalk";
+function isValidGitRange(range) {
+  return /^[a-zA-Z0-9._~^\/\-]+(\.\.[a-zA-Z0-9._~^\/\-]+)?$/.test(range);
+}
+registerCommand("/security-review", async (args, ctx) => {
+  const range = args || "HEAD~5..HEAD";
+  if (!isValidGitRange(range)) {
+    console.log(chalk13.red("  Invalid git range. Use formats like: HEAD~5..HEAD, main..feature, abc123\n"));
+    return;
+  }
+  let diff;
+  let stat;
+  try {
+    stat = execFileSync2("git", ["diff", range, "--stat"], {
+      cwd: ctx.cwd,
+      encoding: "utf-8",
+      timeout: 1e4
+    }).trim();
+    diff = execFileSync2("git", ["diff", range], {
+      cwd: ctx.cwd,
+      encoding: "utf-8",
+      timeout: 1e4,
+      maxBuffer: 1024 * 1024 * 5
+      // 5MB
+    }).trim();
+  } catch {
+    try {
+      stat = execSync8("git diff --stat", {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 1e4
+      }).trim();
+      diff = execSync8("git diff", {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 1e4,
+        maxBuffer: 1024 * 1024 * 5
+      }).trim();
+    } catch (err) {
+      console.log(chalk13.red(`  Could not get diff: ${err.message}
+`));
+      return;
+    }
+  }
+  if (!diff) {
+    console.log(chalk13.gray("  No changes to review.\n"));
+    return;
+  }
+  console.log(chalk13.gray(`  Reviewing changes...
+`));
+  console.log(chalk13.gray(`  ${stat}
+`));
+  const maxDiffLen = 5e4;
+  const truncatedDiff = diff.length > maxDiffLen ? diff.slice(0, maxDiffLen) + "\n... (truncated)" : diff;
+  const prompt = `Perform a thorough security review of these recent code changes. Use your tools to read full files if you need more context.
+
+## Changed Files
+${stat}
+
+## Diff
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+## Review Checklist
+Analyze for these vulnerability categories:
+1. **Secrets & Credentials** \u2014 Hardcoded API keys, tokens, passwords, or connection strings
+2. **Injection** \u2014 SQL injection, command injection, XSS, template injection
+3. **Authentication & Authorization** \u2014 Broken auth, missing access controls, session issues
+4. **Input Validation** \u2014 Missing or insufficient input validation at system boundaries
+5. **Path Traversal** \u2014 Unsanitized file paths that could escape the project root
+6. **Dependency Issues** \u2014 New dependencies with known vulnerabilities
+7. **Cryptography** \u2014 Weak algorithms, hardcoded IVs/salts, insecure random
+8. **Information Disclosure** \u2014 Verbose errors, stack traces in production, debug endpoints
+9. **Race Conditions** \u2014 TOCTOU, unsafe concurrent access to shared state
+10. **Configuration** \u2014 Insecure defaults, overly permissive CORS/CSP/permissions
+
+For each finding, provide:
+- **Severity**: Critical / High / Medium / Low
+- **File and line**: Where the issue is
+- **Description**: What the vulnerability is
+- **Fix**: How to remediate it
+
+If no issues are found, say so explicitly. Do not fabricate issues.`;
+  ctx.messages.push({ role: "user", content: prompt });
+  try {
+    await ctx.runPrompt(prompt, ctx.messages);
+  } catch (err) {
+    console.log(chalk13.red(`  Security review failed: ${err.message}
+`));
+  }
+});
+
+// src/commands/loop.ts
+import chalk14 from "chalk";
+var activeLoop = null;
+function stopActiveLoop() {
+  if (activeLoop) {
+    clearInterval(activeLoop.timer);
+    activeLoop = null;
+  }
+}
+function parseDuration(s) {
+  const match = s.match(/^(\d+)(s|m|h)$/);
+  if (!match) return null;
+  const n = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 6e4;
+    case "h":
+      return n * 36e5;
+    default:
+      return null;
+  }
+}
+function formatDuration(ms) {
+  if (ms >= 36e5) return `${ms / 36e5}h`;
+  if (ms >= 6e4) return `${ms / 6e4}m`;
+  return `${ms / 1e3}s`;
+}
+registerCommand("/loop", async (args, ctx) => {
+  if (args === "stop" || args === "cancel") {
+    if (activeLoop) {
+      clearInterval(activeLoop.timer);
+      console.log(chalk14.gray(`  Stopped loop: ${activeLoop.command} (was every ${formatDuration(activeLoop.intervalMs)})
+`));
+      activeLoop = null;
+    } else {
+      console.log(chalk14.gray("  No active loop.\n"));
+    }
+    return;
+  }
+  if (args === "status" || !args) {
+    if (activeLoop) {
+      console.log(chalk14.gray(`  Active loop: ${chalk14.white(activeLoop.command)} every ${formatDuration(activeLoop.intervalMs)}
+`));
+      console.log(chalk14.gray("  Stop with: /loop stop\n"));
+    } else {
+      console.log(chalk14.gray("  No active loop.\n"));
+      console.log(chalk14.gray("  Usage: /loop <interval> <command>"));
+      console.log(chalk14.gray("  Example: /loop 5m /status\n"));
+    }
+    return;
+  }
+  const parts = args.split(/\s+/);
+  if (parts.length < 2) {
+    console.log(chalk14.gray("  Usage: /loop <interval> <command>"));
+    console.log(chalk14.gray("  Example: /loop 5m /status"));
+    console.log(chalk14.gray("  Intervals: 30s, 5m, 1h\n"));
+    return;
+  }
+  const intervalMs = parseDuration(parts[0]);
+  if (!intervalMs) {
+    console.log(chalk14.red(`  Invalid interval: ${parts[0]}`));
+    console.log(chalk14.gray("  Use formats like: 30s, 5m, 1h\n"));
+    return;
+  }
+  if (intervalMs < 1e4) {
+    console.log(chalk14.red("  Minimum interval is 10s.\n"));
+    return;
+  }
+  const command = parts.slice(1).join(" ");
+  if (!command.startsWith("/")) {
+    console.log(chalk14.red("  Command must start with /\n"));
+    return;
+  }
+  if (activeLoop) {
+    clearInterval(activeLoop.timer);
+  }
+  const timer = setInterval(async () => {
+    console.log(chalk14.gray(`
+  [loop] Running: ${command}`));
+    try {
+      const handled = await dispatchCommand(command, ctx);
+      if (!handled) {
+        console.log(chalk14.gray(`  [loop] Unknown command: ${command}`));
+      }
+    } catch (err) {
+      console.log(chalk14.red(`  [loop] Error: ${err.message}`));
+    }
+  }, intervalMs);
+  activeLoop = { timer, command, intervalMs };
+  console.log(chalk14.green(`  \u2713 Loop started: ${chalk14.white(command)} every ${formatDuration(intervalMs)}`));
+  console.log(chalk14.gray("  Stop with: /loop stop\n"));
+});
+
+// src/commands/batch.ts
+import chalk15 from "chalk";
+import ora from "ora";
+var MAX_CONCURRENT = 3;
+async function pLimit(tasks2, limit) {
+  const results = [];
+  let idx = 0;
+  async function runNext() {
+    while (idx < tasks2.length) {
+      const i = idx++;
+      try {
+        const value = await tasks2[i]();
+        results[i] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[i] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks2.length) }, () => runNext());
+  await Promise.all(workers);
+  return results;
+}
+registerCommand("/batch", async (args, ctx) => {
+  if (!args) {
+    console.log(chalk15.gray("  Usage: /batch <task description>"));
+    console.log(chalk15.gray("  Example: /batch add JSDoc to all exported functions"));
+    console.log(chalk15.gray("  Example: /batch convert var to const in src/**/*.js\n"));
+    return;
+  }
+  const spinner = ora("Identifying target files...").start();
+  const discoveryPrompt = `I need to apply this change across multiple files: "${args}"
+
+List ONLY the file paths that need this change, one per line. Use the glob and grep tools to find them. Output the final list as a simple newline-separated list of file paths with no other text, wrapped in <files> tags like:
+
+<files>
+src/foo.ts
+src/bar.ts
+</files>`;
+  const tempMessages = [
+    { role: "user", content: discoveryPrompt }
+  ];
+  let fileList = [];
+  try {
+    const responseText = await ctx.runPrompt(discoveryPrompt, tempMessages);
+    spinner.stop();
+    const match = responseText.match(/<files>\s*([\s\S]*?)\s*<\/files>/);
+    if (match) {
+      fileList = match[1].split("\n").map((f) => f.trim()).filter(Boolean);
+    }
+    if (fileList.length === 0) {
+      console.log(chalk15.yellow("  No target files identified.\n"));
+      return;
+    }
+  } catch (err) {
+    spinner.fail(`Failed to identify files: ${err.message}`);
+    return;
+  }
+  console.log(chalk15.gray(`
+  Found ${fileList.length} file(s) to process:
+`));
+  for (const f of fileList) {
+    console.log(chalk15.gray(`    \u2022 ${f}`));
+  }
+  console.log("");
+  const batchSpinner = ora(`Processing 0/${fileList.length} files...`).start();
+  let completed = 0;
+  const tasks2 = fileList.map((file) => async () => {
+    const fileMessages = [
+      {
+        role: "user",
+        content: `Apply this change to the file "${file}": ${args}
+
+Read the file first, then make the change. Only modify this one file.`
+      }
+    ];
+    try {
+      await ctx.runPrompt(fileMessages[0].content, fileMessages);
+      completed++;
+      batchSpinner.text = `Processing ${completed}/${fileList.length} files...`;
+      return { file, ok: true };
+    } catch (err) {
+      completed++;
+      batchSpinner.text = `Processing ${completed}/${fileList.length} files...`;
+      return { file, ok: false, error: err.message };
+    }
+  });
+  const results = await pLimit(tasks2, MAX_CONCURRENT);
+  batchSpinner.stop();
+  console.log(chalk15.gray("\n  Batch Results:\n"));
+  let successes = 0;
+  let failures = 0;
+  for (const r of results) {
+    if (r.status === "fulfilled") {
+      if (r.value.ok) {
+        console.log(chalk15.green(`  \u2713 ${r.value.file}`));
+        successes++;
+      } else {
+        console.log(chalk15.red(`  \u2717 ${r.value.file}: ${r.value.error}`));
+        failures++;
+      }
+    } else {
+      console.log(chalk15.red(`  \u2717 Unknown: ${r.reason?.message ?? "failed"}`));
+      failures++;
+    }
+  }
+  console.log("");
+  if (failures === 0) {
+    console.log(chalk15.green(`  \u2713 All ${successes} file(s) processed successfully.
+`));
+  } else {
+    console.log(chalk15.yellow(`  ${successes} succeeded, ${failures} failed.
+`));
+  }
+});
+
+// src/commands/plugin.ts
+import { execSync as execSync9, execFileSync as execFileSync3 } from "child_process";
+import fs21 from "fs/promises";
+import path23 from "path";
+import os9 from "os";
+import chalk16 from "chalk";
+var GLOBAL_PLUGINS_DIR = path23.join(os9.homedir(), ".notch", "plugins");
+registerCommand("/plugin", async (args, ctx) => {
+  const parts = args.split(/\s+/);
+  const subcommand = parts[0] || "list";
+  const target = parts.slice(1).join(" ");
+  switch (subcommand) {
+    case "list":
+    case "ls": {
+      const plugins = pluginManager.list();
+      if (plugins.length === 0) {
+        console.log(chalk16.gray("  No plugins installed.\n"));
+        console.log(chalk16.gray("  Install one: /plugin install <npm-package-or-git-url>\n"));
+        return;
+      }
+      console.log(chalk16.gray("\n  Installed plugins:\n"));
+      for (const p of plugins) {
+        const toolCount = p.tools.length;
+        const hookCount = p.hooks.length;
+        const meta = [
+          toolCount > 0 ? `${toolCount} tool${toolCount > 1 ? "s" : ""}` : "",
+          hookCount > 0 ? `${hookCount} hook${hookCount > 1 ? "s" : ""}` : ""
+        ].filter(Boolean).join(", ");
+        console.log(`  ${chalk16.green("\u25CF")} ${chalk16.white(p.name)} ${chalk16.gray(`v${p.version}`)}${meta ? chalk16.gray(` (${meta})`) : ""}`);
+        if (p.description) {
+          console.log(chalk16.gray(`    ${p.description}`));
+        }
+      }
+      console.log("");
+      return;
+    }
+    case "install":
+    case "add": {
+      if (!target) {
+        console.log(chalk16.gray("  Usage: /plugin install <npm-package-or-git-url>\n"));
+        return;
+      }
+      await fs21.mkdir(GLOBAL_PLUGINS_DIR, { recursive: true });
+      const pluginDir = path23.join(GLOBAL_PLUGINS_DIR, path23.basename(target).replace(/\.git$/, ""));
+      console.log(chalk16.gray(`  Installing ${target}...`));
+      try {
+        if (target.includes("/") && !target.startsWith("@")) {
+          execFileSync3("git", ["clone", "--depth", "1", target, pluginDir], {
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: "pipe"
+          });
+        } else {
+          await fs21.mkdir(pluginDir, { recursive: true });
+          execFileSync3("npm", ["init", "-y"], {
+            cwd: pluginDir,
+            encoding: "utf-8",
+            timeout: 3e4,
+            stdio: "pipe"
+          });
+          execFileSync3("npm", ["install", target], {
+            cwd: pluginDir,
+            encoding: "utf-8",
+            timeout: 12e4,
+            stdio: "pipe"
+          });
+        }
+        try {
+          const pkgExists = await fs21.access(path23.join(pluginDir, "package.json")).then(() => true).catch(() => false);
+          if (pkgExists) {
+            execSync9("npm install --production", {
+              cwd: pluginDir,
+              encoding: "utf-8",
+              timeout: 12e4,
+              stdio: "pipe"
+            });
+          }
+        } catch {
+        }
+        console.log(chalk16.green(`  \u2713 Installed to ${pluginDir}`));
+        console.log(chalk16.gray("  Restart notch to load the plugin.\n"));
+      } catch (err) {
+        console.log(chalk16.red(`  Install failed: ${err.message}
+`));
+      }
+      return;
+    }
+    case "remove":
+    case "rm":
+    case "uninstall": {
+      if (!target) {
+        console.log(chalk16.gray("  Usage: /plugin remove <plugin-name>\n"));
+        return;
+      }
+      const pluginDir = path23.join(GLOBAL_PLUGINS_DIR, target);
+      try {
+        await fs21.access(pluginDir);
+        await fs21.rm(pluginDir, { recursive: true, force: true });
+        console.log(chalk16.green(`  \u2713 Removed ${target}`));
+        console.log(chalk16.gray("  Restart notch to apply.\n"));
+      } catch {
+        console.log(chalk16.red(`  Plugin not found: ${target}
+`));
+      }
+      return;
+    }
+    default:
+      console.log(chalk16.gray("  Usage: /plugin <list|install|remove> [name]\n"));
+  }
+});
+
+// src/commands/commit.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import chalk17 from "chalk";
+import ora2 from "ora";
+function gitCommit(message, cwd) {
+  execFileSync4("git", ["commit", "-m", message], {
+    cwd,
+    encoding: "utf-8",
+    timeout: 3e4
+  });
+}
+registerCommand("/commit", async (args, ctx) => {
+  let diff;
+  let stat;
+  try {
+    const staged = execFileSync4("git", ["diff", "--cached", "--stat"], { cwd: ctx.cwd, encoding: "utf-8" }).trim();
+    if (!staged) {
+      execFileSync4("git", ["add", "-A"], { cwd: ctx.cwd, encoding: "utf-8" });
+    }
+    stat = execFileSync4("git", ["diff", "--cached", "--stat"], { cwd: ctx.cwd, encoding: "utf-8" }).trim();
+    diff = execFileSync4("git", ["diff", "--cached"], { cwd: ctx.cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 }).trim();
+  } catch (err) {
+    console.log(chalk17.red(`  Git error: ${err.message}
+`));
+    return;
+  }
+  if (!diff) {
+    console.log(chalk17.gray("  No changes to commit.\n"));
+    return;
+  }
+  console.log(chalk17.gray(`
+  Staged changes:
+  ${stat}
+`));
+  if (args) {
+    try {
+      gitCommit(args, ctx.cwd);
+      console.log(chalk17.green(`  \u2713 Committed: ${args}
+`));
+    } catch (err) {
+      console.log(chalk17.red(`  Commit failed: ${err.message}
+`));
+    }
+    return;
+  }
+  const spinner = ora2("Generating commit message...").start();
+  const truncatedDiff = diff.length > 3e4 ? diff.slice(0, 3e4) + "\n... (truncated)" : diff;
+  const prompt = `Generate a concise git commit message for these changes. Follow conventional commit format (feat:, fix:, refactor:, docs:, chore:, etc.). Keep the first line under 72 characters. Add a blank line then a brief body if needed.
+
+Changes:
+${stat}
+
+Diff:
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+Reply with ONLY the commit message, nothing else. No markdown, no explanation.`;
+  const tempMessages = [
+    { role: "user", content: prompt }
+  ];
+  try {
+    const message = await ctx.runPrompt(prompt, tempMessages);
+    spinner.stop();
+    const cleanMessage = message.replace(/^```\n?/gm, "").replace(/\n?```$/gm, "").replace(/^["'`]/g, "").replace(/["'`]$/g, "").trim();
+    console.log(chalk17.white(`
+  ${cleanMessage.split("\n")[0]}
+`));
+    if (cleanMessage.includes("\n")) {
+      const body = cleanMessage.split("\n").slice(1).join("\n").trim();
+      if (body) console.log(chalk17.gray(`  ${body}
+`));
+    }
+    const rl = await import("readline");
+    const confirm = rl.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve2) => {
+      confirm.question(chalk17.yellow("  Commit with this message? [Y/n/e(dit)] "), resolve2);
+    });
+    confirm.close();
+    const choice = answer.trim().toLowerCase();
+    if (choice === "n" || choice === "no") {
+      console.log(chalk17.gray("  Commit cancelled.\n"));
+      return;
+    }
+    let finalMessage = cleanMessage;
+    if (choice === "e" || choice === "edit") {
+      const editRl = rl.createInterface({ input: process.stdin, output: process.stdout });
+      finalMessage = await new Promise((resolve2) => {
+        editRl.question(chalk17.gray("  Enter commit message: "), resolve2);
+      });
+      editRl.close();
+      if (!finalMessage.trim()) {
+        console.log(chalk17.gray("  Commit cancelled.\n"));
+        return;
+      }
+    }
+    try {
+      gitCommit(finalMessage, ctx.cwd);
+      console.log(chalk17.green(`  \u2713 Committed: ${finalMessage.split("\n")[0]}
+`));
+    } catch (err) {
+      console.log(chalk17.red(`  Commit failed: ${err.message}
+`));
+    }
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+  }
+});
+
+// src/commands/pr.ts
+import { execSync as execSync11, execFileSync as execFileSync5 } from "child_process";
+import chalk18 from "chalk";
+import ora3 from "ora";
+function tryExec(cmd, cwd) {
+  try {
+    return execSync11(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+registerCommand("/pr", async (args, ctx) => {
+  const branch = tryExec("git branch --show-current", ctx.cwd);
+  if (!branch) {
+    console.log(chalk18.red("  Not a git repository or not on a branch.\n"));
+    return;
+  }
+  const baseBranch = tryExec("git rev-parse --abbrev-ref origin/HEAD", ctx.cwd)?.replace("origin/", "") || tryExec("git symbolic-ref refs/remotes/origin/HEAD", ctx.cwd)?.replace("refs/remotes/origin/", "") || "main";
+  if (branch === baseBranch) {
+    console.log(chalk18.red(`  You're on ${baseBranch}. Switch to a feature branch first.
+`));
+    return;
+  }
+  if (!tryExec("gh --version", ctx.cwd)) {
+    console.log(chalk18.red("  GitHub CLI (gh) not found. Install it: https://cli.github.com\n"));
+    return;
+  }
+  const stat = tryExec(`git diff ${baseBranch}...HEAD --stat`, ctx.cwd) || "";
+  const log = tryExec(`git log ${baseBranch}..HEAD --oneline`, ctx.cwd) || "";
+  const diff = tryExec(`git diff ${baseBranch}...HEAD`, ctx.cwd) || "";
+  if (!log) {
+    console.log(chalk18.gray("  No commits ahead of base branch.\n"));
+    return;
+  }
+  console.log(chalk18.gray(`
+  Branch: ${chalk18.white(branch)} \u2192 ${baseBranch}`));
+  console.log(chalk18.gray(`  Commits:
+${log.split("\n").map((l) => `    ${l}`).join("\n")}
+`));
+  console.log(chalk18.gray(`  Files:
+  ${stat}
+`));
+  const hasRemote = tryExec(`git rev-parse --abbrev-ref ${branch}@{upstream}`, ctx.cwd);
+  if (!hasRemote) {
+    console.log(chalk18.gray("  Pushing branch to origin..."));
+    try {
+      execFileSync5("git", ["push", "-u", "origin", branch], { cwd: ctx.cwd, encoding: "utf-8", timeout: 3e4 });
+      console.log(chalk18.green("  \u2713 Pushed\n"));
+    } catch (err) {
+      console.log(chalk18.red(`  Push failed: ${err.message}
+`));
+      return;
+    }
+  }
+  if (args) {
+    try {
+      const result = execFileSync5("gh", ["pr", "create", "--title", args, "--body", "Auto-generated by Notch CLI", "--base", baseBranch], {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      console.log(chalk18.green(`  \u2713 ${result.trim()}
+`));
+    } catch (err) {
+      console.log(chalk18.red(`  PR creation failed: ${err.message}
+`));
+    }
+    return;
+  }
+  const spinner = ora3("Generating PR description...").start();
+  const truncatedDiff = diff.length > 3e4 ? diff.slice(0, 3e4) + "\n... (truncated)" : diff;
+  const prompt = `Generate a GitHub pull request title and body for these changes.
+
+Branch: ${branch} \u2192 ${baseBranch}
+
+Commits:
+${log}
+
+Files changed:
+${stat}
+
+Diff:
+\`\`\`diff
+${truncatedDiff}
+\`\`\`
+
+Reply in this exact format (no other text):
+TITLE: <short PR title, under 72 chars>
+BODY:
+## Summary
+<2-3 bullet points describing the changes>
+
+## Changes
+<brief list of what was changed and why>`;
+  const tempMessages = [
+    { role: "user", content: prompt }
+  ];
+  try {
+    const response = await ctx.runPrompt(prompt, tempMessages);
+    spinner.stop();
+    const titleMatch = response.match(/TITLE:\s*(.+)/);
+    const bodyMatch = response.match(/BODY:\s*([\s\S]+)/);
+    const title = titleMatch?.[1]?.trim() || `${branch}: changes from Notch`;
+    const body = bodyMatch?.[1]?.trim() || response;
+    console.log(chalk18.white(`
+  Title: ${title}
+`));
+    console.log(chalk18.gray(`  ${body.slice(0, 200)}${body.length > 200 ? "..." : ""}
+`));
+    const rl = await import("readline");
+    const confirm = rl.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve2) => {
+      confirm.question(chalk18.yellow("  Create PR? [Y/n] "), resolve2);
+    });
+    confirm.close();
+    if (answer.trim().toLowerCase() === "n") {
+      console.log(chalk18.gray("  PR cancelled.\n"));
+      return;
+    }
+    try {
+      const result = execFileSync5("gh", ["pr", "create", "--title", title, "--body", body, "--base", baseBranch], {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      console.log(chalk18.green(`  \u2713 ${result.trim()}
+`));
+    } catch (err) {
+      console.log(chalk18.red(`  PR creation failed: ${err.message}
+`));
+    }
+  } catch (err) {
+    spinner.fail(`Failed: ${err.message}`);
+  }
+});
+
+// src/commands/worktree.ts
+import { execSync as execSync12, execFileSync as execFileSync6 } from "child_process";
+import chalk19 from "chalk";
+function tryExec2(cmd, cwd) {
+  try {
+    return execSync12(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+registerCommand("/worktree", async (args, ctx) => {
+  const parts = args.split(/\s+/);
+  const subcommand = parts[0] || "list";
+  switch (subcommand) {
+    case "list":
+    case "ls": {
+      const result = tryExec2("git worktree list", ctx.cwd);
+      if (!result) {
+        console.log(chalk19.red("  Not a git repository.\n"));
+        return;
+      }
+      console.log(chalk19.gray("\n  Git Worktrees:\n"));
+      for (const line of result.split("\n")) {
+        const isCurrent = line.includes(ctx.cwd);
+        console.log(isCurrent ? chalk19.green(`  \u25CF ${line}`) : chalk19.gray(`    ${line}`));
+      }
+      console.log("");
+      return;
+    }
+    case "create":
+    case "new": {
+      const branchName = parts[1];
+      if (!branchName) {
+        console.log(chalk19.gray("  Usage: /worktree create <branch-name> [base-branch]\n"));
+        return;
+      }
+      const baseBranch = parts[2] || "HEAD";
+      const worktreePath = `../${branchName}`;
+      try {
+        execFileSync6("git", ["worktree", "add", worktreePath, "-b", branchName, baseBranch], {
+          cwd: ctx.cwd,
+          encoding: "utf-8",
+          timeout: 15e3
+        });
+        const absPath = tryExec2(`cd "${worktreePath}" && pwd`, ctx.cwd);
+        console.log(chalk19.green(`  \u2713 Created worktree: ${branchName}`));
+        console.log(chalk19.gray(`    Path: ${absPath || worktreePath}`));
+        console.log(chalk19.gray(`    Base: ${baseBranch}`));
+        console.log(chalk19.gray(`
+  Run: /worktree switch ${branchName}
+`));
+      } catch (err) {
+        console.log(chalk19.red(`  Failed: ${err.message}
+`));
+      }
+      return;
+    }
+    case "remove":
+    case "rm": {
+      const target = parts[1];
+      if (!target) {
+        console.log(chalk19.gray("  Usage: /worktree remove <branch-or-path>\n"));
+        return;
+      }
+      try {
+        execFileSync6("git", ["worktree", "remove", target, "--force"], {
+          cwd: ctx.cwd,
+          encoding: "utf-8",
+          timeout: 15e3
+        });
+        try {
+          execFileSync6("git", ["branch", "-D", target], { cwd: ctx.cwd, encoding: "utf-8", timeout: 5e3 });
+        } catch {
+        }
+        console.log(chalk19.green(`  \u2713 Removed worktree: ${target}
+`));
+      } catch (err) {
+        console.log(chalk19.red(`  Failed: ${err.message}
+`));
+      }
+      return;
+    }
+    case "switch": {
+      const target = parts[1];
+      if (!target) {
+        console.log(chalk19.gray("  Usage: /worktree switch <branch-name>\n"));
+        return;
+      }
+      const list = tryExec2("git worktree list --porcelain", ctx.cwd);
+      if (!list) {
+        console.log(chalk19.red("  Not a git repository.\n"));
+        return;
+      }
+      const worktrees = list.split("\n\n").filter((block) => block.trim().length > 0).map((block) => {
+        const lines = block.split("\n");
+        const wtPath = lines.find((l) => l.startsWith("worktree "))?.slice(9)?.trim();
+        const branch = lines.find((l) => l.startsWith("branch "))?.slice(7)?.replace("refs/heads/", "")?.trim();
+        return { path: wtPath, branch };
+      }).filter((wt) => wt.path);
+      const match = worktrees.find(
+        (wt) => wt.branch === target || wt.path?.includes(target)
+      );
+      if (!match?.path) {
+        console.log(chalk19.red(`  Worktree not found: ${target}
+`));
+        return;
+      }
+      console.log(chalk19.green(`  \u2713 Switched context to: ${match.branch || target}`));
+      console.log(chalk19.gray(`    Path: ${match.path}`));
+      console.log(chalk19.gray(`
+  Note: This changes the working directory for Notch tools.
+`));
+      return;
+    }
+    case "prune": {
+      try {
+        execSync12("git worktree prune", { cwd: ctx.cwd, encoding: "utf-8" });
+        console.log(chalk19.green("  \u2713 Pruned stale worktrees.\n"));
+      } catch (err) {
+        console.log(chalk19.red(`  Failed: ${err.message}
+`));
+      }
+      return;
+    }
+    default:
+      console.log(chalk19.gray("  Usage: /worktree <list|create|remove|switch|prune>\n"));
+      console.log(chalk19.gray("  Commands:"));
+      console.log(chalk19.gray("    list                    \u2014 List all worktrees"));
+      console.log(chalk19.gray("    create <branch> [base]  \u2014 Create new worktree"));
+      console.log(chalk19.gray("    remove <branch>         \u2014 Remove a worktree"));
+      console.log(chalk19.gray("    switch <branch>         \u2014 Switch Notch context"));
+      console.log(chalk19.gray("    prune                   \u2014 Clean up stale worktrees\n"));
+  }
+});
+
+// src/commands/tasks.ts
+import chalk20 from "chalk";
+registerCommand("/tasks", async (_args, _ctx) => {
+  const tasks2 = getAllTasks();
+  if (tasks2.length === 0) {
+    console.log(chalk20.gray("  No tasks. The agent will create tasks automatically during complex work.\n"));
+    return;
+  }
+  console.log(chalk20.gray("\n  Task List:\n"));
+  console.log("  " + formatTasksDisplay().split("\n").join("\n  "));
+  const completed = tasks2.filter((t) => t.status === "completed").length;
+  const total = tasks2.length;
+  const pct = total > 0 ? Math.round(completed / total * 100) : 0;
+  console.log(chalk20.gray(`
+  Progress: ${completed}/${total} (${pct}%)
+`));
+});
+
+// src/commands/debug.ts
+import chalk21 from "chalk";
+var debugEnabled = false;
+registerCommand("/debug", async (args, ctx) => {
+  if (args === "off") {
+    debugEnabled = false;
+    console.log(chalk21.gray("  Debug logging disabled.\n"));
+    return;
+  }
+  if (args === "on" || !args) {
+    debugEnabled = !debugEnabled;
+    console.log(debugEnabled ? chalk21.yellow("  Debug logging enabled. Verbose output will be shown.\n") : chalk21.gray("  Debug logging disabled.\n"));
+    return;
+  }
+  if (args === "status") {
+    console.log(chalk21.gray("\n  Debug Status:"));
+    console.log(chalk21.gray(`    Model: ${ctx.modelId}`));
+    console.log(chalk21.gray(`    Messages: ${ctx.messages.length}`));
+    console.log(chalk21.gray(`    CWD: ${ctx.cwd}`));
+    console.log(chalk21.gray(`    Debug: ${debugEnabled ? "on" : "off"}`));
+    console.log(chalk21.gray(`    Last response: ${ctx.lastResponse ? ctx.lastResponse.length + " chars" : "none"}`));
+    const charCount = ctx.messages.reduce((sum, m) => {
+      const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+      return sum + content.length;
+    }, 0);
+    console.log(chalk21.gray(`    Estimated tokens: ~${Math.round(charCount / 4)}`));
+    console.log("");
+    return;
+  }
+  console.log(chalk21.gray("  Usage: /debug [on|off|status]\n"));
+});
+
+// src/commands/rewind.ts
+import chalk22 from "chalk";
+registerCommand("/rewind", async (args, ctx) => {
+  if (ctx.messages.length === 0) {
+    console.log(chalk22.gray("  No conversation to rewind.\n"));
+    return;
+  }
+  const userTurns = [];
+  for (let i = 0; i < ctx.messages.length; i++) {
+    const msg = ctx.messages[i];
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      const preview = content.slice(0, 60).replace(/\n/g, " ");
+      userTurns.push({ index: i, preview });
+    }
+  }
+  if (userTurns.length === 0) {
+    console.log(chalk22.gray("  No turns to rewind to.\n"));
+    return;
+  }
+  if (args) {
+    const turnNum = parseInt(args, 10);
+    if (isNaN(turnNum) || turnNum < 1 || turnNum > userTurns.length) {
+      console.log(chalk22.red(`  Invalid turn number: ${args}`));
+      console.log(chalk22.gray(`  Valid range: 1-${userTurns.length}
+`));
+      return;
+    }
+    const target = userTurns[turnNum - 1];
+    const kept = ctx.messages.slice(0, target.index);
+    ctx.messages.length = 0;
+    ctx.messages.push(...kept);
+    console.log(chalk22.green(`  \u2713 Rewound to before turn ${turnNum}`));
+    console.log(chalk22.gray(`    "${target.preview}"`));
+    console.log(chalk22.gray(`    ${ctx.messages.length} messages remaining.
+`));
+    return;
+  }
+  console.log(chalk22.gray("\n  Conversation turns:\n"));
+  for (let i = 0; i < userTurns.length; i++) {
+    console.log(chalk22.gray(`    ${i + 1}. ${userTurns[i].preview}${userTurns[i].preview.length >= 60 ? "..." : ""}`));
+  }
+  console.log(chalk22.gray(`
+  Rewind to a turn: /rewind <turn-number>
+`));
+});
+
+// src/commands/insights.ts
+import chalk23 from "chalk";
+registerCommand("/insights", async (_args, ctx) => {
+  if (ctx.messages.length === 0) {
+    console.log(chalk23.gray("  No conversation data to analyze.\n"));
+    return;
+  }
+  let userMsgs = 0;
+  let assistantMsgs = 0;
+  let toolCalls = 0;
+  const toolUsage = /* @__PURE__ */ new Map();
+  const filesReferenced = /* @__PURE__ */ new Set();
+  let totalChars = 0;
+  for (const msg of ctx.messages) {
+    if (msg.role === "user") {
+      userMsgs++;
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      totalChars += content.length;
+    } else if (msg.role === "assistant") {
+      assistantMsgs++;
+      if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (typeof part === "object" && "type" in part && part.type === "tool-call") {
+            toolCalls++;
+            const name = part.toolName || "unknown";
+            toolUsage.set(name, (toolUsage.get(name) || 0) + 1);
+            const args = part.args;
+            if (args?.path) filesReferenced.add(String(args.path));
+            if (args?.file) filesReferenced.add(String(args.file));
+          }
+        }
+      }
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      totalChars += content.length;
+    }
+  }
+  const estimatedTokens = Math.round(totalChars / 4);
+  console.log(chalk23.gray("\n  \u2550\u2550\u2550 Session Insights \u2550\u2550\u2550\n"));
+  console.log(chalk23.gray("  Conversation:"));
+  console.log(chalk23.gray(`    ${userMsgs} user turns, ${assistantMsgs} assistant responses`));
+  console.log(chalk23.gray(`    ${ctx.messages.length} total messages`));
+  console.log(chalk23.gray(`    ~${estimatedTokens.toLocaleString()} tokens estimated`));
+  console.log("");
+  if (toolCalls > 0) {
+    console.log(chalk23.gray("  Tool Usage:"));
+    const sorted = [...toolUsage.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [name, count] of sorted) {
+      const bar = "\u2588".repeat(Math.min(count, 20));
+      console.log(chalk23.gray(`    ${name.padEnd(14)} ${chalk23.cyan(bar)} ${count}`));
+    }
+    console.log(chalk23.gray(`    ${"Total".padEnd(14)} ${toolCalls} calls`));
+    console.log("");
+  }
+  if (filesReferenced.size > 0) {
+    console.log(chalk23.gray("  Files Referenced:"));
+    const files = [...filesReferenced].slice(0, 15);
+    for (const f of files) {
+      console.log(chalk23.gray(`    \u2022 ${f}`));
+    }
+    if (filesReferenced.size > 15) {
+      console.log(chalk23.gray(`    ... and ${filesReferenced.size - 15} more`));
+    }
+    console.log("");
+  }
+  const avgToolsPerTurn = userMsgs > 0 ? (toolCalls / userMsgs).toFixed(1) : "0";
+  console.log(chalk23.gray("  Efficiency:"));
+  console.log(chalk23.gray(`    Avg tools per turn: ${avgToolsPerTurn}`));
+  console.log(chalk23.gray(`    Files per session: ${filesReferenced.size}`));
+  console.log(chalk23.gray(`    Tool diversity: ${toolUsage.size} unique tools used`));
+  console.log("");
+});
+
+// src/commands/rename.ts
+import chalk24 from "chalk";
+var sessionName = "";
+function getSessionName() {
+  return sessionName;
+}
+registerCommand("/rename", async (args, _ctx) => {
+  if (!args) {
+    if (sessionName) {
+      console.log(chalk24.gray(`  Current session name: ${chalk24.white(sessionName)}
+`));
+    } else {
+      console.log(chalk24.gray("  Usage: /rename <name>\n"));
+    }
+    return;
+  }
+  sessionName = args.trim();
+  console.log(chalk24.green(`  \u2713 Session named: "${sessionName}"
+`));
+});
+
+// src/commands/sandbox.ts
+import chalk25 from "chalk";
+var sandboxEnabled = false;
+function isSandboxEnabled() {
+  return sandboxEnabled;
+}
+registerCommand("/sandbox", async (args, _ctx) => {
+  if (args === "on") {
+    sandboxEnabled = true;
+  } else if (args === "off") {
+    sandboxEnabled = false;
+  } else {
+    sandboxEnabled = !sandboxEnabled;
+  }
+  if (sandboxEnabled) {
+    console.log(chalk25.yellow("  \u26A0 Sandbox mode ON \u2014 write/edit/shell tools will run in dry-run mode."));
+    console.log(chalk25.gray("  Only read, grep, glob, and web-fetch will execute normally.\n"));
+  } else {
+    console.log(chalk25.green("  \u2713 Sandbox mode OFF \u2014 all tools enabled.\n"));
+  }
+});
+
 // src/ui/completions.ts
-import fs17 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path24 from "path";
 var COMMANDS = [
   "/help",
   "/quit",
@@ -3969,7 +6110,39 @@ var COMMANDS = [
   "/mascot",
   "/cost",
   "/branch",
-  "/branches"
+  "/branches",
+  // Utility commands
+  "/doctor",
+  "/copy",
+  "/btw",
+  "/security-review",
+  "/loop",
+  "/loop stop",
+  "/batch",
+  "/plugin",
+  "/plugin list",
+  "/plugin install",
+  "/plugin remove",
+  // Git workflow
+  "/commit",
+  "/pr",
+  // Worktree
+  "/worktree",
+  "/worktree list",
+  "/worktree create",
+  "/worktree remove",
+  "/worktree switch",
+  // Task management
+  "/tasks",
+  // UX commands
+  "/debug",
+  "/debug on",
+  "/debug off",
+  "/debug status",
+  "/rewind",
+  "/insights",
+  "/rename",
+  "/sandbox"
 ];
 function buildCompleter(cwd) {
   return function completer(line) {
@@ -4000,15 +6173,15 @@ function buildCompleter(cwd) {
 }
 function completeFilePath(partial, cwd) {
   try {
-    const dir = partial.includes("/") ? path18.resolve(cwd, path18.dirname(partial)) : cwd;
-    const prefix = partial.includes("/") ? path18.basename(partial) : partial;
-    const entries = fs17.readdirSync(dir, { withFileTypes: true });
+    const dir = partial.includes("/") ? path24.resolve(cwd, path24.dirname(partial)) : cwd;
+    const prefix = partial.includes("/") ? path24.basename(partial) : partial;
+    const entries = fs22.readdirSync(dir, { withFileTypes: true });
     const matches = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       if (entry.name === "node_modules" || entry.name === ".git") continue;
       if (entry.name.startsWith(prefix)) {
-        const relative = partial.includes("/") ? path18.dirname(partial) + "/" + entry.name : entry.name;
+        const relative = partial.includes("/") ? path24.dirname(partial) + "/" + entry.name : entry.name;
         if (entry.isDirectory()) {
           matches.push(relative + "/");
         } else {
@@ -4023,7 +6196,7 @@ function completeFilePath(partial, cwd) {
 }
 
 // src/index.ts
-import fs18 from "fs/promises";
+import fs23 from "fs/promises";
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var VERSION = _require("../package.json").version;
@@ -4046,7 +6219,7 @@ function printModelTable(activeModel) {
 `));
 }
 function printHelp() {
-  console.log(chalk9.gray(`
+  console.log(chalk26.gray(`
   Commands:
     /model              \u2014 Show available models
     /model <name>       \u2014 Switch model (e.g., /model pyre)
@@ -4080,6 +6253,30 @@ function printHelp() {
     /ralph status       \u2014 Show plan progress
     /ralph clear        \u2014 Discard plan
 
+  Git Workflow:
+    /commit [msg]       \u2014 Smart commit (AI-generated message)
+    /pr [title]         \u2014 Create PR with AI-generated summary
+    /worktree <cmd>     \u2014 Manage git worktrees (create/switch/remove)
+
+  Utilities:
+    /doctor             \u2014 Diagnose installation health
+    /copy               \u2014 Copy last response to clipboard
+    /btw <question>     \u2014 Side question (won't affect context)
+    /security-review    \u2014 Review recent changes for vulnerabilities
+    /loop <int> <cmd>   \u2014 Run a command on interval (e.g. /loop 5m /status)
+    /batch <task>       \u2014 Apply a task across multiple files in parallel
+    /tasks              \u2014 Show agent task list
+    /insights           \u2014 Session analytics and tool usage
+    /rewind [turn]      \u2014 Rewind conversation to a previous turn
+    /rename <name>      \u2014 Name this session
+    /debug [on|off]     \u2014 Toggle debug logging
+    /sandbox            \u2014 Toggle sandbox mode (read-only)
+
+  Plugins:
+    /plugin list        \u2014 List installed plugins
+    /plugin install <n> \u2014 Install a plugin (npm package or git URL)
+    /plugin remove <n>  \u2014 Remove a plugin
+
   Other:
     /branch             \u2014 Fork conversation at this point
     /branches           \u2014 List conversation branches
@@ -4115,17 +6312,17 @@ async function readStdin() {
 }
 async function main() {
   if (promptArgs[0] === "login") {
-    const spinner = ora("Opening browser...").start();
+    const spinner = ora4("Opening browser...").start();
     try {
       spinner.stop();
       const creds = await login();
-      console.log(chalk9.green(`
+      console.log(chalk26.green(`
   \u2713 Signed in as ${creds.email}`));
-      console.log(chalk9.gray(`  API key stored in ${(await import("./auth-S3FIB42I.js")).getCredentialsPath()}
+      console.log(chalk26.gray(`  API key stored in ${(await import("./auth-S3FIB42I.js")).getCredentialsPath()}
 `));
     } catch (err) {
       spinner.stop();
-      console.error(chalk9.red(`
+      console.error(chalk26.red(`
   Login failed: ${err.message}
 `));
       process.exit(1);
@@ -4135,10 +6332,10 @@ async function main() {
   if (promptArgs[0] === "logout") {
     const creds = await loadCredentials();
     if (!creds) {
-      console.log(chalk9.gray("\n  Not signed in.\n"));
+      console.log(chalk26.gray("\n  Not signed in.\n"));
     } else {
       await clearCredentials();
-      console.log(chalk9.green(`
+      console.log(chalk26.green(`
   \u2713 Signed out (${creds.email})
 `));
     }
@@ -4147,13 +6344,13 @@ async function main() {
   if (promptArgs[0] === "whoami") {
     const creds = await loadCredentials();
     if (!creds) {
-      console.log(chalk9.gray("\n  Not signed in. Run: notch login\n"));
+      console.log(chalk26.gray("\n  Not signed in. Run: notch login\n"));
     } else {
       const keyPreview = `${creds.token.slice(0, 12)}...`;
-      console.log(chalk9.gray(`
-  Signed in as ${chalk9.white(creds.email)}`));
-      console.log(chalk9.gray(`  Key: ${keyPreview}`));
-      console.log(chalk9.gray(`  Since: ${new Date(creds.createdAt).toLocaleDateString()}
+      console.log(chalk26.gray(`
+  Signed in as ${chalk26.white(creds.email)}`));
+      console.log(chalk26.gray(`  Key: ${keyPreview}`));
+      console.log(chalk26.gray(`  Since: ${new Date(creds.createdAt).toLocaleDateString()}
 `));
     }
     return;
@@ -4177,8 +6374,8 @@ async function main() {
   const config = await loadConfig(configOverrides);
   if (opts.model) {
     if (!isValidModel(opts.model)) {
-      console.error(chalk9.red(`  Unknown model: ${opts.model}`));
-      console.error(chalk9.gray(`  Available: ${modelChoices}`));
+      console.error(chalk26.red(`  Unknown model: ${opts.model}`));
+      console.error(chalk26.gray(`  Available: ${modelChoices}`));
       process.exit(1);
     }
     config.models.chat.model = opts.model;
@@ -4217,11 +6414,11 @@ async function main() {
   const updateMsg = await checkForUpdates(VERSION);
   if (updateMsg) console.log(updateMsg);
   const hookTrustPrompt = async (commands) => {
-    console.warn(chalk9.yellow("\n\u26A0  This project contains hooks in .notch.json that will run shell commands:"));
-    commands.forEach((cmd) => console.warn(chalk9.gray(`   \u2022 ${cmd}`)));
+    console.warn(chalk26.yellow("\n\u26A0  This project contains hooks in .notch.json that will run shell commands:"));
+    commands.forEach((cmd) => console.warn(chalk26.gray(`   \u2022 ${cmd}`)));
     const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve2) => {
-      rl2.question(chalk9.yellow("\nAllow these hooks for this project? [y/N] "), (answer) => {
+      rl2.question(chalk26.yellow("\nAllow these hooks for this project? [y/N] "), (answer) => {
         rl2.close();
         resolve2(answer.trim().toLowerCase() === "y");
       });
@@ -4233,7 +6430,7 @@ async function main() {
   ]);
   let repoMapStr = "";
   if (config.useRepoMap) {
-    const spinner = ora("Mapping repository...").start();
+    const spinner = ora4("Mapping repository...").start();
     try {
       const repoMap = await buildRepoMap(config.projectRoot);
       repoMapStr = condensedRepoMap(repoMap);
@@ -4260,20 +6457,30 @@ ${repoMapStr}` : ""
   const costTracker = new CostTracker();
   const mcpClients = [];
   try {
-    const configRaw = await fs18.readFile(nodePath.resolve(config.projectRoot, ".notch.json"), "utf-8").catch(() => "{}");
+    const configRaw = await fs23.readFile(nodePath.resolve(config.projectRoot, ".notch.json"), "utf-8").catch(() => "{}");
     const mcpConfigs = parseMCPConfig(JSON.parse(configRaw));
     for (const [name, mcpConfig] of Object.entries(mcpConfigs)) {
       try {
         const client = new MCPClient(mcpConfig, name);
         await client.connect();
         mcpClients.push(client);
-        console.log(chalk9.green(`  MCP: Connected to ${name} (${client.tools.length} tools)`));
+        console.log(chalk26.green(`  MCP: Connected to ${name} (${client.tools.length} tools)`));
       } catch (err) {
-        console.log(chalk9.yellow(`  MCP: Could not connect to ${name}: ${err.message}`));
+        console.log(chalk26.yellow(`  MCP: Could not connect to ${name}: ${err.message}`));
       }
     }
   } catch {
   }
+  try {
+    const pluginCount = await pluginManager.init(config.projectRoot, (msg) => {
+      console.log(chalk26.gray(`  ${msg}`));
+    });
+    if (pluginCount > 0) {
+      console.log(chalk26.green(`  Plugins: ${pluginCount} loaded`));
+    }
+  } catch (err) {
+    console.log(chalk26.yellow(`  Plugin init failed: ${err.message}`));
+  }
   const toolCtx = {
     cwd: config.projectRoot,
     requireConfirm: config.permissionMode !== "trust" && !config.autoConfirm,
@@ -4286,7 +6493,7 @@ ${repoMapStr}` : ""
         });
       });
     },
-    log: (msg) => console.log(chalk9.gray(`  ${msg}`)),
+    log: (msg) => console.log(chalk26.gray(`  ${msg}`)),
     checkPermission: config.permissionMode === "trust" ? () => "allow" : (toolName, args) => checkPermission(permissions, toolName, args),
     runHook: async (event, ctx) => {
       if (!config.enableHooks || hookConfig.hooks.length === 0) return;
@@ -4296,22 +6503,30 @@ ${repoMapStr}` : ""
       });
       for (const r of results) {
         if (!r.ok) {
-          console.log(chalk9.yellow(`  Hook failed (${r.hook.event}): ${r.error}`));
+          console.log(chalk26.yellow(`  Hook failed (${r.hook.event}): ${r.error}`));
         }
       }
     }
   };
   await toolCtx.runHook?.("session-start", {});
+  const stopFileWatcher = startFileWatcher(config.projectRoot, hookConfig, (event, results) => {
+    for (const r of results) {
+      if (!r.ok) {
+        console.log(chalk26.yellow(`  Hook failed (${event}): ${r.error}`));
+      }
+    }
+  });
   const messages = [];
+  let lastAssistantResponse = "";
   if (opts.resume || opts.session) {
     const session = opts.session ? await loadSession(opts.session) : await loadLastSession(config.projectRoot);
     if (session) {
       messages.push(...session.messages);
       sessionId = session.meta.id;
-      console.log(chalk9.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+      console.log(chalk26.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
 `));
     } else {
-      console.log(chalk9.gray("  No session to resume.\n"));
+      console.log(chalk26.gray("  No session to resume.\n"));
     }
   }
   const pipedInput = await readStdin();
@@ -4332,13 +6547,13 @@ Analyze the above input.`;
     const refContext = formatReferences(references);
     const finalPrompt = refContext + cleanInput;
     messages.push({ role: "user", content: finalPrompt });
-    console.log(chalk9.cyan(`> ${oneShot || "(piped input)"}
+    console.log(chalk26.cyan(`> ${oneShot || "(piped input)"}
 `));
     if (references.length > 0) {
-      console.log(chalk9.gray(`  Injected ${references.length} reference(s)
+      console.log(chalk26.gray(`  Injected ${references.length} reference(s)
 `));
     }
-    const spinner = ora("Thinking...").start();
+    const spinner = ora4("Thinking...").start();
     try {
       const response = await withRetry(
         () => runAgentLoop(messages, {
@@ -4354,13 +6569,13 @@ Analyze the above input.`;
           onToolCall: (name, args) => {
             if (spinner.isSpinning) spinner.stop();
             const argSummary = Object.entries(args).map(([k, v]) => `${k}=${String(v).slice(0, 60)}`).join(", ");
-            console.log(chalk9.gray(`
+            console.log(chalk26.gray(`
   \u2192 ${name}(${argSummary})`));
           },
           onToolResult: (_name, result, isError) => {
             const preview = result.slice(0, 100).replace(/\n/g, " ");
-            const icon = isError ? chalk9.red("\u2717") : chalk9.green("\u2713");
-            console.log(chalk9.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
+            const icon = isError ? chalk26.red("\u2717") : chalk26.green("\u2713");
+            console.log(chalk26.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
           }
         })
       );
@@ -4385,7 +6600,7 @@ Analyze the above input.`;
     const savedPlan = await loadPlan(config.projectRoot);
     if (savedPlan) {
       ralphPlan = savedPlan;
-      console.log(chalk9.gray(`  Ralph plan loaded (${savedPlan.tasks.length} tasks)
+      console.log(chalk26.gray(`  Ralph plan loaded (${savedPlan.tasks.length} tasks)
 `));
     }
   } catch {
@@ -4397,7 +6612,7 @@ Analyze the above input.`;
     prompt: theme().prompt("notch> "),
     completer: (line) => completer(line)
   });
-  console.log(chalk9.gray("  Type your request, or /help for commands.\n"));
+  console.log(chalk26.gray("  Type your request, or /help for commands.\n"));
   rl.prompt();
   rl.on("line", async (line) => {
     const input = line.trim();
@@ -4412,8 +6627,9 @@ Analyze the above input.`;
       }
       if (messages.length > 0) {
         try {
+          const name = getSessionName();
           const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
-          console.log(chalk9.gray(`  Session saved: ${id}`));
+          console.log(chalk26.gray(`  Session saved: ${id}${name ? ` (${name})` : ""}`));
         } catch {
         }
       }
@@ -4423,13 +6639,16 @@ Analyze the above input.`;
         } catch {
         }
       }
+      stopActiveLoop();
+      stopFileWatcher();
+      await pluginManager.shutdown();
       await toolCtx.runHook?.("session-end", {});
-      console.log(chalk9.gray("\n  Goodbye!\n"));
+      console.log(chalk26.gray("\n  Goodbye!\n"));
       process.exit(0);
     }
     if (input === "/clear") {
       messages.length = 0;
-      console.log(chalk9.gray("  Conversation cleared.\n"));
+      console.log(chalk26.gray("  Conversation cleared.\n"));
       rl.prompt();
       return;
     }
@@ -4449,8 +6668,8 @@ Analyze the above input.`;
         newModel = `notch-${newModel}`;
       }
       if (!isValidModel(newModel)) {
-        console.log(chalk9.red(`  Unknown model: ${newModel}`));
-        console.log(chalk9.gray(`  Available: ${modelChoices}`));
+        console.log(chalk26.red(`  Unknown model: ${newModel}`));
+        console.log(chalk26.gray(`  Available: ${modelChoices}`));
         rl.prompt();
         return;
       }
@@ -4458,35 +6677,35 @@ Analyze the above input.`;
       config.models.chat.model = activeModelId;
       model = resolveModel(config.models.chat);
       const switchedInfo = MODEL_CATALOG[activeModelId];
-      console.log(chalk9.green(`  Switched to ${switchedInfo.label} (${switchedInfo.id})
+      console.log(chalk26.green(`  Switched to ${switchedInfo.label} (${switchedInfo.id})
 `));
       rl.prompt();
       return;
     }
     if (input === "/status") {
-      const statusSpinner = ora("Checking Notch API...").start();
+      const statusSpinner = ora4("Checking Notch API...").start();
       const check = await validateConfig(config.models.chat);
       if (check.ok) {
         const statusInfo = MODEL_CATALOG[activeModelId];
         statusSpinner.succeed(`${statusInfo.label} (${activeModelId}) is reachable`);
       } else {
         statusSpinner.fail(check.error ?? "API unreachable");
-        console.log(chalk9.gray("  Tip: Set NOTCH_API_KEY or use --api-key, and verify your Modal endpoint is running.\n"));
+        console.log(chalk26.gray("  Tip: Set NOTCH_API_KEY or use --api-key, and verify your Modal endpoint is running.\n"));
       }
       rl.prompt();
       return;
     }
     if (input === "/undo") {
       if (checkpoints.undoCount === 0) {
-        console.log(chalk9.gray("  Nothing to undo.\n"));
+        console.log(chalk26.gray("  Nothing to undo.\n"));
         rl.prompt();
         return;
       }
       const undone = await checkpoints.undo();
       if (undone) {
         const fileCount = undone.files.length;
-        console.log(chalk9.yellow(`  Undid "${undone.description}" (${fileCount} file${fileCount !== 1 ? "s" : ""} restored)`));
-        console.log(chalk9.gray(`  ${checkpoints.undoCount} checkpoint${checkpoints.undoCount !== 1 ? "s" : ""} remaining
+        console.log(chalk26.yellow(`  Undid "${undone.description}" (${fileCount} file${fileCount !== 1 ? "s" : ""} restored)`));
+        console.log(chalk26.gray(`  ${checkpoints.undoCount} checkpoint${checkpoints.undoCount !== 1 ? "s" : ""} remaining
 `));
       }
       rl.prompt();
@@ -4494,7 +6713,7 @@ Analyze the above input.`;
     }
     if (input === "/usage") {
       if (usage.turnCount === 0) {
-        console.log(chalk9.gray("  No usage yet.\n"));
+        console.log(chalk26.gray("  No usage yet.\n"));
       } else {
         console.log(usage.formatSession());
         const currentTokens = estimateTokens(messages);
@@ -4507,7 +6726,7 @@ Analyze the above input.`;
     }
     if (input === "/cost") {
       if (costTracker.totalCost === 0) {
-        console.log(chalk9.gray("  No cost data yet.\n"));
+        console.log(chalk26.gray("  No cost data yet.\n"));
       } else {
         console.log(costTracker.formatTotal());
         console.log(costTracker.formatByModel());
@@ -4522,7 +6741,7 @@ Analyze the above input.`;
       const compressed = await autoCompress2(messages, model, MODEL_CATALOG[activeModelId].contextWindow);
       messages.length = 0;
       messages.push(...compressed);
-      console.log(chalk9.green(`  Compressed: ${before} messages \u2192 ${messages.length} messages`));
+      console.log(chalk26.green(`  Compressed: ${before} messages \u2192 ${messages.length} messages`));
       console.log("");
       rl.prompt();
       return;
@@ -4530,10 +6749,10 @@ Analyze the above input.`;
     if (input === "/diff") {
       const diffs = checkpoints.allDiffs();
       if (diffs.length === 0) {
-        console.log(chalk9.gray("  No file changes this session.\n"));
+        console.log(chalk26.gray("  No file changes this session.\n"));
       } else {
         for (const df of diffs) {
-          console.log(chalk9.cyan(`  ${df.path}:`));
+          console.log(chalk26.cyan(`  ${df.path}:`));
           console.log(unifiedDiff(df.before, df.after, df.path));
           console.log("");
         }
@@ -4549,10 +6768,10 @@ Analyze the above input.`;
           projectRoot: config.projectRoot,
           outputPath: exportPath
         });
-        console.log(chalk9.green(`  Exported to ${ePath}
+        console.log(chalk26.green(`  Exported to ${ePath}
 `));
       } catch (err) {
-        console.log(chalk9.red(`  Export failed: ${err.message}
+        console.log(chalk26.red(`  Export failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -4562,10 +6781,10 @@ Analyze the above input.`;
       try {
         const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
         sessionId = id;
-        console.log(chalk9.green(`  Session saved: ${id}
+        console.log(chalk26.green(`  Session saved: ${id}
 `));
       } catch (err) {
-        console.log(chalk9.red(`  Save failed: ${err.message}
+        console.log(chalk26.red(`  Save failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -4575,16 +6794,16 @@ Analyze the above input.`;
       try {
         const sessions = await listSessions(config.projectRoot);
         if (sessions.length === 0) {
-          console.log(chalk9.gray("  No saved sessions.\n"));
+          console.log(chalk26.gray("  No saved sessions.\n"));
         } else {
-          console.log(chalk9.gray("\n  Saved sessions:\n"));
+          console.log(chalk26.gray("\n  Saved sessions:\n"));
           for (const s of sessions.slice(0, 10)) {
-            console.log(chalk9.gray(`    ${s.id}  ${s.turns} turns  ${s.date}  ${s.model}`));
+            console.log(chalk26.gray(`    ${s.id}  ${s.turns} turns  ${s.date}  ${s.model}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk9.red(`  Error listing sessions: ${err.message}
+        console.log(chalk26.red(`  Error listing sessions: ${err.message}
 `));
       }
       rl.prompt();
@@ -4602,18 +6821,18 @@ Analyze the above input.`;
             const savedPlan = await loadPlan(config.projectRoot);
             if (savedPlan) {
               ralphPlan = savedPlan;
-              console.log(chalk9.green(`  Ralph plan restored (${savedPlan.tasks.length} tasks)
+              console.log(chalk26.green(`  Ralph plan restored (${savedPlan.tasks.length} tasks)
 `));
             }
           } catch {
           }
-          console.log(chalk9.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+          console.log(chalk26.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
 `));
         } else {
-          console.log(chalk9.gray("  No session found.\n"));
+          console.log(chalk26.gray("  No session found.\n"));
         }
       } catch (err) {
-        console.log(chalk9.red(`  Resume failed: ${err.message}
+        console.log(chalk26.red(`  Resume failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -4622,7 +6841,7 @@ Analyze the above input.`;
     if (input.startsWith("/search ")) {
       const query = input.replace("/search ", "").trim().toLowerCase();
       if (!query) {
-        console.log(chalk9.gray("  Usage: /search <query>\n"));
+        console.log(chalk26.gray("  Usage: /search <query>\n"));
         rl.prompt();
         return;
       }
@@ -4639,14 +6858,14 @@ Analyze the above input.`;
         }
       }
       if (matches.length === 0) {
-        console.log(chalk9.gray(`  No matches for "${query}"
+        console.log(chalk26.gray(`  No matches for "${query}"
 `));
       } else {
-        console.log(chalk9.gray(`
+        console.log(chalk26.gray(`
   ${matches.length} match(es) for "${query}":
 `));
         for (const m of matches.slice(0, 10)) {
-          console.log(chalk9.gray(`    [${m.index}] ${m.role}: ${m.preview}`));
+          console.log(chalk26.gray(`    [${m.index}] ${m.role}: ${m.preview}`));
         }
         console.log("");
       }
@@ -4655,12 +6874,12 @@ Analyze the above input.`;
     }
     if (input.startsWith("/plan ") && !input.startsWith("/plan approve") && !input.startsWith("/plan cancel") && !input.startsWith("/plan edit")) {
       const task = input.replace("/plan ", "").trim();
-      const planSpinner = ora("Generating plan...").start();
+      const planSpinner = ora4("Generating plan...").start();
       try {
         activePlan = await generatePlan(task, model, systemPrompt);
         planSpinner.succeed("Plan generated");
         console.log(formatPlan(activePlan));
-        console.log(chalk9.gray("  Use /plan approve to execute, /plan edit to modify, or /plan cancel to discard.\n"));
+        console.log(chalk26.gray("  Use /plan approve to execute, /plan edit to modify, or /plan cancel to discard.\n"));
       } catch (err) {
         planSpinner.fail(`Plan failed: ${err.message}`);
       }
@@ -4669,15 +6888,15 @@ Analyze the above input.`;
     }
     if (input === "/plan approve") {
       if (!activePlan) {
-        console.log(chalk9.gray("  No active plan. Use /plan <task> to create one.\n"));
+        console.log(chalk26.gray("  No active plan. Use /plan <task> to create one.\n"));
         rl.prompt();
         return;
       }
-      console.log(chalk9.green("  Executing plan...\n"));
+      console.log(chalk26.green("  Executing plan...\n"));
       while (!isPlanComplete(activePlan)) {
         const stepPrompt = currentStepPrompt(activePlan);
         messages.push({ role: "user", content: stepPrompt });
-        const planStepSpinner = ora(`Step ${activePlan.currentStep + 1}/${activePlan.steps.length}...`).start();
+        const planStepSpinner = ora4(`Step ${activePlan.currentStep + 1}/${activePlan.steps.length}...`).start();
         try {
           const response = await runAgentLoop(messages, {
             model,
@@ -4691,10 +6910,10 @@ Analyze the above input.`;
             },
             onToolCall: (name) => {
               if (planStepSpinner.isSpinning) planStepSpinner.stop();
-              console.log(chalk9.gray(`  \u2192 ${name}`));
+              console.log(chalk26.gray(`  \u2192 ${name}`));
             },
             onToolResult: (_name, _result, isError) => {
-              console.log(isError ? chalk9.red("    \u2717") : chalk9.green("    \u2713"));
+              console.log(isError ? chalk26.red("    \u2717") : chalk26.green("    \u2713"));
             }
           });
           console.log("\n");
@@ -4707,7 +6926,7 @@ Analyze the above input.`;
         }
       }
       if (activePlan && isPlanComplete(activePlan)) {
-        console.log(chalk9.green("  Plan completed!\n"));
+        console.log(chalk26.green("  Plan completed!\n"));
       }
       activePlan = null;
       rl.prompt();
@@ -4715,26 +6934,26 @@ Analyze the above input.`;
     }
     if (input === "/plan edit") {
       if (!activePlan) {
-        console.log(chalk9.gray("  No active plan to edit.\n"));
+        console.log(chalk26.gray("  No active plan to edit.\n"));
         rl.prompt();
         return;
       }
       console.log(formatPlan(activePlan));
-      console.log(chalk9.gray("  Type a modified plan description and use /plan <new task> to regenerate,"));
-      console.log(chalk9.gray("  or /plan approve to proceed with the current plan.\n"));
+      console.log(chalk26.gray("  Type a modified plan description and use /plan <new task> to regenerate,"));
+      console.log(chalk26.gray("  or /plan approve to proceed with the current plan.\n"));
       rl.prompt();
       return;
     }
     if (input === "/plan cancel") {
       activePlan = null;
-      console.log(chalk9.gray("  Plan discarded.\n"));
+      console.log(chalk26.gray("  Plan discarded.\n"));
       rl.prompt();
       return;
     }
     if (input.startsWith("/agent ")) {
       const task = input.replace("/agent ", "").trim();
       const agentId = nextSubagentId();
-      console.log(chalk9.cyan(`  Spawning subagent #${agentId}: ${task}
+      console.log(chalk26.cyan(`  Spawning subagent #${agentId}: ${task}
 `));
       spawnSubagent({
         id: agentId,
@@ -4744,14 +6963,14 @@ Analyze the above input.`;
         toolContext: toolCtx,
         contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
         onComplete: (result) => {
-          console.log(chalk9.green(`
+          console.log(chalk26.green(`
   Subagent #${agentId} finished:`));
-          console.log(chalk9.gray(`  ${result.slice(0, 200)}
+          console.log(chalk26.gray(`  ${result.slice(0, 200)}
 `));
           rl.prompt();
         },
         onError: (err) => {
-          console.log(chalk9.red(`
+          console.log(chalk26.red(`
   Subagent #${agentId} failed: ${err}
 `));
           rl.prompt();
@@ -4764,18 +6983,18 @@ Analyze the above input.`;
       try {
         const memories = await loadMemories(config.projectRoot);
         if (memories.length === 0) {
-          console.log(chalk9.gray("  No saved memories.\n"));
+          console.log(chalk26.gray("  No saved memories.\n"));
         } else {
-          console.log(chalk9.gray(`
+          console.log(chalk26.gray(`
   ${memories.length} saved memories:
 `));
           for (const m of memories) {
-            console.log(chalk9.gray(`    [${m.type}] ${m.content.slice(0, 80)}`));
+            console.log(chalk26.gray(`    [${m.type}] ${m.content.slice(0, 80)}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk9.red(`  Error: ${err.message}
+        console.log(chalk26.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -4786,16 +7005,16 @@ Analyze the above input.`;
       try {
         const results = await searchMemories(config.projectRoot, query);
         if (results.length === 0) {
-          console.log(chalk9.gray(`  No memories matching "${query}"
+          console.log(chalk26.gray(`  No memories matching "${query}"
 `));
         } else {
           for (const m of results) {
-            console.log(chalk9.gray(`    [${m.type}] ${m.content.slice(0, 100)}`));
+            console.log(chalk26.gray(`    [${m.type}] ${m.content.slice(0, 100)}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk9.red(`  Error: ${err.message}
+        console.log(chalk26.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -4807,10 +7026,10 @@ Analyze the above input.`;
         for (const m of memories) {
           await deleteMemory(config.projectRoot, m.id);
         }
-        console.log(chalk9.yellow(`  Cleared ${memories.length} memories.
+        console.log(chalk26.yellow(`  Cleared ${memories.length} memories.
 `));
       } catch (err) {
-        console.log(chalk9.red(`  Error: ${err.message}
+        console.log(chalk26.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -4824,7 +7043,7 @@ Analyze the above input.`;
     }
     if (input.startsWith("/ralph plan ")) {
       const goal = input.replace("/ralph plan ", "").trim();
-      const planSpinner = ora("Ralph is planning...").start();
+      const planSpinner = ora4("Ralph is planning...").start();
       try {
         ralphPlan = await generateRalphPlan(goal, model, systemPrompt);
         await savePlan(config.projectRoot, ralphPlan);
@@ -4838,27 +7057,27 @@ Analyze the above input.`;
     }
     if (input === "/ralph run") {
       if (!ralphPlan) {
-        console.log(chalk9.gray("  No Ralph plan. Use /ralph plan <goal> first.\n"));
+        console.log(chalk26.gray("  No Ralph plan. Use /ralph plan <goal> first.\n"));
         rl.prompt();
         return;
       }
-      console.log(chalk9.green("  Ralph is running...\n"));
+      console.log(chalk26.green("  Ralph is running...\n"));
       try {
         ralphPlan = await runRalphLoop(ralphPlan, {
           model,
           systemPrompt,
           toolContext: toolCtx,
           contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
-          onTaskStart: (task) => console.log(chalk9.cyan(`  \u25B6 Task: ${task.description}`)),
-          onTaskComplete: (task) => console.log(chalk9.green(`  \u2713 Done: ${task.description}
+          onTaskStart: (task) => console.log(chalk26.cyan(`  \u25B6 Task: ${task.description}`)),
+          onTaskComplete: (task) => console.log(chalk26.green(`  \u2713 Done: ${task.description}
 `)),
-          onTaskFail: (task, err) => console.log(chalk9.red(`  \u2717 Failed: ${task.description} (${err})
+          onTaskFail: (task, err) => console.log(chalk26.red(`  \u2717 Failed: ${task.description} (${err})
 `))
         });
         await savePlan(config.projectRoot, ralphPlan);
         console.log(formatRalphStatus(ralphPlan));
       } catch (err) {
-        console.log(chalk9.red(`  Ralph error: ${err.message}
+        console.log(chalk26.red(`  Ralph error: ${err.message}
 `));
       }
       rl.prompt();
@@ -4866,7 +7085,7 @@ Analyze the above input.`;
     }
     if (input === "/ralph status") {
       if (!ralphPlan) {
-        console.log(chalk9.gray("  No Ralph plan active.\n"));
+        console.log(chalk26.gray("  No Ralph plan active.\n"));
       } else {
         console.log(formatRalphStatus(ralphPlan));
       }
@@ -4877,26 +7096,26 @@ Analyze the above input.`;
       ralphPlan = null;
       await deletePlan(config.projectRoot).catch(() => {
       });
-      console.log(chalk9.gray("  Ralph plan cleared.\n"));
+      console.log(chalk26.gray("  Ralph plan cleared.\n"));
       rl.prompt();
       return;
     }
     if (input === "/branch") {
       const branchId = `branch-${branches.size + 1}`;
       branches.set(branchId, [...messages]);
-      console.log(chalk9.green(`  Forked conversation as "${branchId}" (${messages.length} messages)
+      console.log(chalk26.green(`  Forked conversation as "${branchId}" (${messages.length} messages)
 `));
       rl.prompt();
       return;
     }
     if (input === "/branches") {
       if (branches.size === 0) {
-        console.log(chalk9.gray("  No conversation branches. Use /branch to fork.\n"));
+        console.log(chalk26.gray("  No conversation branches. Use /branch to fork.\n"));
       } else {
-        console.log(chalk9.gray("\n  Branches:\n"));
+        console.log(chalk26.gray("\n  Branches:\n"));
         for (const [name, msgs] of branches) {
-          const marker = name === currentBranch ? chalk9.green(" \u25CF") : "  ";
-          console.log(chalk9.gray(`  ${marker} ${name}  (${msgs.length} messages)`));
+          const marker = name === currentBranch ? chalk26.green(" \u25CF") : "  ";
+          console.log(chalk26.gray(`  ${marker} ${name}  (${msgs.length} messages)`));
         }
         console.log("");
       }
@@ -4933,8 +7152,50 @@ Analyze the above input.`;
       return;
     }
     if (input.startsWith("/")) {
-      console.log(chalk9.red(`  Unknown command: ${input}`));
-      console.log(chalk9.gray("  Type /help for available commands.\n"));
+      const cmdCtx = {
+        cwd: config.projectRoot,
+        modelId: activeModelId,
+        messages,
+        lastResponse: lastAssistantResponse,
+        log: (msg) => console.log(chalk26.gray(`  ${msg}`)),
+        runPrompt: async (prompt, msgs) => {
+          const spinner2 = ora4("Thinking...").start();
+          const response = await withRetry(
+            () => runAgentLoop(msgs, {
+              model,
+              systemPrompt,
+              toolContext: { ...toolCtx, dryRun: isSandboxEnabled() || toolCtx.dryRun },
+              maxIterations: config.maxIterations,
+              contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+              onTextChunk: (chunk) => {
+                if (spinner2.isSpinning) spinner2.stop();
+                process.stdout.write(chunk);
+              },
+              onToolCall: (name, args) => {
+                if (spinner2.isSpinning) spinner2.stop();
+                const argSummary = Object.entries(args).map(([k, v]) => `${k}=${String(v).slice(0, 60)}`).join(", ");
+                console.log(chalk26.gray(`
+  \u2192 ${name}(${argSummary})`));
+              },
+              onToolResult: (_name, result, isError) => {
+                const preview = result.slice(0, 100).replace(/\n/g, " ");
+                const icon = isError ? chalk26.red("\u2717") : chalk26.green("\u2713");
+                console.log(chalk26.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
+              }
+            })
+          );
+          if (spinner2.isSpinning) spinner2.stop();
+          lastAssistantResponse = response.text;
+          return response.text;
+        }
+      };
+      const handled = await dispatchCommand(input, cmdCtx);
+      if (handled) {
+        rl.prompt();
+        return;
+      }
+      console.log(chalk26.red(`  Unknown command: ${input}`));
+      console.log(chalk26.gray("  Type /help for available commands.\n"));
       rl.prompt();
       return;
     }
@@ -4942,16 +7203,16 @@ Analyze the above input.`;
     const refContext = formatReferences(references);
     const finalPrompt = refContext + cleanInput;
     if (references.length > 0) {
-      console.log(chalk9.gray(`  Injected ${references.length} reference(s)`));
+      console.log(chalk26.gray(`  Injected ${references.length} reference(s)`));
     }
     messages.push({ role: "user", content: finalPrompt });
-    const spinner = ora("Thinking...").start();
+    const spinner = ora4("Thinking...").start();
     try {
       const response = await withRetry(
         () => runAgentLoop(messages, {
           model,
           systemPrompt,
-          toolContext: toolCtx,
+          toolContext: { ...toolCtx, dryRun: isSandboxEnabled() || toolCtx.dryRun },
           maxIterations: config.maxIterations,
           contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
           onTextChunk: (chunk) => {
@@ -4968,20 +7229,21 @@ Analyze the above input.`;
               const val = String(v);
               return `${k}=${val.length > 60 ? val.slice(0, 60) + "..." : val}`;
             }).join(", ");
-            console.log(chalk9.gray(`
+            console.log(chalk26.gray(`
   \u2192 ${name}(${argSummary})`));
           },
           onToolResult: (_name, result, isError) => {
             const preview = result.slice(0, 100).replace(/\n/g, " ");
-            const icon = isError ? chalk9.red("\u2717") : chalk9.green("\u2713");
-            console.log(chalk9.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
+            const icon = isError ? chalk26.red("\u2717") : chalk26.green("\u2713");
+            console.log(chalk26.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
           },
           onCompress: () => {
-            console.log(chalk9.yellow("\n  [Context compressed to fit window]\n"));
+            console.log(chalk26.yellow("\n  [Context compressed to fit window]\n"));
           }
         })
       );
       console.log("\n");
+      lastAssistantResponse = response.text;
       checkpoints.commit(`Turn ${usage.turnCount + 1}`);
       if (response.usage) {
         usage.record({
@@ -5010,7 +7272,7 @@ Analyze the above input.`;
               type: "auto",
               content: memMatch[1]
             });
-            console.log(chalk9.gray("  (Saved to memory)\n"));
+            console.log(chalk26.gray("  (Saved to memory)\n"));
           } catch {
           }
         }
@@ -5020,13 +7282,13 @@ Analyze the above input.`;
       checkpoints.discard();
       const msg = err.message?.toLowerCase() ?? "";
       if (msg.includes("fetch") || msg.includes("econnrefused") || msg.includes("network")) {
-        console.log(chalk9.gray("  Tip: Check that your Notch endpoint is running. Use /status to verify.\n"));
+        console.log(chalk26.gray("  Tip: Check that your Notch endpoint is running. Use /status to verify.\n"));
       } else if (msg.includes("401") || msg.includes("unauthorized") || msg.includes("api key")) {
-        console.log(chalk9.gray("  Tip: Set NOTCH_API_KEY env var or use --api-key flag.\n"));
+        console.log(chalk26.gray("  Tip: Set NOTCH_API_KEY env var or use --api-key flag.\n"));
       } else if (msg.includes("429") || msg.includes("rate limit")) {
-        console.log(chalk9.gray("  Tip: Rate limited. Wait a moment and try again.\n"));
+        console.log(chalk26.gray("  Tip: Rate limited. Wait a moment and try again.\n"));
       } else {
-        console.log(chalk9.gray("  (The conversation history is preserved. Try again.)\n"));
+        console.log(chalk26.gray("  (The conversation history is preserved. Try again.)\n"));
       }
     }
     rl.prompt();
@@ -5044,16 +7306,16 @@ async function handleRalphSubcommand(args, cliOpts) {
     cwd: config.projectRoot,
     requireConfirm: false,
     confirm: async () => true,
-    log: (msg) => console.log(chalk9.gray(`  ${msg}`))
+    log: (msg) => console.log(chalk26.gray(`  ${msg}`))
   };
   const subcommand = args[0];
   if (subcommand === "plan") {
     const goal = args.slice(1).join(" ");
     if (!goal) {
-      console.error(chalk9.red("  Usage: notch ralph plan <goal>"));
+      console.error(chalk26.red("  Usage: notch ralph plan <goal>"));
       process.exit(1);
     }
-    const spinner = ora("Ralph is planning...").start();
+    const spinner = ora4("Ralph is planning...").start();
     const plan = await generateRalphPlan(goal, model, systemPrompt);
     await savePlan(config.projectRoot, plan);
     spinner.succeed(`Planned ${plan.tasks.length} tasks`);
@@ -5061,7 +7323,7 @@ async function handleRalphSubcommand(args, cliOpts) {
   } else if (subcommand === "run") {
     let plan = await loadPlan(config.projectRoot);
     if (!plan) {
-      console.error(chalk9.red("  No plan found. Run: notch ralph plan <goal>"));
+      console.error(chalk26.red("  No plan found. Run: notch ralph plan <goal>"));
       process.exit(1);
     }
     plan = await runRalphLoop(plan, {
@@ -5069,27 +7331,27 @@ async function handleRalphSubcommand(args, cliOpts) {
       systemPrompt,
       toolContext: toolCtx,
       contextWindow: MODEL_CATALOG[config.models.chat.model].contextWindow,
-      onTaskStart: (t) => console.log(chalk9.cyan(`  \u25B6 ${t.description}`)),
-      onTaskComplete: (t) => console.log(chalk9.green(`  \u2713 ${t.description}`)),
-      onTaskFail: (t, e) => console.log(chalk9.red(`  \u2717 ${t.description}: ${e}`))
+      onTaskStart: (t) => console.log(chalk26.cyan(`  \u25B6 ${t.description}`)),
+      onTaskComplete: (t) => console.log(chalk26.green(`  \u2713 ${t.description}`)),
+      onTaskFail: (t, e) => console.log(chalk26.red(`  \u2717 ${t.description}: ${e}`))
     });
     await savePlan(config.projectRoot, plan);
     console.log(formatRalphStatus(plan));
   } else if (subcommand === "status") {
     const plan = await loadPlan(config.projectRoot);
     if (!plan) {
-      console.log(chalk9.gray("  No Ralph plan found."));
+      console.log(chalk26.gray("  No Ralph plan found."));
     } else {
       console.log(formatRalphStatus(plan));
     }
   } else {
-    console.error(chalk9.red(`  Unknown: notch ralph ${subcommand}`));
-    console.error(chalk9.gray("  Usage: notch ralph <plan|run|status>"));
+    console.error(chalk26.red(`  Unknown: notch ralph ${subcommand}`));
+    console.error(chalk26.gray("  Usage: notch ralph <plan|run|status>"));
     process.exit(1);
   }
 }
 main().catch((err) => {
-  console.error(chalk9.red(`
+  console.error(chalk26.red(`
 Fatal: ${err.message}
 `));
   process.exit(1);