@freesyntax/notch-cli 0.4.0

package/dist/index.js

@@ -0,0 +1,4764 @@
+#!/usr/bin/env node
+import {
+  clearCredentials,
+  loadCredentials,
+  login
+} from "./chunk-TJS4W4R5.js";
+import {
+  autoCompress,
+  estimateTokens
+} from "./chunk-MWM5TFY4.js";
+
+// src/index.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+import ora from "ora";
+import * as readline from "readline";
+import * as nodePath from "path";
+
+// src/config.ts
+import fs from "fs/promises";
+import path from "path";
+
+// src/providers/registry.ts
+import { createOpenAI } from "@ai-sdk/openai";
+var MODEL_CATALOG = {
+  "notch-cinder": {
+    id: "notch-cinder",
+    label: "Cinder",
+    size: "4B",
+    gpu: "L4",
+    contextWindow: 65536,
+    maxOutputTokens: 8192,
+    baseUrl: "https://cutmob--notch-serve-cinder-notchcinderserver-serve.modal.run/v1"
+  },
+  "notch-forge": {
+    id: "notch-forge",
+    label: "Forge",
+    size: "9B",
+    gpu: "L40S",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://cutmob--notch-serve-forge-notchforgeserver-serve.modal.run/v1"
+  },
+  "notch-pyre": {
+    id: "notch-pyre",
+    label: "Pyre",
+    size: "24B",
+    gpu: "A100-80GB",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://cutmob--notch-serve-pyre-notchpyreserver-serve.modal.run/v1"
+  },
+  "notch-ignis": {
+    id: "notch-ignis",
+    label: "Ignis",
+    size: "27B",
+    gpu: "A100-80GB",
+    contextWindow: 131072,
+    maxOutputTokens: 16384,
+    baseUrl: "https://cutmob--notch-serve-ignis-notchignisserver-serve.modal.run/v1"
+  }
+};
+var MODEL_IDS = Object.keys(MODEL_CATALOG);
+function isValidModel(id) {
+  return id in MODEL_CATALOG;
+}
+function resolveModel(config) {
+  const info = MODEL_CATALOG[config.model];
+  if (!info) {
+    throw new Error(
+      `Unknown model "${config.model}". Available: ${MODEL_IDS.join(", ")}`
+    );
+  }
+  const baseUrl = config.baseUrl ?? process.env.NOTCH_BASE_URL ?? info.baseUrl;
+  const apiKey = config.apiKey ?? process.env.NOTCH_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "NOTCH_API_KEY is not set. Set it via the NOTCH_API_KEY environment variable or --api-key flag."
+    );
+  }
+  const provider = createOpenAI({
+    apiKey,
+    baseURL: baseUrl,
+    headers: config.headers
+  });
+  return provider(config.model);
+}
+async function validateConfig(config) {
+  const info = MODEL_CATALOG[config.model];
+  if (!info) {
+    return { ok: false, error: `Unknown model "${config.model}". Available: ${MODEL_IDS.join(", ")}` };
+  }
+  const baseUrl = config.baseUrl ?? process.env.NOTCH_BASE_URL ?? info.baseUrl;
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/v1$/, "")}/health`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!res.ok) {
+      return { ok: false, error: `Notch ${info.label} returned ${res.status} at ${baseUrl}` };
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, error: `Cannot reach Notch ${info.label} at ${baseUrl}` };
+  }
+}
+
+// src/config.ts
+var DEFAULT_MODEL = {
+  model: "notch-forge",
+  temperature: 0.3
+};
+var DEFAULTS = {
+  models: { chat: DEFAULT_MODEL },
+  projectRoot: process.cwd(),
+  autoConfirm: false,
+  maxIterations: 25,
+  useRepoMap: true,
+  renderMarkdown: true,
+  enableMemory: true,
+  enableHooks: true,
+  permissionMode: "auto",
+  theme: "default"
+};
+async function loadConfig(overrides = {}) {
+  const config = { ...DEFAULTS, models: { chat: { ...DEFAULT_MODEL } } };
+  const configPath = path.resolve(config.projectRoot, ".notch.json");
+  try {
+    const raw = await fs.readFile(configPath, "utf-8");
+    const fileConfig = JSON.parse(raw);
+    if (fileConfig.model && isValidModel(fileConfig.model)) {
+      config.models.chat.model = fileConfig.model;
+    }
+    if (fileConfig.baseUrl) config.models.chat.baseUrl = fileConfig.baseUrl;
+    if (fileConfig.apiKey) config.models.chat.apiKey = fileConfig.apiKey;
+    if (fileConfig.maxIterations) config.maxIterations = fileConfig.maxIterations;
+    if (fileConfig.useRepoMap !== void 0) config.useRepoMap = fileConfig.useRepoMap;
+    if (fileConfig.temperature !== void 0) config.models.chat.temperature = fileConfig.temperature;
+    if (fileConfig.renderMarkdown !== void 0) config.renderMarkdown = fileConfig.renderMarkdown;
+    if (fileConfig.enableMemory !== void 0) config.enableMemory = fileConfig.enableMemory;
+    if (fileConfig.enableHooks !== void 0) config.enableHooks = fileConfig.enableHooks;
+    if (fileConfig.permissionMode) config.permissionMode = fileConfig.permissionMode;
+    if (fileConfig.shellTimeout) config.shellTimeout = fileConfig.shellTimeout;
+    if (fileConfig.theme) config.theme = fileConfig.theme;
+  } catch {
+  }
+  const creds = await loadCredentials();
+  if (creds?.token) {
+    config.models.chat.apiKey = creds.token;
+  }
+  if (process.env.NOTCH_MODEL && isValidModel(process.env.NOTCH_MODEL)) {
+    config.models.chat.model = process.env.NOTCH_MODEL;
+  }
+  if (process.env.NOTCH_BASE_URL) {
+    config.models.chat.baseUrl = process.env.NOTCH_BASE_URL;
+  }
+  if (process.env.NOTCH_API_KEY) {
+    config.models.chat.apiKey = process.env.NOTCH_API_KEY;
+  }
+  if (config.models.chat.temperature !== void 0) {
+    config.models.chat.temperature = Math.max(0, Math.min(2, config.models.chat.temperature));
+  }
+  config.maxIterations = Math.max(1, Math.min(100, config.maxIterations));
+  return { ...config, ...overrides };
+}
+
+// src/agent/loop.ts
+import { streamText } from "ai";
+
+// src/tools/index.ts
+import { tool } from "ai";
+
+// src/tools/read.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import { z } from "zod";
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".ico"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".zip", ".tar", ".gz", ".wasm", ".exe", ".dll", ".so", ".dylib"]);
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_LINES = 2e3;
+var parameters = z.object({
+  path: z.string().describe("Relative or absolute path to the file to read"),
+  offset: z.number().optional().describe("Line number to start reading from (1-based)"),
+  limit: z.number().optional().describe("Maximum number of lines to read")
+});
+async function readImage(filePath, ext) {
+  try {
+    const stat = await fs2.stat(filePath);
+    const buf = await fs2.readFile(filePath);
+    const mimeType = ext === ".svg" ? "image/svg+xml" : ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : ext === ".bmp" ? "image/bmp" : ext === ".ico" ? "image/x-icon" : "image/jpeg";
+    if (ext === ".svg") {
+      const svgText = buf.toString("utf-8");
+      return {
+        content: `Image: ${filePath} (${(stat.size / 1024).toFixed(1)} KB, SVG)
+
+${svgText.slice(0, 1e4)}`
+      };
+    }
+    const base64 = buf.toString("base64");
+    return {
+      content: `Image: ${filePath} (${(stat.size / 1024).toFixed(1)} KB, ${ext})
+data:${mimeType};base64,${base64.slice(0, 200)}... [${base64.length} chars total]
+
+(Image data is available. Describe what changes to make if needed.)`
+    };
+  } catch (err) {
+    return { content: `Error reading image ${filePath}: ${err.message}`, isError: true };
+  }
+}
+async function readPDF(filePath) {
+  try {
+    const stat = await fs2.stat(filePath);
+    const buf = await fs2.readFile(filePath);
+    const text = buf.toString("latin1");
+    const textChunks = [];
+    const streamRegex = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+    let match;
+    while ((match = streamRegex.exec(text)) !== null) {
+      const chunk = match[1].replace(/[^\x20-\x7E\n\r\t]/g, " ").replace(/\s+/g, " ").trim();
+      if (chunk.length > 10) {
+        textChunks.push(chunk);
+      }
+    }
+    const tjRegex = /\(((?:[^)\\]|\\.)*)\)\s*Tj/g;
+    while ((match = tjRegex.exec(text)) !== null) {
+      const decoded = match[1].replace(/\\(.)/g, "$1");
+      if (decoded.trim().length > 0) {
+        textChunks.push(decoded.trim());
+      }
+    }
+    if (textChunks.length === 0) {
+      return {
+        content: `PDF: ${filePath} (${(stat.size / 1024).toFixed(1)} KB)
+
+(Could not extract text \u2014 the PDF may be image-based or encrypted. Consider using an external tool for OCR.)`
+      };
+    }
+    const extractedText = textChunks.join("\n").slice(0, 5e4);
+    return {
+      content: `PDF: ${filePath} (${(stat.size / 1024).toFixed(1)} KB)
+
+Extracted text:
+${extractedText}`
+    };
+  } catch (err) {
+    return { content: `Error reading PDF ${filePath}: ${err.message}`, isError: true };
+  }
+}
+var readTool = {
+  name: "read",
+  description: 'Read file contents with line numbers. Use offset/limit for large files. Supports text files, images (returns metadata + base64), and PDFs (basic text extraction). Returns numbered lines like "  1\\tline content".',
+  parameters,
+  async execute(params, ctx) {
+    const filePath = path2.isAbsolute(params.path) ? params.path : path2.resolve(ctx.cwd, params.path);
+    const ext = path2.extname(filePath).toLowerCase();
+    try {
+      await fs2.access(filePath);
+      if (IMAGE_EXTENSIONS.has(ext)) {
+        return await readImage(filePath, ext);
+      }
+      if (ext === ".pdf") {
+        return await readPDF(filePath);
+      }
+      if (BINARY_EXTENSIONS.has(ext)) {
+        const stat2 = await fs2.stat(filePath);
+        return {
+          content: `Binary file: ${filePath} (${(stat2.size / 1024).toFixed(1)} KB, ${ext})`
+        };
+      }
+      const stat = await fs2.stat(filePath);
+      if (stat.size > MAX_FILE_SIZE) {
+        return {
+          content: `File too large: ${filePath} (${(stat.size / 1024 / 1024).toFixed(1)} MB). Use offset/limit to read portions.`,
+          isError: true
+        };
+      }
+      const cacheKey = `${filePath}:${params.offset ?? 0}:${params.limit ?? 0}`;
+      if (ctx._readCache?.has(cacheKey)) {
+        return { content: ctx._readCache.get(cacheKey) };
+      }
+      const raw = await fs2.readFile(filePath, "utf-8");
+      const allLines = raw.split("\n");
+      const offset = Math.max(0, (params.offset ?? 1) - 1);
+      const limit = params.limit ?? MAX_LINES;
+      const lines = allLines.slice(offset, offset + limit);
+      const numbered = lines.map((line, i) => {
+        const lineNum = String(offset + i + 1).padStart(5);
+        return `${lineNum}	${line}`;
+      }).join("\n");
+      const result = allLines.length > offset + limit ? `${numbered}
+
+(${allLines.length - offset - limit} more lines. Use offset=${offset + limit + 1} to continue.)` : numbered;
+      ctx._readCache?.set(cacheKey, result);
+      return { content: result };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { content: `File not found: ${filePath}`, isError: true };
+      }
+      return { content: `Error reading ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/write.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { z as z2 } from "zod";
+var parameters2 = z2.object({
+  path: z2.string().describe("Relative or absolute path to write"),
+  content: z2.string().describe("Complete file content to write")
+});
+var writeTool = {
+  name: "write",
+  description: "Write a file (create or overwrite). Creates parent directories if needed. Always provide the COMPLETE file content.",
+  parameters: parameters2,
+  async execute(params, ctx) {
+    const filePath = path3.isAbsolute(params.path) ? params.path : path3.resolve(ctx.cwd, params.path);
+    try {
+      await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+      let existed = false;
+      try {
+        await fs3.access(filePath);
+        existed = true;
+      } catch {
+      }
+      await fs3.writeFile(filePath, params.content, "utf-8");
+      const lines = params.content.split("\n").length;
+      const action = existed ? "Updated" : "Created";
+      return { content: `${action} ${filePath} (${lines} lines)` };
+    } catch (err) {
+      return { content: `Error writing ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/edit.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import { z as z3 } from "zod";
+var parameters3 = z3.object({
+  path: z3.string().describe("Relative or absolute path to the file"),
+  old_string: z3.string().describe("Exact string to find and replace (must be unique in file)"),
+  new_string: z3.string().describe("Replacement string"),
+  replace_all: z3.boolean().optional().default(false).describe("Replace all occurrences")
+});
+var editTool = {
+  name: "edit",
+  description: "Perform exact string replacement in a file. old_string must match exactly and be unique unless replace_all is true. Use for surgical edits.",
+  parameters: parameters3,
+  async execute(params, ctx) {
+    const filePath = path4.isAbsolute(params.path) ? params.path : path4.resolve(ctx.cwd, params.path);
+    try {
+      const content = await fs4.readFile(filePath, "utf-8");
+      if (!content.includes(params.old_string)) {
+        return {
+          content: `old_string not found in ${filePath}. Make sure it matches exactly (including whitespace and indentation).`,
+          isError: true
+        };
+      }
+      if (!params.replace_all) {
+        const firstIdx = content.indexOf(params.old_string);
+        const secondIdx = content.indexOf(params.old_string, firstIdx + 1);
+        if (secondIdx !== -1) {
+          return {
+            content: `old_string appears multiple times in ${filePath}. Provide more surrounding context to make it unique, or set replace_all: true.`,
+            isError: true
+          };
+        }
+      }
+      const newContent = params.replace_all ? content.replaceAll(params.old_string, params.new_string) : content.replace(params.old_string, params.new_string);
+      await fs4.writeFile(filePath, newContent, "utf-8");
+      const oldLines = params.old_string.split("\n").length;
+      const newLines = params.new_string.split("\n").length;
+      return {
+        content: `Edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)`
+      };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { content: `File not found: ${filePath}`, isError: true };
+      }
+      return { content: `Error editing ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/shell.ts
+import { execSync } from "child_process";
+import { z as z4 } from "zod";
+var BLOCKED_PATTERNS = [
+  /rm\s+-rf\s+\/(?!\S)/,
+  // rm -rf /
+  /mkfs\./,
+  /dd\s+if=.*of=\/dev/,
+  /:\(\)\s*\{.*:\|:.*\}/,
+  // fork bomb variants
+  /chmod\s+-R\s+777\s+\//
+  // recursive chmod on root
+];
+var DESTRUCTIVE_PATTERNS = [
+  /rm\s+-rf/,
+  /rm\s+-r\s/,
+  /git\s+push\s+--force(?!\s+--with-lease)/,
+  /git\s+reset\s+--hard/,
+  /DROP\s+(TABLE|DATABASE)/i,
+  /TRUNCATE/i,
+  />\s*\/dev\/sd/
+];
+var MAX_OUTPUT = 5e4;
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_TIMEOUT = 6e5;
+var parameters4 = z4.object({
+  command: z4.string().describe("Shell command to execute"),
+  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;
+  let match;
+  while ((match = absolutePathRegex.exec(command)) !== null) {
+    const targetPath = match[1];
+    if (!targetPath.startsWith(cwd) && !targetPath.startsWith("/tmp")) {
+      return `Blocked: command targets path outside project root: ${targetPath}`;
+    }
+  }
+  return null;
+}
+var shellTool = {
+  name: "shell",
+  description: "Execute a shell command in the project directory. Dangerous commands (rm -rf, DROP TABLE, git push --force) require confirmation. Some destructive system commands are blocked entirely.",
+  parameters: parameters4,
+  async execute(params, ctx) {
+    const { command } = params;
+    const maxTimeout = ctx.shellTimeout ?? MAX_TIMEOUT;
+    const timeout = Math.min(params.timeout ?? DEFAULT_TIMEOUT, maxTimeout);
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(command)) {
+        return {
+          content: `Blocked: "${command}" is too dangerous to execute.`,
+          isError: true
+        };
+      }
+    }
+    const pathError = validateCommand(command, ctx.cwd);
+    if (pathError) {
+      return { content: pathError, isError: true };
+    }
+    if (ctx.requireConfirm) {
+      for (const pattern of DESTRUCTIVE_PATTERNS) {
+        if (pattern.test(command)) {
+          const confirmed = await ctx.confirm(
+            `\u26A0 Destructive command: ${command}
+Proceed?`
+          );
+          if (!confirmed) {
+            return { content: "Command cancelled by user.", isError: true };
+          }
+          break;
+        }
+      }
+    }
+    try {
+      const output = execSync(command, {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env, FORCE_COLOR: "0" },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const trimmed = output.length > MAX_OUTPUT ? output.slice(0, MAX_OUTPUT) + `
+... (truncated, ${output.length} chars total)` : output;
+      return { content: trimmed || "(no output)" };
+    } catch (err) {
+      const stderr = err.stderr?.toString() ?? "";
+      const stdout = err.stdout?.toString() ?? "";
+      const combined = [stdout, stderr].filter(Boolean).join("\n");
+      const trimmed = combined.length > MAX_OUTPUT ? combined.slice(0, MAX_OUTPUT) + "\n... (truncated)" : combined;
+      if (err.killed && err.signal === "SIGTERM") {
+        return {
+          content: `Command timed out after ${(timeout / 1e3).toFixed(0)}s: ${command}
+
+Partial output:
+${trimmed || "(none)"}`,
+          isError: true
+        };
+      }
+      return {
+        content: `Command failed (exit ${err.status ?? "unknown"}):
+${trimmed || err.message}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/git.ts
+import { simpleGit } from "simple-git";
+import { z as z5 } from "zod";
+var PROTECTED_BRANCHES = ["main", "master", "production", "release"];
+var parameters5 = z5.object({
+  operation: z5.enum([
+    "status",
+    "diff",
+    "log",
+    "commit",
+    "branch",
+    "checkout",
+    "push",
+    "pull",
+    "stash",
+    "add",
+    "show"
+  ]).describe("Git operation to perform"),
+  args: z5.string().optional().describe("Additional arguments (e.g., branch name, commit message, file paths)")
+});
+var gitTool = {
+  name: "git",
+  description: "Perform git operations with built-in safety. Always prefer this over shell for git commands. Blocks force-push to protected branches. Operations: status, diff, log, commit, branch, checkout, push, pull, stash, add, show.",
+  parameters: parameters5,
+  async execute(params, ctx) {
+    const git = simpleGit(ctx.cwd);
+    try {
+      switch (params.operation) {
+        case "status": {
+          const status = await git.status();
+          const lines = [
+            `Branch: ${status.current}`,
+            `Ahead: ${status.ahead} Behind: ${status.behind}`,
+            status.staged.length ? `Staged: ${status.staged.join(", ")}` : null,
+            status.modified.length ? `Modified: ${status.modified.join(", ")}` : null,
+            status.not_added.length ? `Untracked: ${status.not_added.join(", ")}` : null,
+            status.deleted.length ? `Deleted: ${status.deleted.join(", ")}` : null
+          ].filter(Boolean);
+          return { content: lines.join("\n") };
+        }
+        case "diff": {
+          const diff = await git.diff(params.args?.split(" ") ?? []);
+          return { content: diff || "(no changes)" };
+        }
+        case "log": {
+          const log = await git.log({ maxCount: 10, ...params.args ? {} : {} });
+          const entries = log.all.map(
+            (c) => `${c.hash.slice(0, 8)} ${c.date} ${c.message}`
+          );
+          return { content: entries.join("\n") || "(no commits)" };
+        }
+        case "commit": {
+          if (!params.args) {
+            return { content: 'Commit requires a message. Use args: "your commit message"', isError: true };
+          }
+          const result = await git.commit(params.args);
+          return {
+            content: `Committed: ${result.commit} (${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions)`
+          };
+        }
+        case "add": {
+          const files = params.args?.split(" ") ?? ["."];
+          const sensitive = files.filter(
+            (f) => /\.(env|pem|key|credentials|secret)/i.test(f)
+          );
+          if (sensitive.length > 0) {
+            const confirmed = await ctx.confirm(
+              `\u26A0 Staging potentially sensitive files: ${sensitive.join(", ")}
+Proceed?`
+            );
+            if (!confirmed) {
+              return { content: "Staging cancelled.", isError: true };
+            }
+          }
+          await git.add(files);
+          return { content: `Staged: ${files.join(", ")}` };
+        }
+        case "branch": {
+          if (params.args) {
+            await git.branch(params.args.split(" "));
+            return { content: `Branch operation completed: ${params.args}` };
+          }
+          const branches = await git.branch();
+          return { content: branches.all.map((b) => `${b === branches.current ? "* " : "  "}${b}`).join("\n") };
+        }
+        case "checkout": {
+          if (!params.args) {
+            return { content: "Checkout requires a branch or file path.", isError: true };
+          }
+          await git.checkout(params.args.split(" "));
+          return { content: `Checked out: ${params.args}` };
+        }
+        case "push": {
+          const currentBranch = (await git.status()).current ?? "";
+          const args = params.args?.split(" ") ?? [];
+          const isForce = args.includes("--force") || args.includes("-f");
+          if (isForce && PROTECTED_BRANCHES.includes(currentBranch)) {
+            return {
+              content: `Blocked: cannot force-push to protected branch "${currentBranch}". Use --force-with-lease instead.`,
+              isError: true
+            };
+          }
+          await git.push(args);
+          return { content: `Pushed ${currentBranch} successfully` };
+        }
+        case "pull": {
+          const pullResult = await git.pull(params.args?.split(" "));
+          return {
+            content: `Pulled: ${pullResult.summary.changes} changes, ${pullResult.summary.insertions} insertions, ${pullResult.summary.deletions} deletions`
+          };
+        }
+        case "stash": {
+          if (params.args === "pop") {
+            await git.stash(["pop"]);
+            return { content: "Stash popped" };
+          }
+          if (params.args === "list") {
+            const list = await git.stashList();
+            return { content: list.all.map((s) => `${s.hash} ${s.message}`).join("\n") || "(no stashes)" };
+          }
+          await git.stash(params.args?.split(" "));
+          return { content: "Changes stashed" };
+        }
+        case "show": {
+          const raw = await git.show(params.args?.split(" ") ?? []);
+          return { content: raw };
+        }
+        default:
+          return { content: `Unknown git operation: ${params.operation}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `Git error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/grep.ts
+import { execSync as execSync2 } from "child_process";
+import fs5 from "fs/promises";
+import path5 from "path";
+import { z as z6 } from "zod";
+var parameters6 = z6.object({
+  pattern: z6.string().describe("Regex pattern to search for"),
+  path: z6.string().optional().describe("File or directory to search (defaults to project root)"),
+  glob: z6.string().optional().describe('Glob filter, e.g. "*.ts" or "**/*.tsx"'),
+  context: z6.number().optional().default(0).describe("Lines of context around each match"),
+  max_results: z6.number().optional().default(50).describe("Maximum number of matches to return")
+});
+var grepTool = {
+  name: "grep",
+  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;
+    try {
+      const rgArgs = [
+        "rg",
+        "--no-heading",
+        "--line-number",
+        "--color=never",
+        `--max-count=${params.max_results}`,
+        params.context ? `-C ${params.context}` : "",
+        params.glob ? `--glob "${params.glob}"` : "",
+        "--",
+        JSON.stringify(params.pattern),
+        searchPath
+      ].filter(Boolean).join(" ");
+      const output = execSync2(rgArgs, {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 15e3,
+        maxBuffer: 5 * 1024 * 1024
+      });
+      return { content: output || "(no matches)" };
+    } catch {
+    }
+    try {
+      const regex = new RegExp(params.pattern, "g");
+      const results = [];
+      async function searchDir(dir) {
+        if (results.length >= (params.max_results ?? 50)) return;
+        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        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);
+          if (entry.isDirectory()) {
+            await searchDir(full);
+          } else if (entry.isFile()) {
+            if (params.glob) {
+              const ext = params.glob.replace(/^\*+\.?/, "");
+              if (ext && !entry.name.endsWith(ext)) continue;
+            }
+            try {
+              const content = await fs5.readFile(full, "utf-8");
+              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);
+                  results.push(`${rel}:${i + 1}:${lines[i]}`);
+                  regex.lastIndex = 0;
+                  if (results.length >= (params.max_results ?? 50)) return;
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      const stat = await fs5.stat(searchPath);
+      if (stat.isFile()) {
+        const content = await fs5.readFile(searchPath, "utf-8");
+        const lines = content.split("\n");
+        const rel = path5.relative(ctx.cwd, searchPath);
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push(`${rel}:${i + 1}:${lines[i]}`);
+            regex.lastIndex = 0;
+            if (results.length >= (params.max_results ?? 50)) break;
+          }
+        }
+      } else {
+        await searchDir(searchPath);
+      }
+      return { content: results.join("\n") || "(no matches)" };
+    } catch (err) {
+      return { content: `Search error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/glob.ts
+import { glob as globFn } from "glob";
+import path6 from "path";
+import { z as z7 } from "zod";
+var parameters7 = z7.object({
+  pattern: z7.string().describe('Glob pattern, e.g. "**/*.ts" or "src/**/*.tsx"'),
+  path: z7.string().optional().describe("Directory to search (defaults to project root)")
+});
+var globTool = {
+  name: "glob",
+  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;
+    try {
+      const matches = await globFn(params.pattern, {
+        cwd: searchDir,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
+        nodir: true,
+        dot: false
+      });
+      if (matches.length === 0) {
+        return { content: `No files matching "${params.pattern}" in ${path6.relative(ctx.cwd, searchDir) || "."}` };
+      }
+      const relative = matches.map((m) => path6.relative(ctx.cwd, path6.resolve(searchDir, m)));
+      return {
+        content: `Found ${relative.length} file(s):
+${relative.join("\n")}`
+      };
+    } catch (err) {
+      return { content: `Glob error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/web-fetch.ts
+import { z as z8 } from "zod";
+var MAX_CONTENT_LENGTH = 5e4;
+var FETCH_TIMEOUT = 15e3;
+var parameters8 = z8.object({
+  url: z8.string().describe("URL to fetch"),
+  max_length: z8.number().optional().default(MAX_CONTENT_LENGTH).describe("Max characters to return")
+});
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote|pre|hr)[^>]*>/gi, "\n").replace(/<li[^>]*>/gi, "\n- ").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").replace(/[ \t]+/g, " ").trim();
+}
+var webFetchTool = {
+  name: "web_fetch",
+  description: "Fetch a web page and return its text content. Useful for reading documentation, API references, error lookups, and other web resources. Strips HTML to plain text.",
+  parameters: parameters8,
+  async execute(params, _ctx) {
+    const { url } = params;
+    const maxLen = params.max_length ?? MAX_CONTENT_LENGTH;
+    try {
+      new URL(url);
+    } catch {
+      return { content: `Invalid URL: ${url}`, isError: true };
+    }
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+        headers: {
+          "User-Agent": "Notch-CLI/0.1 (AI coding assistant)",
+          "Accept": "text/html,application/json,text/plain"
+        },
+        redirect: "follow"
+      });
+      if (!response.ok) {
+        return {
+          content: `HTTP ${response.status} ${response.statusText} for ${url}`,
+          isError: true
+        };
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const raw = await response.text();
+      let text;
+      if (contentType.includes("application/json")) {
+        try {
+          text = JSON.stringify(JSON.parse(raw), null, 2);
+        } catch {
+          text = raw;
+        }
+      } else if (contentType.includes("text/html")) {
+        text = htmlToText(raw);
+      } else {
+        text = raw;
+      }
+      if (text.length > maxLen) {
+        text = text.slice(0, maxLen) + `
+
+... (truncated, ${text.length} chars total)`;
+      }
+      return { content: `Fetched ${url} (${response.status}):
+
+${text}` };
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { content: `Timeout fetching ${url} (${FETCH_TIMEOUT / 1e3}s limit)`, isError: true };
+      }
+      return { content: `Fetch error for ${url}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/index.ts
+var ALL_TOOLS = [
+  readTool,
+  writeTool,
+  editTool,
+  shellTool,
+  gitTool,
+  grepTool,
+  globTool,
+  webFetchTool
+];
+function buildToolMap(ctx) {
+  const map = {};
+  for (const t of ALL_TOOLS) {
+    map[t.name] = tool({
+      description: t.description,
+      parameters: t.parameters,
+      execute: async (params) => {
+        if (ctx.checkPermission) {
+          const level = ctx.checkPermission(t.name, params);
+          if (level === "deny") {
+            return {
+              content: `Permission denied: ${t.name} is not allowed by your permission config.`,
+              isError: true
+            };
+          }
+          if (level === "prompt" && ctx.requireConfirm) {
+            const paramSummary = Object.entries(params).map(([k, v]) => `${k}=${String(v).slice(0, 80)}`).join(", ");
+            const confirmed = await ctx.confirm(
+              `Tool ${t.name}(${paramSummary}) requires approval. Proceed?`
+            );
+            if (!confirmed) {
+              return { content: "Cancelled by user.", isError: true };
+            }
+          }
+        }
+        if (ctx.dryRun && ["write", "edit", "shell", "git"].includes(t.name)) {
+          const paramSummary = JSON.stringify(params, null, 2).slice(0, 500);
+          return {
+            content: `[DRY RUN] Would execute ${t.name}:
+${paramSummary}`
+          };
+        }
+        await ctx.runHook?.("pre-tool", { tool: t.name, args: params });
+        const result = await t.execute(params, ctx);
+        await ctx.runHook?.("post-tool", {
+          tool: t.name,
+          args: params,
+          result: result.content.slice(0, 500),
+          isError: result.isError ?? false
+        });
+        return result;
+      }
+    });
+  }
+  return map;
+}
+function describeTools() {
+  return ALL_TOOLS.map(
+    (t) => `- **${t.name}**: ${t.description}`
+  ).join("\n");
+}
+
+// src/context/project-instructions.ts
+import fs6 from "fs/promises";
+import path7 from "path";
+import os from "os";
+var INSTRUCTION_FILES = [".notch.md", "NOTCH.md", ".notch/instructions.md"];
+async function loadProjectInstructions(projectRoot) {
+  const sources = [];
+  const homeDir = os.homedir();
+  for (const file of INSTRUCTION_FILES) {
+    const globalPath = path7.join(homeDir, file);
+    const content = await safeRead(globalPath);
+    if (content) {
+      sources.push({ path: globalPath, content, scope: "global" });
+      break;
+    }
+  }
+  for (const file of INSTRUCTION_FILES) {
+    const projectPath = path7.join(projectRoot, file);
+    const content = await safeRead(projectPath);
+    if (content) {
+      sources.push({ path: projectPath, content, scope: "project" });
+      break;
+    }
+  }
+  if (sources.length === 0) return "";
+  const sections = sources.map((s) => {
+    const label = s.scope === "global" ? "Global Instructions" : "Project Instructions";
+    return `## ${label}
+_Source: ${s.path}_
+
+${s.content}`;
+  });
+  return `
+# Custom Instructions
+
+${sections.join("\n\n")}`;
+}
+async function safeRead(filePath) {
+  try {
+    const content = await fs6.readFile(filePath, "utf-8");
+    return content.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// 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");
+async function ensureDir() {
+  await fs7.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 fileContent = [
+    "---",
+    `name: ${memory.name}`,
+    `description: ${memory.description}`,
+    `type: ${memory.type}`,
+    `updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    "---",
+    "",
+    memory.content
+  ].join("\n");
+  await fs7.writeFile(filePath, fileContent, "utf-8");
+  await updateIndex();
+  return filename;
+}
+async function loadMemories() {
+  await ensureDir();
+  const files = await fs7.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 memory = parseMemoryFile(content, file);
+      if (memory) memories.push(memory);
+    } catch {
+    }
+  }
+  return memories;
+}
+async function deleteMemory(filename) {
+  try {
+    await fs7.unlink(path8.join(MEMORY_DIR, filename));
+    await updateIndex();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function searchMemories(query) {
+  const all = await loadMemories();
+  const q = query.toLowerCase();
+  return all.filter(
+    (m) => m.name.toLowerCase().includes(q) || m.description.toLowerCase().includes(q) || m.content.toLowerCase().includes(q)
+  );
+}
+async function formatMemoriesForPrompt() {
+  const memories = await loadMemories();
+  if (memories.length === 0) return "";
+  const byType = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const list = byType.get(m.type) ?? [];
+    list.push(m);
+    byType.set(m.type, list);
+  }
+  const sections = ["\n## Memory (from previous sessions)\n"];
+  const typeLabels = {
+    user: "User Profile",
+    feedback: "Behavioral Guidance",
+    project: "Project Context",
+    reference: "External References"
+  };
+  for (const [type, label] of Object.entries(typeLabels)) {
+    const mems = byType.get(type);
+    if (!mems || mems.length === 0) continue;
+    sections.push(`### ${label}`);
+    for (const m of mems) {
+      sections.push(`- **${m.name}**: ${m.content.slice(0, 300)}`);
+    }
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function parseMemoryFile(raw, filename) {
+  const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) return null;
+  const frontmatter = fmMatch[1];
+  const content = fmMatch[2].trim();
+  const name = extractField(frontmatter, "name") ?? filename;
+  const description = extractField(frontmatter, "description") ?? "";
+  const type = extractField(frontmatter, "type") ?? "project";
+  return { name, description, type, content, filename };
+}
+function extractField(frontmatter, field) {
+  const match = frontmatter.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim() ?? null;
+}
+async function updateIndex() {
+  const memories = await loadMemories();
+  const lines = [
+    "# Notch Memory Index",
+    "",
+    `_${memories.length} memories stored. Auto-generated \u2014 do not edit._`,
+    ""
+  ];
+  const byType = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    const list = byType.get(m.type) ?? [];
+    list.push(m);
+    byType.set(m.type, list);
+  }
+  for (const [type, mems] of byType) {
+    lines.push(`## ${type}`);
+    for (const m of mems) {
+      lines.push(`- [${m.filename}](${m.filename}) \u2014 ${m.description}`);
+    }
+    lines.push("");
+  }
+  await fs7.writeFile(INDEX_FILE, lines.join("\n"), "utf-8");
+}
+
+// src/agent/loop.ts
+async function runAgentLoop(messages, config) {
+  const readCache = /* @__PURE__ */ new Map();
+  const toolCtxWithCache = {
+    ...config.toolContext,
+    _readCache: readCache
+  };
+  const tools = buildToolMap(toolCtxWithCache);
+  const maxIter = config.maxIterations ?? 25;
+  const contextWindow = config.contextWindow ?? 131072;
+  let iterations = 0;
+  let totalToolCalls = 0;
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let wasCompressed = false;
+  let history = [...messages];
+  history = await autoCompress(history, config.model, contextWindow, () => {
+    wasCompressed = true;
+    config.onCompress?.();
+  });
+  while (iterations < maxIter) {
+    iterations++;
+    const result = streamText({
+      model: config.model,
+      system: config.systemPrompt,
+      messages: history,
+      tools,
+      maxSteps: 1
+      // We manage the loop ourselves for better control
+    });
+    let fullText = "";
+    const toolCalls = [];
+    const toolResults = [];
+    for await (const event of result.fullStream) {
+      if (event.type === "text-delta") {
+        fullText += event.textDelta;
+        config.onTextChunk?.(event.textDelta);
+      } else if (event.type === "tool-call") {
+        toolCalls.push({
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          args: event.args
+        });
+        config.onToolCall?.(event.toolName, event.args);
+      }
+      const evt = event;
+      if (evt.type === "tool-result") {
+        const res = evt.result;
+        toolResults.push({
+          toolCallId: evt.toolCallId,
+          result: evt.result
+        });
+        config.onToolResult?.(
+          toolCalls.find((tc) => tc.toolCallId === evt.toolCallId)?.toolName ?? "unknown",
+          res?.content ?? String(evt.result),
+          res?.isError ?? false
+        );
+      }
+    }
+    try {
+      const u = await result.usage;
+      if (u) {
+        totalPromptTokens += u.promptTokens ?? 0;
+        totalCompletionTokens += u.completionTokens ?? 0;
+      }
+    } catch {
+    }
+    totalToolCalls += toolCalls.length;
+    if (toolCalls.length > 0) {
+      history.push({
+        role: "assistant",
+        content: [
+          ...fullText ? [{ type: "text", text: fullText }] : [],
+          ...toolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            args: tc.args
+          }))
+        ]
+      });
+      history.push({
+        role: "tool",
+        content: toolResults.map((tr) => ({
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: toolCalls.find((tc) => tc.toolCallId === tr.toolCallId)?.toolName ?? "unknown",
+          result: tr.result
+        }))
+      });
+      if (iterations % 5 === 0) {
+        history = await autoCompress(history, config.model, contextWindow, () => {
+          wasCompressed = true;
+          config.onCompress?.();
+        });
+      }
+      continue;
+    }
+    history.push({ role: "assistant", content: fullText });
+    return {
+      text: fullText,
+      messages: history,
+      iterations,
+      toolCallCount: totalToolCalls,
+      compressed: wasCompressed,
+      usage: {
+        promptTokens: totalPromptTokens,
+        completionTokens: totalCompletionTokens,
+        totalTokens: totalPromptTokens + totalCompletionTokens
+      }
+    };
+  }
+  const finalText = "[Reached maximum tool iterations. Please continue or refine your request.]";
+  history.push({ role: "assistant", content: finalText });
+  return {
+    text: finalText,
+    messages: history,
+    iterations,
+    toolCallCount: totalToolCalls,
+    compressed: wasCompressed,
+    usage: {
+      promptTokens: totalPromptTokens,
+      completionTokens: totalCompletionTokens,
+      totalTokens: totalPromptTokens + totalCompletionTokens
+    }
+  };
+}
+async function buildSystemPrompt(projectRoot) {
+  const parts = [
+    "You are Notch, an expert AI coding assistant built by Driftrail.",
+    "You help developers write, debug, refactor, and understand code.",
+    "You have access to tools for reading/writing files, running shell commands, searching code, and git operations.",
+    "",
+    "Guidelines:",
+    "- Always read files before editing them.",
+    "- Use exact string matching for edits \u2014 never guess at file contents.",
+    "- Explain what you're doing before making changes.",
+    "- If a task is complex, break it into steps.",
+    "- When running shell commands, prefer non-destructive operations.",
+    "- If you encounter an error, analyze it and suggest a fix."
+  ];
+  try {
+    const instructions = await loadProjectInstructions(projectRoot);
+    if (instructions) {
+      parts.push("", "## Project Instructions (.notch.md)", instructions);
+    }
+  } catch {
+  }
+  try {
+    const memoryStr = await formatMemoriesForPrompt(projectRoot);
+    if (memoryStr) {
+      parts.push("", "## Saved Context (Memory)", memoryStr);
+    }
+  } catch {
+  }
+  parts.push("", "## Available Tools", describeTools());
+  return parts.join("\n");
+}
+
+// src/agent/checkpoints.ts
+import fs8 from "fs/promises";
+import path9 from "path";
+var CheckpointManager = class {
+  checkpoints = [];
+  nextId = 1;
+  pendingFiles = /* @__PURE__ */ new Map();
+  /** Call before a file is modified — records its current content */
+  async recordBefore(filePath) {
+    if (this.pendingFiles.has(filePath)) return;
+    try {
+      const content = await fs8.readFile(filePath, "utf-8");
+      this.pendingFiles.set(filePath, content);
+    } catch {
+      this.pendingFiles.set(filePath, null);
+    }
+  }
+  /** Commit all pending file changes as a checkpoint */
+  async commit(description) {
+    const files = [];
+    for (const [filePath, before] of this.pendingFiles) {
+      let after = null;
+      try {
+        after = await fs8.readFile(filePath, "utf-8");
+      } catch {
+      }
+      files.push({ path: filePath, before, after });
+    }
+    const checkpoint = {
+      id: this.nextId++,
+      timestamp: Date.now(),
+      files,
+      description
+    };
+    this.checkpoints.push(checkpoint);
+    this.pendingFiles.clear();
+    return checkpoint;
+  }
+  /** Undo the most recent checkpoint — restores all files to their before state */
+  async undo() {
+    const checkpoint = this.checkpoints.pop();
+    if (!checkpoint) return null;
+    for (const snap of checkpoint.files) {
+      if (snap.before === null) {
+        try {
+          await fs8.unlink(snap.path);
+        } catch {
+        }
+      } else {
+        await fs8.mkdir(path9.dirname(snap.path), { recursive: true });
+        await fs8.writeFile(snap.path, snap.before, "utf-8");
+      }
+    }
+    return checkpoint;
+  }
+  /** Get the list of checkpoints (most recent last) */
+  list() {
+    return [...this.checkpoints];
+  }
+  /** How many checkpoints are available to undo */
+  get undoCount() {
+    return this.checkpoints.length;
+  }
+  /** Discard pending without committing */
+  discard() {
+    this.pendingFiles.clear();
+  }
+  /**
+   * Get all diffs across all checkpoints (for /diff command).
+   * Returns unique file paths with their first-seen "before" and latest "after" content.
+   */
+  allDiffs() {
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const checkpoint of this.checkpoints) {
+      for (const snapshot of checkpoint.files) {
+        if (!fileMap.has(snapshot.path)) {
+          fileMap.set(snapshot.path, { before: snapshot.before, after: snapshot.after });
+        } else {
+          fileMap.get(snapshot.path).after = snapshot.after;
+        }
+      }
+    }
+    return Array.from(fileMap.entries()).map(([path19, { before, after }]) => ({
+      path: path19,
+      before,
+      after
+    }));
+  }
+};
+
+// src/agent/usage.ts
+import chalk from "chalk";
+var UsageTracker = class {
+  turns = [];
+  record(usage) {
+    this.turns.push(usage);
+  }
+  get sessionTotal() {
+    return this.turns.reduce(
+      (acc, t) => ({
+        promptTokens: acc.promptTokens + t.promptTokens,
+        completionTokens: acc.completionTokens + t.completionTokens,
+        totalTokens: acc.totalTokens + t.totalTokens,
+        toolCalls: acc.toolCalls + t.toolCalls,
+        iterations: acc.iterations + t.iterations
+      }),
+      { promptTokens: 0, completionTokens: 0, totalTokens: 0, toolCalls: 0, iterations: 0 }
+    );
+  }
+  get turnCount() {
+    return this.turns.length;
+  }
+  formatLast() {
+    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]`);
+  }
+  formatSession() {
+    const total = this.sessionTotal;
+    return [
+      chalk.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}`)
+    ].join("\n");
+  }
+};
+
+// src/agent/retry.ts
+var DEFAULT_RETRYABLE = (err) => {
+  const msg = err.message.toLowerCase();
+  if (msg.includes("fetch") || msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("network") || msg.includes("socket")) {
+    return true;
+  }
+  if (msg.includes("429") || msg.includes("rate limit") || msg.includes("too many requests")) {
+    return true;
+  }
+  if (/\b5\d{2}\b/.test(msg)) {
+    return true;
+  }
+  return false;
+};
+async function withRetry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 3;
+  const baseDelay = options.baseDelay ?? 1e3;
+  const maxDelay = options.maxDelay ?? 3e4;
+  const factor = options.factor ?? 2;
+  const jitter = options.jitter ?? true;
+  const isRetryable = options.isRetryable ?? DEFAULT_RETRYABLE;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt === maxAttempts || !isRetryable(err)) {
+        throw err;
+      }
+      let delay = Math.min(baseDelay * Math.pow(factor, attempt - 1), maxDelay);
+      if (jitter) {
+        delay += Math.random() * delay * 0.5;
+      }
+      options.onRetry?.(attempt, err, delay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/agent/subagent.ts
+import { streamText as streamText2 } from "ai";
+var SUBAGENT_PROMPTS = {
+  explore: `You are an exploration agent. Your job is to quickly search and analyze a codebase to answer questions.
+You have access to read, grep, and glob tools. Use them efficiently \u2014 search broadly first, then narrow down.
+Be thorough but concise. Return your findings as a structured summary.
+Do NOT modify any files. Only read and search.`,
+  plan: `You are a planning agent. Your job is to design implementation strategies.
+Analyze the codebase, identify the files that need changes, and produce a step-by-step plan.
+Consider edge cases, existing patterns, and potential risks.
+Do NOT implement anything. Only plan and recommend.
+Output a structured plan with:
+1. Summary of approach
+2. Files to modify (with specific changes)
+3. New files to create (if any)
+4. Testing strategy
+5. Risks and considerations`,
+  general: `You are a general-purpose worker agent. Complete the task assigned to you.
+You have full access to all tools. Work autonomously and return results when done.
+Be efficient \u2014 use grep/glob to find things before reading entire files.
+If you encounter errors, try to resolve them yourself before reporting back.`
+};
+var EXPLORE_TOOL_FILTER = /* @__PURE__ */ new Set(["read", "grep", "glob", "web_fetch"]);
+var PLAN_TOOL_FILTER = /* @__PURE__ */ new Set(["read", "grep", "glob", "git", "web_fetch"]);
+var subagentCounter = 0;
+async function spawnSubagent(config) {
+  const { id, type, prompt, model, toolContext, maxIterations = 15 } = config;
+  config.onStatus?.(id, `Starting ${type} agent...`);
+  const allTools = buildToolMap(toolContext);
+  const tools = {};
+  if (type === "explore") {
+    for (const [name, tool2] of Object.entries(allTools)) {
+      if (EXPLORE_TOOL_FILTER.has(name)) tools[name] = tool2;
+    }
+  } else if (type === "plan") {
+    for (const [name, tool2] of Object.entries(allTools)) {
+      if (PLAN_TOOL_FILTER.has(name)) tools[name] = tool2;
+    }
+  } else {
+    Object.assign(tools, allTools);
+  }
+  const systemPrompt = `${SUBAGENT_PROMPTS[type]}
+
+## Working Directory
+${toolContext.cwd}
+
+## Available Tools
+${Object.keys(tools).map((n) => `- ${n}`).join("\n")}`;
+  const messages = [
+    { role: "user", content: prompt }
+  ];
+  let iterations = 0;
+  let totalToolCalls = 0;
+  try {
+    while (iterations < maxIterations) {
+      iterations++;
+      config.onStatus?.(id, `Iteration ${iterations}/${maxIterations}...`);
+      const result = streamText2({
+        model,
+        system: systemPrompt,
+        messages,
+        tools,
+        maxSteps: 1
+      });
+      let fullText = "";
+      const toolCalls = [];
+      const toolResults = [];
+      for await (const event of result.fullStream) {
+        if (event.type === "text-delta") {
+          fullText += event.textDelta;
+        } else if (event.type === "tool-call") {
+          toolCalls.push({
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            args: event.args
+          });
+          config.onStatus?.(id, `${event.toolName}(...)`);
+        }
+        const evt = event;
+        if (evt.type === "tool-result") {
+          toolResults.push({
+            toolCallId: evt.toolCallId,
+            toolName: toolCalls.find((tc) => tc.toolCallId === evt.toolCallId)?.toolName ?? "unknown",
+            result: evt.result
+          });
+        }
+      }
+      totalToolCalls += toolCalls.length;
+      if (toolCalls.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: [
+            ...fullText ? [{ type: "text", text: fullText }] : [],
+            ...toolCalls.map((tc) => ({
+              type: "tool-call",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              args: tc.args
+            }))
+          ]
+        });
+        messages.push({
+          role: "tool",
+          content: toolResults.map((tr) => ({
+            type: "tool-result",
+            toolCallId: tr.toolCallId,
+            toolName: tr.toolName,
+            result: tr.result
+          }))
+        });
+        continue;
+      }
+      config.onStatus?.(id, "Complete");
+      return {
+        id,
+        type,
+        text: fullText,
+        toolCalls: totalToolCalls,
+        iterations
+      };
+    }
+    config.onStatus?.(id, "Max iterations reached");
+    return {
+      id,
+      type,
+      text: "[Subagent reached max iterations]",
+      toolCalls: totalToolCalls,
+      iterations
+    };
+  } catch (err) {
+    config.onStatus?.(id, `Error: ${err.message}`);
+    return {
+      id,
+      type,
+      text: "",
+      toolCalls: totalToolCalls,
+      iterations,
+      error: err.message
+    };
+  }
+}
+function nextSubagentId(type) {
+  return `${type}-${++subagentCounter}`;
+}
+
+// src/agent/planner.ts
+import { generateText as generateText2 } from "ai";
+import chalk2 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):
+
+SUMMARY: <one sentence summary of the approach>
+
+STEPS:
+1. <action description> | FILES: <comma-separated file paths>
+2. <action description> | FILES: <comma-separated file paths>
+...
+
+RISKS:
+- <risk or consideration>
+- <risk or consideration>
+
+Rules:
+- Be specific about which files to modify and what changes to make
+- Order steps logically (read before edit, create before use)
+- Include testing steps
+- Keep it concise \u2014 no more than 10 steps
+- Files should be relative paths`;
+async function generatePlan(request, model, context) {
+  const messages = [];
+  if (context.history && context.history.length > 0) {
+    const recentUser = context.history.filter((m) => m.role === "user" && typeof m.content === "string").slice(-3);
+    if (recentUser.length > 0) {
+      messages.push({
+        role: "user",
+        content: `Recent conversation context:
+${recentUser.map((m) => `- ${String(m.content).slice(0, 100)}`).join("\n")}`
+      });
+      messages.push({
+        role: "assistant",
+        content: "Understood, I have the conversation context."
+      });
+    }
+  }
+  let prompt = `Task: ${request}
+
+Working directory: ${context.cwd}`;
+  if (context.repoMap) {
+    prompt += `
+
+Repository structure:
+${context.repoMap.slice(0, 4e3)}`;
+  }
+  messages.push({ role: "user", content: prompt });
+  const result = await generateText2({
+    model,
+    system: PLAN_SYSTEM_PROMPT,
+    messages,
+    maxTokens: 2048
+  });
+  return parsePlan(result.text);
+}
+function parsePlan(text) {
+  const summary = text.match(/SUMMARY:\s*(.+)/)?.[1]?.trim() ?? "Implementation plan";
+  const steps = [];
+  const stepMatches = text.matchAll(/(\d+)\.\s*(.+?)(?:\s*\|\s*FILES:\s*(.+))?$/gm);
+  let idx = 0;
+  for (const match of stepMatches) {
+    const action = match[2]?.trim() ?? "";
+    const filesStr = match[3]?.trim() ?? "";
+    const files = filesStr ? filesStr.split(",").map((f) => f.trim()).filter(Boolean) : [];
+    steps.push({ index: idx++, action, files, status: "pending" });
+  }
+  if (steps.length === 0) {
+    const lines = text.split("\n").filter((l) => l.trim() && !l.startsWith("SUMMARY") && !l.startsWith("RISKS"));
+    for (const line of lines.slice(0, 10)) {
+      steps.push({ index: idx++, action: line.trim(), files: [], status: "pending" });
+    }
+  }
+  const risks = [];
+  const riskSection = text.match(/RISKS:\n([\s\S]*?)(?:\n\n|$)/);
+  if (riskSection) {
+    const riskLines = riskSection[1].split("\n").filter((l) => l.trim().startsWith("-"));
+    for (const line of riskLines) {
+      risks.push(line.replace(/^-\s*/, "").trim());
+    }
+  }
+  return {
+    summary,
+    steps,
+    risks,
+    currentStep: -1,
+    approved: false
+  };
+}
+function formatPlan(plan) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk2.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(", ")}]`) : "";
+    lines.push(`  ${icon} ${num} ${action}${files}`);
+  }
+  if (plan.risks.length > 0) {
+    lines.push("");
+    lines.push(chalk2.yellow("  Risks:"));
+    for (const risk of plan.risks) {
+      lines.push(chalk2.yellow(`    \u26A0 ${risk}`));
+    }
+  }
+  lines.push("");
+  if (!plan.approved) {
+    lines.push(chalk2.gray("  Approve: /plan approve  |  Modify: /plan edit  |  Cancel: /plan cancel"));
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function currentStepPrompt(plan) {
+  const step = plan.steps[plan.currentStep];
+  if (!step) return null;
+  let prompt = `Execute step ${step.index + 1} of the plan: ${step.action}`;
+  if (step.files.length > 0) {
+    prompt += `
+Relevant files: ${step.files.join(", ")}`;
+  }
+  prompt += "\n\nComplete this step, then report what you did.";
+  return prompt;
+}
+function advancePlan(plan) {
+  if (plan.currentStep >= 0 && plan.steps[plan.currentStep]?.status === "in_progress") {
+    plan.steps[plan.currentStep].status = "done";
+  }
+  const next = plan.steps.findIndex((s) => s.status === "pending");
+  if (next === -1) return false;
+  plan.currentStep = next;
+  plan.steps[next].status = "in_progress";
+  return true;
+}
+function isPlanComplete(plan) {
+  return plan.steps.every((s) => s.status === "done" || s.status === "skipped");
+}
+
+// src/agent/cost.ts
+import chalk3 from "chalk";
+var MODEL_COSTS = {
+  "notch-cinder": { input: 0.05, output: 0.15 },
+  // L4 — cheapest
+  "notch-forge": { input: 0.1, output: 0.3 },
+  // L40S
+  "notch-pyre": { input: 0.3, output: 0.9 },
+  // A100
+  "notch-ignis": { input: 0.4, output: 1.2 }
+  // A100
+};
+var CostTracker = class {
+  entries = [];
+  record(model, promptTokens, completionTokens) {
+    const rates = MODEL_COSTS[model] ?? MODEL_COSTS["notch-forge"];
+    const inputCost = promptTokens / 1e6 * rates.input;
+    const outputCost = completionTokens / 1e6 * rates.output;
+    const cost = inputCost + outputCost;
+    const entry = { model, promptTokens, completionTokens, cost };
+    this.entries.push(entry);
+    return entry;
+  }
+  get totalCost() {
+    return this.entries.reduce((sum, e) => sum + e.cost, 0);
+  }
+  get totalTokens() {
+    return this.entries.reduce(
+      (acc, e) => ({
+        prompt: acc.prompt + e.promptTokens,
+        completion: acc.completion + e.completionTokens
+      }),
+      { prompt: 0, completion: 0 }
+    );
+  }
+  formatLastCost() {
+    const last = this.entries[this.entries.length - 1];
+    if (!last) return "";
+    return chalk3.gray(`$${last.cost.toFixed(4)}`);
+  }
+  formatSession() {
+    if (this.entries.length === 0) return chalk3.gray("  No cost data.");
+    const total = this.totalCost;
+    const tokens = this.totalTokens;
+    return [
+      chalk3.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)`)
+    ].join("\n");
+  }
+  /** Alias for formatSession */
+  formatTotal() {
+    return this.formatSession();
+  }
+  /** Breakdown cost by model */
+  formatByModel() {
+    if (this.entries.length === 0) return "";
+    const byModel = /* @__PURE__ */ new Map();
+    for (const e of this.entries) {
+      const existing = byModel.get(e.model) ?? { prompt: 0, completion: 0, cost: 0, turns: 0 };
+      existing.prompt += e.promptTokens;
+      existing.completion += e.completionTokens;
+      existing.cost += e.cost;
+      existing.turns += 1;
+      byModel.set(e.model, existing);
+    }
+    const lines = [chalk3.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)`)
+      );
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/agent/ralph.ts
+import fs10 from "fs/promises";
+import path11 from "path";
+import chalk4 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 { glob } from "glob";
+var PATTERNS = {
+  ts: [
+    /^export\s+(default\s+)?(async\s+)?function\s+(\w+)/gm,
+    /^export\s+(default\s+)?class\s+(\w+)/gm,
+    /^export\s+(const|let|var)\s+(\w+)/gm,
+    /^export\s+(default\s+)?interface\s+(\w+)/gm,
+    /^export\s+(default\s+)?type\s+(\w+)/gm,
+    /^export\s+(default\s+)?enum\s+(\w+)/gm
+  ],
+  js: [
+    /^export\s+(default\s+)?(async\s+)?function\s+(\w+)/gm,
+    /^export\s+(default\s+)?class\s+(\w+)/gm,
+    /^export\s+(const|let|var)\s+(\w+)/gm,
+    /^module\.exports\s*=\s*{([^}]+)}/gm
+  ],
+  py: [
+    /^def\s+(\w+)\s*\(/gm,
+    /^class\s+(\w+)/gm,
+    /^(\w+)\s*=\s*/gm
+  ],
+  rs: [
+    /^pub\s+(async\s+)?fn\s+(\w+)/gm,
+    /^pub\s+struct\s+(\w+)/gm,
+    /^pub\s+enum\s+(\w+)/gm,
+    /^pub\s+trait\s+(\w+)/gm
+  ]
+};
+var IMPORT_PATTERN = /(?:import|from)\s+['"]([^'"]+)['"]/g;
+function getPatterns(filePath) {
+  const ext = path10.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;
+  if (ext === "rs") return PATTERNS.rs;
+  return [];
+}
+function extractSymbols(content, patterns) {
+  const symbols = [];
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = re.exec(content)) !== null) {
+      const name = match[match.length - 1];
+      if (name && name.length < 100) {
+        symbols.push(name.trim());
+      }
+    }
+  }
+  return [...new Set(symbols)];
+}
+function extractImports(content, projectRoot, filePath) {
+  const imports = [];
+  const re = new RegExp(IMPORT_PATTERN.source, IMPORT_PATTERN.flags);
+  let match;
+  while ((match = re.exec(content)) !== null) {
+    const importPath = match[1];
+    if (importPath.startsWith(".") || importPath.startsWith("/")) {
+      imports.push(importPath);
+    }
+  }
+  return imports;
+}
+async function buildRepoMap(root) {
+  const files = await glob("**/*.{ts,tsx,js,jsx,mjs,py,rs}", {
+    cwd: root,
+    ignore: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/__pycache__/**",
+      "**/target/**",
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.d.ts"
+    ],
+    nodir: true
+  });
+  const entries = [];
+  for (const file of files.slice(0, 500)) {
+    const fullPath = path10.resolve(root, file);
+    try {
+      const content = await fs9.readFile(fullPath, "utf-8");
+      const lines = content.split("\n").length;
+      const patterns = getPatterns(file);
+      const symbols = extractSymbols(content, patterns);
+      const imports = extractImports(content, root, file);
+      if (symbols.length > 0 || imports.length > 0) {
+        entries.push({ path: file, symbols, imports, lines });
+      }
+    } catch {
+    }
+  }
+  const summaryLines = entries.map((e) => {
+    const syms = e.symbols.length > 0 ? `: ${e.symbols.join(", ")}` : "";
+    return `  ${e.path} (${e.lines}L)${syms}`;
+  });
+  const summary = [
+    `Repository structure (${entries.length} source files):`,
+    ...summaryLines
+  ].join("\n");
+  return { root, entries, summary };
+}
+function condensedRepoMap(map, maxChars = 8e3) {
+  if (map.summary.length <= maxChars) return map.summary;
+  const lines = [`Repository structure (${map.entries.length} source files):`];
+  let charCount = lines[0].length;
+  for (const entry of map.entries) {
+    const line = `  ${entry.path} (${entry.lines}L)`;
+    if (charCount + line.length + 1 > maxChars) {
+      lines.push(`  ... and ${map.entries.length - lines.length + 1} more files`);
+      break;
+    }
+    lines.push(line);
+    charCount += line.length + 1;
+  }
+  return lines.join("\n");
+}
+
+// src/agent/ralph.ts
+var PLAN_FILE = ".notch-ralph-plan.json";
+var MAX_TASK_ATTEMPTS = 2;
+var PLAN_SYSTEM = `You are a senior software architect. Given a high-level goal, break it into discrete, ordered implementation tasks.
+
+Output EXACTLY this JSON format (no markdown, no explanation):
+{
+  "tasks": [
+    {
+      "title": "Short task name",
+      "description": "Detailed description of what to implement and how",
+      "files": ["path/to/file1.ts", "path/to/file2.ts"]
+    }
+  ]
+}
+
+Rules:
+- Each task should be completable in one focused session (5-15 min of agent work)
+- Order tasks so dependencies come first (create before use)
+- Include a testing/verification task at the end
+- Be specific about file paths and changes
+- 3-12 tasks typical. No more than 15.
+- Each task should commit its own changes`;
+async function generateRalphPlan(goal, model, cwd) {
+  let repoContext = "";
+  try {
+    const repoMap = await buildRepoMap(cwd);
+    repoContext = condensedRepoMap(repoMap, 4e3);
+  } catch {
+  }
+  const prompt = `Goal: ${goal}
+
+Repository (${cwd}):
+${repoContext || "(empty project)"}`;
+  const result = await generateText3({
+    model,
+    system: PLAN_SYSTEM,
+    messages: [{ role: "user", content: prompt }],
+    maxTokens: 4096
+  });
+  const jsonMatch = result.text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    throw new Error("Failed to generate structured plan");
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  const plan = {
+    goal,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    updated: (/* @__PURE__ */ new Date()).toISOString(),
+    tasks: parsed.tasks.map((t, i) => ({
+      id: i + 1,
+      title: t.title,
+      description: t.description,
+      files: t.files ?? [],
+      status: "pending",
+      attempts: 0
+    })),
+    completedCount: 0,
+    totalCount: parsed.tasks.length
+  };
+  return plan;
+}
+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");
+}
+async function loadPlan(cwd) {
+  try {
+    const raw = await fs10.readFile(path11.join(cwd, PLAN_FILE), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function deletePlan(cwd) {
+  try {
+    await fs10.unlink(path11.join(cwd, PLAN_FILE));
+  } catch {
+  }
+}
+async function executeTask(task, plan, model, toolContext, callbacks) {
+  const tools = buildToolMap(toolContext);
+  const maxIter = 20;
+  let repoContext = "";
+  try {
+    const repoMap = await buildRepoMap(toolContext.cwd);
+    repoContext = condensedRepoMap(repoMap, 3e3);
+  } catch {
+  }
+  const systemPrompt = `You are Notch, an AI coding agent executing a specific task from a plan.
+
+## Your Task
+Task ${task.id}/${plan.totalCount}: ${task.title}
+
+${task.description}
+
+${task.files.length > 0 ? `Target files: ${task.files.join(", ")}` : ""}
+
+## Full Plan Context
+Goal: ${plan.goal}
+Completed: ${plan.completedCount}/${plan.totalCount} tasks
+
+Previous tasks (already done):
+${plan.tasks.filter((t) => t.status === "done").map((t) => `  \u2713 ${t.title}`).join("\n") || "  (none yet)"}
+
+## Working Directory
+${toolContext.cwd}
+
+## Repository
+${repoContext}
+
+## Available Tools
+${describeTools()}
+
+## Instructions
+1. Read relevant files to understand the current state
+2. Implement the changes described in your task
+3. Verify your changes work (run tests if applicable)
+4. Commit your changes with a descriptive message
+5. Respond with a brief summary of what you did
+
+Be focused. Only implement what this task requires. Do not scope-creep into other tasks.`;
+  const messages = [
+    { role: "user", content: `Execute task ${task.id}: ${task.title}
+
+${task.description}` }
+  ];
+  let iterations = 0;
+  let totalText = "";
+  try {
+    while (iterations < maxIter) {
+      iterations++;
+      const result = streamText3({
+        model,
+        system: systemPrompt,
+        messages,
+        tools,
+        maxSteps: 1
+      });
+      let fullText = "";
+      const toolCalls = [];
+      const toolResults = [];
+      for await (const event of result.fullStream) {
+        if (event.type === "text-delta") {
+          fullText += event.textDelta;
+          callbacks.onText?.(event.textDelta);
+        } else if (event.type === "tool-call") {
+          toolCalls.push({
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            args: event.args
+          });
+          callbacks.onToolCall?.(event.toolName, event.args);
+        }
+        const evt = event;
+        if (evt.type === "tool-result") {
+          const res = evt.result;
+          toolResults.push({
+            toolCallId: evt.toolCallId,
+            toolName: toolCalls.find((tc) => tc.toolCallId === evt.toolCallId)?.toolName ?? "unknown",
+            result: evt.result
+          });
+          callbacks.onToolResult?.(
+            toolCalls.find((tc) => tc.toolCallId === evt.toolCallId)?.toolName ?? "unknown",
+            res?.content ?? String(evt.result),
+            res?.isError ?? false
+          );
+        }
+      }
+      if (toolCalls.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: [
+            ...fullText ? [{ type: "text", text: fullText }] : [],
+            ...toolCalls.map((tc) => ({
+              type: "tool-call",
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              args: tc.args
+            }))
+          ]
+        });
+        messages.push({
+          role: "tool",
+          content: toolResults.map((tr) => ({
+            type: "tool-result",
+            toolCallId: tr.toolCallId,
+            toolName: tr.toolName,
+            result: tr.result
+          }))
+        });
+        continue;
+      }
+      totalText = fullText;
+      break;
+    }
+    return { success: true, text: totalText };
+  } catch (err) {
+    return { success: false, error: err.message, text: totalText };
+  }
+}
+async function runRalphLoop(plan, model, toolContext, cwd, callbacks) {
+  for (const task of plan.tasks) {
+    if (task.status === "done" || task.status === "skipped") continue;
+    task.status = "in_progress";
+    task.attempts++;
+    callbacks.onTaskStart?.(task);
+    await savePlan(plan, cwd);
+    const result = await executeTask(task, plan, model, toolContext, {
+      onToolCall: callbacks.onToolCall,
+      onToolResult: callbacks.onToolResult,
+      onText: callbacks.onText
+    });
+    if (result.success) {
+      task.status = "done";
+      callbacks.onTaskEnd?.(task, result);
+    } else {
+      if (task.attempts >= MAX_TASK_ATTEMPTS) {
+        task.status = "failed";
+        task.error = result.error;
+        callbacks.onTaskEnd?.(task, result);
+      } else {
+        task.status = "pending";
+        task.error = result.error;
+        callbacks.onTaskEnd?.(task, result);
+      }
+    }
+    await savePlan(plan, cwd);
+  }
+  callbacks.onComplete?.(plan);
+  return plan;
+}
+function formatRalphStatus(plan) {
+  const lines = [];
+  const done = plan.tasks.filter((t) => t.status === "done").length;
+  const failed = plan.tasks.filter((t) => t.status === "failed").length;
+  const pending = plan.tasks.filter((t) => t.status === "pending").length;
+  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));
+  lines.push("");
+  lines.push(chalk4.bold.white(`  Ralph Mode: ${plan.goal}`));
+  lines.push(`  [${bar}] ${progress}% (${done}/${plan.totalCount} tasks)`);
+  if (failed > 0) lines.push(chalk4.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}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/context/references.ts
+import fs11 from "fs/promises";
+import path12 from "path";
+import { glob as glob2 } from "glob";
+async function resolveReferences(input, cwd) {
+  const references = [];
+  const refPattern = /@((?:https?:\/\/\S+)|(?:[^\s`]+))/g;
+  const matches = [...input.matchAll(refPattern)];
+  if (matches.length === 0) {
+    return { cleanInput: input, references: [] };
+  }
+  let cleanInput = input;
+  for (const match of matches) {
+    const ref = match[1];
+    cleanInput = cleanInput.replace(match[0], "").trim();
+    if (ref.startsWith("http://") || ref.startsWith("https://")) {
+      const resolved = await resolveUrl(ref);
+      references.push(resolved);
+    } else if (ref.includes("*")) {
+      const resolved = await resolveGlob(ref, cwd);
+      references.push(...resolved);
+    } else {
+      const resolved = await resolveFile(ref, cwd);
+      references.push(resolved);
+    }
+  }
+  return { cleanInput, references };
+}
+function formatReferences(refs) {
+  if (refs.length === 0) return "";
+  const sections = [];
+  for (const ref of refs) {
+    if (ref.error) {
+      sections.push(`<!-- @${ref.original}: ${ref.error} -->`);
+      continue;
+    }
+    const label = ref.type === "url" ? ref.original : ref.resolved;
+    const truncated = ref.content.length > 3e4 ? ref.content.slice(0, 3e4) + "\n... (truncated)" : ref.content;
+    sections.push(`<referenced_${ref.type} path="${label}">
+${truncated}
+</referenced_${ref.type}>`);
+  }
+  return sections.join("\n\n") + "\n\n";
+}
+async function resolveFile(ref, cwd) {
+  const filePath = path12.isAbsolute(ref) ? ref : path12.resolve(cwd, ref);
+  try {
+    const content = await fs11.readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const numbered = lines.map((line, i) => `${String(i + 1).padStart(4)} | ${line}`).join("\n");
+    return {
+      type: "file",
+      original: ref,
+      resolved: filePath,
+      content: `${filePath} (${lines.length} lines):
+${numbered}`
+    };
+  } catch (err) {
+    return {
+      type: "file",
+      original: ref,
+      resolved: filePath,
+      content: "",
+      error: err.code === "ENOENT" ? `File not found: ${filePath}` : err.message
+    };
+  }
+}
+async function resolveUrl(url) {
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: { "User-Agent": "Notch-CLI/0.2 (AI coding assistant)" }
+    });
+    if (!response.ok) {
+      return {
+        type: "url",
+        original: url,
+        resolved: url,
+        content: "",
+        error: `HTTP ${response.status}`
+      };
+    }
+    const text = await response.text();
+    const contentType = response.headers.get("content-type") ?? "";
+    let content;
+    if (contentType.includes("html")) {
+      content = text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, "").replace(/\s{3,}/g, "\n\n").trim();
+    } else {
+      content = text;
+    }
+    return { type: "url", original: url, resolved: url, content };
+  } catch (err) {
+    return {
+      type: "url",
+      original: url,
+      resolved: url,
+      content: "",
+      error: err.message
+    };
+  }
+}
+async function resolveGlob(pattern, cwd) {
+  try {
+    const matches = await glob2(pattern, {
+      cwd,
+      ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+      nodir: true
+    });
+    if (matches.length === 0) {
+      return [{
+        type: "glob",
+        original: pattern,
+        resolved: pattern,
+        content: "",
+        error: `No files matching: ${pattern}`
+      }];
+    }
+    const capped = matches.slice(0, 10);
+    const results = [];
+    for (const file of capped) {
+      results.push(await resolveFile(file, cwd));
+    }
+    if (matches.length > 10) {
+      results.push({
+        type: "glob",
+        original: pattern,
+        resolved: pattern,
+        content: `\u26A0 Warning: ${matches.length} files matched ${pattern}, but only the first 10 were injected. Narrow your glob pattern for more precise results.`
+      });
+    }
+    return results;
+  } catch (err) {
+    return [{
+      type: "glob",
+      original: pattern,
+      resolved: pattern,
+      content: "",
+      error: err.message
+    }];
+  }
+}
+
+// src/ui/themes.ts
+import chalk5 from "chalk";
+var defaultTheme = {
+  name: "Default",
+  description: "Classic Notch \u2014 green mantis, blue wordmark",
+  brand: chalk5.blueBright,
+  mascot: chalk5.greenBright,
+  mascotAccent: chalk5.yellowBright,
+  tagline: chalk5.cyan,
+  prompt: chalk5.blueBright,
+  border: chalk5.gray,
+  dim: chalk5.gray,
+  text: chalk5.white,
+  bold: chalk5.white.bold,
+  success: chalk5.green,
+  warning: chalk5.yellow,
+  error: chalk5.red,
+  info: chalk5.cyan,
+  toolName: chalk5.gray,
+  toolArgs: chalk5.gray,
+  toolResult: chalk5.gray,
+  diffAdd: chalk5.green,
+  diffRemove: chalk5.red,
+  diffHeader: chalk5.cyan,
+  mdH1: chalk5.white.bold,
+  mdH2: chalk5.blueBright,
+  mdH3: chalk5.cyan,
+  mdCode: chalk5.cyan,
+  mdInlineCode: chalk5.bgGray.white,
+  mdLink: chalk5.blue.underline,
+  meterLow: chalk5.green,
+  meterMid: chalk5.yellow,
+  meterHigh: chalk5.red
+};
+var interstellarTheme = {
+  name: "Interstellar",
+  description: "Deep space amber \u2014 Endurance control panels",
+  brand: chalk5.hex("#FFB347"),
+  // warm amber (instrument readout)
+  mascot: chalk5.hex("#4A90D9"),
+  // pale blue (frozen clouds)
+  mascotAccent: chalk5.hex("#FFD700"),
+  // gold (Gargantua light)
+  tagline: chalk5.hex("#708090"),
+  // slate gray (ship hull)
+  prompt: chalk5.hex("#FFB347"),
+  border: chalk5.hex("#3A3A3A"),
+  // dark hull metal
+  dim: chalk5.hex("#5C5C5C"),
+  text: chalk5.hex("#D4D4D4"),
+  // cool white (display text)
+  bold: chalk5.hex("#FFFFFF").bold,
+  success: chalk5.hex("#7CFC00"),
+  // "CASE: All systems nominal"
+  warning: chalk5.hex("#FFB347"),
+  // amber warning
+  error: chalk5.hex("#FF4444"),
+  // critical alert
+  info: chalk5.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")
+};
+var spaceGrayTheme = {
+  name: "Space Gray",
+  description: "Apple minimalism \u2014 silver, cool gray, ice blue",
+  brand: chalk5.hex("#A2AAAD"),
+  // apple silver
+  mascot: chalk5.hex("#86868B"),
+  // space gray
+  mascotAccent: chalk5.hex("#0071E3"),
+  // apple blue
+  tagline: chalk5.hex("#6E6E73"),
+  // secondary gray
+  prompt: chalk5.hex("#A2AAAD"),
+  border: chalk5.hex("#3A3A3C"),
+  // dark separator
+  dim: chalk5.hex("#6E6E73"),
+  text: chalk5.hex("#E5E5EA"),
+  // system gray 6
+  bold: chalk5.hex("#F5F5F7").bold,
+  // near white
+  success: chalk5.hex("#30D158"),
+  // apple green
+  warning: chalk5.hex("#FFD60A"),
+  // apple yellow
+  error: chalk5.hex("#FF453A"),
+  // apple red
+  info: chalk5.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"),
+  // 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")
+};
+var cyberpunkTheme = {
+  name: "Cyberpunk",
+  description: "Neon pink & cyan \u2014 Night City terminal",
+  brand: chalk5.hex("#FF2079"),
+  // hot pink
+  mascot: chalk5.hex("#00FFFF"),
+  // electric cyan
+  mascotAccent: chalk5.hex("#FF2079"),
+  // hot pink eyes
+  tagline: chalk5.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"),
+  // matrix green
+  warning: chalk5.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")
+};
+var auroraTheme = {
+  name: "Aurora",
+  description: "Northern lights \u2014 teal, violet, polar green",
+  brand: chalk5.hex("#7FFFD4"),
+  // aquamarine
+  mascot: chalk5.hex("#00CED1"),
+  // dark turquoise
+  mascotAccent: chalk5.hex("#DA70D6"),
+  // orchid
+  tagline: chalk5.hex("#9370DB"),
+  // medium purple
+  prompt: chalk5.hex("#7FFFD4"),
+  border: chalk5.hex("#2F4F4F"),
+  // dark slate
+  dim: chalk5.hex("#5F9EA0"),
+  // cadet blue
+  text: chalk5.hex("#E0FFFF"),
+  // light cyan
+  bold: chalk5.hex("#F0FFFF").bold,
+  success: chalk5.hex("#00FA9A"),
+  // medium spring green
+  warning: chalk5.hex("#DDA0DD"),
+  // plum
+  error: chalk5.hex("#FF6B6B"),
+  info: chalk5.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")
+};
+var solarizedTheme = {
+  name: "Solarized",
+  description: "Solarized Dark \u2014 warm, precise, classic dev palette",
+  brand: chalk5.hex("#268BD2"),
+  // blue
+  mascot: chalk5.hex("#859900"),
+  // green
+  mascotAccent: chalk5.hex("#B58900"),
+  // yellow
+  tagline: chalk5.hex("#2AA198"),
+  // cyan
+  prompt: chalk5.hex("#268BD2"),
+  border: chalk5.hex("#073642"),
+  // base02
+  dim: chalk5.hex("#586E75"),
+  // base01
+  text: chalk5.hex("#839496"),
+  // base0
+  bold: chalk5.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")
+};
+var draculaTheme = {
+  name: "Dracula",
+  description: "Dracula \u2014 purple, pink, green on charcoal",
+  brand: chalk5.hex("#BD93F9"),
+  // purple
+  mascot: chalk5.hex("#50FA7B"),
+  // green
+  mascotAccent: chalk5.hex("#FF79C6"),
+  // pink
+  tagline: chalk5.hex("#6272A4"),
+  // comment gray
+  prompt: chalk5.hex("#BD93F9"),
+  border: chalk5.hex("#44475A"),
+  // current line
+  dim: chalk5.hex("#6272A4"),
+  // comment
+  text: chalk5.hex("#F8F8F2"),
+  // foreground
+  bold: chalk5.hex("#F8F8F2").bold,
+  success: chalk5.hex("#50FA7B"),
+  warning: chalk5.hex("#F1FA8C"),
+  // yellow
+  error: chalk5.hex("#FF5555"),
+  info: chalk5.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")
+};
+var monokaiTheme = {
+  name: "Monokai",
+  description: "Monokai Pro \u2014 vivid on dark, a classic",
+  brand: chalk5.hex("#A6E22E"),
+  // green
+  mascot: chalk5.hex("#66D9EF"),
+  // blue
+  mascotAccent: chalk5.hex("#F92672"),
+  // pink
+  tagline: chalk5.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"),
+  // 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")
+};
+var oceanTheme = {
+  name: "Ocean",
+  description: "Deep sea \u2014 midnight blue, bioluminescent glow",
+  brand: chalk5.hex("#00B4D8"),
+  // cerulean
+  mascot: chalk5.hex("#0077B6"),
+  // deep blue
+  mascotAccent: chalk5.hex("#90E0EF"),
+  // light blue (bioluminescent)
+  tagline: chalk5.hex("#023E8A"),
+  // navy
+  prompt: chalk5.hex("#00B4D8"),
+  border: chalk5.hex("#03045E"),
+  // deep navy
+  dim: chalk5.hex("#0077B6"),
+  text: chalk5.hex("#CAF0F8"),
+  // lightest blue
+  bold: chalk5.hex("#CAF0F8").bold,
+  success: chalk5.hex("#2DC653"),
+  // kelp green
+  warning: chalk5.hex("#F4A261"),
+  // sandy
+  error: chalk5.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")
+};
+var emberTheme = {
+  name: "Ember",
+  description: "Fire forged \u2014 charcoal, ember orange, flame red",
+  brand: chalk5.hex("#FF6B35"),
+  // flame orange
+  mascot: chalk5.hex("#D62828"),
+  // deep red
+  mascotAccent: chalk5.hex("#FFD166"),
+  // bright flame
+  tagline: chalk5.hex("#8B4513"),
+  // saddle brown
+  prompt: chalk5.hex("#FF6B35"),
+  border: chalk5.hex("#2B2B2B"),
+  // charcoal
+  dim: chalk5.hex("#6B3A2A"),
+  text: chalk5.hex("#F4E4C1"),
+  // warm parchment
+  bold: chalk5.hex("#FFF5E1").bold,
+  success: chalk5.hex("#FFD166"),
+  // bright flame = success
+  warning: chalk5.hex("#FF6B35"),
+  error: chalk5.hex("#D62828"),
+  info: chalk5.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")
+};
+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")
+};
+var THEME_CATALOG = {
+  "default": defaultTheme,
+  "interstellar": interstellarTheme,
+  "space-gray": spaceGrayTheme,
+  "cyberpunk": cyberpunkTheme,
+  "aurora": auroraTheme,
+  "solarized": solarizedTheme,
+  "dracula": draculaTheme,
+  "monokai": monokaiTheme,
+  "ocean": oceanTheme,
+  "ember": emberTheme,
+  "ghost": ghostTheme
+};
+var THEME_IDS = Object.keys(THEME_CATALOG);
+function isValidTheme(id) {
+  return id in THEME_CATALOG;
+}
+var _activeTheme = defaultTheme;
+var _activeThemeId = "default";
+function theme() {
+  return _activeTheme;
+}
+function themeId() {
+  return _activeThemeId;
+}
+function setTheme(id) {
+  const t = THEME_CATALOG[id];
+  if (!t) throw new Error(`Unknown theme: ${id}. Available: ${THEME_IDS.join(", ")}`);
+  _activeTheme = t;
+  _activeThemeId = id;
+  return t;
+}
+function formatThemeList(activeId) {
+  const lines = ["\n  Available themes:\n"];
+  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}`);
+  }
+  lines.push(chalk5.gray(`
+  Switch with: /theme <name>
+`));
+  return lines.join("\n");
+}
+
+// src/ui/banner.ts
+var MANTIS = [
+  "  \u25C9\u2588\u2580\u2580\u2580\u2580\u2588\u25C9",
+  //  head + eyes
+  "   \u2580\u2588\u2584\u2584\u2588\u2580",
+  //  jaw
+  "     \u2590\u258C",
+  //  thin neck
+  "  \u2588\u2580 \u2590\u258C \u2580\u2588",
+  //  forelegs out
+  "  \u2580\u2588\u2584\u2588\u2588\u2584\u2588\u2580",
+  //  forelegs folding (prayer)
+  "    \u2590\u2588\u2588\u258C",
+  //  thorax
+  "    \u2590\u2588\u2588\u258C",
+  //  abdomen
+  "    \u2590\u2588\u2588\u258C",
+  //  abdomen
+  "   \u2584\u2580  \u2580\u2584",
+  //  legs splay
+  "  \u2580      \u2580"
+  //  feet
+];
+var LOGO_INLINE = [
+  " \u2588\u2588\u2584  \u2588  \u2584\u2580\u2580\u2584 \u2580\u2588\u2580 \u2584\u2580\u2580\u2584 \u2588  \u2588",
+  " \u2588 \u2580\u2584 \u2588  \u2588  \u2588  \u2588  \u2588    \u2588\u2580\u2580\u2588",
+  " \u2588  \u2580\u2588\u2588  \u2580\u2584\u2584\u2580  \u2588  \u2580\u2584\u2584\u2580 \u2588  \u2588"
+];
+function colorMantis(line) {
+  const t = theme();
+  return line.replace(/\u25c9/g, t.mascotAccent("\u25C9")).replace(/[\u2588]/g, (ch) => t.mascot(ch)).replace(/[\u2584\u2580]/g, (ch) => t.mascot(ch)).replace(/\u2590/g, t.mascot("\u2590")).replace(/\u258c/g, t.mascot("\u258C"));
+}
+function printBanner(version, modelLabel, modelId, modelSize, project) {
+  const t = theme();
+  const termWidth = process.stdout.columns || 80;
+  console.log("");
+  for (const line of MANTIS) {
+    console.log("  " + colorMantis(line));
+  }
+  console.log("");
+  for (const line of LOGO_INLINE) {
+    console.log("  " + t.brand(line));
+  }
+  console.log("");
+  const divWidth = Math.min(50, termWidth - 4);
+  const divider = t.border("  " + "\u2500".repeat(divWidth));
+  console.log(divider);
+  console.log(
+    t.dim("  ") + t.bold(modelLabel) + t.dim(` (${modelSize})`) + t.dim("  \u2502  v") + t.text(version) + t.dim("  \u2502  ") + t.dim("by ") + t.tagline("Driftrail")
+  );
+  console.log(t.dim(`  ${project}`));
+  console.log(divider);
+  console.log("");
+}
+function printMantis() {
+  const t = theme();
+  console.log("");
+  for (const line of MANTIS) {
+    console.log("    " + colorMantis(line));
+  }
+  console.log("");
+  console.log(t.dim('    "Precision. Patience. Execution."'));
+  console.log("");
+}
+
+// src/ui/context-meter.ts
+function renderContextMeter(usedTokens, maxTokens, width = 30) {
+  const t = theme();
+  const ratio = Math.min(usedTokens / maxTokens, 1);
+  const percent = Math.round(ratio * 100);
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  const barColor = ratio < 0.5 ? t.meterLow : ratio < 0.75 ? t.meterMid : t.meterHigh;
+  const bar = barColor("\u2588".repeat(filled)) + t.border("\u2591".repeat(empty));
+  const used = formatTokens(usedTokens);
+  const max = formatTokens(maxTokens);
+  return `  Context: [${bar}] ${percent}% (${used} / ${max} tokens)`;
+}
+function compactContextIndicator(usedTokens, maxTokens) {
+  const t = theme();
+  const ratio = Math.min(usedTokens / maxTokens, 1);
+  const percent = Math.round(ratio * 100);
+  if (ratio < 0.5) return t.meterLow(`[${percent}%]`);
+  if (ratio < 0.75) return t.meterMid(`[${percent}%]`);
+  return t.meterHigh(`[${percent}%]`);
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+
+// src/ui/update-checker.ts
+import fs12 from "fs/promises";
+import path13 from "path";
+import os3 from "os";
+import chalk6 from "chalk";
+var CACHE_FILE = path13.join(os3.homedir(), ".notch", "update-check.json");
+var CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+var PACKAGE_NAME = "notch-cli";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+async function checkForUpdates(currentVersion) {
+  try {
+    const cache = await loadCache();
+    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL) {
+      if (cache.latestVersion && isNewer(cache.latestVersion, currentVersion)) {
+        return formatUpdateMessage(currentVersion, cache.latestVersion);
+      }
+      return null;
+    }
+    const response = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(3e3),
+      // Fast timeout — don't slow down startup
+      headers: { "Accept": "application/json" }
+    });
+    if (!response.ok) {
+      await saveCache({ lastCheck: Date.now(), latestVersion: null });
+      return null;
+    }
+    const data = await response.json();
+    const latest = data.version;
+    await saveCache({ lastCheck: Date.now(), latestVersion: latest });
+    if (isNewer(latest, currentVersion)) {
+      return formatUpdateMessage(currentVersion, latest);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const l = latest.split(".").map(Number);
+  const c = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+function formatUpdateMessage(current, latest) {
+  return chalk6.yellow(`  Update available: ${current} -> ${latest}. Run: npm update -g ${PACKAGE_NAME}
+`);
+}
+async function loadCache() {
+  try {
+    const raw = await fs12.readFile(CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveCache(cache) {
+  try {
+    await fs12.mkdir(path13.dirname(CACHE_FILE), { recursive: true });
+    await fs12.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";
+var DEFAULT_PERMISSIONS = {
+  default: "prompt",
+  rules: [
+    // Safe read-only tools auto-allowed
+    { tool: "read", level: "allow" },
+    { tool: "grep", level: "allow" },
+    { tool: "glob", level: "allow" },
+    { tool: "web_fetch", level: "allow" },
+    // Write tools prompt by default
+    { tool: "write", level: "prompt" },
+    { tool: "edit", level: "prompt" },
+    { tool: "shell", level: "prompt" },
+    { tool: "git", level: "prompt" }
+  ]
+};
+async function loadPermissions(projectRoot) {
+  const projectPath = path14.join(projectRoot, ".notch.json");
+  const globalPath = path14.join(os4.homedir(), ".notch", "permissions.json");
+  let config = { ...DEFAULT_PERMISSIONS };
+  try {
+    const raw = await fs13.readFile(globalPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.permissions) {
+      config = mergePermissions(config, parsed.permissions);
+    }
+  } catch {
+  }
+  try {
+    const raw = await fs13.readFile(projectPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.permissions) {
+      config = mergePermissions(config, parsed.permissions);
+    }
+  } catch {
+  }
+  return config;
+}
+function checkPermission(config, toolName, args) {
+  const rule = config.rules.find((r) => {
+    if (r.tool !== toolName) return false;
+    if (r.pattern && args) {
+      const pat = new RegExp(r.pattern);
+      return Object.values(args).some((v) => pat.test(String(v)));
+    }
+    return true;
+  });
+  return rule?.level ?? config.default;
+}
+function formatPermissions(config) {
+  const lines = [`Default: ${config.default}`, ""];
+  for (const rule of config.rules) {
+    const icon = rule.level === "allow" ? "\u2713" : rule.level === "deny" ? "\u2717" : "?";
+    const pattern = rule.pattern ? ` (${rule.pattern})` : "";
+    lines.push(`  ${icon} ${rule.tool.padEnd(12)} ${rule.level}${pattern}`);
+  }
+  return lines.join("\n");
+}
+function mergePermissions(base, override) {
+  const merged = { ...base };
+  if (override.default) merged.default = override.default;
+  if (override.rules) {
+    for (const rule of override.rules) {
+      const idx = merged.rules.findIndex((r) => r.tool === rule.tool && r.pattern === rule.pattern);
+      if (idx >= 0) {
+        merged.rules[idx] = rule;
+      } else {
+        merged.rules.push(rule);
+      }
+    }
+  }
+  return merged;
+}
+
+// src/hooks/index.ts
+import { execSync as execSync3 } from "child_process";
+import fs14 from "fs/promises";
+import path15 from "path";
+import os5 from "os";
+import crypto from "crypto";
+var TRUST_STORE_PATH = path15.join(os5.homedir(), ".notch", "trusted-projects.json");
+async function isTrustedProject(projectRoot, raw) {
+  const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
+  const key = path15.resolve(projectRoot);
+  try {
+    const store = JSON.parse(await fs14.readFile(TRUST_STORE_PATH, "utf-8"));
+    return store[key] === fingerprint;
+  } catch {
+    return false;
+  }
+}
+async function trustProject(projectRoot, raw) {
+  const fingerprint = crypto.createHash("sha256").update(raw).digest("hex");
+  const key = path15.resolve(projectRoot);
+  let store = {};
+  try {
+    store = JSON.parse(await fs14.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));
+}
+async function loadHooks(projectRoot, promptTrust) {
+  const hooks = [];
+  const globalPath = path15.join(os5.homedir(), ".notch", "hooks.json");
+  try {
+    const raw = await fs14.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");
+  try {
+    const raw = await fs14.readFile(projectPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed.hooks) && parsed.hooks.length > 0) {
+      const alreadyTrusted = await isTrustedProject(projectRoot, raw);
+      if (!alreadyTrusted) {
+        const commands = parsed.hooks.map((h) => h.command);
+        const allowed = promptTrust ? await promptTrust(commands) : false;
+        if (!allowed) {
+          console.warn("[notch] Project hooks skipped \u2014 not trusted. Run with --trust-hooks to allow.");
+        } else {
+          await trustProject(projectRoot, raw);
+          hooks.push(...parsed.hooks);
+        }
+      } else {
+        hooks.push(...parsed.hooks);
+      }
+    }
+  } catch {
+  }
+  return { hooks };
+}
+async function runHooks(config, event, context) {
+  const matching = config.hooks.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;
+    return true;
+  });
+  const results = [];
+  for (const hook of matching) {
+    const result = await executeHook(hook, context);
+    results.push(result);
+    if (!result.ok) break;
+  }
+  return { results };
+}
+async function executeHook(hook, context) {
+  const BLOCKED_ENV_KEYS = /* @__PURE__ */ new Set([
+    "NOTCH_API_KEY",
+    "NOTCH_BASE_URL",
+    "SUPABASE_SERVICE_ROLE_KEY",
+    "SUPABASE_ANON_KEY",
+    "OPENAI_API_KEY",
+    "ANTHROPIC_API_KEY",
+    "GOOGLE_API_KEY",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "STRIPE_SECRET_KEY",
+    "STRIPE_WEBHOOK_SECRET"
+  ]);
+  const safeEnv = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== void 0 && !BLOCKED_ENV_KEYS.has(k)) {
+      safeEnv[k] = v;
+    }
+  }
+  const env = {
+    ...safeEnv,
+    NOTCH_EVENT: hook.event,
+    NOTCH_TOOL: context.tool ?? "",
+    NOTCH_FILE: context.file ?? "",
+    NOTCH_ERROR: context.error ?? "",
+    NOTCH_CWD: context.cwd
+  };
+  try {
+    const output = execSync3(hook.command, {
+      cwd: context.cwd,
+      encoding: "utf-8",
+      timeout: hook.timeout ?? 1e4,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { hook, ok: true, output: output.trim() };
+  } catch (err) {
+    return {
+      hook,
+      ok: false,
+      output: err.stdout?.toString() ?? "",
+      error: err.stderr?.toString() ?? err.message
+    };
+  }
+}
+
+// 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");
+var MAX_SESSIONS = 20;
+async function ensureDir2() {
+  await fs15.mkdir(SESSION_DIR, { recursive: true });
+}
+function sessionPath(id) {
+  return path16.join(SESSION_DIR, `${id}.json`);
+}
+function generateId() {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${date}-${rand}`;
+}
+async function saveSession(messages, project, model, existingId) {
+  await ensureDir2();
+  const id = existingId ?? generateId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const firstUser = messages.find((m) => m.role === "user");
+  const preview = firstUser && typeof firstUser.content === "string" ? firstUser.content.slice(0, 80) : "(no preview)";
+  const userCount = messages.filter((m) => m.role === "user").length;
+  const session = {
+    meta: {
+      id,
+      project,
+      model,
+      created: existingId ? (await loadSession(existingId))?.meta.created ?? now : now,
+      updated: now,
+      turns: userCount,
+      preview
+    },
+    messages
+  };
+  await fs15.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");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function listSessions() {
+  await ensureDir2();
+  const files = await fs15.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 session = JSON.parse(raw);
+      sessions.push(session.meta);
+    } catch {
+    }
+  }
+  return sessions.sort((a, b) => b.updated.localeCompare(a.updated));
+}
+async function loadLastSession(project) {
+  const sessions = await listSessions();
+  const match = sessions.find((s) => s.project === project);
+  if (!match) return null;
+  return loadSession(match.id);
+}
+async function deleteSession(id) {
+  try {
+    await fs15.unlink(sessionPath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pruneOldSessions() {
+  const sessions = await listSessions();
+  if (sessions.length <= MAX_SESSIONS) return;
+  const toDelete = sessions.slice(MAX_SESSIONS);
+  for (const s of toDelete) {
+    await deleteSession(s.id);
+  }
+}
+async function exportSession(messages, outputPath, meta) {
+  const lines = [];
+  lines.push("# Notch Conversation Export");
+  lines.push("");
+  if (meta) {
+    lines.push(`- **Model**: ${meta.model}`);
+    lines.push(`- **Project**: ${meta.project}`);
+  }
+  lines.push(`- **Date**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      lines.push("## User");
+      lines.push("");
+      if (typeof msg.content === "string") {
+        lines.push(msg.content);
+      }
+      lines.push("");
+    } else if (msg.role === "assistant") {
+      lines.push("## Notch");
+      lines.push("");
+      if (typeof msg.content === "string") {
+        lines.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if ("text" in part) {
+            lines.push(part.text);
+          } else if ("toolName" in part) {
+            lines.push(`> Tool call: \`${part.toolName}\``);
+          }
+        }
+      }
+      lines.push("");
+    } else if (msg.role === "tool") {
+      lines.push("> *Tool results omitted for brevity*");
+      lines.push("");
+    }
+  }
+  await fs15.writeFile(outputPath, lines.join("\n"), "utf-8");
+  return outputPath;
+}
+
+// src/init.ts
+import fs16 from "fs/promises";
+import path17 from "path";
+import chalk7 from "chalk";
+var DEFAULT_CONFIG = {
+  model: "notch-forge",
+  temperature: 0.3,
+  maxIterations: 25,
+  useRepoMap: true,
+  renderMarkdown: true,
+  permissionMode: "auto"
+};
+var DEFAULT_INSTRUCTIONS = `# Project Instructions for Notch
+
+<!--
+  These instructions are loaded into Notch's system prompt every session.
+  Use them to customize how Notch behaves in this project.
+-->
+
+## Project Overview
+<!-- Describe what this project is and what it does -->
+
+## Code Conventions
+<!-- Add any coding style preferences, naming conventions, etc. -->
+- Follow existing patterns in the codebase
+- Use TypeScript strict mode
+
+## Important Notes
+<!-- Any gotchas, special setup, or things Notch should know -->
+
+## Off-Limits
+<!-- 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");
+  let configExists = false;
+  let instructionsExist = false;
+  try {
+    await fs16.access(configPath);
+    configExists = true;
+  } catch {
+  }
+  try {
+    await fs16.access(instructionsPath);
+    instructionsExist = true;
+  } catch {
+  }
+  if (!configExists) {
+    await fs16.writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf-8");
+    console.log(chalk7.green(`  Created ${configPath}`));
+  } else {
+    console.log(chalk7.gray(`  Skipped ${configPath} (already exists)`));
+  }
+  if (!instructionsExist) {
+    await fs16.writeFile(instructionsPath, DEFAULT_INSTRUCTIONS, "utf-8");
+    console.log(chalk7.green(`  Created ${instructionsPath}`));
+  } else {
+    console.log(chalk7.gray(`  Skipped ${instructionsPath} (already exists)`));
+  }
+  const gitignorePath = path17.join(projectRoot, ".gitignore");
+  try {
+    const gitignore = await fs16.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(chalk7.green(`  Updated .gitignore`));
+    }
+  } catch {
+  }
+  console.log("");
+  console.log(chalk7.cyan("  Notch initialized! Edit .notch.md to customize behavior."));
+  console.log(chalk7.gray('  Run "notch" to start.\n'));
+}
+
+// src/tools/diff-preview.ts
+function unifiedDiff(oldContent, newContent, filePath) {
+  const t = theme();
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const hunks = computeHunks(oldLines, newLines);
+  if (hunks.length === 0) return "(no changes)";
+  const output = [
+    t.diffHeader(`--- a/${filePath}`),
+    t.diffHeader(`+++ b/${filePath}`)
+  ];
+  for (const hunk of hunks) {
+    output.push(t.diffHeader(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`));
+    for (const line of hunk.lines) {
+      if (line.startsWith("+")) {
+        output.push(t.diffAdd(line));
+      } else if (line.startsWith("-")) {
+        output.push(t.diffRemove(line));
+      } else {
+        output.push(t.dim(line));
+      }
+    }
+  }
+  return output.join("\n");
+}
+function computeHunks(oldLines, newLines, context = 3) {
+  const changes = [];
+  let oi = 0;
+  let ni = 0;
+  while (oi < oldLines.length || ni < newLines.length) {
+    if (oi < oldLines.length && ni < newLines.length && oldLines[oi] === newLines[ni]) {
+      changes.push({ type: "same", oldIdx: oi, newIdx: ni, line: oldLines[oi] });
+      oi++;
+      ni++;
+    } else {
+      const syncPoint = findSync(oldLines, newLines, oi, ni, 10);
+      if (syncPoint) {
+        while (oi < syncPoint.oi) {
+          changes.push({ type: "remove", oldIdx: oi, newIdx: ni, line: oldLines[oi] });
+          oi++;
+        }
+        while (ni < syncPoint.ni) {
+          changes.push({ type: "add", oldIdx: oi, newIdx: ni, line: newLines[ni] });
+          ni++;
+        }
+      } else {
+        while (oi < oldLines.length) {
+          changes.push({ type: "remove", oldIdx: oi, newIdx: ni, line: oldLines[oi] });
+          oi++;
+        }
+        while (ni < newLines.length) {
+          changes.push({ type: "add", oldIdx: oi, newIdx: ni, line: newLines[ni] });
+          ni++;
+        }
+      }
+    }
+  }
+  const hunks = [];
+  let currentHunk = null;
+  let contextRemaining = 0;
+  for (let i = 0; i < changes.length; i++) {
+    const c = changes[i];
+    if (c.type !== "same") {
+      if (!currentHunk) {
+        const start = Math.max(0, i - context);
+        currentHunk = {
+          oldStart: changes[start].oldIdx + 1,
+          oldCount: 0,
+          newStart: changes[start].newIdx + 1,
+          newCount: 0,
+          lines: []
+        };
+        for (let j = start; j < i; j++) {
+          currentHunk.lines.push(` ${changes[j].line}`);
+          currentHunk.oldCount++;
+          currentHunk.newCount++;
+        }
+      }
+      if (c.type === "remove") {
+        currentHunk.lines.push(`-${c.line}`);
+        currentHunk.oldCount++;
+      } else {
+        currentHunk.lines.push(`+${c.line}`);
+        currentHunk.newCount++;
+      }
+      contextRemaining = context;
+    } else if (currentHunk) {
+      if (contextRemaining > 0) {
+        currentHunk.lines.push(` ${c.line}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+        contextRemaining--;
+      } else {
+        hunks.push(currentHunk);
+        currentHunk = null;
+      }
+    }
+  }
+  if (currentHunk) hunks.push(currentHunk);
+  return hunks;
+}
+function findSync(oldLines, newLines, oi, ni, lookAhead) {
+  for (let d = 1; d <= lookAhead; d++) {
+    if (oi + d < oldLines.length && ni < newLines.length && oldLines[oi + d] === newLines[ni]) {
+      return { oi: oi + d, ni };
+    }
+    if (oi < oldLines.length && ni + d < newLines.length && oldLines[oi] === newLines[ni + d]) {
+      return { oi, ni: ni + d };
+    }
+    if (oi + d < oldLines.length && ni + d < newLines.length && oldLines[oi + d] === newLines[ni + d]) {
+      return { oi: oi + d, ni: ni + d };
+    }
+  }
+  return null;
+}
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { z as z9 } from "zod";
+var MCPClient = class {
+  constructor(config, serverName) {
+    this.config = config;
+    this.serverName = serverName;
+  }
+  process = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  serverName;
+  _tools = [];
+  /**
+   * Start the MCP server and initialize the connection.
+   */
+  async connect() {
+    this.process = spawn(this.config.command, this.config.args ?? [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.config.env },
+      cwd: this.config.cwd
+    });
+    this.process.stdout?.setEncoding("utf-8");
+    this.process.stdout?.on("data", (data) => {
+      this.buffer += data;
+      this.processBuffer();
+    });
+    this.process.on("error", (err) => {
+      for (const [id, pending] of this.pendingRequests) {
+        pending.reject(new Error(`MCP server ${this.serverName} 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}`));
+        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();
+      this.process.kill();
+      this.process = null;
+    }
+    this.pendingRequests.clear();
+  }
+  sendRequest(method, params) {
+    return new Promise((resolve2, reject) => {
+      const id = ++this.requestId;
+      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
+\r
+`;
+      this.process?.stdin?.write(header + data);
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`MCP request ${method} timed out`));
+        }
+      }, 3e4);
+    });
+  }
+  sendNotification(method, params) {
+    const msg = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    const data = JSON.stringify(msg);
+    const header = `Content-Length: ${Buffer.byteLength(data)}\r
+\r
+`;
+    this.process?.stdin?.write(header + data);
+  }
+  processBuffer() {
+    while (this.buffer.length > 0) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+      const header = this.buffer.slice(0, headerEnd);
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) {
+        const nlIdx = this.buffer.indexOf("\n");
+        if (nlIdx === -1) break;
+        const line = this.buffer.slice(0, nlIdx).trim();
+        this.buffer = this.buffer.slice(nlIdx + 1);
+        if (line) this.handleMessage(line);
+        continue;
+      }
+      const contentLength = parseInt(lengthMatch[1], 10);
+      const messageStart = headerEnd + 4;
+      if (this.buffer.length < messageStart + contentLength) break;
+      const body = this.buffer.slice(messageStart, messageStart + contentLength);
+      this.buffer = this.buffer.slice(messageStart + contentLength);
+      this.handleMessage(body);
+    }
+  }
+  handleMessage(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 error: ${msg.error.message}`));
+        } else {
+          pending.resolve(msg.result);
+        }
+      }
+    } catch {
+    }
+  }
+};
+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
+      };
+    }
+  }
+  return result;
+}
+
+// src/ui/completions.ts
+import fs17 from "fs";
+import path18 from "path";
+var COMMANDS = [
+  "/help",
+  "/quit",
+  "/exit",
+  "/q",
+  "/clear",
+  "/model",
+  "/models",
+  "/status",
+  "/undo",
+  "/usage",
+  "/compact",
+  "/diff",
+  "/export",
+  "/save",
+  "/sessions",
+  "/resume",
+  "/search",
+  "/memory",
+  "/permissions",
+  "/plan",
+  "/plan approve",
+  "/plan cancel",
+  "/plan edit",
+  "/theme",
+  "/themes",
+  "/mascot",
+  "/cost",
+  "/branch",
+  "/branches"
+];
+function buildCompleter(cwd) {
+  return function completer(line) {
+    if (line.startsWith("/")) {
+      const matches = COMMANDS.filter((c) => c.startsWith(line));
+      return [matches.length > 0 ? matches : COMMANDS, line];
+    }
+    if (line.startsWith("/model ")) {
+      const partial = line.slice(7);
+      const modelNames = MODEL_IDS.map((id) => id.replace("notch-", ""));
+      const allNames = [...MODEL_IDS, ...modelNames];
+      const matches = allNames.filter((m) => m.startsWith(partial));
+      return [matches.map((m) => `/model ${m}`), line];
+    }
+    if (line.startsWith("/theme ")) {
+      const partial = line.slice(7);
+      const matches = THEME_IDS.filter((t) => t.startsWith(partial));
+      return [matches.map((t) => `/theme ${t}`), line];
+    }
+    const atMatch = line.match(/@([^\s]*)$/);
+    if (atMatch) {
+      const partial = atMatch[1];
+      const completions = completeFilePath(partial, cwd);
+      return [completions.map((c) => line.slice(0, -partial.length) + c), line];
+    }
+    return [[], line];
+  };
+}
+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 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;
+        if (entry.isDirectory()) {
+          matches.push(relative + "/");
+        } else {
+          matches.push(relative);
+        }
+      }
+    }
+    return matches.slice(0, 20);
+  } catch {
+    return [];
+  }
+}
+
+// src/index.ts
+import fs18 from "fs/promises";
+var VERSION = "0.4.0";
+var modelChoices = MODEL_IDS.join(", ");
+var program = new Command().name("notch").description("Notch CLI \u2014 AI-powered coding assistant by Driftrail").version(VERSION).argument("[prompt...]", "One-shot prompt (runs once and exits)").option(`-m, --model <model>`, `Notch model (${modelChoices})`).option("--base-url <url>", "Override Notch API base URL").option("--api-key <key>", "Notch API key (prefer NOTCH_API_KEY env var)").option("--no-repo-map", "Disable automatic repository mapping").option("--no-markdown", "Disable markdown rendering in output").option("--max-iterations <n>", "Max tool-call rounds per turn", "25").option("-y, --yes", "Auto-confirm destructive actions").option("--trust", "Trust mode \u2014 auto-allow all tool calls").option("--theme <theme>", `UI color theme (${THEME_IDS.join(", ")})`).option("--resume", "Resume the last session for this project").option("--session <id>", "Resume a specific session by ID").option("--cwd <dir>", "Set working directory").parse(process.argv);
+var opts = program.opts();
+var promptArgs = program.args;
+function printModelTable(activeModel) {
+  const t = theme();
+  console.log(t.dim("\n  Available models:\n"));
+  for (const id of MODEL_IDS) {
+    const info = MODEL_CATALOG[id];
+    const active = id === activeModel ? t.success(" \u25CF") : "  ";
+    const label = id === activeModel ? t.bold(`${info.label}`) : t.dim(`${info.label}`);
+    const size = t.info(info.size.padEnd(4));
+    const ctx = t.dim(`${(info.contextWindow / 1024).toFixed(0)}K ctx`);
+    console.log(`  ${active} ${t.brand(id.padEnd(14))} ${size} ${label}  ${ctx}`);
+  }
+  console.log(t.dim(`
+  Switch with: /model <name>
+`));
+}
+function printHelp() {
+  console.log(chalk8.gray(`
+  Commands:
+    /model              \u2014 Show available models
+    /model <name>       \u2014 Switch model (e.g., /model pyre)
+    /status             \u2014 Check Notch API endpoint health
+    /undo               \u2014 Undo last file changes
+    /usage              \u2014 Show token usage + context meter
+    /cost               \u2014 Show estimated session cost
+    /compact            \u2014 Compress conversation history
+    /diff               \u2014 Show all file changes this session
+    /export [path]      \u2014 Export conversation to markdown
+    /save               \u2014 Save current session
+    /sessions           \u2014 List saved sessions
+    /resume [id]        \u2014 Resume a saved session
+    /search <query>     \u2014 Search conversation history
+
+  Planning & Agents:
+    /plan <task>        \u2014 Generate a step-by-step plan
+    /plan approve       \u2014 Approve and execute the plan
+    /plan cancel        \u2014 Discard the current plan
+    /agent <task>       \u2014 Spawn a background subagent
+
+  Memory & Config:
+    /memory             \u2014 List saved memories
+    /memory search <q>  \u2014 Search memories
+    /memory clear       \u2014 Delete all memories
+    /permissions        \u2014 Show current permission config
+
+  Ralph Wiggum Mode (autonomous):
+    /ralph plan <goal>  \u2014 Generate task plan for a goal
+    /ralph run          \u2014 Execute tasks (fresh context per task)
+    /ralph status       \u2014 Show plan progress
+    /ralph clear        \u2014 Discard plan
+
+  Other:
+    /branch             \u2014 Fork conversation at this point
+    /branches           \u2014 List conversation branches
+    /theme              \u2014 List available themes
+    /theme <name>       \u2014 Switch color theme
+    /mascot             \u2014 Show the Notch mantis
+    /clear              \u2014 Clear conversation history
+    /quit, /exit, /q    \u2014 Exit Notch (shows session usage)
+    /help               \u2014 Show this help
+
+  Inline References:
+    @path/to/file       \u2014 Inject file contents into prompt
+    @https://url.com    \u2014 Fetch and inject URL contents
+    @*.ts               \u2014 Inject all matching files (glob)
+
+  Pipe Mode:
+    cat file | notch "explain this"
+  `));
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data.trim() || null));
+    setTimeout(() => {
+      if (!data) resolve2(null);
+    }, 100);
+  });
+}
+async function main() {
+  if (promptArgs[0] === "login") {
+    const spinner = ora("Opening browser...").start();
+    try {
+      spinner.stop();
+      const creds = await login();
+      console.log(chalk8.green(`
+  \u2713 Signed in as ${creds.email}`));
+      console.log(chalk8.gray(`  API key stored in ${(await import("./auth-GTGBXOSH.js")).getCredentialsPath()}
+`));
+    } catch (err) {
+      spinner.stop();
+      console.error(chalk8.red(`
+  Login failed: ${err.message}
+`));
+      process.exit(1);
+    }
+    return;
+  }
+  if (promptArgs[0] === "logout") {
+    const creds = await loadCredentials();
+    if (!creds) {
+      console.log(chalk8.gray("\n  Not signed in.\n"));
+    } else {
+      await clearCredentials();
+      console.log(chalk8.green(`
+  \u2713 Signed out (${creds.email})
+`));
+    }
+    return;
+  }
+  if (promptArgs[0] === "whoami") {
+    const creds = await loadCredentials();
+    if (!creds) {
+      console.log(chalk8.gray("\n  Not signed in. Run: notch login\n"));
+    } else {
+      const keyPreview = `${creds.token.slice(0, 12)}...`;
+      console.log(chalk8.gray(`
+  Signed in as ${chalk8.white(creds.email)}`));
+      console.log(chalk8.gray(`  Key: ${keyPreview}`));
+      console.log(chalk8.gray(`  Since: ${new Date(creds.createdAt).toLocaleDateString()}
+`));
+    }
+    return;
+  }
+  if (promptArgs[0] === "init") {
+    await initProject(opts.cwd ?? process.cwd());
+    return;
+  }
+  if (promptArgs[0] === "ralph") {
+    await handleRalphSubcommand(promptArgs.slice(1), opts);
+    return;
+  }
+  const configOverrides = {};
+  if (opts.cwd) configOverrides.projectRoot = opts.cwd;
+  if (opts.yes) configOverrides.autoConfirm = true;
+  if (opts.trust) configOverrides.permissionMode = "trust";
+  if (opts.maxIterations) configOverrides.maxIterations = parseInt(opts.maxIterations, 10);
+  if (opts.noRepoMap === false) configOverrides.useRepoMap = false;
+  if (opts.noMarkdown === false) configOverrides.renderMarkdown = false;
+  if (opts.theme) configOverrides.theme = opts.theme;
+  const config = await loadConfig(configOverrides);
+  if (opts.model) {
+    if (!isValidModel(opts.model)) {
+      console.error(chalk8.red(`  Unknown model: ${opts.model}`));
+      console.error(chalk8.gray(`  Available: ${modelChoices}`));
+      process.exit(1);
+    }
+    config.models.chat.model = opts.model;
+  }
+  if (opts.baseUrl) config.models.chat.baseUrl = opts.baseUrl;
+  if (opts.apiKey) config.models.chat.apiKey = opts.apiKey;
+  if (config.theme && isValidTheme(config.theme)) {
+    setTheme(config.theme);
+  }
+  let activeModelId = config.models.chat.model;
+  let model = resolveModel(config.models.chat);
+  const info = MODEL_CATALOG[activeModelId];
+  printBanner(VERSION, info.label, info.id, info.size, config.projectRoot);
+  checkForUpdates(VERSION).then((msg) => {
+    if (msg) console.log(msg);
+  });
+  const hookTrustPrompt = async (commands) => {
+    console.warn(chalk8.yellow("\n\u26A0  This project contains hooks in .notch.json that will run shell commands:"));
+    commands.forEach((cmd) => console.warn(chalk8.gray(`   \u2022 ${cmd}`)));
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve2) => {
+      rl2.question(chalk8.yellow("\nAllow these hooks for this project? [y/N] "), (answer) => {
+        rl2.close();
+        resolve2(answer.trim().toLowerCase() === "y");
+      });
+    });
+  };
+  const [permissions, hookConfig] = await Promise.all([
+    loadPermissions(config.projectRoot),
+    config.enableHooks ? loadHooks(config.projectRoot, hookTrustPrompt) : Promise.resolve({ hooks: [] })
+  ]);
+  let repoMapStr = "";
+  if (config.useRepoMap) {
+    const spinner = ora("Mapping repository...").start();
+    try {
+      const repoMap = await buildRepoMap(config.projectRoot);
+      repoMapStr = condensedRepoMap(repoMap);
+      spinner.succeed(`Mapped ${repoMap.entries.length} source files`);
+    } catch {
+      spinner.warn("Could not build repo map");
+    }
+  }
+  const baseSystemPrompt = await buildSystemPrompt(config.projectRoot);
+  const systemPrompt = [
+    baseSystemPrompt,
+    repoMapStr ? `
+## Repository Map
+${repoMapStr}` : ""
+  ].join("");
+  const checkpoints = new CheckpointManager();
+  const usage = new UsageTracker();
+  let sessionId;
+  let activePlan = null;
+  const branches = /* @__PURE__ */ new Map();
+  let currentBranch = "main";
+  const costTracker = new CostTracker();
+  const mcpClients = [];
+  try {
+    const configRaw = await fs18.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(chalk8.green(`  MCP: Connected to ${name} (${client.tools.length} tools)`));
+      } catch (err) {
+        console.log(chalk8.yellow(`  MCP: Could not connect to ${name}: ${err.message}`));
+      }
+    }
+  } catch {
+  }
+  const toolCtx = {
+    cwd: config.projectRoot,
+    requireConfirm: config.permissionMode !== "trust" && !config.autoConfirm,
+    confirm: async (message) => {
+      const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      return new Promise((resolve2) => {
+        rl2.question(`${message} (y/N) `, (answer) => {
+          rl2.close();
+          resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+      });
+    },
+    log: (msg) => console.log(chalk8.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;
+      const { results } = await runHooks(hookConfig, event, {
+        cwd: config.projectRoot,
+        ...ctx
+      });
+      for (const r of results) {
+        if (!r.ok) {
+          console.log(chalk8.yellow(`  Hook failed (${r.hook.event}): ${r.error}`));
+        }
+      }
+    }
+  };
+  await toolCtx.runHook?.("session-start", {});
+  const messages = [];
+  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(chalk8.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+`));
+    } else {
+      console.log(chalk8.gray("  No session to resume.\n"));
+    }
+  }
+  const pipedInput = await readStdin();
+  const oneShot = promptArgs.join(" ").trim();
+  if (oneShot || pipedInput) {
+    let prompt = oneShot;
+    if (pipedInput) {
+      const stdinContext = `<stdin>
+${pipedInput.slice(0, 5e4)}
+</stdin>`;
+      prompt = prompt ? `${stdinContext}
+
+${prompt}` : `${stdinContext}
+
+Analyze the above input.`;
+    }
+    const { cleanInput, references } = await resolveReferences(prompt, config.projectRoot);
+    const refContext = formatReferences(references);
+    const finalPrompt = refContext + cleanInput;
+    messages.push({ role: "user", content: finalPrompt });
+    console.log(chalk8.cyan(`> ${oneShot || "(piped input)"}
+`));
+    if (references.length > 0) {
+      console.log(chalk8.gray(`  Injected ${references.length} reference(s)
+`));
+    }
+    const spinner = ora("Thinking...").start();
+    try {
+      const response = await withRetry(
+        () => runAgentLoop(messages, {
+          model,
+          systemPrompt,
+          toolContext: toolCtx,
+          maxIterations: config.maxIterations,
+          contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+          onTextChunk: (chunk) => {
+            if (spinner.isSpinning) spinner.stop();
+            process.stdout.write(chunk);
+          },
+          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(chalk8.gray(`
+  \u2192 ${name}(${argSummary})`));
+          },
+          onToolResult: (_name, result, isError) => {
+            const preview = result.slice(0, 100).replace(/\n/g, " ");
+            const icon = isError ? chalk8.red("\u2717") : chalk8.green("\u2713");
+            console.log(chalk8.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
+          }
+        })
+      );
+      console.log("\n");
+      if (response.usage) {
+        usage.record({
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens,
+          totalTokens: response.usage.totalTokens,
+          model: activeModelId
+        });
+        costTracker.record(activeModelId, response.usage.promptTokens, response.usage.completionTokens);
+        console.log(usage.formatLast());
+      }
+    } catch (err) {
+      spinner.fail(`Error: ${err.message}`);
+    }
+    process.exit(0);
+  }
+  let ralphPlan = null;
+  try {
+    const savedPlan = await loadPlan(config.projectRoot);
+    if (savedPlan) {
+      ralphPlan = savedPlan;
+      console.log(chalk8.gray(`  Ralph plan loaded (${savedPlan.tasks.length} tasks)
+`));
+    }
+  } catch {
+  }
+  const completer = buildCompleter(config.projectRoot);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: theme().prompt("notch> "),
+    completer: (line) => completer(line)
+  });
+  console.log(chalk8.gray("  Type your request, or /help for commands.\n"));
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    if (input === "/quit" || input === "/exit" || input === "/q") {
+      if (usage.turnCount > 0) {
+        console.log(usage.formatSession());
+        console.log(costTracker.formatTotal());
+      }
+      if (messages.length > 0) {
+        try {
+          const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
+          console.log(chalk8.gray(`  Session saved: ${id}`));
+        } catch {
+        }
+      }
+      for (const client of mcpClients) {
+        try {
+          await client.disconnect();
+        } catch {
+        }
+      }
+      await toolCtx.runHook?.("session-end", {});
+      console.log(chalk8.gray("\n  Goodbye!\n"));
+      process.exit(0);
+    }
+    if (input === "/clear") {
+      messages.length = 0;
+      console.log(chalk8.gray("  Conversation cleared.\n"));
+      rl.prompt();
+      return;
+    }
+    if (input === "/help") {
+      printHelp();
+      rl.prompt();
+      return;
+    }
+    if (input === "/model" || input === "/models") {
+      printModelTable(activeModelId);
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/model ")) {
+      let newModel = input.replace("/model ", "").trim();
+      if (!newModel.startsWith("notch-")) {
+        newModel = `notch-${newModel}`;
+      }
+      if (!isValidModel(newModel)) {
+        console.log(chalk8.red(`  Unknown model: ${newModel}`));
+        console.log(chalk8.gray(`  Available: ${modelChoices}`));
+        rl.prompt();
+        return;
+      }
+      activeModelId = newModel;
+      config.models.chat.model = activeModelId;
+      model = resolveModel(config.models.chat);
+      const switchedInfo = MODEL_CATALOG[activeModelId];
+      console.log(chalk8.green(`  Switched to ${switchedInfo.label} (${switchedInfo.id}, ${switchedInfo.size})
+`));
+      rl.prompt();
+      return;
+    }
+    if (input === "/status") {
+      const statusSpinner = ora("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(chalk8.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(chalk8.gray("  Nothing to undo.\n"));
+        rl.prompt();
+        return;
+      }
+      const undone = await checkpoints.undo();
+      if (undone) {
+        const fileCount = undone.files.length;
+        console.log(chalk8.yellow(`  Undid "${undone.description}" (${fileCount} file${fileCount !== 1 ? "s" : ""} restored)`));
+        console.log(chalk8.gray(`  ${checkpoints.undoCount} checkpoint${checkpoints.undoCount !== 1 ? "s" : ""} remaining
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/usage") {
+      if (usage.turnCount === 0) {
+        console.log(chalk8.gray("  No usage yet.\n"));
+      } else {
+        console.log(usage.formatSession());
+        const currentTokens = estimateTokens(messages);
+        const ctxWindow = MODEL_CATALOG[activeModelId].contextWindow;
+        console.log(renderContextMeter(currentTokens, ctxWindow));
+        console.log("");
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/cost") {
+      if (costTracker.totalCost === 0) {
+        console.log(chalk8.gray("  No cost data yet.\n"));
+      } else {
+        console.log(costTracker.formatTotal());
+        console.log(costTracker.formatByModel());
+        console.log("");
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/compact") {
+      const { autoCompress: autoCompress2 } = await import("./compression-AGHTZF7D.js");
+      const before = messages.length;
+      const compressed = await autoCompress2(messages, model, MODEL_CATALOG[activeModelId].contextWindow);
+      messages.length = 0;
+      messages.push(...compressed);
+      console.log(chalk8.green(`  Compressed: ${before} messages \u2192 ${messages.length} messages`));
+      console.log("");
+      rl.prompt();
+      return;
+    }
+    if (input === "/diff") {
+      const diffs = checkpoints.allDiffs();
+      if (diffs.length === 0) {
+        console.log(chalk8.gray("  No file changes this session.\n"));
+      } else {
+        for (const df of diffs) {
+          console.log(chalk8.cyan(`  ${df.path}:`));
+          console.log(unifiedDiff(df.before, df.after, df.path));
+          console.log("");
+        }
+      }
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/export")) {
+      const exportPath = input.replace("/export", "").trim() || void 0;
+      try {
+        const ePath = await exportSession(messages, {
+          model: activeModelId,
+          projectRoot: config.projectRoot,
+          outputPath: exportPath
+        });
+        console.log(chalk8.green(`  Exported to ${ePath}
+`));
+      } catch (err) {
+        console.log(chalk8.red(`  Export failed: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/save") {
+      try {
+        const id = await saveSession(config.projectRoot, messages, { model: activeModelId });
+        sessionId = id;
+        console.log(chalk8.green(`  Session saved: ${id}
+`));
+      } catch (err) {
+        console.log(chalk8.red(`  Save failed: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/sessions") {
+      try {
+        const sessions = await listSessions(config.projectRoot);
+        if (sessions.length === 0) {
+          console.log(chalk8.gray("  No saved sessions.\n"));
+        } else {
+          console.log(chalk8.gray("\n  Saved sessions:\n"));
+          for (const s of sessions.slice(0, 10)) {
+            console.log(chalk8.gray(`    ${s.id}  ${s.turns} turns  ${s.date}  ${s.model}`));
+          }
+          console.log("");
+        }
+      } catch (err) {
+        console.log(chalk8.red(`  Error listing sessions: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/resume")) {
+      const resumeId = input.replace("/resume", "").trim() || void 0;
+      try {
+        const session = resumeId ? await loadSession(resumeId) : await loadLastSession(config.projectRoot);
+        if (session) {
+          messages.length = 0;
+          messages.push(...session.messages);
+          sessionId = session.meta.id;
+          try {
+            const savedPlan = await loadPlan(config.projectRoot);
+            if (savedPlan) {
+              ralphPlan = savedPlan;
+              console.log(chalk8.green(`  Ralph plan restored (${savedPlan.tasks.length} tasks)
+`));
+            }
+          } catch {
+          }
+          console.log(chalk8.green(`  Resumed session ${session.meta.id} (${session.meta.turns} turns)
+`));
+        } else {
+          console.log(chalk8.gray("  No session found.\n"));
+        }
+      } catch (err) {
+        console.log(chalk8.red(`  Resume failed: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/search ")) {
+      const query = input.replace("/search ", "").trim().toLowerCase();
+      if (!query) {
+        console.log(chalk8.gray("  Usage: /search <query>\n"));
+        rl.prompt();
+        return;
+      }
+      const matches = [];
+      for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const text = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.map((p) => p.text || p.result || "").join(" ") : "";
+        if (text.toLowerCase().includes(query)) {
+          matches.push({
+            index: i,
+            role: msg.role,
+            preview: text.slice(0, 120).replace(/\n/g, " ")
+          });
+        }
+      }
+      if (matches.length === 0) {
+        console.log(chalk8.gray(`  No matches for "${query}"
+`));
+      } else {
+        console.log(chalk8.gray(`
+  ${matches.length} match(es) for "${query}":
+`));
+        for (const m of matches.slice(0, 10)) {
+          console.log(chalk8.gray(`    [${m.index}] ${m.role}: ${m.preview}`));
+        }
+        console.log("");
+      }
+      rl.prompt();
+      return;
+    }
+    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();
+      try {
+        activePlan = await generatePlan(task, model, systemPrompt);
+        planSpinner.succeed("Plan generated");
+        console.log(formatPlan(activePlan));
+        console.log(chalk8.gray("  Use /plan approve to execute, /plan edit to modify, or /plan cancel to discard.\n"));
+      } catch (err) {
+        planSpinner.fail(`Plan failed: ${err.message}`);
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/plan approve") {
+      if (!activePlan) {
+        console.log(chalk8.gray("  No active plan. Use /plan <task> to create one.\n"));
+        rl.prompt();
+        return;
+      }
+      console.log(chalk8.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();
+        try {
+          const response = await runAgentLoop(messages, {
+            model,
+            systemPrompt,
+            toolContext: toolCtx,
+            maxIterations: config.maxIterations,
+            contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+            onTextChunk: (chunk) => {
+              if (planStepSpinner.isSpinning) planStepSpinner.stop();
+              process.stdout.write(chunk);
+            },
+            onToolCall: (name) => {
+              if (planStepSpinner.isSpinning) planStepSpinner.stop();
+              console.log(chalk8.gray(`  \u2192 ${name}`));
+            },
+            onToolResult: (_name, _result, isError) => {
+              console.log(isError ? chalk8.red("    \u2717") : chalk8.green("    \u2713"));
+            }
+          });
+          console.log("\n");
+          messages.length = 0;
+          messages.push(...response.messages);
+          activePlan = advancePlan(activePlan);
+        } catch (err) {
+          planStepSpinner.fail(`Step failed: ${err.message}`);
+          break;
+        }
+      }
+      if (activePlan && isPlanComplete(activePlan)) {
+        console.log(chalk8.green("  Plan completed!\n"));
+      }
+      activePlan = null;
+      rl.prompt();
+      return;
+    }
+    if (input === "/plan edit") {
+      if (!activePlan) {
+        console.log(chalk8.gray("  No active plan to edit.\n"));
+        rl.prompt();
+        return;
+      }
+      console.log(formatPlan(activePlan));
+      console.log(chalk8.gray("  Type a modified plan description and use /plan <new task> to regenerate,"));
+      console.log(chalk8.gray("  or /plan approve to proceed with the current plan.\n"));
+      rl.prompt();
+      return;
+    }
+    if (input === "/plan cancel") {
+      activePlan = null;
+      console.log(chalk8.gray("  Plan discarded.\n"));
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/agent ")) {
+      const task = input.replace("/agent ", "").trim();
+      const agentId = nextSubagentId();
+      console.log(chalk8.cyan(`  Spawning subagent #${agentId}: ${task}
+`));
+      spawnSubagent({
+        id: agentId,
+        task,
+        model,
+        systemPrompt,
+        toolContext: toolCtx,
+        contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+        onComplete: (result) => {
+          console.log(chalk8.green(`
+  Subagent #${agentId} finished:`));
+          console.log(chalk8.gray(`  ${result.slice(0, 200)}
+`));
+          rl.prompt();
+        },
+        onError: (err) => {
+          console.log(chalk8.red(`
+  Subagent #${agentId} failed: ${err}
+`));
+          rl.prompt();
+        }
+      });
+      rl.prompt();
+      return;
+    }
+    if (input === "/memory") {
+      try {
+        const memories = await loadMemories(config.projectRoot);
+        if (memories.length === 0) {
+          console.log(chalk8.gray("  No saved memories.\n"));
+        } else {
+          console.log(chalk8.gray(`
+  ${memories.length} saved memories:
+`));
+          for (const m of memories) {
+            console.log(chalk8.gray(`    [${m.type}] ${m.content.slice(0, 80)}`));
+          }
+          console.log("");
+        }
+      } catch (err) {
+        console.log(chalk8.red(`  Error: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/memory search ")) {
+      const query = input.replace("/memory search ", "").trim();
+      try {
+        const results = await searchMemories(config.projectRoot, query);
+        if (results.length === 0) {
+          console.log(chalk8.gray(`  No memories matching "${query}"
+`));
+        } else {
+          for (const m of results) {
+            console.log(chalk8.gray(`    [${m.type}] ${m.content.slice(0, 100)}`));
+          }
+          console.log("");
+        }
+      } catch (err) {
+        console.log(chalk8.red(`  Error: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/memory clear") {
+      try {
+        const memories = await loadMemories(config.projectRoot);
+        for (const m of memories) {
+          await deleteMemory(config.projectRoot, m.id);
+        }
+        console.log(chalk8.yellow(`  Cleared ${memories.length} memories.
+`));
+      } catch (err) {
+        console.log(chalk8.red(`  Error: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/permissions") {
+      console.log(formatPermissions(permissions));
+      console.log("");
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/ralph plan ")) {
+      const goal = input.replace("/ralph plan ", "").trim();
+      const planSpinner = ora("Ralph is planning...").start();
+      try {
+        ralphPlan = await generateRalphPlan(goal, model, systemPrompt);
+        await savePlan(config.projectRoot, ralphPlan);
+        planSpinner.succeed(`Ralph planned ${ralphPlan.tasks.length} tasks`);
+        console.log(formatRalphStatus(ralphPlan));
+      } catch (err) {
+        planSpinner.fail(`Ralph planning failed: ${err.message}`);
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/ralph run") {
+      if (!ralphPlan) {
+        console.log(chalk8.gray("  No Ralph plan. Use /ralph plan <goal> first.\n"));
+        rl.prompt();
+        return;
+      }
+      console.log(chalk8.green("  Ralph is running...\n"));
+      try {
+        ralphPlan = await runRalphLoop(ralphPlan, {
+          model,
+          systemPrompt,
+          toolContext: toolCtx,
+          contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+          onTaskStart: (task) => console.log(chalk8.cyan(`  \u25B6 Task: ${task.description}`)),
+          onTaskComplete: (task) => console.log(chalk8.green(`  \u2713 Done: ${task.description}
+`)),
+          onTaskFail: (task, err) => console.log(chalk8.red(`  \u2717 Failed: ${task.description} (${err})
+`))
+        });
+        await savePlan(config.projectRoot, ralphPlan);
+        console.log(formatRalphStatus(ralphPlan));
+      } catch (err) {
+        console.log(chalk8.red(`  Ralph error: ${err.message}
+`));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/ralph status") {
+      if (!ralphPlan) {
+        console.log(chalk8.gray("  No Ralph plan active.\n"));
+      } else {
+        console.log(formatRalphStatus(ralphPlan));
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/ralph clear") {
+      ralphPlan = null;
+      await deletePlan(config.projectRoot).catch(() => {
+      });
+      console.log(chalk8.gray("  Ralph plan cleared.\n"));
+      rl.prompt();
+      return;
+    }
+    if (input === "/branch") {
+      const branchId = `branch-${branches.size + 1}`;
+      branches.set(branchId, [...messages]);
+      console.log(chalk8.green(`  Forked conversation as "${branchId}" (${messages.length} messages)
+`));
+      rl.prompt();
+      return;
+    }
+    if (input === "/branches") {
+      if (branches.size === 0) {
+        console.log(chalk8.gray("  No conversation branches. Use /branch to fork.\n"));
+      } else {
+        console.log(chalk8.gray("\n  Branches:\n"));
+        for (const [name, msgs] of branches) {
+          const marker = name === currentBranch ? chalk8.green(" \u25CF") : "  ";
+          console.log(chalk8.gray(`  ${marker} ${name}  (${msgs.length} messages)`));
+        }
+        console.log("");
+      }
+      rl.prompt();
+      return;
+    }
+    if (input === "/theme" || input === "/themes") {
+      console.log(formatThemeList(themeId()));
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/theme ")) {
+      const newTheme = input.replace("/theme ", "").trim();
+      if (!isValidTheme(newTheme)) {
+        const t2 = theme();
+        console.log(t2.error(`  Unknown theme: ${newTheme}`));
+        console.log(t2.dim(`  Available: ${THEME_IDS.join(", ")}
+`));
+        rl.prompt();
+        return;
+      }
+      setTheme(newTheme);
+      const t = theme();
+      console.log(t.success(`  Switched to "${t.name}" theme`));
+      console.log(t.dim(`  ${THEME_IDS.length} themes available. Use /theme to browse.
+`));
+      rl.setPrompt(t.prompt("notch> "));
+      rl.prompt();
+      return;
+    }
+    if (input === "/mascot") {
+      printMantis();
+      rl.prompt();
+      return;
+    }
+    if (input.startsWith("/")) {
+      console.log(chalk8.red(`  Unknown command: ${input}`));
+      console.log(chalk8.gray("  Type /help for available commands.\n"));
+      rl.prompt();
+      return;
+    }
+    const { cleanInput, references } = await resolveReferences(input, config.projectRoot);
+    const refContext = formatReferences(references);
+    const finalPrompt = refContext + cleanInput;
+    if (references.length > 0) {
+      console.log(chalk8.gray(`  Injected ${references.length} reference(s)`));
+    }
+    messages.push({ role: "user", content: finalPrompt });
+    const spinner = ora("Thinking...").start();
+    try {
+      const response = await withRetry(
+        () => runAgentLoop(messages, {
+          model,
+          systemPrompt,
+          toolContext: toolCtx,
+          maxIterations: config.maxIterations,
+          contextWindow: MODEL_CATALOG[activeModelId].contextWindow,
+          onTextChunk: (chunk) => {
+            if (spinner.isSpinning) spinner.stop();
+            process.stdout.write(chunk);
+          },
+          onToolCall: (name, args) => {
+            if (spinner.isSpinning) spinner.stop();
+            if ((name === "write" || name === "edit") && typeof args.path === "string") {
+              const filePath = nodePath.isAbsolute(args.path) ? args.path : nodePath.resolve(toolCtx.cwd, args.path);
+              checkpoints.recordBefore(filePath);
+            }
+            const argSummary = Object.entries(args).map(([k, v]) => {
+              const val = String(v);
+              return `${k}=${val.length > 60 ? val.slice(0, 60) + "..." : val}`;
+            }).join(", ");
+            console.log(chalk8.gray(`
+  \u2192 ${name}(${argSummary})`));
+          },
+          onToolResult: (_name, result, isError) => {
+            const preview = result.slice(0, 100).replace(/\n/g, " ");
+            const icon = isError ? chalk8.red("\u2717") : chalk8.green("\u2713");
+            console.log(chalk8.gray(`    ${icon} ${preview}${result.length > 100 ? "..." : ""}`));
+          },
+          onCompress: () => {
+            console.log(chalk8.yellow("\n  [Context compressed to fit window]\n"));
+          }
+        })
+      );
+      console.log("\n");
+      checkpoints.commit(`Turn ${usage.turnCount + 1}`);
+      if (response.usage) {
+        usage.record({
+          promptTokens: response.usage.promptTokens,
+          completionTokens: response.usage.completionTokens,
+          totalTokens: response.usage.totalTokens,
+          model: activeModelId
+        });
+        costTracker.record(activeModelId, response.usage.promptTokens, response.usage.completionTokens);
+        console.log(usage.formatLast());
+        const currentTokens = estimateTokens(messages);
+        const ctxWindow = MODEL_CATALOG[activeModelId].contextWindow;
+        if (currentTokens > ctxWindow * 0.5) {
+          console.log(compactContextIndicator(currentTokens, ctxWindow));
+        }
+      }
+      console.log("");
+      messages.length = 0;
+      messages.push(...response.messages);
+      const lastText = response.text;
+      if (lastText.includes("[MEMORY:") || lastText.includes("[memory:")) {
+        const memMatch = lastText.match(/\[(?:MEMORY|memory):\s*([^\]]+)\]/);
+        if (memMatch) {
+          try {
+            await saveMemory(config.projectRoot, {
+              type: "auto",
+              content: memMatch[1]
+            });
+            console.log(chalk8.gray("  (Saved to memory)\n"));
+          } catch {
+          }
+        }
+      }
+    } catch (err) {
+      spinner.fail(`Error: ${err.message}`);
+      checkpoints.discard();
+      const msg = err.message?.toLowerCase() ?? "";
+      if (msg.includes("fetch") || msg.includes("econnrefused") || msg.includes("network")) {
+        console.log(chalk8.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(chalk8.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(chalk8.gray("  Tip: Rate limited. Wait a moment and try again.\n"));
+      } else {
+        console.log(chalk8.gray("  (The conversation history is preserved. Try again.)\n"));
+      }
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+async function handleRalphSubcommand(args, cliOpts) {
+  const config = await loadConfig(cliOpts.cwd ? { projectRoot: cliOpts.cwd } : {});
+  if (cliOpts.model) config.models.chat.model = cliOpts.model;
+  const model = resolveModel(config.models.chat);
+  const systemPrompt = await buildSystemPrompt(config.projectRoot);
+  const toolCtx = {
+    cwd: config.projectRoot,
+    requireConfirm: false,
+    confirm: async () => true,
+    log: (msg) => console.log(chalk8.gray(`  ${msg}`))
+  };
+  const subcommand = args[0];
+  if (subcommand === "plan") {
+    const goal = args.slice(1).join(" ");
+    if (!goal) {
+      console.error(chalk8.red("  Usage: notch ralph plan <goal>"));
+      process.exit(1);
+    }
+    const spinner = ora("Ralph is planning...").start();
+    const plan = await generateRalphPlan(goal, model, systemPrompt);
+    await savePlan(config.projectRoot, plan);
+    spinner.succeed(`Planned ${plan.tasks.length} tasks`);
+    console.log(formatRalphStatus(plan));
+  } else if (subcommand === "run") {
+    let plan = await loadPlan(config.projectRoot);
+    if (!plan) {
+      console.error(chalk8.red("  No plan found. Run: notch ralph plan <goal>"));
+      process.exit(1);
+    }
+    plan = await runRalphLoop(plan, {
+      model,
+      systemPrompt,
+      toolContext: toolCtx,
+      contextWindow: MODEL_CATALOG[config.models.chat.model].contextWindow,
+      onTaskStart: (t) => console.log(chalk8.cyan(`  \u25B6 ${t.description}`)),
+      onTaskComplete: (t) => console.log(chalk8.green(`  \u2713 ${t.description}`)),
+      onTaskFail: (t, e) => console.log(chalk8.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(chalk8.gray("  No Ralph plan found."));
+    } else {
+      console.log(formatRalphStatus(plan));
+    }
+  } else {
+    console.error(chalk8.red(`  Unknown: notch ralph ${subcommand}`));
+    console.error(chalk8.gray("  Usage: notch ralph <plan|run|status>"));
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(chalk8.red(`
+Fatal: ${err.message}
+`));
+  process.exit(1);
+});