@hasna/coders 0.0.15 → 0.1.1

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.1"}`
         };
         if (key.isOAuth) {
           headers["Authorization"] = `Bearer ${key.apiKey}`;
@@ -58639,630 +58639,1140 @@ 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." })
-  });
-  registerSlashCommand({
-    name: "memory",
-    category: "core",
-    description: "View saved memories",
-    handler: () => ({ output: "Memories \u2014 use @hasna/mementos for persistent memory." })
-  });
-  registerSlashCommand({
-    name: "tasks",
-    aliases: ["todo", "todos"],
-    category: "task",
-    description: "Toggle task list view",
-    handler: () => ({ action: "toggleView", data: "tasks", output: "Task list toggled." })
-  });
-  registerSlashCommand({
-    name: "diff",
-    category: "git",
-    description: "Show git diff",
-    handler: () => ({ output: "Use Bash tool: git diff" })
-  });
-  registerSlashCommand({
-    name: "pr",
-    category: "git",
-    description: "Create or review a pull request",
-    handler: () => ({ output: "Use Bash tool: gh pr create" })
-  });
-  registerSlashCommand({
-    name: "review",
-    category: "git",
-    description: "Review code changes",
-    handler: () => ({ output: "Code review \u2014 describe what to review." })
-  });
-  registerSlashCommand({
-    name: "transcript",
-    category: "navigation",
-    description: "Toggle conversation transcript",
-    handler: () => ({ action: "toggleView", data: "transcript" })
-  });
-  registerSlashCommand({
-    name: "history",
-    category: "navigation",
-    description: "Search conversation history",
-    handler: () => ({ output: "History search \u2014 not yet wired." })
-  });
-  registerSlashCommand({
-    name: "session",
-    aliases: ["remote"],
-    category: "system",
-    description: "Show session info or remote URL",
-    handler: () => ({ output: "Session info \u2014 not yet wired." })
-  });
-  registerSlashCommand({
-    name: "plugin",
-    aliases: ["plugins"],
-    category: "plugin",
-    description: "Manage plugins",
-    handler: () => ({ output: "Plugins \u2014 use 'coders plugin list' for details." })
-  });
-  registerSlashCommand({
-    name: "terminal",
-    category: "system",
-    description: "Show terminal info",
-    handler: async () => {
-      const { detectTerminal: detectTerminal2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
-      const caps = detectTerminal2();
-      return { output: `Terminal: ${caps.name}, Color: ${caps.colorDepth}bit, Unicode: ${caps.unicode}` };
+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;
     }
-  });
+  }
 }
-var commands;
-var init_slash_commands = __esm({
-  "src/core/slash-commands.ts"() {
-    "use strict";
-    commands = /* @__PURE__ */ new Map();
-    registerDefaults();
-  }
-});
-
-// node_modules/marked/lib/marked.esm.js
-function _getDefaults() {
-  return {
-    async: false,
-    breaks: false,
-    extensions: null,
-    gfm: true,
-    hooks: null,
-    pedantic: false,
-    renderer: null,
-    silent: false,
-    tokenizer: null,
-    walkTokens: null
-  };
-}
-function changeDefaults(newDefaults) {
-  _defaults = newDefaults;
-}
-function edit(regex2, opt = "") {
-  let source = typeof regex2 === "string" ? regex2 : regex2.source;
-  const obj = {
-    replace: (name, val) => {
-      let valSource = typeof val === "string" ? val : val.source;
-      valSource = valSource.replace(other.caret, "$1");
-      source = source.replace(name, valSource);
-      return obj;
-    },
-    getRegex: () => {
-      return new RegExp(source, opt);
-    }
-  };
-  return obj;
-}
-function escape22(html2, encode) {
-  if (encode) {
-    if (other.escapeTest.test(html2)) {
-      return html2.replace(other.escapeReplace, getEscapeReplacement);
-    }
-  } else {
-    if (other.escapeTestNoEncode.test(html2)) {
-      return html2.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
+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;
     }
   }
-  return html2;
 }
-function cleanUrl(href) {
+function dbAll(sql, params = []) {
+  const db = getDb();
   try {
-    href = encodeURI(href).replace(other.percentDecode, "%");
+    const stmt = db.prepare(sql);
+    return stmt.all(...params);
   } catch {
-    return null;
+    try {
+      return db.query(sql).all(...params);
+    } catch {
+      return [];
+    }
   }
-  return href;
 }
-function splitCells(tableRow, count) {
-  const row = tableRow.replace(other.findPipe, (match, offset, str) => {
-    let escaped = false;
-    let curr = offset;
-    while (--curr >= 0 && str[curr] === "\\") escaped = !escaped;
-    if (escaped) {
-      return "|";
-    } else {
-      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 = {};
     }
-  }), cells = row.split(other.splitPipe);
-  let i = 0;
-  if (!cells[0].trim()) {
-    cells.shift();
-  }
-  if (cells.length > 0 && !cells.at(-1)?.trim()) {
-    cells.pop();
+  } catch {
   }
-  if (count) {
-    if (cells.length > count) {
-      cells.splice(count);
-    } else {
-      while (cells.length < count) cells.push("");
+  function flush() {
+    try {
+      writeFileSync2(storePath, JSON.stringify(store), "utf-8");
+    } catch {
     }
   }
-  for (; i < cells.length; i++) {
-    cells[i] = cells[i].trim().replace(other.slashPipe, "|");
-  }
-  return cells;
-}
-function rtrim(str, c, invert) {
-  const l = str.length;
-  if (l === 0) {
-    return "";
-  }
-  let suffLen = 0;
-  while (suffLen < l) {
-    const currChar = str.charAt(l - suffLen - 1);
-    if (currChar === c && !invert) {
-      suffLen++;
-    } else if (currChar !== c && invert) {
-      suffLen++;
-    } else {
-      break;
+  function ensureTable(name) {
+    if (!store.tables[name]) {
+      store.tables[name] = [];
+      store.autoInc[name] = 0;
     }
   }
-  return str.slice(0, l - suffLen);
-}
-function findClosingBracket(str, b) {
-  if (str.indexOf(b[1]) === -1) {
-    return -1;
+  function now() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
   }
-  let level = 0;
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === "\\") {
-      i++;
-    } else if (str[i] === b[0]) {
-      level++;
-    } else if (str[i] === b[1]) {
-      level--;
-      if (level < 0) {
-        return i;
+  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 };
   }
-  if (level > 0) {
-    return -2;
+  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;
   }
-  return -1;
-}
-function outputLink(cap, link22, raw, lexer2, rules) {
-  const href = link22.href;
-  const title = link22.title || null;
-  const text = cap[1].replace(rules.other.outputLinkReplace, "$1");
-  lexer2.state.inLink = true;
-  const token = {
-    type: cap[0].charAt(0) === "!" ? "image" : "link",
-    raw,
-    href,
-    title,
-    text,
-    tokens: lexer2.inlineTokens(text)
-  };
-  lexer2.state.inLink = false;
-  return token;
-}
-function indentCodeCompensation(raw, text, rules) {
-  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
-  if (matchIndentToCode === null) {
-    return text;
+  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 };
   }
-  const indentToCode = matchIndentToCode[1];
-  return text.split("\n").map((node) => {
-    const matchIndentInNode = node.match(rules.other.beginningSpace);
-    if (matchIndentInNode === null) {
-      return node;
+  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 [indentInNode] = matchIndentInNode;
-    if (indentInNode.length >= indentToCode.length) {
-      return node.slice(indentToCode.length);
+    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();
     }
-    return node;
-  }).join("\n");
+  };
 }
-function marked(src, opt) {
-  return markedInstance.parse(src, opt);
+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;
 }
-var _defaults, noopTest, other, newline, blockCode, fences, hr, heading, bullet, lheadingCore, lheading, lheadingGfm, _paragraph, blockText, _blockLabel, def, list, _tag, _comment, html, paragraph, blockquote, blockNormal, gfmTable, blockGfm, blockPedantic, escape2, inlineCode, br, inlineText, _punctuation, _punctuationOrSpace, _notPunctuationOrSpace, punctuation, _punctuationGfmStrongEm, _punctuationOrSpaceGfmStrongEm, _notPunctuationOrSpaceGfmStrongEm, blockSkip, emStrongLDelimCore, emStrongLDelim, emStrongLDelimGfm, emStrongRDelimAstCore, emStrongRDelimAst, emStrongRDelimAstGfm, emStrongRDelimUnd, anyPunctuation, autolink, _inlineComment, tag, _inlineLabel, link2, reflink, nolink, reflinkSearch, inlineNormal, inlinePedantic, inlineGfm, inlineBreaks, block, inline, escapeReplacements, getEscapeReplacement, _Tokenizer, _Lexer, _Renderer, _TextRenderer, _Parser, _Hooks, Marked, markedInstance, options, setOptions, use, walkTokens, parseInline, parser, lexer;
-var init_marked_esm = __esm({
-  "node_modules/marked/lib/marked.esm.js"() {
-    _defaults = _getDefaults();
-    noopTest = { exec: () => null };
-    other = {
-      codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
-      outputLinkReplace: /\\([\[\]])/g,
-      indentCodeCompensation: /^(\s+)(?:```)/,
-      beginningSpace: /^\s+/,
-      endingHash: /#$/,
-      startingSpaceChar: /^ /,
-      endingSpaceChar: / $/,
-      nonSpaceChar: /[^ ]/,
-      newLineCharGlobal: /\n/g,
-      tabCharGlobal: /\t/g,
-      multipleSpaceGlobal: /\s+/g,
-      blankLine: /^[ \t]*$/,
-      doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
-      blockquoteStart: /^ {0,3}>/,
-      blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
-      blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
-      listReplaceTabs: /^\t+/,
-      listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
-      listIsTask: /^\[[ xX]\] /,
-      listReplaceTask: /^\[[ xX]\] +/,
-      anyLine: /\n.*\n/,
-      hrefBrackets: /^<(.*)>$/,
-      tableDelimiter: /[:|]/,
-      tableAlignChars: /^\||\| *$/g,
-      tableRowBlankLine: /\n[ \t]*$/,
-      tableAlignRight: /^ *-+: *$/,
-      tableAlignCenter: /^ *:-+: *$/,
-      tableAlignLeft: /^ *:-+ *$/,
-      startATag: /^<a /i,
-      endATag: /^<\/a>/i,
-      startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
-      endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
-      startAngleBracket: /^</,
-      endAngleBracket: />$/,
-      pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
-      unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
-      escapeTest: /[&<>"']/,
-      escapeReplace: /[&<>"']/g,
-      escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
-      escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
-      unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
-      caret: /(^|[^\[])\^/g,
-      percentDecode: /%25/g,
-      findPipe: /\|/g,
-      splitPipe: / \|/,
-      slashPipe: /\\\|/g,
-      carriageReturn: /\r\n|\r/g,
-      spaceLine: /^ +$/gm,
-      notSpaceStart: /^\S*/,
-      endingNewline: /\n$/,
-      listItemRegex: (bull) => new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`),
-      nextBulletRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`),
-      hrRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
-      fencesBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
-      headingBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
-      htmlBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, "i")
-    };
-    newline = /^(?:[ \t]*(?:\n|$))+/;
-    blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
-    fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
-    hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
-    heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
-    bullet = /(?:[*+-]|\d{1,9}[.)])/;
-    lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
-    lheading = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
-    lheadingGfm = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
-    _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
-    blockText = /^[^\n]+/;
-    _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
-    def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
-    list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
-    _tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
-    _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
-    html = edit(
-      "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))",
-      "i"
-    ).replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
-    paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
-    blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
-    blockNormal = {
-      blockquote,
-      code: blockCode,
-      def,
-      fences,
-      heading,
-      hr,
-      html,
-      lheading,
-      list,
-      newline,
-      paragraph,
-      table: noopTest,
-      text: blockText
-    };
-    gfmTable = edit(
-      "^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"
-    ).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
-    blockGfm = {
-      ...blockNormal,
-      lheading: lheadingGfm,
-      table: gfmTable,
-      paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
-    };
-    blockPedantic = {
-      ...blockNormal,
-      html: edit(
-        `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
-      ).replace("comment", _comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
-      def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
-      heading: /^(#{1,6})(.*)(?:\n+|$)/,
-      fences: noopTest,
-      // fences not supported
-      lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
-      paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
-    };
-    escape2 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
-    inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
-    br = /^( {2,}|\\)\n(?!\s*$)/;
-    inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
-    _punctuation = /[\p{P}\p{S}]/u;
-    _punctuationOrSpace = /[\s\p{P}\p{S}]/u;
-    _notPunctuationOrSpace = /[^\s\p{P}\p{S}]/u;
-    punctuation = edit(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, _punctuationOrSpace).getRegex();
-    _punctuationGfmStrongEm = /(?!~)[\p{P}\p{S}]/u;
-    _punctuationOrSpaceGfmStrongEm = /(?!~)[\s\p{P}\p{S}]/u;
-    _notPunctuationOrSpaceGfmStrongEm = /(?:[^\s\p{P}\p{S}]|~)/u;
-    blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
-    emStrongLDelimCore = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
-    emStrongLDelim = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuation).getRegex();
-    emStrongLDelimGfm = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuationGfmStrongEm).getRegex();
-    emStrongRDelimAstCore = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
-    emStrongRDelimAst = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
-    emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm).replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm).replace(/punct/g, _punctuationGfmStrongEm).getRegex();
-    emStrongRDelimUnd = edit(
-      "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)",
-      "gu"
-    ).replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
-    anyPunctuation = edit(/\\(punct)/, "gu").replace(/punct/g, _punctuation).getRegex();
-    autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
-    _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
-    tag = edit(
-      "^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
-    ).replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
-    _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
-    link2 = edit(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
-    reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
-    nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
-    reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
-    inlineNormal = {
-      _backpedal: noopTest,
+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",
+    description: "View saved memories",
+    handler: () => ({ output: "Memories \u2014 use @hasna/mementos for persistent memory." })
+  });
+  registerSlashCommand({
+    name: "tasks",
+    aliases: ["todo", "todos"],
+    category: "task",
+    description: "Toggle task list view",
+    handler: () => ({ action: "toggleView", data: "tasks", output: "Task list toggled." })
+  });
+  registerSlashCommand({
+    name: "diff",
+    category: "git",
+    description: "Show git diff",
+    handler: () => ({ output: "Use Bash tool: git diff" })
+  });
+  registerSlashCommand({
+    name: "pr",
+    category: "git",
+    description: "Create or review a pull request",
+    handler: () => ({ output: "Use Bash tool: gh pr create" })
+  });
+  registerSlashCommand({
+    name: "review",
+    category: "git",
+    description: "Review code changes",
+    handler: () => ({ output: "Code review \u2014 describe what to review." })
+  });
+  registerSlashCommand({
+    name: "transcript",
+    category: "navigation",
+    description: "Toggle conversation transcript",
+    handler: () => ({ action: "toggleView", data: "transcript" })
+  });
+  registerSlashCommand({
+    name: "history",
+    category: "navigation",
+    description: "Search conversation history",
+    handler: () => ({ output: "History search \u2014 not yet wired." })
+  });
+  registerSlashCommand({
+    name: "session",
+    aliases: ["remote"],
+    category: "system",
+    description: "Show session info or remote URL",
+    handler: () => ({ output: "Session info \u2014 not yet wired." })
+  });
+  registerSlashCommand({
+    name: "plugin",
+    aliases: ["plugins"],
+    category: "plugin",
+    description: "Manage plugins",
+    handler: () => ({ output: "Plugins \u2014 use 'coders plugin list' for details." })
+  });
+  registerSlashCommand({
+    name: "terminal",
+    category: "system",
+    description: "Show terminal info",
+    handler: async () => {
+      const { detectTerminal: detectTerminal2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
+      const caps = detectTerminal2();
+      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();
+  }
+});
+
+// node_modules/marked/lib/marked.esm.js
+function _getDefaults() {
+  return {
+    async: false,
+    breaks: false,
+    extensions: null,
+    gfm: true,
+    hooks: null,
+    pedantic: false,
+    renderer: null,
+    silent: false,
+    tokenizer: null,
+    walkTokens: null
+  };
+}
+function changeDefaults(newDefaults) {
+  _defaults = newDefaults;
+}
+function edit(regex2, opt = "") {
+  let source = typeof regex2 === "string" ? regex2 : regex2.source;
+  const obj = {
+    replace: (name, val) => {
+      let valSource = typeof val === "string" ? val : val.source;
+      valSource = valSource.replace(other.caret, "$1");
+      source = source.replace(name, valSource);
+      return obj;
+    },
+    getRegex: () => {
+      return new RegExp(source, opt);
+    }
+  };
+  return obj;
+}
+function escape22(html2, encode) {
+  if (encode) {
+    if (other.escapeTest.test(html2)) {
+      return html2.replace(other.escapeReplace, getEscapeReplacement);
+    }
+  } else {
+    if (other.escapeTestNoEncode.test(html2)) {
+      return html2.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
+    }
+  }
+  return html2;
+}
+function cleanUrl(href) {
+  try {
+    href = encodeURI(href).replace(other.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return href;
+}
+function splitCells(tableRow, count) {
+  const row = tableRow.replace(other.findPipe, (match, offset, str) => {
+    let escaped = false;
+    let curr = offset;
+    while (--curr >= 0 && str[curr] === "\\") escaped = !escaped;
+    if (escaped) {
+      return "|";
+    } else {
+      return " |";
+    }
+  }), cells = row.split(other.splitPipe);
+  let i = 0;
+  if (!cells[0].trim()) {
+    cells.shift();
+  }
+  if (cells.length > 0 && !cells.at(-1)?.trim()) {
+    cells.pop();
+  }
+  if (count) {
+    if (cells.length > count) {
+      cells.splice(count);
+    } else {
+      while (cells.length < count) cells.push("");
+    }
+  }
+  for (; i < cells.length; i++) {
+    cells[i] = cells[i].trim().replace(other.slashPipe, "|");
+  }
+  return cells;
+}
+function rtrim(str, c, invert) {
+  const l = str.length;
+  if (l === 0) {
+    return "";
+  }
+  let suffLen = 0;
+  while (suffLen < l) {
+    const currChar = str.charAt(l - suffLen - 1);
+    if (currChar === c && !invert) {
+      suffLen++;
+    } else if (currChar !== c && invert) {
+      suffLen++;
+    } else {
+      break;
+    }
+  }
+  return str.slice(0, l - suffLen);
+}
+function findClosingBracket(str, b) {
+  if (str.indexOf(b[1]) === -1) {
+    return -1;
+  }
+  let level = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === "\\") {
+      i++;
+    } else if (str[i] === b[0]) {
+      level++;
+    } else if (str[i] === b[1]) {
+      level--;
+      if (level < 0) {
+        return i;
+      }
+    }
+  }
+  if (level > 0) {
+    return -2;
+  }
+  return -1;
+}
+function outputLink(cap, link22, raw, lexer2, rules) {
+  const href = link22.href;
+  const title = link22.title || null;
+  const text = cap[1].replace(rules.other.outputLinkReplace, "$1");
+  lexer2.state.inLink = true;
+  const token = {
+    type: cap[0].charAt(0) === "!" ? "image" : "link",
+    raw,
+    href,
+    title,
+    text,
+    tokens: lexer2.inlineTokens(text)
+  };
+  lexer2.state.inLink = false;
+  return token;
+}
+function indentCodeCompensation(raw, text, rules) {
+  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
+  if (matchIndentToCode === null) {
+    return text;
+  }
+  const indentToCode = matchIndentToCode[1];
+  return text.split("\n").map((node) => {
+    const matchIndentInNode = node.match(rules.other.beginningSpace);
+    if (matchIndentInNode === null) {
+      return node;
+    }
+    const [indentInNode] = matchIndentInNode;
+    if (indentInNode.length >= indentToCode.length) {
+      return node.slice(indentToCode.length);
+    }
+    return node;
+  }).join("\n");
+}
+function marked(src, opt) {
+  return markedInstance.parse(src, opt);
+}
+var _defaults, noopTest, other, newline, blockCode, fences, hr, heading, bullet, lheadingCore, lheading, lheadingGfm, _paragraph, blockText, _blockLabel, def, list, _tag, _comment, html, paragraph, blockquote, blockNormal, gfmTable, blockGfm, blockPedantic, escape2, inlineCode, br, inlineText, _punctuation, _punctuationOrSpace, _notPunctuationOrSpace, punctuation, _punctuationGfmStrongEm, _punctuationOrSpaceGfmStrongEm, _notPunctuationOrSpaceGfmStrongEm, blockSkip, emStrongLDelimCore, emStrongLDelim, emStrongLDelimGfm, emStrongRDelimAstCore, emStrongRDelimAst, emStrongRDelimAstGfm, emStrongRDelimUnd, anyPunctuation, autolink, _inlineComment, tag, _inlineLabel, link2, reflink, nolink, reflinkSearch, inlineNormal, inlinePedantic, inlineGfm, inlineBreaks, block, inline, escapeReplacements, getEscapeReplacement, _Tokenizer, _Lexer, _Renderer, _TextRenderer, _Parser, _Hooks, Marked, markedInstance, options, setOptions, use, walkTokens, parseInline, parser, lexer;
+var init_marked_esm = __esm({
+  "node_modules/marked/lib/marked.esm.js"() {
+    _defaults = _getDefaults();
+    noopTest = { exec: () => null };
+    other = {
+      codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
+      outputLinkReplace: /\\([\[\]])/g,
+      indentCodeCompensation: /^(\s+)(?:```)/,
+      beginningSpace: /^\s+/,
+      endingHash: /#$/,
+      startingSpaceChar: /^ /,
+      endingSpaceChar: / $/,
+      nonSpaceChar: /[^ ]/,
+      newLineCharGlobal: /\n/g,
+      tabCharGlobal: /\t/g,
+      multipleSpaceGlobal: /\s+/g,
+      blankLine: /^[ \t]*$/,
+      doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
+      blockquoteStart: /^ {0,3}>/,
+      blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
+      blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
+      listReplaceTabs: /^\t+/,
+      listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
+      listIsTask: /^\[[ xX]\] /,
+      listReplaceTask: /^\[[ xX]\] +/,
+      anyLine: /\n.*\n/,
+      hrefBrackets: /^<(.*)>$/,
+      tableDelimiter: /[:|]/,
+      tableAlignChars: /^\||\| *$/g,
+      tableRowBlankLine: /\n[ \t]*$/,
+      tableAlignRight: /^ *-+: *$/,
+      tableAlignCenter: /^ *:-+: *$/,
+      tableAlignLeft: /^ *:-+ *$/,
+      startATag: /^<a /i,
+      endATag: /^<\/a>/i,
+      startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
+      endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
+      startAngleBracket: /^</,
+      endAngleBracket: />$/,
+      pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
+      unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
+      escapeTest: /[&<>"']/,
+      escapeReplace: /[&<>"']/g,
+      escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
+      escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
+      unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
+      caret: /(^|[^\[])\^/g,
+      percentDecode: /%25/g,
+      findPipe: /\|/g,
+      splitPipe: / \|/,
+      slashPipe: /\\\|/g,
+      carriageReturn: /\r\n|\r/g,
+      spaceLine: /^ +$/gm,
+      notSpaceStart: /^\S*/,
+      endingNewline: /\n$/,
+      listItemRegex: (bull) => new RegExp(`^( {0,3}${bull})((?:[	 ][^\\n]*)?(?:\\n|$))`),
+      nextBulletRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`),
+      hrRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
+      fencesBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
+      headingBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
+      htmlBeginRegex: (indent) => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, "i")
+    };
+    newline = /^(?:[ \t]*(?:\n|$))+/;
+    blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+    fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+    hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+    heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+    bullet = /(?:[*+-]|\d{1,9}[.)])/;
+    lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+    lheading = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+    lheadingGfm = edit(lheadingCore).replace(/bull/g, bullet).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+    _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
+    blockText = /^[^\n]+/;
+    _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
+    def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", _blockLabel).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+    list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
+    _tag = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+    _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+    html = edit(
+      "^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ 	]*)+\\n|$))",
+      "i"
+    ).replace("comment", _comment).replace("tag", _tag).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+    paragraph = edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+    blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", paragraph).getRegex();
+    blockNormal = {
+      blockquote,
+      code: blockCode,
+      def,
+      fences,
+      heading,
+      hr,
+      html,
+      lheading,
+      list,
+      newline,
+      paragraph,
+      table: noopTest,
+      text: blockText
+    };
+    gfmTable = edit(
+      "^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)"
+    ).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}	)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex();
+    blockGfm = {
+      ...blockNormal,
+      lheading: lheadingGfm,
+      table: gfmTable,
+      paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", gfmTable).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", _tag).getRegex()
+    };
+    blockPedantic = {
+      ...blockNormal,
+      html: edit(
+        `^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`
+      ).replace("comment", _comment).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),
+      def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
+      heading: /^(#{1,6})(.*)(?:\n+|$)/,
+      fences: noopTest,
+      // fences not supported
+      lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
+      paragraph: edit(_paragraph).replace("hr", hr).replace("heading", " *#{1,6} *[^\n]").replace("lheading", lheading).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex()
+    };
+    escape2 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+    inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+    br = /^( {2,}|\\)\n(?!\s*$)/;
+    inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+    _punctuation = /[\p{P}\p{S}]/u;
+    _punctuationOrSpace = /[\s\p{P}\p{S}]/u;
+    _notPunctuationOrSpace = /[^\s\p{P}\p{S}]/u;
+    punctuation = edit(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, _punctuationOrSpace).getRegex();
+    _punctuationGfmStrongEm = /(?!~)[\p{P}\p{S}]/u;
+    _punctuationOrSpaceGfmStrongEm = /(?!~)[\s\p{P}\p{S}]/u;
+    _notPunctuationOrSpaceGfmStrongEm = /(?:[^\s\p{P}\p{S}]|~)/u;
+    blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
+    emStrongLDelimCore = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
+    emStrongLDelim = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuation).getRegex();
+    emStrongLDelimGfm = edit(emStrongLDelimCore, "u").replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+    emStrongRDelimAstCore = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+    emStrongRDelimAst = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+    emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, "gu").replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm).replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm).replace(/punct/g, _punctuationGfmStrongEm).getRegex();
+    emStrongRDelimUnd = edit(
+      "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)",
+      "gu"
+    ).replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
+    anyPunctuation = edit(/\\(punct)/, "gu").replace(/punct/g, _punctuation).getRegex();
+    autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+    _inlineComment = edit(_comment).replace("(?:-->|$)", "-->").getRegex();
+    tag = edit(
+      "^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
+    ).replace("comment", _inlineComment).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+    _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
+    link2 = edit(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]*(?:\n[ \t]*)?)(title))?\s*\)/).replace("label", _inlineLabel).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]*/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+    reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace("label", _inlineLabel).replace("ref", _blockLabel).getRegex();
+    nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace("ref", _blockLabel).getRegex();
+    reflinkSearch = edit("reflink|nolink(?!\\()", "g").replace("reflink", reflink).replace("nolink", nolink).getRegex();
+    inlineNormal = {
+      _backpedal: noopTest,
       // only used for GFM url
       anyPunctuation,
       autolink,
@@ -60520,1406 +61030,1002 @@ ${text}</tr>
       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;
-      }
-      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();
-      }
-      /**
-       * Static Parse Method
-       */
-      static parse(tokens, options2) {
-        const parser2 = new __Parser(options2);
-        return parser2.parse(tokens);
-      }
-      /**
-       * 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;
-            }
-          }
-          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);
-              }
-            }
-          }
-        }
-        return out;
-      }
-      /**
-       * 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);
-              }
-            }
-          }
-        }
-        return out;
-      }
-    };
-    _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;
+    };
+    _TextRenderer = class {
+      // no need for block level renderers
+      strong({ text }) {
+        return text;
       }
-      /**
-       * Process HTML after marked is finished
-       */
-      postprocess(html2) {
-        return html2;
+      em({ text }) {
+        return text;
       }
-      /**
-       * Process all tokens before walk tokens
-       */
-      processAllTokens(tokens) {
-        return tokens;
+      codespan({ text }) {
+        return text;
       }
-      /**
-       * Provide function to tokenize markdown
-       */
-      provideLexer() {
-        return this.block ? _Lexer.lex : _Lexer.lexInline;
+      del({ text }) {
+        return text;
       }
-      /**
-       * Provide function to parse tokens
-       */
-      provideParser() {
-        return this.block ? _Parser.parse : _Parser.parseInline;
+      html({ text }) {
+        return text;
       }
-    };
-    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);
+      text({ text }) {
+        return text;
       }
-      /**
-       * 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));
-              }
-            }
-          }
-        }
-        return values;
+      link({ text }) {
+        return "" + text;
       }
-      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;
+      image({ text }) {
+        return "" + text;
       }
-      setOptions(opt) {
-        this.defaults = { ...this.defaults, ...opt };
-        return this;
+      br() {
+        return "";
       }
-      lexer(src, options2) {
-        return _Lexer.lex(src, options2 ?? this.defaults);
+    };
+    _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();
       }
-      parser(tokens, options2) {
-        return _Parser.parse(tokens, options2 ?? this.defaults);
+      /**
+       * Static Parse Method
+       */
+      static parse(tokens, options2) {
+        const parser2 = new __Parser(options2);
+        return parser2.parse(tokens);
       }
-      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);
+      /**
+       * 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;
+            }
           }
-          try {
-            if (opt.hooks) {
-              src = opt.hooks.preprocess(src);
+          const token = anyToken;
+          switch (token.type) {
+            case "space": {
+              out += this.renderer.space(token);
+              continue;
             }
-            let tokens = lexer2(src, opt);
-            if (opt.hooks) {
-              tokens = opt.hooks.processAllTokens(tokens);
+            case "hr": {
+              out += this.renderer.hr(token);
+              continue;
             }
-            if (opt.walkTokens) {
-              this.walkTokens(tokens, opt.walkTokens);
+            case "heading": {
+              out += this.renderer.heading(token);
+              continue;
             }
-            let html2 = parser2(tokens, opt);
-            if (opt.hooks) {
-              html2 = opt.hooks.postprocess(html2);
+            case "code": {
+              out += this.renderer.code(token);
+              continue;
             }
-            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 "table": {
+              out += this.renderer.table(token);
+              continue;
             }
-            return msg;
-          }
-          if (async) {
-            return Promise.reject(e);
-          }
-          throw e;
-        };
-      }
-    };
-    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}`));
+            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);
+              }
+            }
+          }
         }
+        return out;
+      }
+      /**
+       * 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);
+              }
+            }
+          }
+        }
+        return out;
       }
-    }
-  }
-  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;
+    _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;
+      }
+    };
+    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 (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);
+          }
+          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);
           }
-        }
-        if (event.type === "message_stop" || event.type === "message_delta") {
-          if (accumulated.content) {
-            contentBlocks.length = 0;
-            contentBlocks.push(...accumulated.content);
+        };
+        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);
+            }
+            return msg;
           }
-          stopReason = accumulated.stopReason ?? null;
-          if (accumulated.usage) {
-            totalInputTokens += accumulated.usage.inputTokens;
-            totalOutputTokens += accumulated.usage.outputTokens;
+          if (async) {
+            return Promise.reject(e);
           }
-        }
-      }
-    } catch (error) {
-      if (error.name === "AbortError") {
-        aborted = true;
-        break;
+          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 };
+    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 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;
+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;
+    }
   }
-});
-
-// src/config/permissions.ts
-function createDefaultPermissionContext(settings) {
-  const defaultMode = settings?.permissions?.defaultMode ?? "default";
-  return {
-    mode: defaultMode,
-    allowRules: settings?.permissions?.allow ?? [],
-    denyRules: settings?.permissions?.deny ?? []
-  };
+  return lines.join("\n");
 }
-var init_permissions = __esm({
-  "src/config/permissions.ts"() {
-    "use strict";
-  }
-});
-
-// 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");
+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 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;
-    }
-  }
-  try {
-    _db.exec("PRAGMA journal_mode=WAL");
-  } catch {
+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;
-}
-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'))
-    );
-  `);
+  lines.push(`${FG_GRAY}\u2514${"\u2500".repeat(Math.min(maxWidth, 60) - 1)}${FG_DEFAULT}`);
+  return lines;
 }
-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 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 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 = {};
+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);
     }
-  } catch {
   }
-  function flush() {
-    try {
-      writeFileSync2(storePath, JSON.stringify(store), "utf-8");
-    } catch {
+  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));
     }
   }
-  function ensureTable(name) {
-    if (!store.tables[name]) {
-      store.tables[name] = [];
-      store.autoInc[name] = 0;
-    }
+  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);
   }
-  function now() {
-    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
+  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}`
+    );
   }
-  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, "");
+  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`;
+  }
+});
+
+// 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;
+        }
+        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 (!row["id"] && store.autoInc[table] !== void 0) {
-      store.autoInc[table]++;
-      row["id"] = store.autoInc[table];
+    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 }
+  };
+}
+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 });
     }
-    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 (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 (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,10 +62587,13 @@ var init_bash = __esm({
         }
         return {
           behavior: "passthrough",
-          message: `Run command: ${truncate(cmd, 100)}`
+          message: `Run command: ${truncate2(cmd, 100)}`
         };
       },
       async call(input, context) {
+        if (!input.command || typeof input.command !== "string") {
+          return { data: { stdout: "", stderr: "Error: command is required", exitCode: 1, interrupted: false, durationMs: 0 } };
+        }
         const { command, timeout, run_in_background } = input;
         const timeoutMs = timeout ?? getDefaultTimeout();
         const startTime = performance.now();
@@ -62858,7 +62967,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 +63177,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 +63215,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 +63229,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 +63293,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: {
@@ -70165,61 +70287,31 @@ function ToolItem({ tool }) {
   ] });
 }
 function formatToolResult(toolName, result) {
-  const lines = [];
-  if (!result || result === "(no output)") {
-    lines.push("Done");
-    return lines;
-  }
+  if (!result || result === "(no output)") return ["Done"];
+  const totalLines = result.split("\n").length;
   switch (toolName) {
     case "Bash": {
-      const preview = result.split("\n").slice(0, 5);
-      lines.push(...preview);
-      const total = result.split("\n").length;
-      if (total > 5) lines.push(`\u2026 +${total - 5} lines (ctrl+o to expand)`);
-      break;
-    }
-    case "Read": {
-      const numLines = result.split("\n").length;
-      lines.push(`Read ${numLines} lines`);
-      break;
-    }
-    case "Edit": {
-      if (result.includes("Successfully edited")) lines.push(result.split("\n")[0]);
-      else lines.push(result.slice(0, 100));
-      break;
-    }
-    case "Write": {
-      if (result.includes("Created") || result.includes("Updated")) lines.push(result.split("\n")[0]);
-      else lines.push(result.slice(0, 100));
-      break;
-    }
-    case "Glob": {
-      const files = result.split("\n").filter((l) => l.trim());
-      lines.push(`Found ${files.length} files`);
-      if (files.length > 0 && files.length <= 3) lines.push(...files);
-      else if (files.length > 3) {
-        lines.push(...files.slice(0, 3));
-        lines.push(`\u2026 +${files.length - 3} more files`);
-      }
-      break;
-    }
-    case "Grep": {
-      const matches = result.split("\n").filter((l) => l.trim());
-      if (result.includes("No matches")) lines.push("No matches found");
-      else {
-        lines.push(`${matches.length} matches`);
-        if (matches.length <= 3) lines.push(...matches);
-        else {
-          lines.push(...matches.slice(0, 3));
-          lines.push(`\u2026 +${matches.length - 3} more`);
-        }
-      }
-      break;
+      if (result.includes("Exit code:")) return [result.split("\n").find((l) => l.includes("Exit code:")) ?? "Done"];
+      const firstLine = result.split("\n").find((l) => l.trim()) ?? "Done";
+      if (totalLines > 1) return [`${firstLine.slice(0, 80)}\u2026 +${totalLines - 1} lines`];
+      return [firstLine.slice(0, 100)];
     }
+    case "Read":
+      return [`Read ${totalLines} lines`];
+    case "Edit":
+      if (result.includes("Successfully")) return [result.split("\n")[0].slice(0, 100)];
+      if (result.includes("replacement")) return [result.split("\n")[0].slice(0, 100)];
+      return [`Edited (${totalLines} lines changed)`];
+    case "Write":
+      return [result.split("\n")[0].slice(0, 100)];
+    case "Glob":
+      return [`Found ${result.split("\n").filter((l) => l.trim()).length} files`];
+    case "Grep":
+      if (result.includes("No matches")) return ["No matches found"];
+      return [`${result.split("\n").filter((l) => l.trim()).length} matches`];
     default:
-      lines.push(result.slice(0, 100));
+      return [result.split("\n")[0]?.slice(0, 80) ?? "Done"];
   }
-  return lines;
 }
 function MessageView({ msg }) {
   if (msg.role === "user") {
@@ -70270,6 +70362,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) => {
@@ -70337,11 +70434,14 @@ function App2({ model, mode, initialPrompt }) {
           permissionContext: permCtx,
           maxTurns: 10,
           onTextDelta: (text2) => {
-            setStreaming((prev) => prev + text2);
+            if (activeToolsRef.current.length === 0 || activeToolsRef.current.every((t) => t.status === "done" || t.status === "error")) {
+              setStreaming((prev) => prev + text2);
+            }
           },
           onThinkingDelta: () => {
           },
           onToolUseStart: (name, id, toolInput) => {
+            setStreaming("");
             onToolStart(id, name, toolSummary(name, toolInput));
           },
           onToolUseEnd: (name, id, toolResult) => {
@@ -70401,12 +70501,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 +70569,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 +70878,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.1";
+    BUILD_TIME = "2026-03-20T12:58:42.260Z";
     PACKAGE_NAME2 = "@hasna/coders";
     ISSUES_URL2 = "https://github.com/hasnaxyz/open-coders/issues";
     startupTimestamps = {};