@hasna/coders 0.0.15 → 0.1.0

package/dist/cli.mjs

@@ -58441,7 +58441,7 @@ var init_client = __esm({
           "Content-Type": "application/json",
           "anthropic-version": "2023-06-01",
           "anthropic-beta": BETA_HEADERS.join(","),
-          "User-Agent": `coders/${"0.0.15"}`
+          "User-Agent": `coders/${"0.1.0"}`
         };
         if (key.isOAuth) {
           headers["Authorization"] = `Bearer ${key.apiKey}`;
@@ -58639,237 +58639,680 @@ var init_client = __esm({
   }
 });
 
-// src/ui/screen/terminal.ts
-var terminal_exports = {};
-__export(terminal_exports, {
-  detectTerminal: () => detectTerminal,
-  getTerminalSize: () => getTerminalSize,
-  onResize: () => onResize
-});
-function detectTerminal() {
-  const termProgram = process.env.TERM_PROGRAM ?? "";
-  const term = process.env.TERM ?? "";
-  const colorTerm = process.env.COLORTERM ?? "";
-  const caps = {
-    name: detectTerminalName(termProgram, term),
-    colorDepth: detectColorDepth(termProgram, colorTerm, term),
-    unicode: detectUnicode(),
-    hyperlinks: detectHyperlinks(termProgram),
-    kittyProtocol: detectKittyProtocol(termProgram),
-    mouseSupport: true,
-    // Most modern terminals support SGR mouse
-    sixelGraphics: detectSixel(termProgram),
-    iterm2Images: termProgram === "iTerm.app"
-  };
-  return caps;
-}
-function detectTerminalName(termProgram, term) {
-  if (termProgram === "iTerm.app") return "iTerm2";
-  if (termProgram === "WezTerm") return "WezTerm";
-  if (termProgram === "vscode") return "VSCode";
-  if (termProgram === "Alacritty") return "Alacritty";
-  if (termProgram === "ghostty") return "Ghostty";
-  if (termProgram === "contour") return "Contour";
-  if (termProgram === "mintty") return "Mintty";
-  if (process.env.KITTY_WINDOW_ID) return "Kitty";
-  if (termProgram === "kitty") return "Kitty";
-  if (term === "foot" || term === "foot-extra") return "foot";
-  if (process.env.WARP_IS_LOCAL_SHELL_SESSION) return "Warp";
-  if (termProgram === "Warp") return "Warp";
-  if (process.env.WT_SESSION) return "Windows Terminal";
-  if (process.env.ConEmuANSI || process.env.ConEmuPID) return "ConEmu";
-  const vteVersion = process.env.VTE_VERSION;
-  if (vteVersion) {
-    const ver = parseInt(vteVersion, 10);
-    if (ver >= 6800) return "VTE (modern)";
-    return "VTE";
-  }
-  if (term.startsWith("xterm")) return "xterm";
-  if (term.startsWith("screen")) return "screen";
-  if (term.startsWith("tmux")) return "tmux";
-  return "unknown";
-}
-function detectColorDepth(termProgram, colorTerm, term) {
-  if (colorTerm === "truecolor" || colorTerm === "24bit") return 24;
-  const truecolorTerminals = [
-    "iTerm.app",
-    "WezTerm",
-    "Alacritty",
-    "kitty",
-    "ghostty",
-    "contour",
-    "foot"
-  ];
-  if (truecolorTerminals.includes(termProgram)) return 24;
-  if (process.env.KITTY_WINDOW_ID) return 24;
-  if (process.env.WT_SESSION) return 24;
-  if (termProgram === "vscode") return 24;
-  if (term.includes("256color")) return 8;
-  if (colorTerm) return 8;
-  if (term.includes("color") || term.startsWith("xterm")) return 4;
-  if (term === "dumb" || !process.stdout.isTTY) return 1;
-  return 4;
-}
-function detectUnicode() {
-  const lang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LC_CTYPE ?? "";
-  return lang.toLowerCase().includes("utf");
-}
-function detectHyperlinks(termProgram) {
-  const supported = [
-    "iTerm.app",
-    "WezTerm",
-    "Alacritty",
-    "kitty",
-    "ghostty",
-    "contour",
-    "foot",
-    "vscode"
-  ];
-  if (supported.includes(termProgram)) return true;
-  if (process.env.KITTY_WINDOW_ID) return true;
-  if (process.env.WT_SESSION) return true;
-  return false;
-}
-function detectKittyProtocol(termProgram) {
-  if (process.env.KITTY_WINDOW_ID) return true;
-  if (termProgram === "kitty") return true;
-  if (termProgram === "ghostty") return true;
-  if (termProgram === "foot") return true;
-  if (termProgram === "WezTerm") return true;
-  return false;
-}
-function detectSixel(termProgram) {
-  if (termProgram === "WezTerm") return true;
-  if (termProgram === "foot") return true;
-  if (termProgram === "contour") return true;
-  return false;
-}
-function getTerminalSize() {
-  return {
-    columns: process.stdout.columns ?? 80,
-    rows: process.stdout.rows ?? 24
-  };
-}
-function onResize(callback) {
-  const handler = () => {
-    const { columns, rows } = getTerminalSize();
-    callback(columns, rows);
-  };
-  process.stdout.on("resize", handler);
-  return () => process.stdout.removeListener("resize", handler);
+// src/db/index.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+function getDbPath() {
+  const dir = getConfigDir();
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  return join2(dir, "coders.db");
 }
-var init_terminal = __esm({
-  "src/ui/screen/terminal.ts"() {
-    "use strict";
+function getDb() {
+  if (_db) return _db;
+  const dbPath = getDbPath();
+  try {
+    const { Database } = __require("bun:sqlite");
+    _db = new Database(dbPath);
+  } catch {
+    try {
+      const BetterSqlite3 = __require("better-sqlite3");
+      _db = new BetterSqlite3(dbPath);
+    } catch {
+      _db = createJsonFileDb();
+      initSchema(_db);
+      return _db;
+    }
   }
-});
-
-// src/core/slash-commands.ts
-function registerSlashCommand(cmd) {
-  commands.set(cmd.name, cmd);
-  if (cmd.aliases) {
-    for (const alias of cmd.aliases) commands.set(alias, cmd);
+  try {
+    _db.exec("PRAGMA journal_mode=WAL");
+  } catch {
   }
-}
-function getAllSlashCommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const cmd of commands.values()) {
-    if (!seen.has(cmd.name)) {
-      seen.add(cmd.name);
-      result.push(cmd);
-    }
+  try {
+    _db.exec("PRAGMA foreign_keys=ON");
+  } catch {
   }
-  return result;
-}
-function isSlashCommand(input) {
-  return input.startsWith("/") && commands.has(input.slice(1).split(/\s/)[0]);
-}
-async function executeSlashCommand(input) {
-  const parts = input.replace(/^\//, "").split(/\s+/);
-  const name = parts[0];
-  const args = parts.slice(1).join(" ");
-  const cmd = commands.get(name);
-  if (!cmd) return { output: `Unknown command: /${name}. Type /help for available commands.` };
-  return cmd.handler(args);
+  initSchema(_db);
+  return _db;
 }
-function registerDefaults() {
-  registerSlashCommand({
-    name: "help",
-    aliases: ["h", "?"],
-    category: "core",
-    description: "Show available commands",
-    handler: () => {
-      const cmds = getAllSlashCommands().sort((a, b) => a.name.localeCompare(b.name));
-      const lines = cmds.map((c) => `  /${c.name.padEnd(16)} ${c.description}`);
-      return { output: `Available commands:
-${lines.join("\n")}` };
-    }
-  });
-  registerSlashCommand({
-    name: "clear",
-    category: "core",
-    description: "Clear conversation history",
-    handler: () => ({ action: "clear", output: "Conversation cleared." })
-  });
-  registerSlashCommand({
-    name: "compact",
-    category: "core",
-    description: "Compact conversation context",
-    handler: () => ({ action: "compact", output: "Context compacted." })
-  });
-  registerSlashCommand({
-    name: "exit",
-    aliases: ["quit", "q"],
-    category: "core",
-    description: "Exit coders",
-    handler: () => ({ action: "exit" })
-  });
-  registerSlashCommand({
-    name: "plan",
-    category: "core",
-    description: "View or edit the current plan",
-    handler: () => ({ output: "Plan mode \u2014 use EnterPlanMode tool to start planning." })
-  });
-  registerSlashCommand({
-    name: "model",
-    category: "mode",
-    description: "View or change the current model",
-    handler: (args) => {
-      if (args) return { action: "setModel", data: args, output: `Model set to: ${args}` };
-      return { output: "Current model \u2014 use /model <name> to change." };
-    }
-  });
-  registerSlashCommand({
-    name: "fast",
-    category: "mode",
-    description: "Toggle fast mode",
-    handler: () => ({ output: "Fast mode toggled." })
-  });
-  registerSlashCommand({
-    name: "verbose",
-    category: "mode",
-    description: "Toggle verbose output",
-    handler: () => ({ output: "Verbose mode toggled." })
-  });
-  registerSlashCommand({
-    name: "status",
-    category: "system",
-    description: "Show session status",
-    handler: () => ({ output: "Session status \u2014 not yet wired." })
-  });
-  registerSlashCommand({
-    name: "config",
-    category: "system",
-    description: "View or modify settings",
-    handler: (args) => ({ output: args ? `Config: ${args}` : "Use /config <key> [value]" })
-  });
-  registerSlashCommand({
-    name: "mcp",
-    category: "system",
-    description: "Show MCP server status",
-    handler: () => ({ output: "MCP servers \u2014 use 'coders mcp list' for details." })
-  });
+function initSchema(db) {
+  db.exec(`
+    -- Sessions
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      device_id TEXT NOT NULL,
+      project_dir TEXT,
+      original_cwd TEXT,
+      model TEXT,
+      app_version TEXT,
+      build_time TEXT,
+      fingerprint TEXT, -- JSON
+      metadata TEXT,    -- JSON
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Messages (conversation history)
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id),
+      role TEXT NOT NULL CHECK(role IN ('user','assistant','system')),
+      content TEXT NOT NULL,
+      tool_uses TEXT,    -- JSON array of tool use displays
+      thinking TEXT,
+      duration_ms REAL,
+      tokens_in INTEGER DEFAULT 0,
+      tokens_out INTEGER DEFAULT 0,
+      cost_usd REAL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+
+    -- File history (tracks reads per session)
+    CREATE TABLE IF NOT EXISTS file_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      content_hash TEXT,
+      byte_size INTEGER,
+      line_count INTEGER,
+      read_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(session_id, file_path)
+    );
+
+    -- File checkpoints (for /rewind)
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      original_content TEXT NOT NULL,
+      edit_operation TEXT, -- JSON {old_string, new_string}
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_session_file ON checkpoints(session_id, file_path);
+
+    -- Tasks (replaces in-memory fallback for @hasna/todos)
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      subject TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      status TEXT DEFAULT 'pending' CHECK(status IN ('pending','in_progress','completed','failed','cancelled')),
+      active_form TEXT,
+      owner TEXT,
+      blocks TEXT DEFAULT '[]',      -- JSON array of task IDs
+      blocked_by TEXT DEFAULT '[]',   -- JSON array of task IDs
+      metadata TEXT DEFAULT '{}',     -- JSON
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Config (replaces JSON files)
+    CREATE TABLE IF NOT EXISTS config (
+      key TEXT PRIMARY KEY,
+      value TEXT, -- JSON
+      scope TEXT DEFAULT 'user' CHECK(scope IN ('user','project','local','global')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Memories (replaces in-memory fallback for @hasna/mementos)
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      key TEXT UNIQUE NOT NULL,
+      value TEXT NOT NULL,
+      scope TEXT DEFAULT 'shared' CHECK(scope IN ('global','shared','private')),
+      category TEXT DEFAULT 'knowledge',
+      importance INTEGER DEFAULT 5 CHECK(importance BETWEEN 1 AND 10),
+      tags TEXT DEFAULT '[]', -- JSON array
+      version INTEGER DEFAULT 1,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Teams
+    CREATE TABLE IF NOT EXISTS teams (
+      name TEXT PRIMARY KEY,
+      description TEXT,
+      task_list_id TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Team members
+    CREATE TABLE IF NOT EXISTS team_members (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      team_name TEXT NOT NULL REFERENCES teams(name),
+      agent_name TEXT NOT NULL,
+      role TEXT,
+      status TEXT DEFAULT 'idle',
+      current_task TEXT,
+      UNIQUE(team_name, agent_name)
+    );
+
+    -- Team messages
+    CREATE TABLE IF NOT EXISTS team_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      from_agent TEXT NOT NULL,
+      to_agent TEXT NOT NULL,
+      team_name TEXT,
+      content TEXT NOT NULL,
+      is_read INTEGER DEFAULT 0,
+      is_blocking INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_team_msgs_to ON team_messages(to_agent, is_read);
+
+    -- Permissions (persisted allow/deny rules)
+    CREATE TABLE IF NOT EXISTS permissions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT,
+      command_pattern TEXT,
+      path_pattern TEXT,
+      behavior TEXT NOT NULL CHECK(behavior IN ('allow','deny')),
+      scope TEXT DEFAULT 'session',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- MCP servers
+    CREATE TABLE IF NOT EXISTS mcp_servers (
+      name TEXT PRIMARY KEY,
+      command TEXT,
+      args TEXT,    -- JSON array
+      env TEXT,     -- JSON object
+      url TEXT,
+      transport TEXT DEFAULT 'stdio',
+      scope TEXT DEFAULT 'user',
+      enabled INTEGER DEFAULT 1,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Metrics (per-turn tracking)
+    CREATE TABLE IF NOT EXISTS metrics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      turn_index INTEGER,
+      tokens_in INTEGER DEFAULT 0,
+      tokens_out INTEGER DEFAULT 0,
+      cost_usd REAL DEFAULT 0,
+      api_duration_ms REAL DEFAULT 0,
+      tool_duration_ms REAL DEFAULT 0,
+      hook_duration_ms REAL DEFAULT 0,
+      tool_count INTEGER DEFAULT 0,
+      model TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    -- Audit log (for security \u2014 tracks all tool executions)
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      tool_name TEXT NOT NULL,
+      input_summary TEXT,
+      result_summary TEXT,
+      exit_code INTEGER,
+      duration_ms REAL,
+      was_allowed INTEGER DEFAULT 1,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+  `);
+}
+function dbRun(sql, params = []) {
+  const db = getDb();
+  try {
+    const stmt = db.prepare(sql);
+    return stmt.run(...params);
+  } catch (e) {
+    try {
+      return db.run(sql, params);
+    } catch {
+      throw e;
+    }
+  }
+}
+function dbGet(sql, params = []) {
+  const db = getDb();
+  try {
+    const stmt = db.prepare(sql);
+    return stmt.get(...params);
+  } catch {
+    try {
+      return db.query(sql).get(...params);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function dbAll(sql, params = []) {
+  const db = getDb();
+  try {
+    const stmt = db.prepare(sql);
+    return stmt.all(...params);
+  } catch {
+    try {
+      return db.query(sql).all(...params);
+    } catch {
+      return [];
+    }
+  }
+}
+function createJsonFileDb() {
+  const storePath = join2(getConfigDir(), "coders-fallback.json");
+  let store = { tables: {}, autoInc: {} };
+  try {
+    if (existsSync4(storePath)) {
+      store = JSON.parse(readFileSync3(storePath, "utf-8"));
+      if (!store.tables) store.tables = {};
+      if (!store.autoInc) store.autoInc = {};
+    }
+  } catch {
+  }
+  function flush() {
+    try {
+      writeFileSync2(storePath, JSON.stringify(store), "utf-8");
+    } catch {
+    }
+  }
+  function ensureTable(name) {
+    if (!store.tables[name]) {
+      store.tables[name] = [];
+      store.autoInc[name] = 0;
+    }
+  }
+  function now() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+  }
+  function parseInsert(sql, params) {
+    const m = sql.match(/INSERT\s+(?:OR\s+\w+\s+)?INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i);
+    if (!m) return { changes: 0, lastInsertRowid: 0 };
+    const table = m[1];
+    ensureTable(table);
+    const cols = m[2].split(",").map((c) => c.trim());
+    const valuePlaceholders = m[3].split(",").map((v) => v.trim());
+    const row = {};
+    let paramIdx = 0;
+    for (let i = 0; i < cols.length; i++) {
+      const ph = valuePlaceholders[i];
+      if (ph === "?") {
+        row[cols[i]] = params[paramIdx++];
+      } else if (/^datetime\(/i.test(ph)) {
+        row[cols[i]] = now();
+      } else {
+        row[cols[i]] = ph.replace(/^['"]|['"]$/g, "");
+      }
+    }
+    if (!row["id"] && store.autoInc[table] !== void 0) {
+      store.autoInc[table]++;
+      row["id"] = store.autoInc[table];
+    }
+    store.tables[table].push(row);
+    flush();
+    return { changes: 1, lastInsertRowid: typeof row["id"] === "number" ? row["id"] : 0 };
+  }
+  function parseSelect(sql, params) {
+    const m = sql.match(/SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?(?:\s+LIMIT\s+(\d+))?$/i);
+    if (!m) return [];
+    const table = m[2];
+    if (!store.tables[table]) return [];
+    let rows = [...store.tables[table]];
+    if (m[3]) {
+      const whereParts = m[3].trim();
+      const wm = whereParts.match(/(\w+)\s*=\s*\?/);
+      if (wm && params.length > 0) {
+        const col = wm[1];
+        const val = params[0];
+        rows = rows.filter((r) => r[col] === val);
+      }
+    }
+    if (m[5]) {
+      rows = rows.slice(0, parseInt(m[5], 10));
+    }
+    return rows;
+  }
+  function parseUpdate(sql, params) {
+    const m = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)\s+WHERE\s+(.+)/i);
+    if (!m) return { changes: 0 };
+    const table = m[1];
+    if (!store.tables[table]) return { changes: 0 };
+    const setClauses = m[2].split(",").map((s) => s.trim());
+    const whereClause = m[3].trim();
+    const setParamCount = setClauses.filter((c) => c.includes("?")).length;
+    const wm = whereClause.match(/(\w+)\s*=\s*\?/);
+    const whereCol = wm ? wm[1] : null;
+    const whereVal = wm ? params[setParamCount] : null;
+    let changes = 0;
+    for (const row of store.tables[table]) {
+      if (whereCol && row[whereCol] !== whereVal) continue;
+      let paramIdx = 0;
+      for (const clause of setClauses) {
+        const cm = clause.match(/(\w+)\s*=\s*(.+)/);
+        if (!cm) continue;
+        const col = cm[1];
+        const val = cm[2].trim();
+        if (val === "?") {
+          row[col] = params[paramIdx++];
+        } else if (/^datetime\(/i.test(val)) {
+          row[col] = now();
+        }
+      }
+      changes++;
+    }
+    if (changes > 0) flush();
+    return { changes };
+  }
+  function parseDelete(sql, params) {
+    const m = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?/i);
+    if (!m) return { changes: 0 };
+    const table = m[1];
+    if (!store.tables[table]) return { changes: 0 };
+    if (!m[2]) {
+      const count = store.tables[table].length;
+      store.tables[table] = [];
+      flush();
+      return { changes: count };
+    }
+    const wm = m[2].match(/(\w+)\s*=\s*\?/);
+    if (!wm) return { changes: 0 };
+    const col = wm[1];
+    const val = params[0];
+    const before = store.tables[table].length;
+    store.tables[table] = store.tables[table].filter((r) => r[col] !== val);
+    const changes = before - store.tables[table].length;
+    if (changes > 0) flush();
+    return { changes };
+  }
+  function execSql(sql, params = []) {
+    const trimmed = sql.trim();
+    if (/^INSERT/i.test(trimmed)) return parseInsert(trimmed, params);
+    if (/^SELECT/i.test(trimmed)) return parseSelect(trimmed, params);
+    if (/^UPDATE/i.test(trimmed)) return parseUpdate(trimmed, params);
+    if (/^DELETE/i.test(trimmed)) return parseDelete(trimmed, params);
+    return { changes: 0 };
+  }
+  return {
+    exec(sql) {
+      const matches = sql.matchAll(/CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+(\w+)/gi);
+      for (const m of matches) {
+        ensureTable(m[1]);
+      }
+    },
+    prepare(sql) {
+      return {
+        run(...params) {
+          return execSql(sql, params);
+        },
+        get(...params) {
+          const result = execSql(sql, params);
+          if (Array.isArray(result)) return result[0];
+          return void 0;
+        },
+        all(...params) {
+          const result = execSql(sql, params);
+          if (Array.isArray(result)) return result;
+          return [];
+        }
+      };
+    },
+    // Bun-style API aliases
+    run(sql, params = []) {
+      return execSql(sql, params);
+    },
+    query(sql) {
+      return {
+        get(...params) {
+          const result = execSql(sql, params);
+          if (Array.isArray(result)) return result[0];
+          return void 0;
+        },
+        all(...params) {
+          const result = execSql(sql, params);
+          if (Array.isArray(result)) return result;
+          return [];
+        }
+      };
+    },
+    close() {
+      flush();
+    }
+  };
+}
+var _db;
+var init_db = __esm({
+  "src/db/index.ts"() {
+    "use strict";
+    init_paths();
+    _db = null;
+  }
+});
+
+// src/ui/screen/terminal.ts
+var terminal_exports = {};
+__export(terminal_exports, {
+  detectTerminal: () => detectTerminal,
+  getTerminalSize: () => getTerminalSize,
+  onResize: () => onResize
+});
+function detectTerminal() {
+  const termProgram = process.env.TERM_PROGRAM ?? "";
+  const term = process.env.TERM ?? "";
+  const colorTerm = process.env.COLORTERM ?? "";
+  const caps = {
+    name: detectTerminalName(termProgram, term),
+    colorDepth: detectColorDepth(termProgram, colorTerm, term),
+    unicode: detectUnicode(),
+    hyperlinks: detectHyperlinks(termProgram),
+    kittyProtocol: detectKittyProtocol(termProgram),
+    mouseSupport: true,
+    // Most modern terminals support SGR mouse
+    sixelGraphics: detectSixel(termProgram),
+    iterm2Images: termProgram === "iTerm.app"
+  };
+  return caps;
+}
+function detectTerminalName(termProgram, term) {
+  if (termProgram === "iTerm.app") return "iTerm2";
+  if (termProgram === "WezTerm") return "WezTerm";
+  if (termProgram === "vscode") return "VSCode";
+  if (termProgram === "Alacritty") return "Alacritty";
+  if (termProgram === "ghostty") return "Ghostty";
+  if (termProgram === "contour") return "Contour";
+  if (termProgram === "mintty") return "Mintty";
+  if (process.env.KITTY_WINDOW_ID) return "Kitty";
+  if (termProgram === "kitty") return "Kitty";
+  if (term === "foot" || term === "foot-extra") return "foot";
+  if (process.env.WARP_IS_LOCAL_SHELL_SESSION) return "Warp";
+  if (termProgram === "Warp") return "Warp";
+  if (process.env.WT_SESSION) return "Windows Terminal";
+  if (process.env.ConEmuANSI || process.env.ConEmuPID) return "ConEmu";
+  const vteVersion = process.env.VTE_VERSION;
+  if (vteVersion) {
+    const ver = parseInt(vteVersion, 10);
+    if (ver >= 6800) return "VTE (modern)";
+    return "VTE";
+  }
+  if (term.startsWith("xterm")) return "xterm";
+  if (term.startsWith("screen")) return "screen";
+  if (term.startsWith("tmux")) return "tmux";
+  return "unknown";
+}
+function detectColorDepth(termProgram, colorTerm, term) {
+  if (colorTerm === "truecolor" || colorTerm === "24bit") return 24;
+  const truecolorTerminals = [
+    "iTerm.app",
+    "WezTerm",
+    "Alacritty",
+    "kitty",
+    "ghostty",
+    "contour",
+    "foot"
+  ];
+  if (truecolorTerminals.includes(termProgram)) return 24;
+  if (process.env.KITTY_WINDOW_ID) return 24;
+  if (process.env.WT_SESSION) return 24;
+  if (termProgram === "vscode") return 24;
+  if (term.includes("256color")) return 8;
+  if (colorTerm) return 8;
+  if (term.includes("color") || term.startsWith("xterm")) return 4;
+  if (term === "dumb" || !process.stdout.isTTY) return 1;
+  return 4;
+}
+function detectUnicode() {
+  const lang = process.env.LANG ?? process.env.LC_ALL ?? process.env.LC_CTYPE ?? "";
+  return lang.toLowerCase().includes("utf");
+}
+function detectHyperlinks(termProgram) {
+  const supported = [
+    "iTerm.app",
+    "WezTerm",
+    "Alacritty",
+    "kitty",
+    "ghostty",
+    "contour",
+    "foot",
+    "vscode"
+  ];
+  if (supported.includes(termProgram)) return true;
+  if (process.env.KITTY_WINDOW_ID) return true;
+  if (process.env.WT_SESSION) return true;
+  return false;
+}
+function detectKittyProtocol(termProgram) {
+  if (process.env.KITTY_WINDOW_ID) return true;
+  if (termProgram === "kitty") return true;
+  if (termProgram === "ghostty") return true;
+  if (termProgram === "foot") return true;
+  if (termProgram === "WezTerm") return true;
+  return false;
+}
+function detectSixel(termProgram) {
+  if (termProgram === "WezTerm") return true;
+  if (termProgram === "foot") return true;
+  if (termProgram === "contour") return true;
+  return false;
+}
+function getTerminalSize() {
+  return {
+    columns: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  };
+}
+function onResize(callback) {
+  const handler = () => {
+    const { columns, rows } = getTerminalSize();
+    callback(columns, rows);
+  };
+  process.stdout.on("resize", handler);
+  return () => process.stdout.removeListener("resize", handler);
+}
+var init_terminal = __esm({
+  "src/ui/screen/terminal.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/slash-commands.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+function registerSlashCommand(cmd) {
+  commands.set(cmd.name, cmd);
+  if (cmd.aliases) {
+    for (const alias of cmd.aliases) commands.set(alias, cmd);
+  }
+}
+function getAllSlashCommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const cmd of commands.values()) {
+    if (!seen.has(cmd.name)) {
+      seen.add(cmd.name);
+      result.push(cmd);
+    }
+  }
+  return result;
+}
+function isSlashCommand(input) {
+  return input.startsWith("/") && commands.has(input.slice(1).split(/\s/)[0]);
+}
+async function executeSlashCommand(input) {
+  const parts = input.replace(/^\//, "").split(/\s+/);
+  const name = parts[0];
+  const args = parts.slice(1).join(" ");
+  const cmd = commands.get(name);
+  if (!cmd) return { output: `Unknown command: /${name}. Type /help for available commands.` };
+  return cmd.handler(args);
+}
+function registerDefaults() {
+  registerSlashCommand({
+    name: "help",
+    aliases: ["h", "?"],
+    category: "core",
+    description: "Show available commands",
+    handler: () => {
+      const cmds = getAllSlashCommands().sort((a, b) => a.name.localeCompare(b.name));
+      const lines = cmds.map((c) => `  /${c.name.padEnd(16)} ${c.description}`);
+      return { output: `Available commands:
+${lines.join("\n")}` };
+    }
+  });
+  registerSlashCommand({
+    name: "clear",
+    category: "core",
+    description: "Clear conversation history",
+    handler: () => ({ action: "clear", output: "Conversation cleared." })
+  });
+  registerSlashCommand({
+    name: "compact",
+    category: "core",
+    description: "Compact conversation context",
+    handler: () => ({ action: "compact", output: "Context compacted." })
+  });
+  registerSlashCommand({
+    name: "exit",
+    aliases: ["quit", "q"],
+    category: "core",
+    description: "Exit coders",
+    handler: () => ({ action: "exit" })
+  });
+  registerSlashCommand({
+    name: "plan",
+    category: "core",
+    description: "View or edit the current plan",
+    handler: () => ({ output: "Plan mode \u2014 use EnterPlanMode tool to start planning." })
+  });
+  registerSlashCommand({
+    name: "model",
+    category: "mode",
+    description: "View or change the current model",
+    handler: (args) => {
+      if (args) return { action: "setModel", data: args, output: `Model set to: ${args}` };
+      return { output: "Current model \u2014 use /model <name> to change." };
+    }
+  });
+  registerSlashCommand({
+    name: "fast",
+    category: "mode",
+    description: "Toggle fast mode",
+    handler: () => ({ output: "Fast mode toggled." })
+  });
+  registerSlashCommand({
+    name: "verbose",
+    category: "mode",
+    description: "Toggle verbose output",
+    handler: () => ({ output: "Verbose mode toggled." })
+  });
+  registerSlashCommand({
+    name: "status",
+    category: "system",
+    description: "Show session status",
+    handler: () => ({ output: "Session status \u2014 not yet wired." })
+  });
+  registerSlashCommand({
+    name: "config",
+    category: "system",
+    description: "View or modify settings",
+    handler: (args) => ({ output: args ? `Config: ${args}` : "Use /config <key> [value]" })
+  });
+  registerSlashCommand({
+    name: "mcp",
+    category: "system",
+    description: "Show MCP server status",
+    handler: () => ({ output: "MCP servers \u2014 use 'coders mcp list' for details." })
+  });
   registerSlashCommand({
     name: "memory",
     category: "core",
@@ -58937,11 +59380,78 @@ ${lines.join("\n")}` };
       return { output: `Terminal: ${caps.name}, Color: ${caps.colorDepth}bit, Unicode: ${caps.unicode}` };
     }
   });
+  registerSlashCommand({
+    name: "rewind",
+    category: "core",
+    description: "List recent file checkpoints and restore one",
+    handler: (args) => {
+      const checkpoints = dbAll(
+        "SELECT * FROM checkpoints ORDER BY created_at DESC LIMIT 10"
+      );
+      if (checkpoints.length === 0) {
+        return { output: "No checkpoints found. Checkpoints are created when files are edited or overwritten." };
+      }
+      const choice = parseInt(args, 10);
+      if (!isNaN(choice) && choice >= 1 && choice <= checkpoints.length) {
+        const cp = checkpoints[choice - 1];
+        try {
+          writeFileSync3(cp.file_path, cp.original_content, "utf-8");
+          const op = cp.edit_operation ? JSON.parse(cp.edit_operation) : null;
+          const summary = op?.old_string ? `Reverted edit: "${truncate(op.old_string, 40)}" -> "${truncate(op.new_string, 40)}"` : "Restored original content";
+          return { output: `Restored checkpoint #${choice}: ${cp.file_path}
+${summary}` };
+        } catch (e) {
+          return { output: `Failed to restore checkpoint: ${e instanceof Error ? e.message : String(e)}` };
+        }
+      }
+      const lines = checkpoints.map((cp, i) => {
+        const op = cp.edit_operation ? JSON.parse(cp.edit_operation) : null;
+        const summary = op?.old_string ? `"${truncate(op.old_string, 30)}" -> "${truncate(op.new_string, 30)}"` : op?.type === "write_overwrite" ? "file overwrite" : "unknown operation";
+        return `  ${i + 1}. [${cp.created_at}] ${cp.file_path}
+     ${summary}`;
+      });
+      return {
+        output: `Recent checkpoints:
+${lines.join("\n")}
+
+Use /rewind <number> to restore a checkpoint.`
+      };
+    }
+  });
+  registerSlashCommand({
+    name: "undo",
+    category: "core",
+    description: "Revert the last file edit from the most recent checkpoint",
+    handler: () => {
+      const cp = dbGet(
+        "SELECT * FROM checkpoints ORDER BY created_at DESC LIMIT 1"
+      );
+      if (!cp) {
+        return { output: "No checkpoints found. Nothing to undo." };
+      }
+      try {
+        writeFileSync3(cp.file_path, cp.original_content, "utf-8");
+        const op = cp.edit_operation ? JSON.parse(cp.edit_operation) : null;
+        const summary = op?.old_string ? `Reverted: "${truncate(op.old_string, 50)}" -> "${truncate(op.new_string, 50)}"` : op?.type === "write_overwrite" ? "Restored file before overwrite" : "Restored original content";
+        return { output: `Undo successful: ${cp.file_path}
+${summary}
+[checkpoint: ${cp.id} at ${cp.created_at}]` };
+      } catch (e) {
+        return { output: `Failed to undo: ${e instanceof Error ? e.message : String(e)}` };
+      }
+    }
+  });
+}
+function truncate(s, max) {
+  if (!s) return "";
+  const oneLine = s.replace(/\n/g, "\\n");
+  return oneLine.length > max ? oneLine.slice(0, max) + "..." : oneLine;
 }
 var commands;
 var init_slash_commands = __esm({
   "src/core/slash-commands.ts"() {
     "use strict";
+    init_db();
     commands = /* @__PURE__ */ new Map();
     registerDefaults();
   }
@@ -60378,1548 +60888,1144 @@ ${currentText}` : currentText;
       }
       blockquote({ tokens }) {
         const body = this.parser.parse(tokens);
-        return `<blockquote>
-${body}</blockquote>
-`;
-      }
-      html({ text }) {
-        return text;
-      }
-      heading({ tokens, depth }) {
-        return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>
-`;
-      }
-      hr(token) {
-        return "<hr>\n";
-      }
-      list(token) {
-        const ordered = token.ordered;
-        const start = token.start;
-        let body = "";
-        for (let j = 0; j < token.items.length; j++) {
-          const item = token.items[j];
-          body += this.listitem(item);
-        }
-        const type = ordered ? "ol" : "ul";
-        const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : "";
-        return "<" + type + startAttr + ">\n" + body + "</" + type + ">\n";
-      }
-      listitem(item) {
-        let itemBody = "";
-        if (item.task) {
-          const checkbox = this.checkbox({ checked: !!item.checked });
-          if (item.loose) {
-            if (item.tokens[0]?.type === "paragraph") {
-              item.tokens[0].text = checkbox + " " + item.tokens[0].text;
-              if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
-                item.tokens[0].tokens[0].text = checkbox + " " + escape22(item.tokens[0].tokens[0].text);
-                item.tokens[0].tokens[0].escaped = true;
-              }
-            } else {
-              item.tokens.unshift({
-                type: "text",
-                raw: checkbox + " ",
-                text: checkbox + " ",
-                escaped: true
-              });
-            }
-          } else {
-            itemBody += checkbox + " ";
-          }
-        }
-        itemBody += this.parser.parse(item.tokens, !!item.loose);
-        return `<li>${itemBody}</li>
-`;
-      }
-      checkbox({ checked }) {
-        return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
-      }
-      paragraph({ tokens }) {
-        return `<p>${this.parser.parseInline(tokens)}</p>
-`;
-      }
-      table(token) {
-        let header = "";
-        let cell = "";
-        for (let j = 0; j < token.header.length; j++) {
-          cell += this.tablecell(token.header[j]);
-        }
-        header += this.tablerow({ text: cell });
-        let body = "";
-        for (let j = 0; j < token.rows.length; j++) {
-          const row = token.rows[j];
-          cell = "";
-          for (let k = 0; k < row.length; k++) {
-            cell += this.tablecell(row[k]);
-          }
-          body += this.tablerow({ text: cell });
-        }
-        if (body) body = `<tbody>${body}</tbody>`;
-        return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
-      }
-      tablerow({ text }) {
-        return `<tr>
-${text}</tr>
-`;
-      }
-      tablecell(token) {
-        const content = this.parser.parseInline(token.tokens);
-        const type = token.header ? "th" : "td";
-        const tag2 = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
-        return tag2 + content + `</${type}>
-`;
-      }
-      /**
-       * span level renderer
-       */
-      strong({ tokens }) {
-        return `<strong>${this.parser.parseInline(tokens)}</strong>`;
-      }
-      em({ tokens }) {
-        return `<em>${this.parser.parseInline(tokens)}</em>`;
-      }
-      codespan({ text }) {
-        return `<code>${escape22(text, true)}</code>`;
-      }
-      br(token) {
-        return "<br>";
-      }
-      del({ tokens }) {
-        return `<del>${this.parser.parseInline(tokens)}</del>`;
-      }
-      link({ href, title, tokens }) {
-        const text = this.parser.parseInline(tokens);
-        const cleanHref = cleanUrl(href);
-        if (cleanHref === null) {
-          return text;
-        }
-        href = cleanHref;
-        let out = '<a href="' + href + '"';
-        if (title) {
-          out += ' title="' + escape22(title) + '"';
-        }
-        out += ">" + text + "</a>";
-        return out;
-      }
-      image({ href, title, text, tokens }) {
-        if (tokens) {
-          text = this.parser.parseInline(tokens, this.parser.textRenderer);
-        }
-        const cleanHref = cleanUrl(href);
-        if (cleanHref === null) {
-          return escape22(text);
-        }
-        href = cleanHref;
-        let out = `<img src="${href}" alt="${text}"`;
-        if (title) {
-          out += ` title="${escape22(title)}"`;
-        }
-        out += ">";
-        return out;
-      }
-      text(token) {
-        return "tokens" in token && token.tokens ? this.parser.parseInline(token.tokens) : "escaped" in token && token.escaped ? token.text : escape22(token.text);
-      }
-    };
-    _TextRenderer = class {
-      // no need for block level renderers
-      strong({ text }) {
-        return text;
-      }
-      em({ text }) {
-        return text;
-      }
-      codespan({ text }) {
-        return text;
-      }
-      del({ text }) {
-        return text;
+        return `<blockquote>
+${body}</blockquote>
+`;
       }
       html({ text }) {
         return text;
       }
-      text({ text }) {
-        return text;
-      }
-      link({ text }) {
-        return "" + text;
-      }
-      image({ text }) {
-        return "" + text;
-      }
-      br() {
-        return "";
-      }
-    };
-    _Parser = class __Parser {
-      options;
-      renderer;
-      textRenderer;
-      constructor(options2) {
-        this.options = options2 || _defaults;
-        this.options.renderer = this.options.renderer || new _Renderer();
-        this.renderer = this.options.renderer;
-        this.renderer.options = this.options;
-        this.renderer.parser = this;
-        this.textRenderer = new _TextRenderer();
+      heading({ tokens, depth }) {
+        return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>
+`;
       }
-      /**
-       * Static Parse Method
-       */
-      static parse(tokens, options2) {
-        const parser2 = new __Parser(options2);
-        return parser2.parse(tokens);
+      hr(token) {
+        return "<hr>\n";
       }
-      /**
-       * Static Parse Inline Method
-       */
-      static parseInline(tokens, options2) {
-        const parser2 = new __Parser(options2);
-        return parser2.parseInline(tokens);
+      list(token) {
+        const ordered = token.ordered;
+        const start = token.start;
+        let body = "";
+        for (let j = 0; j < token.items.length; j++) {
+          const item = token.items[j];
+          body += this.listitem(item);
+        }
+        const type = ordered ? "ol" : "ul";
+        const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : "";
+        return "<" + type + startAttr + ">\n" + body + "</" + type + ">\n";
       }
-      /**
-       * Parse Loop
-       */
-      parse(tokens, top = true) {
-        let out = "";
-        for (let i = 0; i < tokens.length; i++) {
-          const anyToken = tokens[i];
-          if (this.options.extensions?.renderers?.[anyToken.type]) {
-            const genericToken = anyToken;
-            const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
-            if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
-              out += ret || "";
-              continue;
-            }
-          }
-          const token = anyToken;
-          switch (token.type) {
-            case "space": {
-              out += this.renderer.space(token);
-              continue;
-            }
-            case "hr": {
-              out += this.renderer.hr(token);
-              continue;
-            }
-            case "heading": {
-              out += this.renderer.heading(token);
-              continue;
-            }
-            case "code": {
-              out += this.renderer.code(token);
-              continue;
-            }
-            case "table": {
-              out += this.renderer.table(token);
-              continue;
-            }
-            case "blockquote": {
-              out += this.renderer.blockquote(token);
-              continue;
-            }
-            case "list": {
-              out += this.renderer.list(token);
-              continue;
-            }
-            case "html": {
-              out += this.renderer.html(token);
-              continue;
-            }
-            case "paragraph": {
-              out += this.renderer.paragraph(token);
-              continue;
-            }
-            case "text": {
-              let textToken = token;
-              let body = this.renderer.text(textToken);
-              while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
-                textToken = tokens[++i];
-                body += "\n" + this.renderer.text(textToken);
-              }
-              if (top) {
-                out += this.renderer.paragraph({
-                  type: "paragraph",
-                  raw: body,
-                  text: body,
-                  tokens: [{ type: "text", raw: body, text: body, escaped: true }]
-                });
-              } else {
-                out += body;
-              }
-              continue;
-            }
-            default: {
-              const errMsg = 'Token with "' + token.type + '" type was not found.';
-              if (this.options.silent) {
-                console.error(errMsg);
-                return "";
-              } else {
-                throw new Error(errMsg);
+      listitem(item) {
+        let itemBody = "";
+        if (item.task) {
+          const checkbox = this.checkbox({ checked: !!item.checked });
+          if (item.loose) {
+            if (item.tokens[0]?.type === "paragraph") {
+              item.tokens[0].text = checkbox + " " + item.tokens[0].text;
+              if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === "text") {
+                item.tokens[0].tokens[0].text = checkbox + " " + escape22(item.tokens[0].tokens[0].text);
+                item.tokens[0].tokens[0].escaped = true;
               }
+            } else {
+              item.tokens.unshift({
+                type: "text",
+                raw: checkbox + " ",
+                text: checkbox + " ",
+                escaped: true
+              });
             }
+          } else {
+            itemBody += checkbox + " ";
           }
         }
-        return out;
+        itemBody += this.parser.parse(item.tokens, !!item.loose);
+        return `<li>${itemBody}</li>
+`;
       }
-      /**
-       * Parse Inline Tokens
-       */
-      parseInline(tokens, renderer2 = this.renderer) {
-        let out = "";
-        for (let i = 0; i < tokens.length; i++) {
-          const anyToken = tokens[i];
-          if (this.options.extensions?.renderers?.[anyToken.type]) {
-            const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
-            if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(anyToken.type)) {
-              out += ret || "";
-              continue;
-            }
-          }
-          const token = anyToken;
-          switch (token.type) {
-            case "escape": {
-              out += renderer2.text(token);
-              break;
-            }
-            case "html": {
-              out += renderer2.html(token);
-              break;
-            }
-            case "link": {
-              out += renderer2.link(token);
-              break;
-            }
-            case "image": {
-              out += renderer2.image(token);
-              break;
-            }
-            case "strong": {
-              out += renderer2.strong(token);
-              break;
-            }
-            case "em": {
-              out += renderer2.em(token);
-              break;
-            }
-            case "codespan": {
-              out += renderer2.codespan(token);
-              break;
-            }
-            case "br": {
-              out += renderer2.br(token);
-              break;
-            }
-            case "del": {
-              out += renderer2.del(token);
-              break;
-            }
-            case "text": {
-              out += renderer2.text(token);
-              break;
-            }
-            default: {
-              const errMsg = 'Token with "' + token.type + '" type was not found.';
-              if (this.options.silent) {
-                console.error(errMsg);
-                return "";
-              } else {
-                throw new Error(errMsg);
-              }
-            }
+      checkbox({ checked }) {
+        return "<input " + (checked ? 'checked="" ' : "") + 'disabled="" type="checkbox">';
+      }
+      paragraph({ tokens }) {
+        return `<p>${this.parser.parseInline(tokens)}</p>
+`;
+      }
+      table(token) {
+        let header = "";
+        let cell = "";
+        for (let j = 0; j < token.header.length; j++) {
+          cell += this.tablecell(token.header[j]);
+        }
+        header += this.tablerow({ text: cell });
+        let body = "";
+        for (let j = 0; j < token.rows.length; j++) {
+          const row = token.rows[j];
+          cell = "";
+          for (let k = 0; k < row.length; k++) {
+            cell += this.tablecell(row[k]);
           }
+          body += this.tablerow({ text: cell });
+        }
+        if (body) body = `<tbody>${body}</tbody>`;
+        return "<table>\n<thead>\n" + header + "</thead>\n" + body + "</table>\n";
+      }
+      tablerow({ text }) {
+        return `<tr>
+${text}</tr>
+`;
+      }
+      tablecell(token) {
+        const content = this.parser.parseInline(token.tokens);
+        const type = token.header ? "th" : "td";
+        const tag2 = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
+        return tag2 + content + `</${type}>
+`;
+      }
+      /**
+       * span level renderer
+       */
+      strong({ tokens }) {
+        return `<strong>${this.parser.parseInline(tokens)}</strong>`;
+      }
+      em({ tokens }) {
+        return `<em>${this.parser.parseInline(tokens)}</em>`;
+      }
+      codespan({ text }) {
+        return `<code>${escape22(text, true)}</code>`;
+      }
+      br(token) {
+        return "<br>";
+      }
+      del({ tokens }) {
+        return `<del>${this.parser.parseInline(tokens)}</del>`;
+      }
+      link({ href, title, tokens }) {
+        const text = this.parser.parseInline(tokens);
+        const cleanHref = cleanUrl(href);
+        if (cleanHref === null) {
+          return text;
+        }
+        href = cleanHref;
+        let out = '<a href="' + href + '"';
+        if (title) {
+          out += ' title="' + escape22(title) + '"';
+        }
+        out += ">" + text + "</a>";
+        return out;
+      }
+      image({ href, title, text, tokens }) {
+        if (tokens) {
+          text = this.parser.parseInline(tokens, this.parser.textRenderer);
+        }
+        const cleanHref = cleanUrl(href);
+        if (cleanHref === null) {
+          return escape22(text);
+        }
+        href = cleanHref;
+        let out = `<img src="${href}" alt="${text}"`;
+        if (title) {
+          out += ` title="${escape22(title)}"`;
         }
+        out += ">";
         return out;
       }
+      text(token) {
+        return "tokens" in token && token.tokens ? this.parser.parseInline(token.tokens) : "escaped" in token && token.escaped ? token.text : escape22(token.text);
+      }
     };
-    _Hooks = class {
-      options;
-      block;
-      constructor(options2) {
-        this.options = options2 || _defaults;
+    _TextRenderer = class {
+      // no need for block level renderers
+      strong({ text }) {
+        return text;
       }
-      static passThroughHooks = /* @__PURE__ */ new Set([
-        "preprocess",
-        "postprocess",
-        "processAllTokens"
-      ]);
-      /**
-       * Process markdown before marked
-       */
-      preprocess(markdown) {
-        return markdown;
+      em({ text }) {
+        return text;
       }
-      /**
-       * Process HTML after marked is finished
-       */
-      postprocess(html2) {
-        return html2;
+      codespan({ text }) {
+        return text;
       }
-      /**
-       * Process all tokens before walk tokens
-       */
-      processAllTokens(tokens) {
-        return tokens;
+      del({ text }) {
+        return text;
       }
-      /**
-       * Provide function to tokenize markdown
-       */
-      provideLexer() {
-        return this.block ? _Lexer.lex : _Lexer.lexInline;
+      html({ text }) {
+        return text;
       }
-      /**
-       * Provide function to parse tokens
-       */
-      provideParser() {
-        return this.block ? _Parser.parse : _Parser.parseInline;
+      text({ text }) {
+        return text;
+      }
+      link({ text }) {
+        return "" + text;
+      }
+      image({ text }) {
+        return "" + text;
+      }
+      br() {
+        return "";
       }
     };
-    Marked = class {
-      defaults = _getDefaults();
-      options = this.setOptions;
-      parse = this.parseMarkdown(true);
-      parseInline = this.parseMarkdown(false);
-      Parser = _Parser;
-      Renderer = _Renderer;
-      TextRenderer = _TextRenderer;
-      Lexer = _Lexer;
-      Tokenizer = _Tokenizer;
-      Hooks = _Hooks;
-      constructor(...args) {
-        this.use(...args);
+    _Parser = class __Parser {
+      options;
+      renderer;
+      textRenderer;
+      constructor(options2) {
+        this.options = options2 || _defaults;
+        this.options.renderer = this.options.renderer || new _Renderer();
+        this.renderer = this.options.renderer;
+        this.renderer.options = this.options;
+        this.renderer.parser = this;
+        this.textRenderer = new _TextRenderer();
       }
       /**
-       * Run callback for every token
+       * Static Parse Method
        */
-      walkTokens(tokens, callback) {
-        let values = [];
-        for (const token of tokens) {
-          values = values.concat(callback.call(this, token));
-          switch (token.type) {
-            case "table": {
-              const tableToken = token;
-              for (const cell of tableToken.header) {
-                values = values.concat(this.walkTokens(cell.tokens, callback));
-              }
-              for (const row of tableToken.rows) {
-                for (const cell of row) {
-                  values = values.concat(this.walkTokens(cell.tokens, callback));
-                }
-              }
-              break;
-            }
-            case "list": {
-              const listToken = token;
-              values = values.concat(this.walkTokens(listToken.items, callback));
-              break;
-            }
-            default: {
-              const genericToken = token;
-              if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
-                this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
-                  const tokens2 = genericToken[childTokens].flat(Infinity);
-                  values = values.concat(this.walkTokens(tokens2, callback));
-                });
-              } else if (genericToken.tokens) {
-                values = values.concat(this.walkTokens(genericToken.tokens, callback));
-              }
-            }
-          }
-        }
-        return values;
+      static parse(tokens, options2) {
+        const parser2 = new __Parser(options2);
+        return parser2.parse(tokens);
       }
-      use(...args) {
-        const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
-        args.forEach((pack) => {
-          const opts = { ...pack };
-          opts.async = this.defaults.async || opts.async || false;
-          if (pack.extensions) {
-            pack.extensions.forEach((ext) => {
-              if (!ext.name) {
-                throw new Error("extension name required");
-              }
-              if ("renderer" in ext) {
-                const prevRenderer = extensions.renderers[ext.name];
-                if (prevRenderer) {
-                  extensions.renderers[ext.name] = function(...args2) {
-                    let ret = ext.renderer.apply(this, args2);
-                    if (ret === false) {
-                      ret = prevRenderer.apply(this, args2);
-                    }
-                    return ret;
-                  };
-                } else {
-                  extensions.renderers[ext.name] = ext.renderer;
-                }
-              }
-              if ("tokenizer" in ext) {
-                if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
-                  throw new Error("extension level must be 'block' or 'inline'");
-                }
-                const extLevel = extensions[ext.level];
-                if (extLevel) {
-                  extLevel.unshift(ext.tokenizer);
-                } else {
-                  extensions[ext.level] = [ext.tokenizer];
-                }
-                if (ext.start) {
-                  if (ext.level === "block") {
-                    if (extensions.startBlock) {
-                      extensions.startBlock.push(ext.start);
-                    } else {
-                      extensions.startBlock = [ext.start];
-                    }
-                  } else if (ext.level === "inline") {
-                    if (extensions.startInline) {
-                      extensions.startInline.push(ext.start);
-                    } else {
-                      extensions.startInline = [ext.start];
-                    }
-                  }
-                }
-              }
-              if ("childTokens" in ext && ext.childTokens) {
-                extensions.childTokens[ext.name] = ext.childTokens;
-              }
-            });
-            opts.extensions = extensions;
-          }
-          if (pack.renderer) {
-            const renderer2 = this.defaults.renderer || new _Renderer(this.defaults);
-            for (const prop in pack.renderer) {
-              if (!(prop in renderer2)) {
-                throw new Error(`renderer '${prop}' does not exist`);
-              }
-              if (["options", "parser"].includes(prop)) {
-                continue;
-              }
-              const rendererProp = prop;
-              const rendererFunc = pack.renderer[rendererProp];
-              const prevRenderer = renderer2[rendererProp];
-              renderer2[rendererProp] = (...args2) => {
-                let ret = rendererFunc.apply(renderer2, args2);
-                if (ret === false) {
-                  ret = prevRenderer.apply(renderer2, args2);
-                }
-                return ret || "";
-              };
+      /**
+       * Static Parse Inline Method
+       */
+      static parseInline(tokens, options2) {
+        const parser2 = new __Parser(options2);
+        return parser2.parseInline(tokens);
+      }
+      /**
+       * Parse Loop
+       */
+      parse(tokens, top = true) {
+        let out = "";
+        for (let i = 0; i < tokens.length; i++) {
+          const anyToken = tokens[i];
+          if (this.options.extensions?.renderers?.[anyToken.type]) {
+            const genericToken = anyToken;
+            const ret = this.options.extensions.renderers[genericToken.type].call({ parser: this }, genericToken);
+            if (ret !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "html", "paragraph", "text"].includes(genericToken.type)) {
+              out += ret || "";
+              continue;
             }
-            opts.renderer = renderer2;
           }
-          if (pack.tokenizer) {
-            const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
-            for (const prop in pack.tokenizer) {
-              if (!(prop in tokenizer)) {
-                throw new Error(`tokenizer '${prop}' does not exist`);
-              }
-              if (["options", "rules", "lexer"].includes(prop)) {
-                continue;
-              }
-              const tokenizerProp = prop;
-              const tokenizerFunc = pack.tokenizer[tokenizerProp];
-              const prevTokenizer = tokenizer[tokenizerProp];
-              tokenizer[tokenizerProp] = (...args2) => {
-                let ret = tokenizerFunc.apply(tokenizer, args2);
-                if (ret === false) {
-                  ret = prevTokenizer.apply(tokenizer, args2);
-                }
-                return ret;
-              };
+          const token = anyToken;
+          switch (token.type) {
+            case "space": {
+              out += this.renderer.space(token);
+              continue;
             }
-            opts.tokenizer = tokenizer;
-          }
-          if (pack.hooks) {
-            const hooks = this.defaults.hooks || new _Hooks();
-            for (const prop in pack.hooks) {
-              if (!(prop in hooks)) {
-                throw new Error(`hook '${prop}' does not exist`);
-              }
-              if (["options", "block"].includes(prop)) {
-                continue;
+            case "hr": {
+              out += this.renderer.hr(token);
+              continue;
+            }
+            case "heading": {
+              out += this.renderer.heading(token);
+              continue;
+            }
+            case "code": {
+              out += this.renderer.code(token);
+              continue;
+            }
+            case "table": {
+              out += this.renderer.table(token);
+              continue;
+            }
+            case "blockquote": {
+              out += this.renderer.blockquote(token);
+              continue;
+            }
+            case "list": {
+              out += this.renderer.list(token);
+              continue;
+            }
+            case "html": {
+              out += this.renderer.html(token);
+              continue;
+            }
+            case "paragraph": {
+              out += this.renderer.paragraph(token);
+              continue;
+            }
+            case "text": {
+              let textToken = token;
+              let body = this.renderer.text(textToken);
+              while (i + 1 < tokens.length && tokens[i + 1].type === "text") {
+                textToken = tokens[++i];
+                body += "\n" + this.renderer.text(textToken);
               }
-              const hooksProp = prop;
-              const hooksFunc = pack.hooks[hooksProp];
-              const prevHook = hooks[hooksProp];
-              if (_Hooks.passThroughHooks.has(prop)) {
-                hooks[hooksProp] = (arg) => {
-                  if (this.defaults.async) {
-                    return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
-                      return prevHook.call(hooks, ret2);
-                    });
-                  }
-                  const ret = hooksFunc.call(hooks, arg);
-                  return prevHook.call(hooks, ret);
-                };
+              if (top) {
+                out += this.renderer.paragraph({
+                  type: "paragraph",
+                  raw: body,
+                  text: body,
+                  tokens: [{ type: "text", raw: body, text: body, escaped: true }]
+                });
               } else {
-                hooks[hooksProp] = (...args2) => {
-                  let ret = hooksFunc.apply(hooks, args2);
-                  if (ret === false) {
-                    ret = prevHook.apply(hooks, args2);
-                  }
-                  return ret;
-                };
+                out += body;
               }
+              continue;
             }
-            opts.hooks = hooks;
-          }
-          if (pack.walkTokens) {
-            const walkTokens2 = this.defaults.walkTokens;
-            const packWalktokens = pack.walkTokens;
-            opts.walkTokens = function(token) {
-              let values = [];
-              values.push(packWalktokens.call(this, token));
-              if (walkTokens2) {
-                values = values.concat(walkTokens2.call(this, token));
+            default: {
+              const errMsg = 'Token with "' + token.type + '" type was not found.';
+              if (this.options.silent) {
+                console.error(errMsg);
+                return "";
+              } else {
+                throw new Error(errMsg);
               }
-              return values;
-            };
+            }
           }
-          this.defaults = { ...this.defaults, ...opts };
-        });
-        return this;
-      }
-      setOptions(opt) {
-        this.defaults = { ...this.defaults, ...opt };
-        return this;
-      }
-      lexer(src, options2) {
-        return _Lexer.lex(src, options2 ?? this.defaults);
-      }
-      parser(tokens, options2) {
-        return _Parser.parse(tokens, options2 ?? this.defaults);
+        }
+        return out;
       }
-      parseMarkdown(blockType) {
-        const parse2 = (src, options2) => {
-          const origOpt = { ...options2 };
-          const opt = { ...this.defaults, ...origOpt };
-          const throwError = this.onError(!!opt.silent, !!opt.async);
-          if (this.defaults.async === true && origOpt.async === false) {
-            return throwError(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
-          }
-          if (typeof src === "undefined" || src === null) {
-            return throwError(new Error("marked(): input parameter is undefined or null"));
-          }
-          if (typeof src !== "string") {
-            return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
-          }
-          if (opt.hooks) {
-            opt.hooks.options = opt;
-            opt.hooks.block = blockType;
-          }
-          const lexer2 = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
-          const parser2 = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
-          if (opt.async) {
-            return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html2) => opt.hooks ? opt.hooks.postprocess(html2) : html2).catch(throwError);
+      /**
+       * Parse Inline Tokens
+       */
+      parseInline(tokens, renderer2 = this.renderer) {
+        let out = "";
+        for (let i = 0; i < tokens.length; i++) {
+          const anyToken = tokens[i];
+          if (this.options.extensions?.renderers?.[anyToken.type]) {
+            const ret = this.options.extensions.renderers[anyToken.type].call({ parser: this }, anyToken);
+            if (ret !== false || !["escape", "html", "link", "image", "strong", "em", "codespan", "br", "del", "text"].includes(anyToken.type)) {
+              out += ret || "";
+              continue;
+            }
           }
-          try {
-            if (opt.hooks) {
-              src = opt.hooks.preprocess(src);
+          const token = anyToken;
+          switch (token.type) {
+            case "escape": {
+              out += renderer2.text(token);
+              break;
             }
-            let tokens = lexer2(src, opt);
-            if (opt.hooks) {
-              tokens = opt.hooks.processAllTokens(tokens);
+            case "html": {
+              out += renderer2.html(token);
+              break;
             }
-            if (opt.walkTokens) {
-              this.walkTokens(tokens, opt.walkTokens);
+            case "link": {
+              out += renderer2.link(token);
+              break;
             }
-            let html2 = parser2(tokens, opt);
-            if (opt.hooks) {
-              html2 = opt.hooks.postprocess(html2);
+            case "image": {
+              out += renderer2.image(token);
+              break;
             }
-            return html2;
-          } catch (e) {
-            return throwError(e);
-          }
-        };
-        return parse2;
-      }
-      onError(silent, async) {
-        return (e) => {
-          e.message += "\nPlease report this to https://github.com/markedjs/marked.";
-          if (silent) {
-            const msg = "<p>An error occurred:</p><pre>" + escape22(e.message + "", true) + "</pre>";
-            if (async) {
-              return Promise.resolve(msg);
+            case "strong": {
+              out += renderer2.strong(token);
+              break;
+            }
+            case "em": {
+              out += renderer2.em(token);
+              break;
+            }
+            case "codespan": {
+              out += renderer2.codespan(token);
+              break;
+            }
+            case "br": {
+              out += renderer2.br(token);
+              break;
+            }
+            case "del": {
+              out += renderer2.del(token);
+              break;
+            }
+            case "text": {
+              out += renderer2.text(token);
+              break;
+            }
+            default: {
+              const errMsg = 'Token with "' + token.type + '" type was not found.';
+              if (this.options.silent) {
+                console.error(errMsg);
+                return "";
+              } else {
+                throw new Error(errMsg);
+              }
             }
-            return msg;
-          }
-          if (async) {
-            return Promise.reject(e);
           }
-          throw e;
-        };
+        }
+        return out;
       }
     };
-    markedInstance = new Marked();
-    marked.options = marked.setOptions = function(options2) {
-      markedInstance.setOptions(options2);
-      marked.defaults = markedInstance.defaults;
-      changeDefaults(marked.defaults);
-      return marked;
-    };
-    marked.getDefaults = _getDefaults;
-    marked.defaults = _defaults;
-    marked.use = function(...args) {
-      markedInstance.use(...args);
-      marked.defaults = markedInstance.defaults;
-      changeDefaults(marked.defaults);
-      return marked;
-    };
-    marked.walkTokens = function(tokens, callback) {
-      return markedInstance.walkTokens(tokens, callback);
-    };
-    marked.parseInline = markedInstance.parseInline;
-    marked.Parser = _Parser;
-    marked.parser = _Parser.parse;
-    marked.Renderer = _Renderer;
-    marked.TextRenderer = _TextRenderer;
-    marked.Lexer = _Lexer;
-    marked.lexer = _Lexer.lex;
-    marked.Tokenizer = _Tokenizer;
-    marked.Hooks = _Hooks;
-    marked.parse = marked;
-    options = marked.options;
-    setOptions = marked.setOptions;
-    use = marked.use;
-    walkTokens = marked.walkTokens;
-    parseInline = marked.parseInline;
-    parser = _Parser.parse;
-    lexer = _Lexer.lex;
-  }
-});
-
-// src/ui/components/markdown.tsx
-function renderMarkdown(markdown, maxWidth = 120) {
-  const lexer2 = new _Lexer();
-  const tokens = lexer2.lex(markdown);
-  return renderTokens(tokens, maxWidth);
-}
-function renderTokens(tokens, maxWidth) {
-  const lines = [];
-  for (const token of tokens) {
-    switch (token.type) {
-      case "heading":
-        lines.push(renderHeading(token));
-        lines.push("");
-        break;
-      case "paragraph":
-        lines.push(renderInline(token.text));
-        lines.push("");
-        break;
-      case "code":
-        lines.push(...renderCodeBlock(token, maxWidth));
-        lines.push("");
-        break;
-      case "list":
-        lines.push(...renderList(token));
-        lines.push("");
-        break;
-      case "blockquote":
-        lines.push(...renderBlockquote(token));
-        lines.push("");
-        break;
-      case "table":
-        lines.push(...renderTable(token, maxWidth));
-        lines.push("");
-        break;
-      case "hr":
-        lines.push(`${FG_GRAY}${"\u2500".repeat(Math.min(maxWidth, 60))}${RESET}`);
-        lines.push("");
-        break;
-      case "space":
-        lines.push("");
-        break;
-      case "html":
-        lines.push(renderInline(token.text.replace(/<[^>]+>/g, "")));
-        break;
-      default:
-        if ("text" in token) {
-          lines.push(renderInline(String(token.text)));
-        }
-        break;
-    }
-  }
-  return lines.join("\n");
-}
-function renderHeading(token) {
-  const prefix = token.depth <= 2 ? `${BOLD}${FG_CYAN}` : `${BOLD}${FG_BLUE}`;
-  const marker = "#".repeat(token.depth);
-  return `${prefix}${marker} ${renderInline(token.text)}${RESET}`;
-}
-function renderCodeBlock(token, maxWidth) {
-  const lines = [];
-  const lang = token.lang ?? "";
-  if (lang) {
-    lines.push(`${FG_GRAY}\u250C\u2500 ${lang} ${"\u2500".repeat(Math.max(0, Math.min(maxWidth, 60) - lang.length - 4))}${RESET}`);
-  } else {
-    lines.push(`${FG_GRAY}\u250C${"\u2500".repeat(Math.min(maxWidth, 60) - 1)}${RESET}`);
-  }
-  for (const line of token.text.split("\n")) {
-    const highlighted = lang ? highlightSyntax(line, lang) : `${FG_GREEN}${line}${RESET}`;
-    lines.push(`${FG_GRAY}\u2502${RESET} ${highlighted}`);
-  }
-  lines.push(`${FG_GRAY}\u2514${"\u2500".repeat(Math.min(maxWidth, 60) - 1)}${RESET}`);
-  return lines;
-}
-function renderList(token) {
-  const lines = [];
-  const ordered = token.ordered;
-  for (let i = 0; i < token.items.length; i++) {
-    const item = token.items[i];
-    const marker = ordered ? `${FG_YELLOW}${i + 1}.${RESET}` : `${FG_YELLOW}\u2022${RESET}`;
-    const text = renderInline(item.text);
-    lines.push(`  ${marker} ${text}`);
-    if (item.tokens) {
-      for (const subToken of item.tokens) {
-        if (subToken.type === "list") {
-          const subLines = renderList(subToken);
-          lines.push(...subLines.map((l) => `    ${l}`));
-        }
+    _Hooks = class {
+      options;
+      block;
+      constructor(options2) {
+        this.options = options2 || _defaults;
+      }
+      static passThroughHooks = /* @__PURE__ */ new Set([
+        "preprocess",
+        "postprocess",
+        "processAllTokens"
+      ]);
+      /**
+       * Process markdown before marked
+       */
+      preprocess(markdown) {
+        return markdown;
+      }
+      /**
+       * Process HTML after marked is finished
+       */
+      postprocess(html2) {
+        return html2;
+      }
+      /**
+       * Process all tokens before walk tokens
+       */
+      processAllTokens(tokens) {
+        return tokens;
+      }
+      /**
+       * Provide function to tokenize markdown
+       */
+      provideLexer() {
+        return this.block ? _Lexer.lex : _Lexer.lexInline;
+      }
+      /**
+       * Provide function to parse tokens
+       */
+      provideParser() {
+        return this.block ? _Parser.parse : _Parser.parseInline;
       }
-    }
-  }
-  return lines;
-}
-function renderBlockquote(token) {
-  const inner = renderTokens(token.tokens, 100);
-  return inner.split("\n").map((line) => `${FG_GRAY}\u2502${RESET} ${DIM}${line}${RESET}`);
-}
-function renderTable(token, maxWidth) {
-  const lines = [];
-  const colWidths = token.header.map((h) => h.text.length);
-  for (const row of token.rows) {
-    for (let i = 0; i < row.length; i++) {
-      colWidths[i] = Math.max(colWidths[i] ?? 0, row[i].text.length);
-    }
-  }
-  const totalWidth = colWidths.reduce((a, b) => a + b, 0) + colWidths.length * 3 + 1;
-  if (totalWidth > maxWidth) {
-    const scale = maxWidth / totalWidth;
-    for (let i = 0; i < colWidths.length; i++) {
-      colWidths[i] = Math.max(3, Math.floor(colWidths[i] * scale));
-    }
-  }
-  const headerLine = token.header.map((h, i) => pad(h.text, colWidths[i])).join(` ${FG_GRAY}\u2502${RESET} `);
-  lines.push(`${BOLD}${headerLine}${RESET}`);
-  const sepLine = colWidths.map((w) => "\u2500".repeat(w)).join(`\u2500\u253C\u2500`);
-  lines.push(`${FG_GRAY}${sepLine}${RESET}`);
-  for (const row of token.rows) {
-    const rowLine = row.map((cell, i) => pad(cell.text, colWidths[i])).join(` ${FG_GRAY}\u2502${RESET} `);
-    lines.push(rowLine);
-  }
-  return lines;
-}
-function renderInline(text) {
-  return text.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET}`).replace(/__(.+?)__/g, `${BOLD}$1${RESET}`).replace(/\*(.+?)\*/g, `${ITALIC}$1${RESET}`).replace(/_(.+?)_/g, `${ITALIC}$1${RESET}`).replace(/~~(.+?)~~/g, `${STRIKETHROUGH}$1${RESET}`).replace(/`([^`]+)`/g, `${BG_GRAY}${FG_GREEN} $1 ${RESET}`).replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${UNDERLINE}${FG_BLUE}$1${RESET}${FG_GRAY} ($2)${RESET}`).replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
-}
-function highlightSyntax(line, lang) {
-  const keywords = {
-    typescript: ["import", "export", "from", "const", "let", "var", "function", "class", "interface", "type", "return", "if", "else", "for", "while", "async", "await", "new", "this", "extends", "implements"],
-    javascript: ["import", "export", "from", "const", "let", "var", "function", "class", "return", "if", "else", "for", "while", "async", "await", "new", "this"],
-    python: ["import", "from", "def", "class", "return", "if", "elif", "else", "for", "while", "with", "as", "try", "except", "finally", "raise", "yield", "async", "await", "self"],
-    rust: ["fn", "let", "mut", "pub", "struct", "enum", "impl", "trait", "use", "mod", "return", "if", "else", "for", "while", "match", "self", "super", "crate"],
-    go: ["func", "var", "const", "type", "struct", "interface", "return", "if", "else", "for", "range", "switch", "case", "package", "import", "defer", "go", "chan"]
-  };
-  const ts = keywords.typescript ?? [];
-  const kw = keywords[lang] ?? keywords[lang.replace(/x$/, "")] ?? ts;
-  let result = line;
-  result = result.replace(/(\/\/.*$)/gm, `${FG_GRAY}$1${RESET}`);
-  result = result.replace(/(#.*$)/gm, `${FG_GRAY}$1${RESET}`);
-  result = result.replace(/("[^"]*")/g, `${FG_GREEN}$1${RESET}`);
-  result = result.replace(/('[^']*')/g, `${FG_GREEN}$1${RESET}`);
-  result = result.replace(/(`[^`]*`)/g, `${FG_GREEN}$1${RESET}`);
-  for (const kwd of kw) {
-    result = result.replace(
-      new RegExp(`\\b(${kwd})\\b`, "g"),
-      `${FG_MAGENTA}$1${RESET}`
-    );
-  }
-  result = result.replace(/\b(\d+\.?\d*)\b/g, `${FG_YELLOW}$1${RESET}`);
-  return result;
-}
-function pad(text, width) {
-  if (text.length >= width) return text.slice(0, width);
-  return text + " ".repeat(width - text.length);
-}
-var ESC2, RESET, BOLD, DIM, ITALIC, UNDERLINE, STRIKETHROUGH, FG_CYAN, FG_YELLOW, FG_GREEN, FG_BLUE, FG_MAGENTA, FG_GRAY, BG_GRAY;
-var init_markdown = __esm({
-  "src/ui/components/markdown.tsx"() {
-    "use strict";
-    init_marked_esm();
-    ESC2 = "\x1B[";
-    RESET = `${ESC2}0m`;
-    BOLD = `${ESC2}1m`;
-    DIM = `${ESC2}2m`;
-    ITALIC = `${ESC2}3m`;
-    UNDERLINE = `${ESC2}4m`;
-    STRIKETHROUGH = `${ESC2}9m`;
-    FG_CYAN = `${ESC2}36m`;
-    FG_YELLOW = `${ESC2}33m`;
-    FG_GREEN = `${ESC2}32m`;
-    FG_BLUE = `${ESC2}34m`;
-    FG_MAGENTA = `${ESC2}35m`;
-    FG_GRAY = `${ESC2}90m`;
-    BG_GRAY = `${ESC2}100m`;
-  }
-});
-
-// src/api/index.ts
-var init_api = __esm({
-  "src/api/index.ts"() {
-    "use strict";
-    init_client();
-    init_models();
-    init_streaming();
-  }
-});
-
-// src/core/errors.ts
-function errorToString(err) {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  return String(err);
-}
-var init_errors2 = __esm({
-  "src/core/errors.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/agent-loop.ts
-async function runAgentLoop(initialMessages, options2) {
-  const client = options2.client ?? getApiClient();
-  const messages = [...initialMessages];
-  const maxTurns = options2.maxTurns ?? DEFAULT_MAX_TURNS;
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let turnIndex = 0;
-  let aborted = false;
-  const toolDefs = buildToolDefinitions(options2.tools);
-  const toolMap = new Map(options2.tools.map((t) => [t.name, t]));
-  while (turnIndex < maxTurns) {
-    if (options2.signal?.aborted) {
-      aborted = true;
-      break;
-    }
-    options2.onProgress?.({ type: "turn_start", turnIndex });
-    const request = {
-      model: options2.model,
-      messages,
-      systemPrompt: options2.systemPrompt,
-      tools: toolDefs.length > 0 ? toolDefs : void 0,
-      thinkingConfig: options2.thinkingConfig,
-      maxTokens: options2.maxTokens,
-      stream: true,
-      signal: options2.signal,
-      querySource: options2.querySource
     };
-    options2.onProgress?.({ type: "streaming", turnIndex });
-    const contentBlocks = [];
-    let stopReason = null;
-    try {
-      for await (const item of client.streamMessage(request)) {
-        if (options2.signal?.aborted) {
-          aborted = true;
-          break;
+    Marked = class {
+      defaults = _getDefaults();
+      options = this.setOptions;
+      parse = this.parseMarkdown(true);
+      parseInline = this.parseMarkdown(false);
+      Parser = _Parser;
+      Renderer = _Renderer;
+      TextRenderer = _TextRenderer;
+      Lexer = _Lexer;
+      Tokenizer = _Tokenizer;
+      Hooks = _Hooks;
+      constructor(...args) {
+        this.use(...args);
+      }
+      /**
+       * Run callback for every token
+       */
+      walkTokens(tokens, callback) {
+        let values = [];
+        for (const token of tokens) {
+          values = values.concat(callback.call(this, token));
+          switch (token.type) {
+            case "table": {
+              const tableToken = token;
+              for (const cell of tableToken.header) {
+                values = values.concat(this.walkTokens(cell.tokens, callback));
+              }
+              for (const row of tableToken.rows) {
+                for (const cell of row) {
+                  values = values.concat(this.walkTokens(cell.tokens, callback));
+                }
+              }
+              break;
+            }
+            case "list": {
+              const listToken = token;
+              values = values.concat(this.walkTokens(listToken.items, callback));
+              break;
+            }
+            default: {
+              const genericToken = token;
+              if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
+                this.defaults.extensions.childTokens[genericToken.type].forEach((childTokens) => {
+                  const tokens2 = genericToken[childTokens].flat(Infinity);
+                  values = values.concat(this.walkTokens(tokens2, callback));
+                });
+              } else if (genericToken.tokens) {
+                values = values.concat(this.walkTokens(genericToken.tokens, callback));
+              }
+            }
+          }
         }
-        const { event, accumulated } = item;
-        if (event.type === "content_block_delta" && event.delta) {
-          if (event.delta.type === "text_delta") {
-            options2.onTextDelta?.(event.delta.text);
-          } else if (event.delta.type === "thinking_delta") {
-            options2.onThinkingDelta?.(event.delta.thinking);
+        return values;
+      }
+      use(...args) {
+        const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+        args.forEach((pack) => {
+          const opts = { ...pack };
+          opts.async = this.defaults.async || opts.async || false;
+          if (pack.extensions) {
+            pack.extensions.forEach((ext) => {
+              if (!ext.name) {
+                throw new Error("extension name required");
+              }
+              if ("renderer" in ext) {
+                const prevRenderer = extensions.renderers[ext.name];
+                if (prevRenderer) {
+                  extensions.renderers[ext.name] = function(...args2) {
+                    let ret = ext.renderer.apply(this, args2);
+                    if (ret === false) {
+                      ret = prevRenderer.apply(this, args2);
+                    }
+                    return ret;
+                  };
+                } else {
+                  extensions.renderers[ext.name] = ext.renderer;
+                }
+              }
+              if ("tokenizer" in ext) {
+                if (!ext.level || ext.level !== "block" && ext.level !== "inline") {
+                  throw new Error("extension level must be 'block' or 'inline'");
+                }
+                const extLevel = extensions[ext.level];
+                if (extLevel) {
+                  extLevel.unshift(ext.tokenizer);
+                } else {
+                  extensions[ext.level] = [ext.tokenizer];
+                }
+                if (ext.start) {
+                  if (ext.level === "block") {
+                    if (extensions.startBlock) {
+                      extensions.startBlock.push(ext.start);
+                    } else {
+                      extensions.startBlock = [ext.start];
+                    }
+                  } else if (ext.level === "inline") {
+                    if (extensions.startInline) {
+                      extensions.startInline.push(ext.start);
+                    } else {
+                      extensions.startInline = [ext.start];
+                    }
+                  }
+                }
+              }
+              if ("childTokens" in ext && ext.childTokens) {
+                extensions.childTokens[ext.name] = ext.childTokens;
+              }
+            });
+            opts.extensions = extensions;
+          }
+          if (pack.renderer) {
+            const renderer2 = this.defaults.renderer || new _Renderer(this.defaults);
+            for (const prop in pack.renderer) {
+              if (!(prop in renderer2)) {
+                throw new Error(`renderer '${prop}' does not exist`);
+              }
+              if (["options", "parser"].includes(prop)) {
+                continue;
+              }
+              const rendererProp = prop;
+              const rendererFunc = pack.renderer[rendererProp];
+              const prevRenderer = renderer2[rendererProp];
+              renderer2[rendererProp] = (...args2) => {
+                let ret = rendererFunc.apply(renderer2, args2);
+                if (ret === false) {
+                  ret = prevRenderer.apply(renderer2, args2);
+                }
+                return ret || "";
+              };
+            }
+            opts.renderer = renderer2;
+          }
+          if (pack.tokenizer) {
+            const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
+            for (const prop in pack.tokenizer) {
+              if (!(prop in tokenizer)) {
+                throw new Error(`tokenizer '${prop}' does not exist`);
+              }
+              if (["options", "rules", "lexer"].includes(prop)) {
+                continue;
+              }
+              const tokenizerProp = prop;
+              const tokenizerFunc = pack.tokenizer[tokenizerProp];
+              const prevTokenizer = tokenizer[tokenizerProp];
+              tokenizer[tokenizerProp] = (...args2) => {
+                let ret = tokenizerFunc.apply(tokenizer, args2);
+                if (ret === false) {
+                  ret = prevTokenizer.apply(tokenizer, args2);
+                }
+                return ret;
+              };
+            }
+            opts.tokenizer = tokenizer;
+          }
+          if (pack.hooks) {
+            const hooks = this.defaults.hooks || new _Hooks();
+            for (const prop in pack.hooks) {
+              if (!(prop in hooks)) {
+                throw new Error(`hook '${prop}' does not exist`);
+              }
+              if (["options", "block"].includes(prop)) {
+                continue;
+              }
+              const hooksProp = prop;
+              const hooksFunc = pack.hooks[hooksProp];
+              const prevHook = hooks[hooksProp];
+              if (_Hooks.passThroughHooks.has(prop)) {
+                hooks[hooksProp] = (arg) => {
+                  if (this.defaults.async) {
+                    return Promise.resolve(hooksFunc.call(hooks, arg)).then((ret2) => {
+                      return prevHook.call(hooks, ret2);
+                    });
+                  }
+                  const ret = hooksFunc.call(hooks, arg);
+                  return prevHook.call(hooks, ret);
+                };
+              } else {
+                hooks[hooksProp] = (...args2) => {
+                  let ret = hooksFunc.apply(hooks, args2);
+                  if (ret === false) {
+                    ret = prevHook.apply(hooks, args2);
+                  }
+                  return ret;
+                };
+              }
+            }
+            opts.hooks = hooks;
+          }
+          if (pack.walkTokens) {
+            const walkTokens2 = this.defaults.walkTokens;
+            const packWalktokens = pack.walkTokens;
+            opts.walkTokens = function(token) {
+              let values = [];
+              values.push(packWalktokens.call(this, token));
+              if (walkTokens2) {
+                values = values.concat(walkTokens2.call(this, token));
+              }
+              return values;
+            };
+          }
+          this.defaults = { ...this.defaults, ...opts };
+        });
+        return this;
+      }
+      setOptions(opt) {
+        this.defaults = { ...this.defaults, ...opt };
+        return this;
+      }
+      lexer(src, options2) {
+        return _Lexer.lex(src, options2 ?? this.defaults);
+      }
+      parser(tokens, options2) {
+        return _Parser.parse(tokens, options2 ?? this.defaults);
+      }
+      parseMarkdown(blockType) {
+        const parse2 = (src, options2) => {
+          const origOpt = { ...options2 };
+          const opt = { ...this.defaults, ...origOpt };
+          const throwError = this.onError(!!opt.silent, !!opt.async);
+          if (this.defaults.async === true && origOpt.async === false) {
+            return throwError(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
           }
-        }
-        if (event.type === "message_stop" || event.type === "message_delta") {
-          if (accumulated.content) {
-            contentBlocks.length = 0;
-            contentBlocks.push(...accumulated.content);
+          if (typeof src === "undefined" || src === null) {
+            return throwError(new Error("marked(): input parameter is undefined or null"));
           }
-          stopReason = accumulated.stopReason ?? null;
-          if (accumulated.usage) {
-            totalInputTokens += accumulated.usage.inputTokens;
-            totalOutputTokens += accumulated.usage.outputTokens;
+          if (typeof src !== "string") {
+            return throwError(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(src) + ", string expected"));
           }
-        }
+          if (opt.hooks) {
+            opt.hooks.options = opt;
+            opt.hooks.block = blockType;
+          }
+          const lexer2 = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
+          const parser2 = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
+          if (opt.async) {
+            return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then((src2) => lexer2(src2, opt)).then((tokens) => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then((tokens) => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then((tokens) => parser2(tokens, opt)).then((html2) => opt.hooks ? opt.hooks.postprocess(html2) : html2).catch(throwError);
+          }
+          try {
+            if (opt.hooks) {
+              src = opt.hooks.preprocess(src);
+            }
+            let tokens = lexer2(src, opt);
+            if (opt.hooks) {
+              tokens = opt.hooks.processAllTokens(tokens);
+            }
+            if (opt.walkTokens) {
+              this.walkTokens(tokens, opt.walkTokens);
+            }
+            let html2 = parser2(tokens, opt);
+            if (opt.hooks) {
+              html2 = opt.hooks.postprocess(html2);
+            }
+            return html2;
+          } catch (e) {
+            return throwError(e);
+          }
+        };
+        return parse2;
       }
-    } catch (error) {
-      if (error.name === "AbortError") {
-        aborted = true;
-        break;
+      onError(silent, async) {
+        return (e) => {
+          e.message += "\nPlease report this to https://github.com/markedjs/marked.";
+          if (silent) {
+            const msg = "<p>An error occurred:</p><pre>" + escape22(e.message + "", true) + "</pre>";
+            if (async) {
+              return Promise.resolve(msg);
+            }
+            return msg;
+          }
+          if (async) {
+            return Promise.reject(e);
+          }
+          throw e;
+        };
       }
-      throw error;
-    }
-    if (aborted) break;
-    const assistantMessage = {
-      role: "assistant",
-      content: contentBlocks
     };
-    messages.push(assistantMessage);
-    const toolUseBlocks = contentBlocks.filter(
-      (b) => b.type === "tool_use"
-    );
-    if (toolUseBlocks.length === 0 || stopReason === "end_turn") {
-      options2.onTurnComplete?.(turnIndex, assistantMessage);
-      options2.onProgress?.({ type: "turn_end", turnIndex, stopReason });
-      turnIndex++;
-      break;
-    }
-    const toolResults = await executeTools(
-      toolUseBlocks,
-      toolMap,
-      options2
-    );
-    const toolResultMessage = {
-      role: "user",
-      content: toolResults.map((r) => ({
-        type: "tool_result",
-        tool_use_id: r.toolUseId,
-        content: r.error ?? (typeof r.data === "string" ? r.data : JSON.stringify(r.data)),
-        is_error: r.isError
-      }))
+    markedInstance = new Marked();
+    marked.options = marked.setOptions = function(options2) {
+      markedInstance.setOptions(options2);
+      marked.defaults = markedInstance.defaults;
+      changeDefaults(marked.defaults);
+      return marked;
     };
-    messages.push(toolResultMessage);
-    options2.onTurnComplete?.(turnIndex, assistantMessage);
-    options2.onProgress?.({ type: "turn_end", turnIndex, stopReason });
-    turnIndex++;
-  }
-  options2.onProgress?.({ type: "loop_end", totalTurns: turnIndex });
-  return {
-    messages,
-    totalTurns: turnIndex,
-    aborted,
-    usage: { totalInputTokens, totalOutputTokens }
-  };
-}
-async function executeTools(toolUseBlocks, toolMap, options2) {
-  const results = [];
-  const concurrentTools = [];
-  const sequentialTools = [];
-  for (const block2 of toolUseBlocks) {
-    const handler = toolMap.get(block2.name);
-    if (!handler) {
-      results.push({
-        toolUseId: block2.id,
-        toolName: block2.name,
-        error: `Unknown tool: ${block2.name}`,
-        isError: true
-      });
-      continue;
-    }
-    if (handler.isConcurrencySafe) {
-      concurrentTools.push({ block: block2, handler });
-    } else {
-      sequentialTools.push({ block: block2, handler });
-    }
-  }
-  if (concurrentTools.length > 0) {
-    const concurrentResults = await Promise.all(
-      concurrentTools.map(
-        ({ block: block2, handler }) => executeSingleTool(block2, handler, options2)
-      )
-    );
-    results.push(...concurrentResults);
-  }
-  for (const { block: block2, handler } of sequentialTools) {
-    if (options2.signal?.aborted) break;
-    const result = await executeSingleTool(block2, handler, options2);
-    results.push(result);
-  }
-  return results;
-}
-async function executeSingleTool(block2, handler, options2) {
-  const { id: toolUseId, name: toolName, input } = block2;
-  options2.onProgress?.({ type: "tool_execution", toolName, toolUseId });
-  const parseFailed = block2._inputParseFailed;
-  if (parseFailed) {
-    const rawJson = block2._rawInputJson;
-    const error = `Tool input not fully received \u2014 JSON parsing failed for ${toolName}. Partial input (${rawJson?.length ?? 0} chars) could not be parsed. This is a streaming issue; retrying the request should resolve it.`;
-    options2.onToolUseRejected?.(toolName, toolUseId, error);
-    return { toolUseId, toolName, error, isError: true };
-  }
-  if (input && Object.keys(input).length === 0 && handler.inputSchema && Array.isArray(handler.inputSchema.required) && (handler.inputSchema.required ?? []).length > 0) {
-    const error = `Tool input not fully received \u2014 ${toolName} requires parameters (${(handler.inputSchema.required ?? []).join(", ")}) but received empty input {}. Skipping execution to prevent undefined behavior.`;
-    options2.onToolUseRejected?.(toolName, toolUseId, error);
-    return { toolUseId, toolName, error, isError: true };
-  }
-  options2.onToolUseStart?.(toolName, toolUseId, input);
-  try {
-    if (options2.onPermissionCheck) {
-      const permResult = await options2.onPermissionCheck(toolName, input);
-      if (permResult.behavior === "deny") {
-        const reason = permResult.message ?? "Permission denied";
-        options2.onToolUseRejected?.(toolName, toolUseId, reason);
-        return { toolUseId, toolName, error: reason, isError: true };
-      }
-    }
-    if (handler.validateInput) {
-      const validation = await handler.validateInput(input);
-      if (!validation.result) {
-        const error = validation.message ?? "Invalid input";
-        return { toolUseId, toolName, error, isError: true };
-      }
-    }
-    const result = await handler.call(input, {
-      abortSignal: options2.signal,
-      agentId: options2.agentId,
-      toolUseId
-    });
-    options2.onToolUseEnd?.(toolName, toolUseId, result);
-    if (result.isError || result.error) {
-      return { toolUseId, toolName, error: result.error, isError: true };
-    }
-    return { toolUseId, toolName, data: result.data };
-  } catch (error) {
-    const errorMsg = errorToString(error);
-    options2.onToolUseEnd?.(toolName, toolUseId, { error: errorMsg, isError: true });
-    return { toolUseId, toolName, error: errorMsg, isError: true };
-  }
-}
-function buildToolDefinitions(tools) {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.inputSchema
-  }));
-}
-var DEFAULT_MAX_TURNS;
-var init_agent_loop = __esm({
-  "src/core/agent-loop.ts"() {
-    "use strict";
-    init_api();
-    init_errors2();
-    DEFAULT_MAX_TURNS = 100;
-  }
-});
-
-// src/config/permissions.ts
-function createDefaultPermissionContext(settings) {
-  const defaultMode = settings?.permissions?.defaultMode ?? "default";
-  return {
-    mode: defaultMode,
-    allowRules: settings?.permissions?.allow ?? [],
-    denyRules: settings?.permissions?.deny ?? []
-  };
-}
-var init_permissions = __esm({
-  "src/config/permissions.ts"() {
-    "use strict";
+    marked.getDefaults = _getDefaults;
+    marked.defaults = _defaults;
+    marked.use = function(...args) {
+      markedInstance.use(...args);
+      marked.defaults = markedInstance.defaults;
+      changeDefaults(marked.defaults);
+      return marked;
+    };
+    marked.walkTokens = function(tokens, callback) {
+      return markedInstance.walkTokens(tokens, callback);
+    };
+    marked.parseInline = markedInstance.parseInline;
+    marked.Parser = _Parser;
+    marked.parser = _Parser.parse;
+    marked.Renderer = _Renderer;
+    marked.TextRenderer = _TextRenderer;
+    marked.Lexer = _Lexer;
+    marked.lexer = _Lexer.lex;
+    marked.Tokenizer = _Tokenizer;
+    marked.Hooks = _Hooks;
+    marked.parse = marked;
+    options = marked.options;
+    setOptions = marked.setOptions;
+    use = marked.use;
+    walkTokens = marked.walkTokens;
+    parseInline = marked.parseInline;
+    parser = _Parser.parse;
+    lexer = _Lexer.lex;
   }
 });
 
-// src/db/index.ts
-import { join as join2 } from "path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-function getDbPath() {
-  const dir = getConfigDir();
-  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
-  return join2(dir, "coders.db");
+// src/ui/components/markdown.tsx
+function renderMarkdown(markdown, maxWidth = 120) {
+  const lexer2 = new _Lexer();
+  const tokens = lexer2.lex(markdown);
+  return renderTokens(tokens, maxWidth);
 }
-function getDb() {
-  if (_db) return _db;
-  const dbPath = getDbPath();
-  try {
-    const { Database } = __require("bun:sqlite");
-    _db = new Database(dbPath);
-  } catch {
-    try {
-      const BetterSqlite3 = __require("better-sqlite3");
-      _db = new BetterSqlite3(dbPath);
-    } catch {
-      _db = createJsonFileDb();
-      initSchema(_db);
-      return _db;
+function renderTokens(tokens, maxWidth) {
+  const lines = [];
+  for (const token of tokens) {
+    switch (token.type) {
+      case "heading":
+        lines.push(renderHeading(token));
+        lines.push("");
+        break;
+      case "paragraph":
+        lines.push(renderInline(token.text));
+        lines.push("");
+        break;
+      case "code":
+        lines.push(...renderCodeBlock(token, maxWidth));
+        lines.push("");
+        break;
+      case "list":
+        lines.push(...renderList(token));
+        lines.push("");
+        break;
+      case "blockquote":
+        lines.push(...renderBlockquote(token));
+        lines.push("");
+        break;
+      case "table":
+        lines.push(...renderTable(token, maxWidth));
+        lines.push("");
+        break;
+      case "hr":
+        lines.push(`${FG_GRAY}${"\u2500".repeat(Math.min(maxWidth, 60))}${FG_DEFAULT}`);
+        lines.push("");
+        break;
+      case "space":
+        lines.push("");
+        break;
+      case "html":
+        lines.push(renderInline(token.text.replace(/<[^>]+>/g, "")));
+        break;
+      default:
+        if ("text" in token) {
+          lines.push(renderInline(String(token.text)));
+        }
+        break;
     }
   }
-  try {
-    _db.exec("PRAGMA journal_mode=WAL");
-  } catch {
+  return lines.join("\n");
+}
+function renderHeading(token) {
+  const color = token.depth <= 2 ? FG_CYAN : FG_BLUE;
+  const prefix = `${BOLD}${color}`;
+  const marker = "#".repeat(token.depth);
+  const inner = renderInlineWithRestore(token.text, prefix);
+  return `${prefix}${marker} ${inner}${RESET}`;
+}
+function renderCodeBlock(token, maxWidth) {
+  const lines = [];
+  const lang = token.lang ?? "";
+  if (lang) {
+    lines.push(`${FG_GRAY}\u250C\u2500 ${lang} ${"\u2500".repeat(Math.max(0, Math.min(maxWidth, 60) - lang.length - 4))}${FG_DEFAULT}`);
+  } else {
+    lines.push(`${FG_GRAY}\u250C${"\u2500".repeat(Math.min(maxWidth, 60) - 1)}${FG_DEFAULT}`);
   }
-  try {
-    _db.exec("PRAGMA foreign_keys=ON");
-  } catch {
+  for (const line of token.text.split("\n")) {
+    const highlighted = lang ? highlightSyntax(line, lang) : `${FG_GREEN}${line}${FG_DEFAULT}`;
+    lines.push(`${FG_GRAY}\u2502${FG_DEFAULT} ${highlighted}`);
   }
-  initSchema(_db);
-  return _db;
+  lines.push(`${FG_GRAY}\u2514${"\u2500".repeat(Math.min(maxWidth, 60) - 1)}${FG_DEFAULT}`);
+  return lines;
 }
-function initSchema(db) {
-  db.exec(`
-    -- Sessions
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      device_id TEXT NOT NULL,
-      project_dir TEXT,
-      original_cwd TEXT,
-      model TEXT,
-      app_version TEXT,
-      build_time TEXT,
-      fingerprint TEXT, -- JSON
-      metadata TEXT,    -- JSON
-      created_at TEXT DEFAULT (datetime('now')),
-      updated_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- Messages (conversation history)
-    CREATE TABLE IF NOT EXISTS messages (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES sessions(id),
-      role TEXT NOT NULL CHECK(role IN ('user','assistant','system')),
-      content TEXT NOT NULL,
-      tool_uses TEXT,    -- JSON array of tool use displays
-      thinking TEXT,
-      duration_ms REAL,
-      tokens_in INTEGER DEFAULT 0,
-      tokens_out INTEGER DEFAULT 0,
-      cost_usd REAL DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
-
-    -- File history (tracks reads per session)
-    CREATE TABLE IF NOT EXISTS file_history (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      content_hash TEXT,
-      byte_size INTEGER,
-      line_count INTEGER,
-      read_at TEXT DEFAULT (datetime('now')),
-      UNIQUE(session_id, file_path)
-    );
-
-    -- File checkpoints (for /rewind)
-    CREATE TABLE IF NOT EXISTS checkpoints (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      original_content TEXT NOT NULL,
-      edit_operation TEXT, -- JSON {old_string, new_string}
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_checkpoints_session_file ON checkpoints(session_id, file_path);
-
-    -- Tasks (replaces in-memory fallback for @hasna/todos)
-    CREATE TABLE IF NOT EXISTS tasks (
-      id TEXT PRIMARY KEY,
-      subject TEXT NOT NULL,
-      description TEXT DEFAULT '',
-      status TEXT DEFAULT 'pending' CHECK(status IN ('pending','in_progress','completed','failed','cancelled')),
-      active_form TEXT,
-      owner TEXT,
-      blocks TEXT DEFAULT '[]',      -- JSON array of task IDs
-      blocked_by TEXT DEFAULT '[]',   -- JSON array of task IDs
-      metadata TEXT DEFAULT '{}',     -- JSON
-      created_at TEXT DEFAULT (datetime('now')),
-      updated_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- Config (replaces JSON files)
-    CREATE TABLE IF NOT EXISTS config (
-      key TEXT PRIMARY KEY,
-      value TEXT, -- JSON
-      scope TEXT DEFAULT 'user' CHECK(scope IN ('user','project','local','global')),
-      updated_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- Memories (replaces in-memory fallback for @hasna/mementos)
-    CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      key TEXT UNIQUE NOT NULL,
-      value TEXT NOT NULL,
-      scope TEXT DEFAULT 'shared' CHECK(scope IN ('global','shared','private')),
-      category TEXT DEFAULT 'knowledge',
-      importance INTEGER DEFAULT 5 CHECK(importance BETWEEN 1 AND 10),
-      tags TEXT DEFAULT '[]', -- JSON array
-      version INTEGER DEFAULT 1,
-      created_at TEXT DEFAULT (datetime('now')),
-      updated_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- Teams
-    CREATE TABLE IF NOT EXISTS teams (
-      name TEXT PRIMARY KEY,
-      description TEXT,
-      task_list_id TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- Team members
-    CREATE TABLE IF NOT EXISTS team_members (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      team_name TEXT NOT NULL REFERENCES teams(name),
-      agent_name TEXT NOT NULL,
-      role TEXT,
-      status TEXT DEFAULT 'idle',
-      current_task TEXT,
-      UNIQUE(team_name, agent_name)
-    );
-
-    -- Team messages
-    CREATE TABLE IF NOT EXISTS team_messages (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      from_agent TEXT NOT NULL,
-      to_agent TEXT NOT NULL,
-      team_name TEXT,
-      content TEXT NOT NULL,
-      is_read INTEGER DEFAULT 0,
-      is_blocking INTEGER DEFAULT 0,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_team_msgs_to ON team_messages(to_agent, is_read);
-
-    -- Permissions (persisted allow/deny rules)
-    CREATE TABLE IF NOT EXISTS permissions (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      tool_name TEXT,
-      command_pattern TEXT,
-      path_pattern TEXT,
-      behavior TEXT NOT NULL CHECK(behavior IN ('allow','deny')),
-      scope TEXT DEFAULT 'session',
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-
-    -- MCP servers
-    CREATE TABLE IF NOT EXISTS mcp_servers (
-      name TEXT PRIMARY KEY,
-      command TEXT,
-      args TEXT,    -- JSON array
-      env TEXT,     -- JSON object
-      url TEXT,
-      transport TEXT DEFAULT 'stdio',
-      scope TEXT DEFAULT 'user',
-      enabled INTEGER DEFAULT 1,
-      created_at TEXT DEFAULT (datetime('now'))
+function renderList(token) {
+  const lines = [];
+  const ordered = token.ordered;
+  for (let i = 0; i < token.items.length; i++) {
+    const item = token.items[i];
+    const marker = ordered ? `${FG_YELLOW}${i + 1}.${FG_DEFAULT}` : `${FG_YELLOW}\u2022${FG_DEFAULT}`;
+    const text = renderInline(item.text);
+    lines.push(`  ${marker} ${text}`);
+    if (item.tokens) {
+      for (const subToken of item.tokens) {
+        if (subToken.type === "list") {
+          const subLines = renderList(subToken);
+          lines.push(...subLines.map((l) => `    ${l}`));
+        }
+      }
+    }
+  }
+  return lines;
+}
+function renderBlockquote(token) {
+  const inner = renderTokens(token.tokens, 100);
+  return inner.split("\n").map((line) => `${FG_GRAY}\u2502${FG_DEFAULT} ${DIM}${line}${DIM_OFF}`);
+}
+function renderTable(token, maxWidth) {
+  const lines = [];
+  const colWidths = token.header.map((h) => h.text.length);
+  for (const row of token.rows) {
+    for (let i = 0; i < row.length; i++) {
+      colWidths[i] = Math.max(colWidths[i] ?? 0, row[i].text.length);
+    }
+  }
+  const totalWidth = colWidths.reduce((a, b) => a + b, 0) + colWidths.length * 3 + 1;
+  if (totalWidth > maxWidth) {
+    const scale = maxWidth / totalWidth;
+    for (let i = 0; i < colWidths.length; i++) {
+      colWidths[i] = Math.max(3, Math.floor(colWidths[i] * scale));
+    }
+  }
+  const headerLine = token.header.map((h, i) => pad(h.text, colWidths[i])).join(` ${FG_GRAY}\u2502${FG_DEFAULT} `);
+  lines.push(`${BOLD}${headerLine}${BOLD_OFF}`);
+  const sepLine = colWidths.map((w) => "\u2500".repeat(w)).join(`\u2500\u253C\u2500`);
+  lines.push(`${FG_GRAY}${sepLine}${FG_DEFAULT}`);
+  for (const row of token.rows) {
+    const rowLine = row.map((cell, i) => pad(cell.text, colWidths[i])).join(` ${FG_GRAY}\u2502${FG_DEFAULT} `);
+    lines.push(rowLine);
+  }
+  return lines;
+}
+function renderInline(text) {
+  return renderInlineWithRestore(text, "");
+}
+function renderInlineWithRestore(text, restore) {
+  return text.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${BOLD_OFF}${restore}`).replace(/__(.+?)__/g, `${BOLD}$1${BOLD_OFF}${restore}`).replace(/\*(.+?)\*/g, `${ITALIC}$1${ITALIC_OFF}${restore}`).replace(/_(.+?)_/g, `${ITALIC}$1${ITALIC_OFF}${restore}`).replace(/~~(.+?)~~/g, `${STRIKETHROUGH}$1${STRIKE_OFF}${restore}`).replace(/`([^`]+)`/g, `${BG_GRAY}${FG_GREEN} $1 ${FG_DEFAULT}${BG_DEFAULT}${restore}`).replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${UNDERLINE}${FG_BLUE}$1${UNDERLINE_OFF}${FG_DEFAULT}${FG_GRAY} ($2)${FG_DEFAULT}${restore}`).replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+}
+function highlightSyntax(line, lang) {
+  const keywords = {
+    typescript: ["import", "export", "from", "const", "let", "var", "function", "class", "interface", "type", "return", "if", "else", "for", "while", "async", "await", "new", "this", "extends", "implements"],
+    javascript: ["import", "export", "from", "const", "let", "var", "function", "class", "return", "if", "else", "for", "while", "async", "await", "new", "this"],
+    python: ["import", "from", "def", "class", "return", "if", "elif", "else", "for", "while", "with", "as", "try", "except", "finally", "raise", "yield", "async", "await", "self"],
+    rust: ["fn", "let", "mut", "pub", "struct", "enum", "impl", "trait", "use", "mod", "return", "if", "else", "for", "while", "match", "self", "super", "crate"],
+    go: ["func", "var", "const", "type", "struct", "interface", "return", "if", "else", "for", "range", "switch", "case", "package", "import", "defer", "go", "chan"]
+  };
+  const ts = keywords.typescript ?? [];
+  const kw = keywords[lang] ?? keywords[lang.replace(/x$/, "")] ?? ts;
+  let result = line;
+  result = result.replace(/(\/\/.*$)/gm, `${FG_GRAY}$1${FG_DEFAULT}`);
+  result = result.replace(/(#.*$)/gm, `${FG_GRAY}$1${FG_DEFAULT}`);
+  result = result.replace(/("[^"]*")/g, `${FG_GREEN}$1${FG_DEFAULT}`);
+  result = result.replace(/('[^']*')/g, `${FG_GREEN}$1${FG_DEFAULT}`);
+  result = result.replace(/(`[^`]*`)/g, `${FG_GREEN}$1${FG_DEFAULT}`);
+  for (const kwd of kw) {
+    result = result.replace(
+      new RegExp(`\\b(${kwd})\\b`, "g"),
+      `${FG_MAGENTA}$1${FG_DEFAULT}`
     );
+  }
+  result = result.replace(/\b(\d+\.?\d*)\b/g, `${FG_YELLOW}$1${FG_DEFAULT}`);
+  return result;
+}
+function pad(text, width) {
+  if (text.length >= width) return text.slice(0, width);
+  return text + " ".repeat(width - text.length);
+}
+var ESC2, RESET, BOLD, BOLD_OFF, DIM, DIM_OFF, ITALIC, ITALIC_OFF, UNDERLINE, UNDERLINE_OFF, STRIKETHROUGH, STRIKE_OFF, FG_CYAN, FG_YELLOW, FG_GREEN, FG_BLUE, FG_MAGENTA, FG_GRAY, FG_DEFAULT, BG_GRAY, BG_DEFAULT;
+var init_markdown = __esm({
+  "src/ui/components/markdown.tsx"() {
+    "use strict";
+    init_marked_esm();
+    ESC2 = "\x1B[";
+    RESET = `${ESC2}0m`;
+    BOLD = `${ESC2}1m`;
+    BOLD_OFF = `${ESC2}22m`;
+    DIM = `${ESC2}2m`;
+    DIM_OFF = `${ESC2}22m`;
+    ITALIC = `${ESC2}3m`;
+    ITALIC_OFF = `${ESC2}23m`;
+    UNDERLINE = `${ESC2}4m`;
+    UNDERLINE_OFF = `${ESC2}24m`;
+    STRIKETHROUGH = `${ESC2}9m`;
+    STRIKE_OFF = `${ESC2}29m`;
+    FG_CYAN = `${ESC2}36m`;
+    FG_YELLOW = `${ESC2}33m`;
+    FG_GREEN = `${ESC2}32m`;
+    FG_BLUE = `${ESC2}34m`;
+    FG_MAGENTA = `${ESC2}35m`;
+    FG_GRAY = `${ESC2}90m`;
+    FG_DEFAULT = `${ESC2}39m`;
+    BG_GRAY = `${ESC2}100m`;
+    BG_DEFAULT = `${ESC2}49m`;
+  }
+});
 
-    -- Metrics (per-turn tracking)
-    CREATE TABLE IF NOT EXISTS metrics (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL,
-      turn_index INTEGER,
-      tokens_in INTEGER DEFAULT 0,
-      tokens_out INTEGER DEFAULT 0,
-      cost_usd REAL DEFAULT 0,
-      api_duration_ms REAL DEFAULT 0,
-      tool_duration_ms REAL DEFAULT 0,
-      hook_duration_ms REAL DEFAULT 0,
-      tool_count INTEGER DEFAULT 0,
-      model TEXT,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
+// src/api/index.ts
+var init_api = __esm({
+  "src/api/index.ts"() {
+    "use strict";
+    init_client();
+    init_models();
+    init_streaming();
+  }
+});
 
-    -- Audit log (for security \u2014 tracks all tool executions)
-    CREATE TABLE IF NOT EXISTS audit_log (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT,
-      tool_name TEXT NOT NULL,
-      input_summary TEXT,
-      result_summary TEXT,
-      exit_code INTEGER,
-      duration_ms REAL,
-      was_allowed INTEGER DEFAULT 1,
-      created_at TEXT DEFAULT (datetime('now'))
-    );
-  `);
+// src/core/errors.ts
+function errorToString(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return String(err);
 }
-function dbRun(sql, params = []) {
-  const db = getDb();
-  try {
-    const stmt = db.prepare(sql);
-    return stmt.run(...params);
-  } catch (e) {
+var init_errors2 = __esm({
+  "src/core/errors.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/agent-loop.ts
+async function runAgentLoop(initialMessages, options2) {
+  const client = options2.client ?? getApiClient();
+  const messages = [...initialMessages];
+  const maxTurns = options2.maxTurns ?? DEFAULT_MAX_TURNS;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let turnIndex = 0;
+  let aborted = false;
+  const toolDefs = buildToolDefinitions(options2.tools);
+  const toolMap = new Map(options2.tools.map((t) => [t.name, t]));
+  while (turnIndex < maxTurns) {
+    if (options2.signal?.aborted) {
+      aborted = true;
+      break;
+    }
+    options2.onProgress?.({ type: "turn_start", turnIndex });
+    const request = {
+      model: options2.model,
+      messages,
+      systemPrompt: options2.systemPrompt,
+      tools: toolDefs.length > 0 ? toolDefs : void 0,
+      thinkingConfig: options2.thinkingConfig,
+      maxTokens: options2.maxTokens,
+      stream: true,
+      signal: options2.signal,
+      querySource: options2.querySource
+    };
+    options2.onProgress?.({ type: "streaming", turnIndex });
+    const contentBlocks = [];
+    let stopReason = null;
     try {
-      return db.run(sql, params);
-    } catch {
-      throw e;
+      for await (const item of client.streamMessage(request)) {
+        if (options2.signal?.aborted) {
+          aborted = true;
+          break;
+        }
+        const { event, accumulated } = item;
+        if (event.type === "content_block_delta" && event.delta) {
+          if (event.delta.type === "text_delta") {
+            options2.onTextDelta?.(event.delta.text);
+          } else if (event.delta.type === "thinking_delta") {
+            options2.onThinkingDelta?.(event.delta.thinking);
+          }
+        }
+        if (event.type === "message_stop" || event.type === "message_delta") {
+          if (accumulated.content) {
+            contentBlocks.length = 0;
+            contentBlocks.push(...accumulated.content);
+          }
+          stopReason = accumulated.stopReason ?? null;
+          if (accumulated.usage) {
+            totalInputTokens += accumulated.usage.inputTokens;
+            totalOutputTokens += accumulated.usage.outputTokens;
+          }
+        }
+      }
+    } catch (error) {
+      if (error.name === "AbortError") {
+        aborted = true;
+        break;
+      }
+      throw error;
+    }
+    if (aborted) break;
+    const assistantMessage = {
+      role: "assistant",
+      content: contentBlocks
+    };
+    messages.push(assistantMessage);
+    const toolUseBlocks = contentBlocks.filter(
+      (b) => b.type === "tool_use"
+    );
+    if (toolUseBlocks.length === 0 || stopReason === "end_turn") {
+      options2.onTurnComplete?.(turnIndex, assistantMessage);
+      options2.onProgress?.({ type: "turn_end", turnIndex, stopReason });
+      turnIndex++;
+      break;
     }
+    const toolResults = await executeTools(
+      toolUseBlocks,
+      toolMap,
+      options2
+    );
+    const toolResultMessage = {
+      role: "user",
+      content: toolResults.map((r) => ({
+        type: "tool_result",
+        tool_use_id: r.toolUseId,
+        content: r.error ?? (typeof r.data === "string" ? r.data : JSON.stringify(r.data)),
+        is_error: r.isError
+      }))
+    };
+    messages.push(toolResultMessage);
+    options2.onTurnComplete?.(turnIndex, assistantMessage);
+    options2.onProgress?.({ type: "turn_end", turnIndex, stopReason });
+    turnIndex++;
   }
+  options2.onProgress?.({ type: "loop_end", totalTurns: turnIndex });
+  return {
+    messages,
+    totalTurns: turnIndex,
+    aborted,
+    usage: { totalInputTokens, totalOutputTokens }
+  };
 }
-function createJsonFileDb() {
-  const storePath = join2(getConfigDir(), "coders-fallback.json");
-  let store = { tables: {}, autoInc: {} };
-  try {
-    if (existsSync4(storePath)) {
-      store = JSON.parse(readFileSync3(storePath, "utf-8"));
-      if (!store.tables) store.tables = {};
-      if (!store.autoInc) store.autoInc = {};
+async function executeTools(toolUseBlocks, toolMap, options2) {
+  const results = [];
+  const concurrentTools = [];
+  const sequentialTools = [];
+  for (const block2 of toolUseBlocks) {
+    const handler = toolMap.get(block2.name);
+    if (!handler) {
+      results.push({
+        toolUseId: block2.id,
+        toolName: block2.name,
+        error: `Unknown tool: ${block2.name}`,
+        isError: true
+      });
+      continue;
     }
-  } catch {
-  }
-  function flush() {
-    try {
-      writeFileSync2(storePath, JSON.stringify(store), "utf-8");
-    } catch {
+    if (handler.isConcurrencySafe) {
+      concurrentTools.push({ block: block2, handler });
+    } else {
+      sequentialTools.push({ block: block2, handler });
     }
   }
-  function ensureTable(name) {
-    if (!store.tables[name]) {
-      store.tables[name] = [];
-      store.autoInc[name] = 0;
-    }
+  if (concurrentTools.length > 0) {
+    const concurrentResults = await Promise.all(
+      concurrentTools.map(
+        ({ block: block2, handler }) => executeSingleTool(block2, handler, options2)
+      )
+    );
+    results.push(...concurrentResults);
   }
-  function now() {
-    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+  for (const { block: block2, handler } of sequentialTools) {
+    if (options2.signal?.aborted) break;
+    const result = await executeSingleTool(block2, handler, options2);
+    results.push(result);
   }
-  function parseInsert(sql, params) {
-    const m = sql.match(/INSERT\s+(?:OR\s+\w+\s+)?INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i);
-    if (!m) return { changes: 0, lastInsertRowid: 0 };
-    const table = m[1];
-    ensureTable(table);
-    const cols = m[2].split(",").map((c) => c.trim());
-    const valuePlaceholders = m[3].split(",").map((v) => v.trim());
-    const row = {};
-    let paramIdx = 0;
-    for (let i = 0; i < cols.length; i++) {
-      const ph = valuePlaceholders[i];
-      if (ph === "?") {
-        row[cols[i]] = params[paramIdx++];
-      } else if (/^datetime\(/i.test(ph)) {
-        row[cols[i]] = now();
-      } else {
-        row[cols[i]] = ph.replace(/^['"]|['"]$/g, "");
-      }
-    }
-    if (!row["id"] && store.autoInc[table] !== void 0) {
-      store.autoInc[table]++;
-      row["id"] = store.autoInc[table];
-    }
-    store.tables[table].push(row);
-    flush();
-    return { changes: 1, lastInsertRowid: typeof row["id"] === "number" ? row["id"] : 0 };
+  return results;
+}
+async function executeSingleTool(block2, handler, options2) {
+  const { id: toolUseId, name: toolName, input } = block2;
+  options2.onProgress?.({ type: "tool_execution", toolName, toolUseId });
+  const parseFailed = block2._inputParseFailed;
+  if (parseFailed) {
+    const rawJson = block2._rawInputJson;
+    const error = `Tool input not fully received \u2014 JSON parsing failed for ${toolName}. Partial input (${rawJson?.length ?? 0} chars) could not be parsed. This is a streaming issue; retrying the request should resolve it.`;
+    options2.onToolUseRejected?.(toolName, toolUseId, error);
+    return { toolUseId, toolName, error, isError: true };
   }
-  function parseSelect(sql, params) {
-    const m = sql.match(/SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+?))?(?:\s+ORDER\s+BY\s+(.+?))?(?:\s+LIMIT\s+(\d+))?$/i);
-    if (!m) return [];
-    const table = m[2];
-    if (!store.tables[table]) return [];
-    let rows = [...store.tables[table]];
-    if (m[3]) {
-      const whereParts = m[3].trim();
-      const wm = whereParts.match(/(\w+)\s*=\s*\?/);
-      if (wm && params.length > 0) {
-        const col = wm[1];
-        const val = params[0];
-        rows = rows.filter((r) => r[col] === val);
+  if (input && Object.keys(input).length === 0 && handler.inputSchema && Array.isArray(handler.inputSchema.required) && (handler.inputSchema.required ?? []).length > 0) {
+    const error = `Tool input not fully received \u2014 ${toolName} requires parameters (${(handler.inputSchema.required ?? []).join(", ")}) but received empty input {}. Skipping execution to prevent undefined behavior.`;
+    options2.onToolUseRejected?.(toolName, toolUseId, error);
+    return { toolUseId, toolName, error, isError: true };
+  }
+  options2.onToolUseStart?.(toolName, toolUseId, input);
+  try {
+    if (options2.onPermissionCheck) {
+      const permResult = await options2.onPermissionCheck(toolName, input);
+      if (permResult.behavior === "deny") {
+        const reason = permResult.message ?? "Permission denied";
+        options2.onToolUseRejected?.(toolName, toolUseId, reason);
+        return { toolUseId, toolName, error: reason, isError: true };
       }
     }
-    if (m[5]) {
-      rows = rows.slice(0, parseInt(m[5], 10));
-    }
-    return rows;
-  }
-  function parseUpdate(sql, params) {
-    const m = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)\s+WHERE\s+(.+)/i);
-    if (!m) return { changes: 0 };
-    const table = m[1];
-    if (!store.tables[table]) return { changes: 0 };
-    const setClauses = m[2].split(",").map((s) => s.trim());
-    const whereClause = m[3].trim();
-    const setParamCount = setClauses.filter((c) => c.includes("?")).length;
-    const wm = whereClause.match(/(\w+)\s*=\s*\?/);
-    const whereCol = wm ? wm[1] : null;
-    const whereVal = wm ? params[setParamCount] : null;
-    let changes = 0;
-    for (const row of store.tables[table]) {
-      if (whereCol && row[whereCol] !== whereVal) continue;
-      let paramIdx = 0;
-      for (const clause of setClauses) {
-        const cm = clause.match(/(\w+)\s*=\s*(.+)/);
-        if (!cm) continue;
-        const col = cm[1];
-        const val = cm[2].trim();
-        if (val === "?") {
-          row[col] = params[paramIdx++];
-        } else if (/^datetime\(/i.test(val)) {
-          row[col] = now();
-        }
+    if (handler.validateInput) {
+      const validation = await handler.validateInput(input);
+      if (!validation.result) {
+        const error = validation.message ?? "Invalid input";
+        return { toolUseId, toolName, error, isError: true };
       }
-      changes++;
     }
-    if (changes > 0) flush();
-    return { changes };
-  }
-  function parseDelete(sql, params) {
-    const m = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?/i);
-    if (!m) return { changes: 0 };
-    const table = m[1];
-    if (!store.tables[table]) return { changes: 0 };
-    if (!m[2]) {
-      const count = store.tables[table].length;
-      store.tables[table] = [];
-      flush();
-      return { changes: count };
+    const result = await handler.call(input, {
+      abortSignal: options2.signal,
+      agentId: options2.agentId,
+      toolUseId
+    });
+    options2.onToolUseEnd?.(toolName, toolUseId, result);
+    if (result.isError || result.error) {
+      return { toolUseId, toolName, error: result.error, isError: true };
     }
-    const wm = m[2].match(/(\w+)\s*=\s*\?/);
-    if (!wm) return { changes: 0 };
-    const col = wm[1];
-    const val = params[0];
-    const before = store.tables[table].length;
-    store.tables[table] = store.tables[table].filter((r) => r[col] !== val);
-    const changes = before - store.tables[table].length;
-    if (changes > 0) flush();
-    return { changes };
+    return { toolUseId, toolName, data: result.data };
+  } catch (error) {
+    const errorMsg = errorToString(error);
+    options2.onToolUseEnd?.(toolName, toolUseId, { error: errorMsg, isError: true });
+    return { toolUseId, toolName, error: errorMsg, isError: true };
   }
-  function execSql(sql, params = []) {
-    const trimmed = sql.trim();
-    if (/^INSERT/i.test(trimmed)) return parseInsert(trimmed, params);
-    if (/^SELECT/i.test(trimmed)) return parseSelect(trimmed, params);
-    if (/^UPDATE/i.test(trimmed)) return parseUpdate(trimmed, params);
-    if (/^DELETE/i.test(trimmed)) return parseDelete(trimmed, params);
-    return { changes: 0 };
+}
+function buildToolDefinitions(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema
+  }));
+}
+var DEFAULT_MAX_TURNS;
+var init_agent_loop = __esm({
+  "src/core/agent-loop.ts"() {
+    "use strict";
+    init_api();
+    init_errors2();
+    DEFAULT_MAX_TURNS = 100;
   }
+});
+
+// src/config/permissions.ts
+function createDefaultPermissionContext(settings) {
+  const defaultMode = settings?.permissions?.defaultMode ?? "default";
   return {
-    exec(sql) {
-      const matches = sql.matchAll(/CREATE\s+TABLE\s+IF\s+NOT\s+EXISTS\s+(\w+)/gi);
-      for (const m of matches) {
-        ensureTable(m[1]);
-      }
-    },
-    prepare(sql) {
-      return {
-        run(...params) {
-          return execSql(sql, params);
-        },
-        get(...params) {
-          const result = execSql(sql, params);
-          if (Array.isArray(result)) return result[0];
-          return void 0;
-        },
-        all(...params) {
-          const result = execSql(sql, params);
-          if (Array.isArray(result)) return result;
-          return [];
-        }
-      };
-    },
-    // Bun-style API aliases
-    run(sql, params = []) {
-      return execSql(sql, params);
-    },
-    query(sql) {
-      return {
-        get(...params) {
-          const result = execSql(sql, params);
-          if (Array.isArray(result)) return result[0];
-          return void 0;
-        },
-        all(...params) {
-          const result = execSql(sql, params);
-          if (Array.isArray(result)) return result;
-          return [];
-        }
-      };
-    },
-    close() {
-      flush();
-    }
+    mode: defaultMode,
+    allowRules: settings?.permissions?.allow ?? [],
+    denyRules: settings?.permissions?.deny ?? []
   };
 }
-var _db;
-var init_db = __esm({
-  "src/db/index.ts"() {
+var init_permissions = __esm({
+  "src/config/permissions.ts"() {
     "use strict";
-    init_paths();
-    _db = null;
   }
 });
 
@@ -62210,7 +62316,7 @@ function getShell() {
   }
   return process.env.SHELL ?? "/bin/bash";
 }
-function truncate(str, maxLen) {
+function truncate2(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 3) + "...";
 }
@@ -62455,7 +62561,7 @@ var init_bash = __esm({
         return input.command;
       },
       getActivityDescription(input) {
-        return input.description ?? `Running: ${truncate(input.command, 60)}`;
+        return input.description ?? `Running: ${truncate2(input.command, 60)}`;
       },
       async validateInput(input) {
         if (!input.command || !input.command.trim()) {
@@ -62481,7 +62587,7 @@ var init_bash = __esm({
         }
         return {
           behavior: "passthrough",
-          message: `Run command: ${truncate(cmd, 100)}`
+          message: `Run command: ${truncate2(cmd, 100)}`
         };
       },
       async call(input, context) {
@@ -62858,7 +62964,7 @@ Usage:
 });
 
 // src/tools/builtin/edit.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "fs";
 import { resolve as resolve3, isAbsolute as isAbsolute2 } from "path";
 import { randomUUID } from "crypto";
 function resolvePath2(filePath) {
@@ -63068,7 +63174,7 @@ var init_edit = __esm({
           );
         } catch {
         }
-        writeFileSync3(resolved, newContent, "utf-8");
+        writeFileSync4(resolved, newContent, "utf-8");
         markFileAsRead(resolved);
         const gitDiff = generateUnifiedDiff(originalContent, newContent, input.file_path);
         return {
@@ -63106,8 +63212,9 @@ Usage:
 });
 
 // src/tools/builtin/write.ts
-import { writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { writeFileSync as writeFileSync5, readFileSync as readFileSync7, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { dirname as dirname3, resolve as resolve4, isAbsolute as isAbsolute3 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 function resolvePath3(filePath) {
   if (isAbsolute3(filePath)) return filePath;
   return resolve4(process.cwd(), filePath);
@@ -63119,6 +63226,7 @@ var init_write = __esm({
     init_zod();
     init_constants();
     init_read();
+    init_db();
     WriteInputSchema = external_exports.strictObject({
       file_path: external_exports.string().describe("The absolute path to the file to write"),
       content: external_exports.string().describe("The content to write to the file")
@@ -63182,7 +63290,18 @@ var init_write = __esm({
         if (!existsSync8(dir)) {
           mkdirSync4(dir, { recursive: true });
         }
-        writeFileSync4(resolved, input.content, "utf-8");
+        if (!created) {
+          try {
+            const originalContent = readFileSync7(resolved, "utf-8");
+            const cpId = randomUUID2().slice(0, 8);
+            dbRun(
+              "INSERT INTO checkpoints (id, session_id, file_path, original_content, edit_operation) VALUES (?, ?, ?, ?, ?)",
+              [cpId, "current", resolved, originalContent, JSON.stringify({ type: "write_overwrite" })]
+            );
+          } catch {
+          }
+        }
+        writeFileSync5(resolved, input.content, "utf-8");
         markFileAsRead(resolved);
         return {
           data: {
@@ -70270,6 +70389,11 @@ function App2({ model, mode, initialPrompt }) {
   const activeToolsRef = import_react22.default.useRef([]);
   activeToolsRef.current = activeTools;
   const rows = stdout?.rows ?? 24;
+  const [slashSelected, setSlashSelected] = (0, import_react22.useState)(0);
+  const allCommands = getAllSlashCommands();
+  const showSlashMenu = input.startsWith("/") && !busy;
+  const slashFilter = input.slice(1).toLowerCase();
+  const filteredCommands = showSlashMenu ? allCommands.filter((c) => c.name.toLowerCase().startsWith(slashFilter)).slice(0, 8) : [];
   const [permissionPending, setPermissionPending] = (0, import_react22.useState)(null);
   const requestPermission = (0, import_react22.useCallback)((toolName, summary) => {
     return new Promise((resolve7) => {
@@ -70401,12 +70525,39 @@ function App2({ model, mode, initialPrompt }) {
       }
       return;
     }
+    if (showSlashMenu && filteredCommands.length > 0) {
+      if (key.downArrow || key.tab && !key.shift) {
+        setSlashSelected((s) => Math.min(s + 1, filteredCommands.length - 1));
+        return;
+      }
+      if (key.upArrow || key.tab && key.shift) {
+        setSlashSelected((s) => Math.max(s - 1, 0));
+        return;
+      }
+      if (key.return) {
+        const cmd = filteredCommands[slashSelected];
+        if (cmd) {
+          setInput("");
+          setSlashSelected(0);
+          submit(`/${cmd.name}`);
+          return;
+        }
+      }
+      if (key.escape) {
+        setInput("");
+        setSlashSelected(0);
+        return;
+      }
+    }
     if (key.return) {
       const t = input;
       setInput("");
+      setSlashSelected(0);
       submit(t);
-    } else if (key.backspace || key.delete) setInput((p) => p.slice(0, -1));
-    else if (key.ctrl && ch === "c") exit();
+    } else if (key.backspace || key.delete) {
+      setInput((p) => p.slice(0, -1));
+      setSlashSelected(0);
+    } else if (key.ctrl && ch === "c") exit();
     else if (key.ctrl && ch === "d") exit();
     else if (key.ctrl && ch === "l") {
       setMsgs([]);
@@ -70442,6 +70593,17 @@ function App2({ model, mode, initialPrompt }) {
         input.startsWith("/") ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: "magenta", children: input }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { children: input }),
         !busy && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: "gray", children: "\u258E" })
       ] }),
+      showSlashMenu && filteredCommands.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Box_default, { flexDirection: "column", paddingLeft: 2, children: filteredCommands.map((cmd, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { color: i === slashSelected ? "cyan" : void 0, bold: i === slashSelected, children: i === slashSelected ? "\u25B8 " : "  " }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { color: i === slashSelected ? "cyan" : "blue", children: [
+          "/",
+          cmd.name.padEnd(16)
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Text, { dimColor: true, children: [
+          " ",
+          cmd.description
+        ] })
+      ] }, cmd.name)) }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Text, { dimColor: true, children: sep }),
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StatusBar, { model, mode, cost, tokens })
     ] })
@@ -70740,8 +70902,8 @@ async function bootstrap() {
 var VERSION, BUILD_TIME, PACKAGE_NAME2, ISSUES_URL2, startupTimestamps, originalCwd, RESET_TERMINAL, cleanupHandlers, earlyInput, earlyInputCapturing;
 var init_index = __esm({
   "src/cli/index.ts"() {
-    VERSION = "0.0.15";
-    BUILD_TIME = "2026-03-20T11:11:38.468Z";
+    VERSION = "0.1.0";
+    BUILD_TIME = "2026-03-20T12:44:32.414Z";
     PACKAGE_NAME2 = "@hasna/coders";
     ISSUES_URL2 = "https://github.com/hasnaxyz/open-coders/issues";
     startupTimestamps = {};