@freesyntax/notch-cli 0.5.0 → 0.5.1

package/dist/index.js

@@ -14,7 +14,7 @@ import {
 
 // src/index.ts
 import { Command } from "commander";
-import chalk26 from "chalk";
+import chalk27 from "chalk";
 import ora4 from "ora";
 import * as readline from "readline";
 import * as nodePath from "path";
@@ -418,6 +418,7 @@ var editTool = {
 
 // src/tools/shell.ts
 import { execSync } from "child_process";
+import path5 from "path";
 import { z as z4 } from "zod";
 var BLOCKED_PATTERNS = [
   /rm\s+-rf\s+\/(?!\S)/,
@@ -446,14 +447,17 @@ var parameters4 = z4.object({
   timeout: z4.number().optional().describe("Timeout in ms (default 30s, max configurable up to 10m)")
 });
 function validateCommand(command, cwd) {
-  const absolutePathRegex = /(?:^|\s)(?:>|>>|cat|cp|mv|ln)\s+(\/(?!tmp|dev\/null)[^\s]+)/g;
+  const fileOpRegex = /(?:^|\s)(?:>|>>|cat|cp|mv|ln|tee|tar|zip|scp|rsync|chmod|chown|rm)\s+(\/(?!tmp\b|dev\/null\b)[^\s]+)/g;
   let match;
-  while ((match = absolutePathRegex.exec(command)) !== null) {
-    const targetPath = match[1];
+  while ((match = fileOpRegex.exec(command)) !== null) {
+    const targetPath = path5.normalize(match[1]);
     if (!targetPath.startsWith(cwd) && !targetPath.startsWith("/tmp")) {
       return `Blocked: command targets path outside project root: ${targetPath}`;
     }
   }
+  if (/(?:^|\s)(?:\.\.\/){3,}/.test(command)) {
+    return "Blocked: deep path traversal detected";
+  }
   return null;
 }
 var shellTool = {
@@ -664,7 +668,7 @@ Proceed?`
 // src/tools/grep.ts
 import { execSync as execSync2 } from "child_process";
 import fs5 from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { z as z6 } from "zod";
 var parameters6 = z6.object({
   pattern: z6.string().describe("Regex pattern to search for"),
@@ -678,7 +682,7 @@ var grepTool = {
   description: "Search file contents by regex pattern. Returns matching lines with file paths and line numbers. Supports glob filtering and context lines.",
   parameters: parameters6,
   async execute(params, ctx) {
-    const searchPath = params.path ? path5.isAbsolute(params.path) ? params.path : path5.resolve(ctx.cwd, params.path) : ctx.cwd;
+    const searchPath = params.path ? path6.isAbsolute(params.path) ? params.path : path6.resolve(ctx.cwd, params.path) : ctx.cwd;
     try {
       const rgArgs = [
         "rg",
@@ -710,7 +714,7 @@ var grepTool = {
         for (const entry of entries) {
           if (results.length >= (params.max_results ?? 50)) return;
           if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const full = path5.join(dir, entry.name);
+          const full = path6.join(dir, entry.name);
           if (entry.isDirectory()) {
             await searchDir(full);
           } else if (entry.isFile()) {
@@ -723,7 +727,7 @@ var grepTool = {
               const lines = content.split("\n");
               for (let i = 0; i < lines.length; i++) {
                 if (regex.test(lines[i])) {
-                  const rel = path5.relative(ctx.cwd, full);
+                  const rel = path6.relative(ctx.cwd, full);
                   results.push(`${rel}:${i + 1}:${lines[i]}`);
                   regex.lastIndex = 0;
                   if (results.length >= (params.max_results ?? 50)) return;
@@ -738,7 +742,7 @@ var grepTool = {
       if (stat.isFile()) {
         const content = await fs5.readFile(searchPath, "utf-8");
         const lines = content.split("\n");
-        const rel = path5.relative(ctx.cwd, searchPath);
+        const rel = path6.relative(ctx.cwd, searchPath);
         for (let i = 0; i < lines.length; i++) {
           if (regex.test(lines[i])) {
             results.push(`${rel}:${i + 1}:${lines[i]}`);
@@ -758,7 +762,7 @@ var grepTool = {
 
 // src/tools/glob.ts
 import { glob as globFn } from "glob";
-import path6 from "path";
+import path7 from "path";
 import { z as z7 } from "zod";
 var parameters7 = z7.object({
   pattern: z7.string().describe('Glob pattern, e.g. "**/*.ts" or "src/**/*.tsx"'),
@@ -769,7 +773,7 @@ var globTool = {
   description: "Find files matching a glob pattern. Returns relative paths sorted by modification time. Ignores node_modules and .git by default.",
   parameters: parameters7,
   async execute(params, ctx) {
-    const searchDir = params.path ? path6.isAbsolute(params.path) ? params.path : path6.resolve(ctx.cwd, params.path) : ctx.cwd;
+    const searchDir = params.path ? path7.isAbsolute(params.path) ? params.path : path7.resolve(ctx.cwd, params.path) : ctx.cwd;
     try {
       const matches = await globFn(params.pattern, {
         cwd: searchDir,
@@ -778,9 +782,9 @@ var globTool = {
         dot: false
       });
       if (matches.length === 0) {
-        return { content: `No files matching "${params.pattern}" in ${path6.relative(ctx.cwd, searchDir) || "."}` };
+        return { content: `No files matching "${params.pattern}" in ${path7.relative(ctx.cwd, searchDir) || "."}` };
       }
-      const relative = matches.map((m) => path6.relative(ctx.cwd, path6.resolve(searchDir, m)));
+      const relative = matches.map((m) => path7.relative(ctx.cwd, path7.resolve(searchDir, m)));
       return {
         content: `Found ${relative.length} file(s):
 ${relative.join("\n")}`
@@ -866,7 +870,7 @@ var GITHUB_API = "https://api.github.com";
 function getToken() {
   return process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
 }
-async function ghFetch(path25, opts2 = {}) {
+async function ghFetch(path26, opts2 = {}) {
   const token = getToken();
   const headers = {
     "Accept": "application/vnd.github+json",
@@ -874,7 +878,7 @@ async function ghFetch(path25, opts2 = {}) {
     ...opts2.headers ?? {}
   };
   if (token) headers["Authorization"] = `Bearer ${token}`;
-  return fetch(`${GITHUB_API}${path25}`, { ...opts2, headers });
+  return fetch(`${GITHUB_API}${path26}`, { ...opts2, headers });
 }
 var parameters9 = z9.object({
   action: z9.enum([
@@ -1032,9 +1036,9 @@ var githubTool = {
 };
 
 // src/tools/lsp.ts
-import { execSync as execSync3, execFileSync } from "child_process";
+import { execFileSync } from "child_process";
 import fs6 from "fs/promises";
-import path7 from "path";
+import path8 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)"),
@@ -1044,7 +1048,7 @@ var parameters10 = z10.object({
   symbol: z10.string().optional().describe("Symbol name to search for (alternative to line/character)")
 });
 function detectLanguage(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   switch (ext) {
     case ".ts":
     case ".tsx":
@@ -1074,10 +1078,11 @@ function isAvailable(cmd) {
 }
 async function tsDiagnostics(filePath, cwd) {
   try {
-    const result = execSync3(
-      `npx tsc --noEmit --pretty false "${filePath}" 2>&1`,
-      { cwd, encoding: "utf-8", timeout: 3e4 }
-    );
+    const result = execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false", filePath], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e4
+    });
     return result.trim() || "No type errors found.";
   } catch (err) {
     const output = err.stdout || err.stderr || "";
@@ -1086,11 +1091,13 @@ async function tsDiagnostics(filePath, cwd) {
       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.";
+      const result = execFileSync("npx", ["tsc", "--noEmit", "--pretty", "false"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 3e4
+      });
+      const allLines = result.trim().split("\n").slice(0, 30).join("\n");
+      return allLines || "No type errors found.";
     } catch (err2) {
       const out = err2.stdout || err2.stderr || "";
       const errLines = out.split("\n").filter((l) => l.includes("error TS"));
@@ -1099,6 +1106,9 @@ async function tsDiagnostics(filePath, cwd) {
   }
 }
 async function findDefinition(symbol, cwd) {
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(symbol)) {
+    return `Invalid symbol name: "${symbol}"`;
+  }
   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`,
@@ -1111,40 +1121,76 @@ async function findDefinition(symbol, cwd) {
   ];
   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 }
-    );
+    const result = execFileSync("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}"`;
+      const result = execFileSync("grep", [
+        "-rn",
+        "-E",
+        combinedPattern,
+        "--include=*.ts",
+        "--include=*.tsx",
+        "--include=*.js",
+        "--include=*.py",
+        "--include=*.go",
+        "--include=*.rs",
+        "."
+      ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+      const lines = result.trim().split("\n").slice(0, 10).join("\n");
+      return lines || `No definition found for "${symbol}"`;
     } catch {
       return `No definition found for "${symbol}"`;
     }
   }
 }
 async function findReferences(symbol, cwd) {
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(symbol)) {
+    return `Invalid symbol name: "${symbol}"`;
+  }
   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 result = execFileSync("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");
+      const result = execFileSync("grep", [
+        "-rn",
+        "-w",
+        symbol,
+        "--include=*.ts",
+        "--include=*.tsx",
+        "--include=*.js",
+        "--include=*.py",
+        "--include=*.go",
+        "--include=*.rs",
+        "."
+      ], { cwd, encoding: "utf-8", timeout: 1e4, maxBuffer: 1024 * 1024 });
+      const lines = result.trim().split("\n").slice(0, 30);
       return `Found ${lines.length} reference(s) for "${symbol}":
 
 ${lines.join("\n")}`;
@@ -1155,7 +1201,7 @@ ${lines.join("\n")}`;
 }
 async function getHoverInfo(symbol, filePath, line, cwd) {
   try {
-    const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+    const absPath = path8.isAbsolute(filePath) ? filePath : path8.resolve(cwd, filePath);
     const content = await fs6.readFile(absPath, "utf-8");
     const lines = content.split("\n");
     const startLine = Math.max(0, line - 3);
@@ -1174,7 +1220,7 @@ ${def}`;
   }
 }
 async function getDiagnostics(filePath, cwd) {
-  const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+  const absPath = path8.isAbsolute(filePath) ? filePath : path8.resolve(cwd, filePath);
   const { lang } = detectLanguage(absPath);
   switch (lang) {
     case "typescript":
@@ -1217,13 +1263,13 @@ async function getDiagnostics(filePath, cwd) {
     }
     case "rust": {
       try {
-        const result = execSync3(`cargo check --message-format short 2>&1 | head -30`, {
+        const result = execFileSync("cargo", ["check", "--message-format", "short"], {
           cwd,
           encoding: "utf-8",
-          timeout: 6e4,
-          shell: true
+          timeout: 6e4
         });
-        return result.trim() || "No issues found.";
+        const lines = result.trim().split("\n").slice(0, 30).join("\n");
+        return lines || "No issues found.";
       } catch (err) {
         return err.stderr || err.stdout || "Cargo check failed.";
       }
@@ -1238,7 +1284,7 @@ var lspTool = {
   parameters: parameters10,
   async execute(params, ctx) {
     const filePath = params.file;
-    const absPath = path7.isAbsolute(filePath) ? filePath : path7.resolve(ctx.cwd, filePath);
+    const absPath = path8.isAbsolute(filePath) ? filePath : path8.resolve(ctx.cwd, filePath);
     try {
       switch (params.action) {
         case "definition": {
@@ -1303,7 +1349,7 @@ async function extractSymbol(filePath, line, character) {
 
 // src/tools/notebook.ts
 import fs7 from "fs/promises";
-import path8 from "path";
+import path9 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)"),
@@ -1315,7 +1361,7 @@ var parameters11 = z11.object({
 });
 function formatNotebook(nb, filePath) {
   const parts = [
-    `# ${path8.basename(filePath)}`,
+    `# ${path9.basename(filePath)}`,
     `# ${nb.cells.length} cells | nbformat ${nb.nbformat}.${nb.nbformat_minor}`,
     ""
   ];
@@ -1346,7 +1392,7 @@ var notebookTool = {
   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);
+    const filePath = path9.isAbsolute(params.path) ? params.path : path9.resolve(ctx.cwd, params.path);
     try {
       switch (params.action) {
         case "read": {
@@ -1371,7 +1417,7 @@ var notebookTool = {
           );
           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)}.` };
+          return { content: `Cell [${params.cell_index}] updated in ${path9.basename(filePath)}.` };
         }
         case "add": {
           if (params.content === void 0) {
@@ -1392,7 +1438,7 @@ var notebookTool = {
           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)}.` };
+          return { content: `Added ${cellType} cell at index [${insertIdx}] in ${path9.basename(filePath)}.` };
         }
         case "remove": {
           if (params.cell_index === void 0) {
@@ -1405,7 +1451,7 @@ var notebookTool = {
           }
           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.` };
+          return { content: `Removed ${removed.cell_type} cell [${params.cell_index}] from ${path9.basename(filePath)}. ${nb.cells.length} cells remaining.` };
         }
         default:
           return { content: `Unknown action: ${params.action}`, isError: true };
@@ -1958,11 +2004,11 @@ function parseMCPConfig(config) {
 
 // src/plugins/discovery.ts
 import fs8 from "fs/promises";
-import path9 from "path";
+import path10 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 globalDir = path10.join(os.homedir(), ".notch", "plugins");
+  const projectDir = path10.join(projectRoot, ".notch", "plugins");
   const plugins = /* @__PURE__ */ new Map();
   for (const plugin of await scanDirectory(globalDir)) {
     plugins.set(plugin.name, plugin);
@@ -1978,8 +2024,8 @@ async function scanDirectory(dir) {
     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");
+      const pluginDir = path10.join(dir, entry.name);
+      const pkgPath = path10.join(pluginDir, "package.json");
       try {
         const raw = await fs8.readFile(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
@@ -2001,7 +2047,7 @@ async function scanDirectory(dir) {
 }
 
 // src/plugins/loader.ts
-import path10 from "path";
+import path11 from "path";
 import { pathToFileURL } from "url";
 
 // src/commands/registry.ts
@@ -2022,7 +2068,7 @@ async function dispatchCommand(input, ctx) {
 
 // src/plugins/loader.ts
 async function loadPlugin(discovered, projectRoot, log) {
-  const entryPath = path10.resolve(discovered.path, discovered.manifest.main);
+  const entryPath = path11.resolve(discovered.path, discovered.manifest.main);
   const tools = [];
   const hooks = [];
   const ctx = {
@@ -2189,14 +2235,14 @@ function describeTools() {
 
 // src/context/project-instructions.ts
 import fs9 from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 import os2 from "os";
 var INSTRUCTION_FILES = [".notch.md", "NOTCH.md", ".notch/instructions.md"];
 async function loadProjectInstructions(projectRoot) {
   const sources = [];
   const homeDir = os2.homedir();
   for (const file of INSTRUCTION_FILES) {
-    const globalPath = path11.join(homeDir, file);
+    const globalPath = path12.join(homeDir, file);
     const content = await safeRead(globalPath);
     if (content) {
       sources.push({ path: globalPath, content, scope: "global" });
@@ -2204,7 +2250,7 @@ async function loadProjectInstructions(projectRoot) {
     }
   }
   for (const file of INSTRUCTION_FILES) {
-    const projectPath = path11.join(projectRoot, file);
+    const projectPath = path12.join(projectRoot, file);
     const content = await safeRead(projectPath);
     if (content) {
       sources.push({ path: projectPath, content, scope: "project" });
@@ -2235,10 +2281,10 @@ async function safeRead(filePath) {
 
 // src/memory/store.ts
 import fs10 from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 import os3 from "os";
-var MEMORY_DIR = path12.join(os3.homedir(), ".notch", "memory");
-var INDEX_FILE = path12.join(MEMORY_DIR, "MEMORY.md");
+var MEMORY_DIR = path13.join(os3.homedir(), ".notch", "memory");
+var INDEX_FILE = path13.join(MEMORY_DIR, "MEMORY.md");
 async function ensureDir() {
   await fs10.mkdir(MEMORY_DIR, { recursive: true });
 }
@@ -2246,7 +2292,7 @@ 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 = path12.join(MEMORY_DIR, filename);
+  const filePath = path13.join(MEMORY_DIR, filename);
   const fileContent = [
     "---",
     `name: ${memory.name}`,
@@ -2268,7 +2314,7 @@ async function loadMemories() {
   for (const file of files) {
     if (!file.endsWith(".md") || file === "MEMORY.md") continue;
     try {
-      const content = await fs10.readFile(path12.join(MEMORY_DIR, file), "utf-8");
+      const content = await fs10.readFile(path13.join(MEMORY_DIR, file), "utf-8");
       const memory = parseMemoryFile(content, file);
       if (memory) memories.push(memory);
     } catch {
@@ -2278,7 +2324,7 @@ async function loadMemories() {
 }
 async function deleteMemory(filename) {
   try {
-    await fs10.unlink(path12.join(MEMORY_DIR, filename));
+    await fs10.unlink(path13.join(MEMORY_DIR, filename));
     await updateIndex();
     return true;
   } catch {
@@ -2544,7 +2590,7 @@ async function buildSystemPrompt(projectRoot, modelId) {
 
 // src/agent/checkpoints.ts
 import fs11 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 var CheckpointManager = class {
   checkpoints = [];
   nextId = 1;
@@ -2591,7 +2637,7 @@ var CheckpointManager = class {
         } catch {
         }
       } else {
-        await fs11.mkdir(path13.dirname(snap.path), { recursive: true });
+        await fs11.mkdir(path14.dirname(snap.path), { recursive: true });
         await fs11.writeFile(snap.path, snap.before, "utf-8");
       }
     }
@@ -2624,8 +2670,8 @@ var CheckpointManager = class {
         }
       }
     }
-    return Array.from(fileMap.entries()).map(([path25, { before, after }]) => ({
-      path: path25,
+    return Array.from(fileMap.entries()).map(([path26, { before, after }]) => ({
+      path: path26,
       before,
       after
     }));
@@ -3092,13 +3138,13 @@ var CostTracker = class {
 
 // src/agent/ralph.ts
 import fs13 from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import chalk5 from "chalk";
 import { generateText as generateText3, streamText as streamText3 } from "ai";
 
 // src/context/repo-map.ts
 import fs12 from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 import { glob } from "glob";
 var PATTERNS = {
   ts: [
@@ -3129,7 +3175,7 @@ var PATTERNS = {
 };
 var IMPORT_PATTERN = /(?:import|from)\s+['"]([^'"]+)['"]/g;
 function getPatterns(filePath) {
-  const ext = path14.extname(filePath).slice(1);
+  const ext = path15.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;
@@ -3180,7 +3226,7 @@ async function buildRepoMap(root) {
   });
   const entries = [];
   for (const file of files.slice(0, 500)) {
-    const fullPath = path14.resolve(root, file);
+    const fullPath = path15.resolve(root, file);
     try {
       const content = await fs12.readFile(fullPath, "utf-8");
       const lines = content.split("\n").length;
@@ -3284,11 +3330,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 fs13.writeFile(path15.join(cwd, PLAN_FILE), JSON.stringify(plan, null, 2), "utf-8");
+  await fs13.writeFile(path16.join(cwd, PLAN_FILE), JSON.stringify(plan, null, 2), "utf-8");
 }
 async function loadPlan(cwd) {
   try {
-    const raw = await fs13.readFile(path15.join(cwd, PLAN_FILE), "utf-8");
+    const raw = await fs13.readFile(path16.join(cwd, PLAN_FILE), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3296,7 +3342,7 @@ async function loadPlan(cwd) {
 }
 async function deletePlan(cwd) {
   try {
-    await fs13.unlink(path15.join(cwd, PLAN_FILE));
+    await fs13.unlink(path16.join(cwd, PLAN_FILE));
   } catch {
   }
 }
@@ -3480,7 +3526,7 @@ function formatRalphStatus(plan) {
 
 // src/context/references.ts
 import fs14 from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import { glob as glob2 } from "glob";
 async function resolveReferences(input, cwd) {
   const references = [];
@@ -3523,7 +3569,7 @@ ${truncated}
   return sections.join("\n\n") + "\n\n";
 }
 async function resolveFile(ref, cwd) {
-  const filePath = path16.isAbsolute(ref) ? ref : path16.resolve(cwd, ref);
+  const filePath = path17.isAbsolute(ref) ? ref : path17.resolve(cwd, ref);
   try {
     const content = await fs14.readFile(filePath, "utf-8");
     const lines = content.split("\n");
@@ -4250,11 +4296,11 @@ function formatTokens(n) {
 
 // src/ui/update-checker.ts
 import fs15 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import os4 from "os";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import chalk8 from "chalk";
-var CACHE_FILE = path17.join(os4.homedir(), ".notch", "update-check.json");
+var CACHE_FILE = path18.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`;
@@ -4291,7 +4337,7 @@ function autoUpdate(current, latest) {
   \u2B06 Updating Notch CLI: ${current} \u2192 ${latest}...
 `));
   try {
-    execSync4(`npm install -g ${PACKAGE_NAME}@${latest}`, {
+    execSync3(`npm install -g ${PACKAGE_NAME}@${latest}`, {
       stdio: "inherit",
       timeout: 6e4
     });
@@ -4326,7 +4372,7 @@ async function loadCache() {
 }
 async function saveCache(cache) {
   try {
-    await fs15.mkdir(path17.dirname(CACHE_FILE), { recursive: true });
+    await fs15.mkdir(path18.dirname(CACHE_FILE), { recursive: true });
     await fs15.writeFile(CACHE_FILE, JSON.stringify(cache), "utf-8");
   } catch {
   }
@@ -4334,7 +4380,7 @@ async function saveCache(cache) {
 
 // src/permissions/index.ts
 import fs16 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import os5 from "os";
 var DEFAULT_PERMISSIONS = {
   default: "prompt",
@@ -4352,8 +4398,8 @@ var DEFAULT_PERMISSIONS = {
   ]
 };
 async function loadPermissions(projectRoot) {
-  const projectPath = path18.join(projectRoot, ".notch.json");
-  const globalPath = path18.join(os5.homedir(), ".notch", "permissions.json");
+  const projectPath = path19.join(projectRoot, ".notch.json");
+  const globalPath = path19.join(os5.homedir(), ".notch", "permissions.json");
   let config = { ...DEFAULT_PERMISSIONS };
   try {
     const raw = await fs16.readFile(globalPath, "utf-8");
@@ -4410,16 +4456,16 @@ function mergePermissions(base, override) {
 }
 
 // src/hooks/index.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import fs17 from "fs/promises";
 import { watch } from "fs";
-import path19 from "path";
+import path20 from "path";
 import os6 from "os";
 import crypto from "crypto";
-var TRUST_STORE_PATH = path19.join(os6.homedir(), ".notch", "trusted-projects.json");
+var TRUST_STORE_PATH = path20.join(os6.homedir(), ".notch", "trusted-projects.json");
 async function isTrustedProject(projectRoot, raw) {
   const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
-  const key = path19.resolve(projectRoot);
+  const key = path20.resolve(projectRoot);
   try {
     const store = JSON.parse(await fs17.readFile(TRUST_STORE_PATH, "utf-8"));
     return store[key] === fingerprint;
@@ -4429,19 +4475,19 @@ async function isTrustedProject(projectRoot, raw) {
 }
 async function trustProject(projectRoot, raw) {
   const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
-  const key = path19.resolve(projectRoot);
+  const key = path20.resolve(projectRoot);
   let store = {};
   try {
     store = JSON.parse(await fs17.readFile(TRUST_STORE_PATH, "utf-8"));
   } catch {
   }
   store[key] = fingerprint;
-  await fs17.mkdir(path19.dirname(TRUST_STORE_PATH), { recursive: true });
+  await fs17.mkdir(path20.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 = path19.join(os6.homedir(), ".notch", "hooks.json");
+  const globalPath = path20.join(os6.homedir(), ".notch", "hooks.json");
   try {
     const raw = await fs17.readFile(globalPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -4450,7 +4496,7 @@ async function loadHooks(projectRoot, promptTrust) {
     }
   } catch {
   }
-  const projectPath = path19.join(projectRoot, ".notch.json");
+  const projectPath = path20.join(projectRoot, ".notch.json");
   try {
     const raw = await fs17.readFile(projectPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -4518,7 +4564,7 @@ async function executeHook(hook, context) {
     NOTCH_CWD: context.cwd
   };
   try {
-    const output = execSync5(hook.command, {
+    const output = execSync4(hook.command, {
       cwd: context.cwd,
       encoding: "utf-8",
       timeout: hook.timeout ?? 1e4,
@@ -4547,7 +4593,7 @@ function startFileWatcher(projectRoot, hookConfig, onHookResult) {
       if (existing) clearTimeout(existing);
       pending.set(filename, setTimeout(async () => {
         pending.delete(filename);
-        const filePath = path19.join(projectRoot, filename);
+        const filePath = path20.join(projectRoot, filename);
         const context = { cwd: projectRoot, file: filePath };
         const { results } = await runHooks(hookConfig, "file-changed", context);
         onHookResult?.("file-changed", results);
@@ -4568,15 +4614,15 @@ function startFileWatcher(projectRoot, hookConfig, onHookResult) {
 
 // src/session/index.ts
 import fs18 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import os7 from "os";
-var SESSION_DIR = path20.join(os7.homedir(), ".notch", "sessions");
+var SESSION_DIR = path21.join(os7.homedir(), ".notch", "sessions");
 var MAX_SESSIONS = 20;
 async function ensureDir2() {
   await fs18.mkdir(SESSION_DIR, { recursive: true });
 }
 function sessionPath(id) {
-  return path20.join(SESSION_DIR, `${id}.json`);
+  return path21.join(SESSION_DIR, `${id}.json`);
 }
 function generateId() {
   const now = /* @__PURE__ */ new Date();
@@ -4622,7 +4668,7 @@ async function listSessions() {
   for (const file of files) {
     if (!file.endsWith(".json")) continue;
     try {
-      const raw = await fs18.readFile(path20.join(SESSION_DIR, file), "utf-8");
+      const raw = await fs18.readFile(path21.join(SESSION_DIR, file), "utf-8");
       const session = JSON.parse(raw);
       sessions.push(session.meta);
     } catch {
@@ -4698,7 +4744,7 @@ async function exportSession(messages, outputPath, meta) {
 
 // src/init.ts
 import fs19 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import chalk9 from "chalk";
 var DEFAULT_CONFIG = {
   model: "notch-forge",
@@ -4730,8 +4776,8 @@ var DEFAULT_INSTRUCTIONS = `# Project Instructions for Notch
 <!-- Files or areas Notch should NOT modify -->
 `;
 async function initProject(projectRoot) {
-  const configPath = path21.join(projectRoot, ".notch.json");
-  const instructionsPath = path21.join(projectRoot, ".notch.md");
+  const configPath = path22.join(projectRoot, ".notch.json");
+  const instructionsPath = path22.join(projectRoot, ".notch.md");
   let configExists = false;
   let instructionsExist = false;
   try {
@@ -4756,7 +4802,7 @@ async function initProject(projectRoot) {
   } else {
     console.log(chalk9.gray(`  Skipped ${instructionsPath} (already exists)`));
   }
-  const gitignorePath = path21.join(projectRoot, ".gitignore");
+  const gitignorePath = path22.join(projectRoot, ".gitignore");
   try {
     const gitignore = await fs19.readFile(gitignorePath, "utf-8");
     const additions = [];
@@ -4890,9 +4936,9 @@ function findSync(oldLines, newLines, oi, ni, lookAhead) {
 }
 
 // src/commands/doctor.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import fs20 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import os8 from "os";
 import chalk10 from "chalk";
 async function runDiagnostics(cwd) {
@@ -4907,7 +4953,7 @@ async function runDiagnostics(cwd) {
     results.push({ name: "Node.js", status: "fail", message: `v${nodeVersion} (requires >= 18)` });
   }
   try {
-    const gitVersion = execSync6("git --version", { encoding: "utf-8", timeout: 5e3 }).trim();
+    const gitVersion = execSync5("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." });
@@ -4934,12 +4980,12 @@ async function runDiagnostics(cwd) {
     results.push({ name: "Config", status: "fail", message: `Could not load: ${err.message}` });
   }
   try {
-    await fs20.access(path22.join(cwd, ".notch.json"));
+    await fs20.access(path23.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");
+  const notchDir = path23.join(os8.homedir(), ".notch");
   try {
     await fs20.access(notchDir);
     results.push({ name: "~/.notch/", status: "ok", message: "Exists" });
@@ -4947,13 +4993,13 @@ async function runDiagnostics(cwd) {
     results.push({ name: "~/.notch/", status: "warn", message: "Not found (will be created on first use)" });
   }
   try {
-    await fs20.access(path22.join(cwd, ".notch.md"));
+    await fs20.access(path23.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 configRaw = await fs20.readFile(path23.join(cwd, ".notch.json"), "utf-8").catch(() => "{}");
     const mcpConfigs = parseMCPConfig(JSON.parse(configRaw));
     const serverNames = Object.keys(mcpConfigs);
     if (serverNames.length === 0) {
@@ -4974,7 +5020,7 @@ async function runDiagnostics(cwd) {
     results.push({ name: "MCP Servers", status: "ok", message: "No config to check" });
   }
   try {
-    const sessionsDir = path22.join(notchDir, "sessions");
+    const sessionsDir = path23.join(notchDir, "sessions");
     const entries = await fs20.readdir(sessionsDir).catch(() => []);
     results.push({ name: "Sessions", status: "ok", message: `${entries.length} saved` });
   } catch {
@@ -5009,23 +5055,23 @@ registerCommand("/doctor", async (_args, ctx) => {
 });
 
 // src/commands/copy.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync6 } 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 });
+      execSync6("clip.exe", { input: text, timeout: 5e3 });
     } else if (platform === "darwin") {
-      execSync7("pbcopy", { input: text, timeout: 5e3 });
+      execSync6("pbcopy", { input: text, timeout: 5e3 });
     } else {
       try {
-        execSync7("xclip -selection clipboard", { input: text, timeout: 5e3 });
+        execSync6("xclip -selection clipboard", { input: text, timeout: 5e3 });
       } catch {
         try {
-          execSync7("xsel --clipboard --input", { input: text, timeout: 5e3 });
+          execSync6("xsel --clipboard --input", { input: text, timeout: 5e3 });
         } catch {
-          execSync7("wl-copy", { input: text, timeout: 5e3 });
+          execSync6("wl-copy", { input: text, timeout: 5e3 });
         }
       }
     }
@@ -5071,7 +5117,7 @@ registerCommand("/btw", async (args, ctx) => {
 });
 
 // src/commands/security-review.ts
-import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
+import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
 import chalk13 from "chalk";
 function isValidGitRange(range) {
   return /^[a-zA-Z0-9._~^\/\-]+(\.\.[a-zA-Z0-9._~^\/\-]+)?$/.test(range);
@@ -5099,12 +5145,12 @@ registerCommand("/security-review", async (args, ctx) => {
     }).trim();
   } catch {
     try {
-      stat = execSync8("git diff --stat", {
+      stat = execSync7("git diff --stat", {
         cwd: ctx.cwd,
         encoding: "utf-8",
         timeout: 1e4
       }).trim();
-      diff = execSync8("git diff", {
+      diff = execSync7("git diff", {
         cwd: ctx.cwd,
         encoding: "utf-8",
         timeout: 1e4,
@@ -5376,12 +5422,12 @@ Read the file first, then make the change. Only modify this one file.`
 });
 
 // src/commands/plugin.ts
-import { execSync as execSync9, execFileSync as execFileSync3 } from "child_process";
+import { execSync as execSync8, execFileSync as execFileSync3 } from "child_process";
 import fs21 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import os9 from "os";
 import chalk16 from "chalk";
-var GLOBAL_PLUGINS_DIR = path23.join(os9.homedir(), ".notch", "plugins");
+var GLOBAL_PLUGINS_DIR = path24.join(os9.homedir(), ".notch", "plugins");
 registerCommand("/plugin", async (args, ctx) => {
   const parts = args.split(/\s+/);
   const subcommand = parts[0] || "list";
@@ -5418,7 +5464,7 @@ registerCommand("/plugin", async (args, ctx) => {
         return;
       }
       await fs21.mkdir(GLOBAL_PLUGINS_DIR, { recursive: true });
-      const pluginDir = path23.join(GLOBAL_PLUGINS_DIR, path23.basename(target).replace(/\.git$/, ""));
+      const pluginDir = path24.join(GLOBAL_PLUGINS_DIR, path24.basename(target).replace(/\.git$/, ""));
       console.log(chalk16.gray(`  Installing ${target}...`));
       try {
         if (target.includes("/") && !target.startsWith("@")) {
@@ -5443,9 +5489,9 @@ registerCommand("/plugin", async (args, ctx) => {
           });
         }
         try {
-          const pkgExists = await fs21.access(path23.join(pluginDir, "package.json")).then(() => true).catch(() => false);
+          const pkgExists = await fs21.access(path24.join(pluginDir, "package.json")).then(() => true).catch(() => false);
           if (pkgExists) {
-            execSync9("npm install --production", {
+            execSync8("npm install --production", {
               cwd: pluginDir,
               encoding: "utf-8",
               timeout: 12e4,
@@ -5469,7 +5515,7 @@ registerCommand("/plugin", async (args, ctx) => {
         console.log(chalk16.gray("  Usage: /plugin remove <plugin-name>\n"));
         return;
       }
-      const pluginDir = path23.join(GLOBAL_PLUGINS_DIR, target);
+      const pluginDir = path24.join(GLOBAL_PLUGINS_DIR, target);
       try {
         await fs21.access(pluginDir);
         await fs21.rm(pluginDir, { recursive: true, force: true });
@@ -5596,12 +5642,12 @@ Reply with ONLY the commit message, nothing else. No markdown, no explanation.`;
 });
 
 // src/commands/pr.ts
-import { execSync as execSync11, execFileSync as execFileSync5 } from "child_process";
+import { execSync as execSync10, 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();
+    return execSync10(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
   } catch {
     return null;
   }
@@ -5732,11 +5778,11 @@ BODY:
 });
 
 // src/commands/worktree.ts
-import { execSync as execSync12, execFileSync as execFileSync6 } from "child_process";
+import { execSync as execSync11, 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();
+    return execSync11(cmd, { cwd, encoding: "utf-8", timeout: 15e3 }).trim();
   } catch {
     return null;
   }
@@ -5847,7 +5893,7 @@ registerCommand("/worktree", async (args, ctx) => {
     }
     case "prune": {
       try {
-        execSync12("git worktree prune", { cwd: ctx.cwd, encoding: "utf-8" });
+        execSync11("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}
@@ -6080,7 +6126,7 @@ registerCommand("/sandbox", async (args, _ctx) => {
 
 // src/ui/completions.ts
 import fs22 from "fs";
-import path24 from "path";
+import path25 from "path";
 var COMMANDS = [
   "/help",
   "/quit",
@@ -6173,15 +6219,15 @@ function buildCompleter(cwd) {
 }
 function completeFilePath(partial, cwd) {
   try {
-    const dir = partial.includes("/") ? path24.resolve(cwd, path24.dirname(partial)) : cwd;
-    const prefix = partial.includes("/") ? path24.basename(partial) : partial;
+    const dir = partial.includes("/") ? path25.resolve(cwd, path25.dirname(partial)) : cwd;
+    const prefix = partial.includes("/") ? path25.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("/") ? path24.dirname(partial) + "/" + entry.name : entry.name;
+        const relative = partial.includes("/") ? path25.dirname(partial) + "/" + entry.name : entry.name;
         if (entry.isDirectory()) {
           matches.push(relative + "/");
         } else {
@@ -6195,6 +6241,258 @@ function completeFilePath(partial, cwd) {
   }
 }
 
+// src/ui/slash-menu.ts
+import chalk26 from "chalk";
+var SLASH_COMMANDS = [
+  // Core
+  { name: "/help", description: "Show available commands", category: "Core" },
+  { name: "/clear", description: "Clear conversation history", category: "Core" },
+  { name: "/quit", description: "Exit Notch", category: "Core" },
+  // Model & Status
+  { name: "/model", description: "Switch or list models", category: "Model" },
+  { name: "/status", description: "Check API endpoint health", category: "Model" },
+  // Session
+  { name: "/save", description: "Save current session", category: "Session" },
+  { name: "/sessions", description: "List saved sessions", category: "Session" },
+  { name: "/resume", description: "Resume a saved session", category: "Session" },
+  { name: "/rename", description: "Name this session", category: "Session" },
+  { name: "/export", description: "Export conversation to markdown", category: "Session" },
+  { name: "/branch", description: "Fork conversation at this point", category: "Session" },
+  // Context
+  { name: "/usage", description: "Show token usage + context meter", category: "Context" },
+  { name: "/cost", description: "Show estimated session cost", category: "Context" },
+  { name: "/compact", description: "Compress conversation history", category: "Context" },
+  { name: "/rewind", description: "Rewind to a previous turn", category: "Context" },
+  { name: "/insights", description: "Session analytics & tool usage", category: "Context" },
+  // Tools
+  { name: "/undo", description: "Undo last file changes", category: "Tools" },
+  { name: "/diff", description: "Show all file changes this session", category: "Tools" },
+  { name: "/search", description: "Search conversation history", category: "Tools" },
+  { name: "/tasks", description: "Show agent task list", category: "Tools" },
+  // Git
+  { name: "/commit", description: "Smart commit with AI message", category: "Git" },
+  { name: "/pr", description: "Create PR with AI summary", category: "Git" },
+  { name: "/worktree", description: "Manage git worktrees", category: "Git" },
+  // Planning & Agents
+  { name: "/plan", description: "Generate a step-by-step plan", category: "Planning" },
+  { name: "/agent", description: "Spawn a background subagent", category: "Planning" },
+  { name: "/ralph plan", description: "Generate autonomous task plan", category: "Planning" },
+  { name: "/ralph run", description: "Execute autonomous tasks", category: "Planning" },
+  // Utilities
+  { name: "/doctor", description: "Diagnose installation health", category: "Utility" },
+  { name: "/copy", description: "Copy last response to clipboard", category: "Utility" },
+  { name: "/btw", description: "Side question (isolated context)", category: "Utility" },
+  { name: "/security-review", description: "Review changes for vulnerabilities", category: "Utility" },
+  { name: "/loop", description: "Run command on a recurring interval", category: "Utility" },
+  { name: "/batch", description: "Apply task across files in parallel", category: "Utility" },
+  { name: "/sandbox", description: "Toggle read-only sandbox mode", category: "Utility" },
+  { name: "/debug", description: "Toggle debug logging", category: "Utility" },
+  // Config
+  { name: "/memory", description: "List saved memories", category: "Config" },
+  { name: "/permissions", description: "Show permission config", category: "Config" },
+  { name: "/theme", description: "Switch color theme", category: "Config" },
+  { name: "/plugin", description: "Manage plugins", category: "Config" }
+];
+var MAX_VISIBLE = 10;
+function createMenuState() {
+  return {
+    visible: false,
+    filter: "",
+    selected: 0,
+    filtered: [],
+    renderedLines: 0
+  };
+}
+function updateMenu(state, input) {
+  if (!input.startsWith("/") || input.includes(" ") || input.length === 0) {
+    state.visible = false;
+    state.filtered = [];
+    state.selected = 0;
+    return false;
+  }
+  state.filter = input.toLowerCase();
+  state.filtered = SLASH_COMMANDS.filter(
+    (cmd) => cmd.name.toLowerCase().startsWith(state.filter) || cmd.name.toLowerCase().includes(state.filter.slice(1)) || cmd.description.toLowerCase().includes(state.filter.slice(1))
+  );
+  if (state.selected >= state.filtered.length) {
+    state.selected = Math.max(0, state.filtered.length - 1);
+  }
+  state.visible = state.filtered.length > 0;
+  return state.visible;
+}
+function menuUp(state) {
+  if (state.selected > 0) state.selected--;
+}
+function menuDown(state) {
+  if (state.selected < state.filtered.length - 1) state.selected++;
+}
+function menuSelect(state) {
+  if (!state.visible || state.filtered.length === 0) return null;
+  return state.filtered[state.selected]?.name ?? null;
+}
+function menuDismiss(state) {
+  state.visible = false;
+  state.filtered = [];
+  state.selected = 0;
+}
+function renderMenu(state) {
+  if (!state.visible || state.filtered.length === 0) return "";
+  const items = state.filtered.slice(0, MAX_VISIBLE);
+  const hasMore = state.filtered.length > MAX_VISIBLE;
+  let currentCategory = "";
+  const lines = [];
+  lines.push(chalk26.gray("  \u250C\u2500 Commands \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  for (let i = 0; i < items.length; i++) {
+    const cmd = items[i];
+    const isSelected = i === state.selected;
+    if (cmd.category !== currentCategory) {
+      currentCategory = cmd.category;
+      if (i > 0) {
+        lines.push(chalk26.gray("  \u2502                                                \u2502"));
+      }
+      lines.push(chalk26.gray(`  \u2502 `) + chalk26.gray.dim(cmd.category.toUpperCase().padEnd(47)) + chalk26.gray("\u2502"));
+    }
+    const name = cmd.name.padEnd(22);
+    const desc = cmd.description.slice(0, 25).padEnd(25);
+    if (isSelected) {
+      lines.push(
+        chalk26.gray("  \u2502 ") + chalk26.bgWhite.black(` ${name}`) + chalk26.gray(` ${desc}`) + chalk26.gray(" \u2502")
+      );
+    } else {
+      lines.push(
+        chalk26.gray("  \u2502 ") + chalk26.cyan(` ${name}`) + chalk26.gray(` ${desc}`) + chalk26.gray(" \u2502")
+      );
+    }
+  }
+  if (hasMore) {
+    const remaining = state.filtered.length - MAX_VISIBLE;
+    lines.push(chalk26.gray(`  \u2502   ${chalk26.dim(`+${remaining} more\u2026`)}${"".padEnd(41 - String(remaining).length)}\u2502`));
+  }
+  lines.push(chalk26.gray("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 \u2191\u2193 navigate \xB7 enter select \u2500\u2500\u2518"));
+  state.renderedLines = lines.length;
+  return lines.join("\n");
+}
+function clearMenu(state) {
+  if (state.renderedLines === 0) return "";
+  const lines = state.renderedLines;
+  state.renderedLines = 0;
+  let ansi = "";
+  for (let i = 0; i < lines; i++) {
+    ansi += "\x1B[1A\x1B[2K";
+  }
+  return ansi;
+}
+
+// src/ui/interactive-input.ts
+function attachSlashMenu(rl) {
+  const state = createMenuState();
+  let lastInput = "";
+  const keypressHandler = (_ch, key) => {
+    const currentLine = rl.line ?? "";
+    if (state.visible && key) {
+      if (key.name === "up") {
+        process.stdout.write(clearMenu(state));
+        menuUp(state);
+        process.stdout.write(renderMenu(state) + "\n");
+        rewritePromptLine(rl);
+        return;
+      }
+      if (key.name === "down") {
+        process.stdout.write(clearMenu(state));
+        menuDown(state);
+        process.stdout.write(renderMenu(state) + "\n");
+        rewritePromptLine(rl);
+        return;
+      }
+      if (key.name === "escape") {
+        process.stdout.write(clearMenu(state));
+        menuDismiss(state);
+        return;
+      }
+      if (key.name === "return") {
+        const selected = menuSelect(state);
+        if (selected) {
+          process.stdout.write(clearMenu(state));
+          menuDismiss(state);
+          rl.line = "";
+          rl.cursor = 0;
+          rl.write(null, { ctrl: true, name: "u" });
+          rl.write(selected + " ");
+          return;
+        }
+      }
+      if (key.name === "tab") {
+        const selected = menuSelect(state);
+        if (selected) {
+          process.stdout.write(clearMenu(state));
+          menuDismiss(state);
+          rl.line = "";
+          rl.cursor = 0;
+          rl.write(null, { ctrl: true, name: "u" });
+          rl.write(selected + " ");
+          return;
+        }
+      }
+    }
+    setImmediate(() => {
+      const line = rl.line ?? "";
+      if (line !== lastInput) {
+        lastInput = line;
+        const wasVisible = state.visible;
+        const shouldShow = updateMenu(state, line);
+        if (wasVisible && !shouldShow) {
+          process.stdout.write(clearMenu(state));
+        } else if (shouldShow) {
+          if (wasVisible) {
+            process.stdout.write(clearMenu(state));
+          }
+          const menuStr = renderMenu(state);
+          if (menuStr) {
+            process.stdout.write("\x1B[s");
+            process.stdout.write(menuStr + "\n");
+            rewritePromptLine(rl);
+            process.stdout.write("\x1B[u");
+          }
+        }
+      }
+    });
+  };
+  process.stdin.on("keypress", keypressHandler);
+  const closeHandler = () => {
+    if (state.visible) {
+      process.stdout.write(clearMenu(state));
+    }
+    process.stdin.removeListener("keypress", keypressHandler);
+  };
+  rl.on("close", closeHandler);
+  const lineHandler = () => {
+    if (state.visible) {
+      process.stdout.write(clearMenu(state));
+      menuDismiss(state);
+    }
+    lastInput = "";
+  };
+  rl.on("line", lineHandler);
+  return {
+    cleanup: () => {
+      process.stdin.removeListener("keypress", keypressHandler);
+      rl.removeListener("close", closeHandler);
+      rl.removeListener("line", lineHandler);
+    }
+  };
+}
+function rewritePromptLine(rl) {
+  const prompt = rl._prompt ?? "notch> ";
+  const line = rl.line ?? "";
+  const cursor = rl.cursor ?? line.length;
+  process.stdout.write("\x1B[2K\r");
+  process.stdout.write(prompt + line);
+  const cursorOffset = line.length - cursor;
+  if (cursorOffset > 0) {
+    process.stdout.write(`\x1B[${cursorOffset}D`);
+  }
+}
+
 // src/index.ts
 import fs23 from "fs/promises";
 import { createRequire } from "module";
@@ -6219,7 +6517,7 @@ function printModelTable(activeModel) {
 `));
 }
 function printHelp() {
-  console.log(chalk26.gray(`
+  console.log(chalk27.gray(`
   Commands:
     /model              \u2014 Show available models
     /model <name>       \u2014 Switch model (e.g., /model pyre)
@@ -6316,13 +6614,13 @@ async function main() {
     try {
       spinner.stop();
       const creds = await login();
-      console.log(chalk26.green(`
+      console.log(chalk27.green(`
   \u2713 Signed in as ${creds.email}`));
-      console.log(chalk26.gray(`  API key stored in ${(await import("./auth-S3FIB42I.js")).getCredentialsPath()}
+      console.log(chalk27.gray(`  API key stored in ${(await import("./auth-S3FIB42I.js")).getCredentialsPath()}
 `));
     } catch (err) {
       spinner.stop();
-      console.error(chalk26.red(`
+      console.error(chalk27.red(`
   Login failed: ${err.message}
 `));
       process.exit(1);
@@ -6332,10 +6630,10 @@ async function main() {
   if (promptArgs[0] === "logout") {
     const creds = await loadCredentials();
     if (!creds) {
-      console.log(chalk26.gray("\n  Not signed in.\n"));
+      console.log(chalk27.gray("\n  Not signed in.\n"));
     } else {
       await clearCredentials();
-      console.log(chalk26.green(`
+      console.log(chalk27.green(`
   \u2713 Signed out (${creds.email})
 `));
     }
@@ -6344,13 +6642,13 @@ async function main() {
   if (promptArgs[0] === "whoami") {
     const creds = await loadCredentials();
     if (!creds) {
-      console.log(chalk26.gray("\n  Not signed in. Run: notch login\n"));
+      console.log(chalk27.gray("\n  Not signed in. Run: notch login\n"));
     } else {
       const keyPreview = `${creds.token.slice(0, 12)}...`;
-      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()}
+      console.log(chalk27.gray(`
+  Signed in as ${chalk27.white(creds.email)}`));
+      console.log(chalk27.gray(`  Key: ${keyPreview}`));
+      console.log(chalk27.gray(`  Since: ${new Date(creds.createdAt).toLocaleDateString()}
 `));
     }
     return;
@@ -6374,8 +6672,8 @@ async function main() {
   const config = await loadConfig(configOverrides);
   if (opts.model) {
     if (!isValidModel(opts.model)) {
-      console.error(chalk26.red(`  Unknown model: ${opts.model}`));
-      console.error(chalk26.gray(`  Available: ${modelChoices}`));
+      console.error(chalk27.red(`  Unknown model: ${opts.model}`));
+      console.error(chalk27.gray(`  Available: ${modelChoices}`));
       process.exit(1);
     }
     config.models.chat.model = opts.model;
@@ -6414,11 +6712,11 @@ async function main() {
   const updateMsg = await checkForUpdates(VERSION);
   if (updateMsg) console.log(updateMsg);
   const hookTrustPrompt = async (commands) => {
-    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}`)));
+    console.warn(chalk27.yellow("\n\u26A0  This project contains hooks in .notch.json that will run shell commands:"));
+    commands.forEach((cmd) => console.warn(chalk27.gray(`   \u2022 ${cmd}`)));
     const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve2) => {
-      rl2.question(chalk26.yellow("\nAllow these hooks for this project? [y/N] "), (answer) => {
+      rl2.question(chalk27.yellow("\nAllow these hooks for this project? [y/N] "), (answer) => {
         rl2.close();
         resolve2(answer.trim().toLowerCase() === "y");
       });
@@ -6464,22 +6762,22 @@ ${repoMapStr}` : ""
         const client = new MCPClient(mcpConfig, name);
         await client.connect();
         mcpClients.push(client);
-        console.log(chalk26.green(`  MCP: Connected to ${name} (${client.tools.length} tools)`));
+        console.log(chalk27.green(`  MCP: Connected to ${name} (${client.tools.length} tools)`));
       } catch (err) {
-        console.log(chalk26.yellow(`  MCP: Could not connect to ${name}: ${err.message}`));
+        console.log(chalk27.yellow(`  MCP: Could not connect to ${name}: ${err.message}`));
       }
     }
   } catch {
   }
   try {
     const pluginCount = await pluginManager.init(config.projectRoot, (msg) => {
-      console.log(chalk26.gray(`  ${msg}`));
+      console.log(chalk27.gray(`  ${msg}`));
     });
     if (pluginCount > 0) {
-      console.log(chalk26.green(`  Plugins: ${pluginCount} loaded`));
+      console.log(chalk27.green(`  Plugins: ${pluginCount} loaded`));
     }
   } catch (err) {
-    console.log(chalk26.yellow(`  Plugin init failed: ${err.message}`));
+    console.log(chalk27.yellow(`  Plugin init failed: ${err.message}`));
   }
   const toolCtx = {
     cwd: config.projectRoot,
@@ -6493,7 +6791,7 @@ ${repoMapStr}` : ""
         });
       });
     },
-    log: (msg) => console.log(chalk26.gray(`  ${msg}`)),
+    log: (msg) => console.log(chalk27.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;
@@ -6503,7 +6801,7 @@ ${repoMapStr}` : ""
       });
       for (const r of results) {
         if (!r.ok) {
-          console.log(chalk26.yellow(`  Hook failed (${r.hook.event}): ${r.error}`));
+          console.log(chalk27.yellow(`  Hook failed (${r.hook.event}): ${r.error}`));
         }
       }
     }
@@ -6512,7 +6810,7 @@ ${repoMapStr}` : ""
   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}`));
+        console.log(chalk27.yellow(`  Hook failed (${event}): ${r.error}`));
       }
     }
   });
@@ -6523,10 +6821,10 @@ ${repoMapStr}` : ""
     if (session) {
       messages.push(...session.messages);
       sessionId = session.meta.id;
-      console.log(chalk26.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+      console.log(chalk27.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
 `));
     } else {
-      console.log(chalk26.gray("  No session to resume.\n"));
+      console.log(chalk27.gray("  No session to resume.\n"));
     }
   }
   const pipedInput = await readStdin();
@@ -6547,10 +6845,10 @@ Analyze the above input.`;
     const refContext = formatReferences(references);
     const finalPrompt = refContext + cleanInput;
     messages.push({ role: "user", content: finalPrompt });
-    console.log(chalk26.cyan(`> ${oneShot || "(piped input)"}
+    console.log(chalk27.cyan(`> ${oneShot || "(piped input)"}
 `));
     if (references.length > 0) {
-      console.log(chalk26.gray(`  Injected ${references.length} reference(s)
+      console.log(chalk27.gray(`  Injected ${references.length} reference(s)
 `));
     }
     const spinner = ora4("Thinking...").start();
@@ -6569,13 +6867,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(chalk26.gray(`
+            console.log(chalk27.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 ? "..." : ""}`));
+            const icon = isError ? chalk27.red("\u2717") : chalk27.green("\u2713");
+            console.log(chalk27.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
           }
         })
       );
@@ -6600,19 +6898,21 @@ Analyze the above input.`;
     const savedPlan = await loadPlan(config.projectRoot);
     if (savedPlan) {
       ralphPlan = savedPlan;
-      console.log(chalk26.gray(`  Ralph plan loaded (${savedPlan.tasks.length} tasks)
+      console.log(chalk27.gray(`  Ralph plan loaded (${savedPlan.tasks.length} tasks)
 `));
     }
   } catch {
   }
   const completer = buildCompleter(config.projectRoot);
+  readline.emitKeypressEvents(process.stdin);
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: theme().prompt("notch> "),
     completer: (line) => completer(line)
   });
-  console.log(chalk26.gray("  Type your request, or /help for commands.\n"));
+  const slashMenu = attachSlashMenu(rl);
+  console.log(chalk27.gray("  Type your request, or /help for commands.\n"));
   rl.prompt();
   rl.on("line", async (line) => {
     const input = line.trim();
@@ -6629,7 +6929,7 @@ Analyze the above input.`;
         try {
           const name = getSessionName();
           const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
-          console.log(chalk26.gray(`  Session saved: ${id}${name ? ` (${name})` : ""}`));
+          console.log(chalk27.gray(`  Session saved: ${id}${name ? ` (${name})` : ""}`));
         } catch {
         }
       }
@@ -6639,16 +6939,17 @@ Analyze the above input.`;
         } catch {
         }
       }
+      slashMenu.cleanup();
       stopActiveLoop();
       stopFileWatcher();
       await pluginManager.shutdown();
       await toolCtx.runHook?.("session-end", {});
-      console.log(chalk26.gray("\n  Goodbye!\n"));
+      console.log(chalk27.gray("\n  Goodbye!\n"));
       process.exit(0);
     }
     if (input === "/clear") {
       messages.length = 0;
-      console.log(chalk26.gray("  Conversation cleared.\n"));
+      console.log(chalk27.gray("  Conversation cleared.\n"));
       rl.prompt();
       return;
     }
@@ -6668,8 +6969,8 @@ Analyze the above input.`;
         newModel = `notch-${newModel}`;
       }
       if (!isValidModel(newModel)) {
-        console.log(chalk26.red(`  Unknown model: ${newModel}`));
-        console.log(chalk26.gray(`  Available: ${modelChoices}`));
+        console.log(chalk27.red(`  Unknown model: ${newModel}`));
+        console.log(chalk27.gray(`  Available: ${modelChoices}`));
         rl.prompt();
         return;
       }
@@ -6677,7 +6978,7 @@ Analyze the above input.`;
       config.models.chat.model = activeModelId;
       model = resolveModel(config.models.chat);
       const switchedInfo = MODEL_CATALOG[activeModelId];
-      console.log(chalk26.green(`  Switched to ${switchedInfo.label} (${switchedInfo.id})
+      console.log(chalk27.green(`  Switched to ${switchedInfo.label} (${switchedInfo.id})
 `));
       rl.prompt();
       return;
@@ -6690,22 +6991,22 @@ Analyze the above input.`;
         statusSpinner.succeed(`${statusInfo.label} (${activeModelId}) is reachable`);
       } else {
         statusSpinner.fail(check.error ?? "API unreachable");
-        console.log(chalk26.gray("  Tip: Set NOTCH_API_KEY or use --api-key, and verify your Modal endpoint is running.\n"));
+        console.log(chalk27.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(chalk26.gray("  Nothing to undo.\n"));
+        console.log(chalk27.gray("  Nothing to undo.\n"));
         rl.prompt();
         return;
       }
       const undone = await checkpoints.undo();
       if (undone) {
         const fileCount = undone.files.length;
-        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
+        console.log(chalk27.yellow(`  Undid "${undone.description}" (${fileCount} file${fileCount !== 1 ? "s" : ""} restored)`));
+        console.log(chalk27.gray(`  ${checkpoints.undoCount} checkpoint${checkpoints.undoCount !== 1 ? "s" : ""} remaining
 `));
       }
       rl.prompt();
@@ -6713,7 +7014,7 @@ Analyze the above input.`;
     }
     if (input === "/usage") {
       if (usage.turnCount === 0) {
-        console.log(chalk26.gray("  No usage yet.\n"));
+        console.log(chalk27.gray("  No usage yet.\n"));
       } else {
         console.log(usage.formatSession());
         const currentTokens = estimateTokens(messages);
@@ -6726,7 +7027,7 @@ Analyze the above input.`;
     }
     if (input === "/cost") {
       if (costTracker.totalCost === 0) {
-        console.log(chalk26.gray("  No cost data yet.\n"));
+        console.log(chalk27.gray("  No cost data yet.\n"));
       } else {
         console.log(costTracker.formatTotal());
         console.log(costTracker.formatByModel());
@@ -6741,7 +7042,7 @@ Analyze the above input.`;
       const compressed = await autoCompress2(messages, model, MODEL_CATALOG[activeModelId].contextWindow);
       messages.length = 0;
       messages.push(...compressed);
-      console.log(chalk26.green(`  Compressed: ${before} messages \u2192 ${messages.length} messages`));
+      console.log(chalk27.green(`  Compressed: ${before} messages \u2192 ${messages.length} messages`));
       console.log("");
       rl.prompt();
       return;
@@ -6749,10 +7050,10 @@ Analyze the above input.`;
     if (input === "/diff") {
       const diffs = checkpoints.allDiffs();
       if (diffs.length === 0) {
-        console.log(chalk26.gray("  No file changes this session.\n"));
+        console.log(chalk27.gray("  No file changes this session.\n"));
       } else {
         for (const df of diffs) {
-          console.log(chalk26.cyan(`  ${df.path}:`));
+          console.log(chalk27.cyan(`  ${df.path}:`));
           console.log(unifiedDiff(df.before, df.after, df.path));
           console.log("");
         }
@@ -6768,10 +7069,10 @@ Analyze the above input.`;
           projectRoot: config.projectRoot,
           outputPath: exportPath
         });
-        console.log(chalk26.green(`  Exported to ${ePath}
+        console.log(chalk27.green(`  Exported to ${ePath}
 `));
       } catch (err) {
-        console.log(chalk26.red(`  Export failed: ${err.message}
+        console.log(chalk27.red(`  Export failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -6781,10 +7082,10 @@ Analyze the above input.`;
       try {
         const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
         sessionId = id;
-        console.log(chalk26.green(`  Session saved: ${id}
+        console.log(chalk27.green(`  Session saved: ${id}
 `));
       } catch (err) {
-        console.log(chalk26.red(`  Save failed: ${err.message}
+        console.log(chalk27.red(`  Save failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -6794,16 +7095,16 @@ Analyze the above input.`;
       try {
         const sessions = await listSessions(config.projectRoot);
         if (sessions.length === 0) {
-          console.log(chalk26.gray("  No saved sessions.\n"));
+          console.log(chalk27.gray("  No saved sessions.\n"));
         } else {
-          console.log(chalk26.gray("\n  Saved sessions:\n"));
+          console.log(chalk27.gray("\n  Saved sessions:\n"));
           for (const s of sessions.slice(0, 10)) {
-            console.log(chalk26.gray(`    ${s.id}  ${s.turns} turns  ${s.date}  ${s.model}`));
+            console.log(chalk27.gray(`    ${s.id}  ${s.turns} turns  ${s.date}  ${s.model}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk26.red(`  Error listing sessions: ${err.message}
+        console.log(chalk27.red(`  Error listing sessions: ${err.message}
 `));
       }
       rl.prompt();
@@ -6821,18 +7122,18 @@ Analyze the above input.`;
             const savedPlan = await loadPlan(config.projectRoot);
             if (savedPlan) {
               ralphPlan = savedPlan;
-              console.log(chalk26.green(`  Ralph plan restored (${savedPlan.tasks.length} tasks)
+              console.log(chalk27.green(`  Ralph plan restored (${savedPlan.tasks.length} tasks)
 `));
             }
           } catch {
           }
-          console.log(chalk26.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+          console.log(chalk27.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
 `));
         } else {
-          console.log(chalk26.gray("  No session found.\n"));
+          console.log(chalk27.gray("  No session found.\n"));
         }
       } catch (err) {
-        console.log(chalk26.red(`  Resume failed: ${err.message}
+        console.log(chalk27.red(`  Resume failed: ${err.message}
 `));
       }
       rl.prompt();
@@ -6841,7 +7142,7 @@ Analyze the above input.`;
     if (input.startsWith("/search ")) {
       const query = input.replace("/search ", "").trim().toLowerCase();
       if (!query) {
-        console.log(chalk26.gray("  Usage: /search <query>\n"));
+        console.log(chalk27.gray("  Usage: /search <query>\n"));
         rl.prompt();
         return;
       }
@@ -6858,14 +7159,14 @@ Analyze the above input.`;
         }
       }
       if (matches.length === 0) {
-        console.log(chalk26.gray(`  No matches for "${query}"
+        console.log(chalk27.gray(`  No matches for "${query}"
 `));
       } else {
-        console.log(chalk26.gray(`
+        console.log(chalk27.gray(`
   ${matches.length} match(es) for "${query}":
 `));
         for (const m of matches.slice(0, 10)) {
-          console.log(chalk26.gray(`    [${m.index}] ${m.role}: ${m.preview}`));
+          console.log(chalk27.gray(`    [${m.index}] ${m.role}: ${m.preview}`));
         }
         console.log("");
       }
@@ -6879,7 +7180,7 @@ Analyze the above input.`;
         activePlan = await generatePlan(task, model, systemPrompt);
         planSpinner.succeed("Plan generated");
         console.log(formatPlan(activePlan));
-        console.log(chalk26.gray("  Use /plan approve to execute, /plan edit to modify, or /plan cancel to discard.\n"));
+        console.log(chalk27.gray("  Use /plan approve to execute, /plan edit to modify, or /plan cancel to discard.\n"));
       } catch (err) {
         planSpinner.fail(`Plan failed: ${err.message}`);
       }
@@ -6888,11 +7189,11 @@ Analyze the above input.`;
     }
     if (input === "/plan approve") {
       if (!activePlan) {
-        console.log(chalk26.gray("  No active plan. Use /plan <task> to create one.\n"));
+        console.log(chalk27.gray("  No active plan. Use /plan <task> to create one.\n"));
         rl.prompt();
         return;
       }
-      console.log(chalk26.green("  Executing plan...\n"));
+      console.log(chalk27.green("  Executing plan...\n"));
       while (!isPlanComplete(activePlan)) {
         const stepPrompt = currentStepPrompt(activePlan);
         messages.push({ role: "user", content: stepPrompt });
@@ -6910,10 +7211,10 @@ Analyze the above input.`;
             },
             onToolCall: (name) => {
               if (planStepSpinner.isSpinning) planStepSpinner.stop();
-              console.log(chalk26.gray(`  \u2192 ${name}`));
+              console.log(chalk27.gray(`  \u2192 ${name}`));
             },
             onToolResult: (_name, _result, isError) => {
-              console.log(isError ? chalk26.red("    \u2717") : chalk26.green("    \u2713"));
+              console.log(isError ? chalk27.red("    \u2717") : chalk27.green("    \u2713"));
             }
           });
           console.log("\n");
@@ -6926,7 +7227,7 @@ Analyze the above input.`;
         }
       }
       if (activePlan && isPlanComplete(activePlan)) {
-        console.log(chalk26.green("  Plan completed!\n"));
+        console.log(chalk27.green("  Plan completed!\n"));
       }
       activePlan = null;
       rl.prompt();
@@ -6934,26 +7235,26 @@ Analyze the above input.`;
     }
     if (input === "/plan edit") {
       if (!activePlan) {
-        console.log(chalk26.gray("  No active plan to edit.\n"));
+        console.log(chalk27.gray("  No active plan to edit.\n"));
         rl.prompt();
         return;
       }
       console.log(formatPlan(activePlan));
-      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"));
+      console.log(chalk27.gray("  Type a modified plan description and use /plan <new task> to regenerate,"));
+      console.log(chalk27.gray("  or /plan approve to proceed with the current plan.\n"));
       rl.prompt();
       return;
     }
     if (input === "/plan cancel") {
       activePlan = null;
-      console.log(chalk26.gray("  Plan discarded.\n"));
+      console.log(chalk27.gray("  Plan discarded.\n"));
       rl.prompt();
       return;
     }
     if (input.startsWith("/agent ")) {
       const task = input.replace("/agent ", "").trim();
       const agentId = nextSubagentId();
-      console.log(chalk26.cyan(`  Spawning subagent #${agentId}: ${task}
+      console.log(chalk27.cyan(`  Spawning subagent #${agentId}: ${task}
 `));
       spawnSubagent({
         id: agentId,
@@ -6963,14 +7264,14 @@ Analyze the above input.`;
         toolContext: toolCtx,
         contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
         onComplete: (result) => {
-          console.log(chalk26.green(`
+          console.log(chalk27.green(`
   Subagent #${agentId} finished:`));
-          console.log(chalk26.gray(`  ${result.slice(0, 200)}
+          console.log(chalk27.gray(`  ${result.slice(0, 200)}
 `));
           rl.prompt();
         },
         onError: (err) => {
-          console.log(chalk26.red(`
+          console.log(chalk27.red(`
   Subagent #${agentId} failed: ${err}
 `));
           rl.prompt();
@@ -6983,18 +7284,18 @@ Analyze the above input.`;
       try {
         const memories = await loadMemories(config.projectRoot);
         if (memories.length === 0) {
-          console.log(chalk26.gray("  No saved memories.\n"));
+          console.log(chalk27.gray("  No saved memories.\n"));
         } else {
-          console.log(chalk26.gray(`
+          console.log(chalk27.gray(`
   ${memories.length} saved memories:
 `));
           for (const m of memories) {
-            console.log(chalk26.gray(`    [${m.type}] ${m.content.slice(0, 80)}`));
+            console.log(chalk27.gray(`    [${m.type}] ${m.content.slice(0, 80)}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk26.red(`  Error: ${err.message}
+        console.log(chalk27.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -7005,16 +7306,16 @@ Analyze the above input.`;
       try {
         const results = await searchMemories(config.projectRoot, query);
         if (results.length === 0) {
-          console.log(chalk26.gray(`  No memories matching "${query}"
+          console.log(chalk27.gray(`  No memories matching "${query}"
 `));
         } else {
           for (const m of results) {
-            console.log(chalk26.gray(`    [${m.type}] ${m.content.slice(0, 100)}`));
+            console.log(chalk27.gray(`    [${m.type}] ${m.content.slice(0, 100)}`));
           }
           console.log("");
         }
       } catch (err) {
-        console.log(chalk26.red(`  Error: ${err.message}
+        console.log(chalk27.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -7026,10 +7327,10 @@ Analyze the above input.`;
         for (const m of memories) {
           await deleteMemory(config.projectRoot, m.id);
         }
-        console.log(chalk26.yellow(`  Cleared ${memories.length} memories.
+        console.log(chalk27.yellow(`  Cleared ${memories.length} memories.
 `));
       } catch (err) {
-        console.log(chalk26.red(`  Error: ${err.message}
+        console.log(chalk27.red(`  Error: ${err.message}
 `));
       }
       rl.prompt();
@@ -7057,27 +7358,27 @@ Analyze the above input.`;
     }
     if (input === "/ralph run") {
       if (!ralphPlan) {
-        console.log(chalk26.gray("  No Ralph plan. Use /ralph plan <goal> first.\n"));
+        console.log(chalk27.gray("  No Ralph plan. Use /ralph plan <goal> first.\n"));
         rl.prompt();
         return;
       }
-      console.log(chalk26.green("  Ralph is running...\n"));
+      console.log(chalk27.green("  Ralph is running...\n"));
       try {
         ralphPlan = await runRalphLoop(ralphPlan, {
           model,
           systemPrompt,
           toolContext: toolCtx,
           contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
-          onTaskStart: (task) => console.log(chalk26.cyan(`  \u25B6 Task: ${task.description}`)),
-          onTaskComplete: (task) => console.log(chalk26.green(`  \u2713 Done: ${task.description}
+          onTaskStart: (task) => console.log(chalk27.cyan(`  \u25B6 Task: ${task.description}`)),
+          onTaskComplete: (task) => console.log(chalk27.green(`  \u2713 Done: ${task.description}
 `)),
-          onTaskFail: (task, err) => console.log(chalk26.red(`  \u2717 Failed: ${task.description} (${err})
+          onTaskFail: (task, err) => console.log(chalk27.red(`  \u2717 Failed: ${task.description} (${err})
 `))
         });
         await savePlan(config.projectRoot, ralphPlan);
         console.log(formatRalphStatus(ralphPlan));
       } catch (err) {
-        console.log(chalk26.red(`  Ralph error: ${err.message}
+        console.log(chalk27.red(`  Ralph error: ${err.message}
 `));
       }
       rl.prompt();
@@ -7085,7 +7386,7 @@ Analyze the above input.`;
     }
     if (input === "/ralph status") {
       if (!ralphPlan) {
-        console.log(chalk26.gray("  No Ralph plan active.\n"));
+        console.log(chalk27.gray("  No Ralph plan active.\n"));
       } else {
         console.log(formatRalphStatus(ralphPlan));
       }
@@ -7096,26 +7397,26 @@ Analyze the above input.`;
       ralphPlan = null;
       await deletePlan(config.projectRoot).catch(() => {
       });
-      console.log(chalk26.gray("  Ralph plan cleared.\n"));
+      console.log(chalk27.gray("  Ralph plan cleared.\n"));
       rl.prompt();
       return;
     }
     if (input === "/branch") {
       const branchId = `branch-${branches.size + 1}`;
       branches.set(branchId, [...messages]);
-      console.log(chalk26.green(`  Forked conversation as "${branchId}" (${messages.length} messages)
+      console.log(chalk27.green(`  Forked conversation as "${branchId}" (${messages.length} messages)
 `));
       rl.prompt();
       return;
     }
     if (input === "/branches") {
       if (branches.size === 0) {
-        console.log(chalk26.gray("  No conversation branches. Use /branch to fork.\n"));
+        console.log(chalk27.gray("  No conversation branches. Use /branch to fork.\n"));
       } else {
-        console.log(chalk26.gray("\n  Branches:\n"));
+        console.log(chalk27.gray("\n  Branches:\n"));
         for (const [name, msgs] of branches) {
-          const marker = name === currentBranch ? chalk26.green(" \u25CF") : "  ";
-          console.log(chalk26.gray(`  ${marker} ${name}  (${msgs.length} messages)`));
+          const marker = name === currentBranch ? chalk27.green(" \u25CF") : "  ";
+          console.log(chalk27.gray(`  ${marker} ${name}  (${msgs.length} messages)`));
         }
         console.log("");
       }
@@ -7157,7 +7458,7 @@ Analyze the above input.`;
         modelId: activeModelId,
         messages,
         lastResponse: lastAssistantResponse,
-        log: (msg) => console.log(chalk26.gray(`  ${msg}`)),
+        log: (msg) => console.log(chalk27.gray(`  ${msg}`)),
         runPrompt: async (prompt, msgs) => {
           const spinner2 = ora4("Thinking...").start();
           const response = await withRetry(
@@ -7174,13 +7475,13 @@ Analyze the above input.`;
               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(`
+                console.log(chalk27.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 ? "..." : ""}`));
+                const icon = isError ? chalk27.red("\u2717") : chalk27.green("\u2713");
+                console.log(chalk27.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
               }
             })
           );
@@ -7194,8 +7495,8 @@ Analyze the above input.`;
         rl.prompt();
         return;
       }
-      console.log(chalk26.red(`  Unknown command: ${input}`));
-      console.log(chalk26.gray("  Type /help for available commands.\n"));
+      console.log(chalk27.red(`  Unknown command: ${input}`));
+      console.log(chalk27.gray("  Type /help for available commands.\n"));
       rl.prompt();
       return;
     }
@@ -7203,7 +7504,7 @@ Analyze the above input.`;
     const refContext = formatReferences(references);
     const finalPrompt = refContext + cleanInput;
     if (references.length > 0) {
-      console.log(chalk26.gray(`  Injected ${references.length} reference(s)`));
+      console.log(chalk27.gray(`  Injected ${references.length} reference(s)`));
     }
     messages.push({ role: "user", content: finalPrompt });
     const spinner = ora4("Thinking...").start();
@@ -7229,16 +7530,16 @@ Analyze the above input.`;
               const val = String(v);
               return `${k}=${val.length > 60 ? val.slice(0, 60) + "..." : val}`;
             }).join(", ");
-            console.log(chalk26.gray(`
+            console.log(chalk27.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 ? "..." : ""}`));
+            const icon = isError ? chalk27.red("\u2717") : chalk27.green("\u2713");
+            console.log(chalk27.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
           },
           onCompress: () => {
-            console.log(chalk26.yellow("\n  [Context compressed to fit window]\n"));
+            console.log(chalk27.yellow("\n  [Context compressed to fit window]\n"));
           }
         })
       );
@@ -7272,7 +7573,7 @@ Analyze the above input.`;
               type: "auto",
               content: memMatch[1]
             });
-            console.log(chalk26.gray("  (Saved to memory)\n"));
+            console.log(chalk27.gray("  (Saved to memory)\n"));
           } catch {
           }
         }
@@ -7282,13 +7583,13 @@ Analyze the above input.`;
       checkpoints.discard();
       const msg = err.message?.toLowerCase() ?? "";
       if (msg.includes("fetch") || msg.includes("econnrefused") || msg.includes("network")) {
-        console.log(chalk26.gray("  Tip: Check that your Notch endpoint is running. Use /status to verify.\n"));
+        console.log(chalk27.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(chalk26.gray("  Tip: Set NOTCH_API_KEY env var or use --api-key flag.\n"));
+        console.log(chalk27.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(chalk26.gray("  Tip: Rate limited. Wait a moment and try again.\n"));
+        console.log(chalk27.gray("  Tip: Rate limited. Wait a moment and try again.\n"));
       } else {
-        console.log(chalk26.gray("  (The conversation history is preserved. Try again.)\n"));
+        console.log(chalk27.gray("  (The conversation history is preserved. Try again.)\n"));
       }
     }
     rl.prompt();
@@ -7306,13 +7607,13 @@ async function handleRalphSubcommand(args, cliOpts) {
     cwd: config.projectRoot,
     requireConfirm: false,
     confirm: async () => true,
-    log: (msg) => console.log(chalk26.gray(`  ${msg}`))
+    log: (msg) => console.log(chalk27.gray(`  ${msg}`))
   };
   const subcommand = args[0];
   if (subcommand === "plan") {
     const goal = args.slice(1).join(" ");
     if (!goal) {
-      console.error(chalk26.red("  Usage: notch ralph plan <goal>"));
+      console.error(chalk27.red("  Usage: notch ralph plan <goal>"));
       process.exit(1);
     }
     const spinner = ora4("Ralph is planning...").start();
@@ -7323,7 +7624,7 @@ async function handleRalphSubcommand(args, cliOpts) {
   } else if (subcommand === "run") {
     let plan = await loadPlan(config.projectRoot);
     if (!plan) {
-      console.error(chalk26.red("  No plan found. Run: notch ralph plan <goal>"));
+      console.error(chalk27.red("  No plan found. Run: notch ralph plan <goal>"));
       process.exit(1);
     }
     plan = await runRalphLoop(plan, {
@@ -7331,27 +7632,27 @@ async function handleRalphSubcommand(args, cliOpts) {
       systemPrompt,
       toolContext: toolCtx,
       contextWindow: MODEL_CATALOG[config.models.chat.model].contextWindow,
-      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}`))
+      onTaskStart: (t) => console.log(chalk27.cyan(`  \u25B6 ${t.description}`)),
+      onTaskComplete: (t) => console.log(chalk27.green(`  \u2713 ${t.description}`)),
+      onTaskFail: (t, e) => console.log(chalk27.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(chalk26.gray("  No Ralph plan found."));
+      console.log(chalk27.gray("  No Ralph plan found."));
     } else {
       console.log(formatRalphStatus(plan));
     }
   } else {
-    console.error(chalk26.red(`  Unknown: notch ralph ${subcommand}`));
-    console.error(chalk26.gray("  Usage: notch ralph <plan|run|status>"));
+    console.error(chalk27.red(`  Unknown: notch ralph ${subcommand}`));
+    console.error(chalk27.gray("  Usage: notch ralph <plan|run|status>"));
     process.exit(1);
   }
 }
 main().catch((err) => {
-  console.error(chalk26.red(`
+  console.error(chalk27.red(`
 Fatal: ${err.message}
 `));
   process.exit(1);