@gemdoq/codi 0.1.8 → 0.2.0

package/dist/cli.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -95,15 +101,20 @@ function renderToolCall(toolName, args) {
   return `${header}
 ${argStr}`;
 }
-function renderToolResult(toolName, result, isError) {
+function renderToolResult(toolName, result, isError, durationMs) {
   const icon = isError ? chalk2.red("\u2717") : chalk2.green("\u2713");
-  const header = `${icon} ${chalk2.yellow(toolName)}`;
+  const duration = durationMs != null ? chalk2.dim(` (${formatDuration(durationMs)})`) : "";
+  const header = `${icon} ${chalk2.yellow(toolName)}${duration}`;
   const content = isError ? chalk2.red(result) : chalk2.dim(result);
   const maxLen = 500;
   const truncated = content.length > maxLen ? content.slice(0, maxLen) + chalk2.dim("\n... (truncated)") : content;
   return `${header}
 ${truncated}`;
 }
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
 function renderError(message) {
   return chalk2.red(`\u2717 ${message}`);
 }
@@ -323,9 +334,98 @@ var init_task_tools = __esm({
   }
 });
 
+// src/tools/file-backup.ts
+var file_backup_exports = {};
+__export(file_backup_exports, {
+  backupFile: () => backupFile,
+  cleanupBackups: () => cleanupBackups,
+  getBackupHistory: () => getBackupHistory,
+  restoreFile: () => restoreFile,
+  undoLast: () => undoLast
+});
+import * as fs11 from "fs";
+import * as os12 from "os";
+import * as path12 from "path";
+function ensureBackupDir() {
+  if (!fs11.existsSync(backupDir)) {
+    fs11.mkdirSync(backupDir, { recursive: true });
+  }
+}
+function registerCleanup() {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  process.on("exit", () => {
+    cleanupBackups();
+  });
+}
+function backupFile(filePath) {
+  const resolved = path12.resolve(filePath);
+  ensureBackupDir();
+  registerCleanup();
+  const wasNew = !fs11.existsSync(resolved);
+  const backupName = `${Date.now()}-${Math.random().toString(36).slice(2)}-${path12.basename(resolved)}`;
+  const backupPath = path12.join(backupDir, backupName);
+  if (!wasNew) {
+    fs11.copyFileSync(resolved, backupPath);
+  }
+  const entry = {
+    backupPath,
+    originalPath: resolved,
+    wasNew,
+    timestamp: Date.now()
+  };
+  backupHistory.push(entry);
+  return backupPath;
+}
+function restoreFile(entry) {
+  if (entry.wasNew) {
+    if (fs11.existsSync(entry.originalPath)) {
+      fs11.unlinkSync(entry.originalPath);
+    }
+  } else {
+    if (fs11.existsSync(entry.backupPath)) {
+      fs11.copyFileSync(entry.backupPath, entry.originalPath);
+    }
+  }
+}
+function cleanupBackups() {
+  if (fs11.existsSync(backupDir)) {
+    try {
+      fs11.rmSync(backupDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  backupHistory.length = 0;
+}
+function getBackupHistory() {
+  return backupHistory;
+}
+function undoLast() {
+  const entry = backupHistory.pop();
+  if (!entry) return null;
+  restoreFile(entry);
+  if (!entry.wasNew && fs11.existsSync(entry.backupPath)) {
+    try {
+      fs11.unlinkSync(entry.backupPath);
+    } catch {
+    }
+  }
+  return entry;
+}
+var backupDir, backupHistory, cleanupRegistered;
+var init_file_backup = __esm({
+  "src/tools/file-backup.ts"() {
+    "use strict";
+    init_esm_shims();
+    backupDir = path12.join(os12.tmpdir(), `codi-backups-${process.pid}`);
+    backupHistory = [];
+    cleanupRegistered = false;
+  }
+});
+
 // src/cli.ts
 init_esm_shims();
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // src/setup-wizard.ts
 init_esm_shims();
@@ -637,6 +737,7 @@ init_esm_shims();
 import * as readline2 from "readline/promises";
 import { stdin as input2, stdout as output2 } from "process";
 import * as os3 from "os";
+import * as fs4 from "fs";
 import chalk4 from "chalk";
 import { execSync } from "child_process";
 import { edit } from "external-editor";
@@ -779,14 +880,17 @@ function completer(line) {
 }
 
 // src/repl.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import * as path5 from "path";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = path5.dirname(__filename2);
+var HISTORY_DIR = path5.join(os3.homedir(), ".codi");
+var HISTORY_FILE = path5.join(HISTORY_DIR, "history");
+var MAX_HISTORY = 1e3;
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(path5.join(__dirname2, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync4(path5.join(__dirname2, "..", "package.json"), "utf-8"));
     return `v${pkg.version}`;
   } catch {
     return "v0.1.4";
@@ -815,15 +919,50 @@ var Repl = class {
       description: "Clear screen"
     });
   }
+  loadHistory() {
+    try {
+      const content = fs4.readFileSync(HISTORY_FILE, "utf-8");
+      return content.split("\n").filter(Boolean).slice(-MAX_HISTORY);
+    } catch {
+      return [];
+    }
+  }
+  saveHistory() {
+    if (!this.rl) return;
+    try {
+      const rlAny = this.rl;
+      const history = rlAny.history ?? [];
+      const entries = history.slice(0, MAX_HISTORY).reverse();
+      fs4.mkdirSync(HISTORY_DIR, { recursive: true });
+      fs4.writeFileSync(HISTORY_FILE, entries.join("\n") + "\n", "utf-8");
+    } catch {
+    }
+  }
+  shouldSaveToHistory(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return false;
+    if (trimmed.startsWith("/")) return false;
+    return true;
+  }
   async start() {
     this.running = true;
+    const loadedHistory = this.loadHistory();
     this.rl = readline2.createInterface({
       input: input2,
       output: output2,
       prompt: renderPrompt(),
       completer: (line) => completer(line),
-      terminal: true
+      terminal: true,
+      history: loadedHistory,
+      historySize: MAX_HISTORY
     });
+    const rlAny = this.rl;
+    if (rlAny.history && loadedHistory.length > 0) {
+      rlAny.history.length = 0;
+      for (let i = loadedHistory.length - 1; i >= 0; i--) {
+        rlAny.history.push(loadedHistory[i]);
+      }
+    }
     if (process.stdin.isTTY && os3.platform() !== "win32") {
       process.stdout.write("\x1B[?2004h");
     }
@@ -857,10 +996,10 @@ var Repl = class {
         }
         this.rl.setPrompt(renderPrompt());
         this.rl.prompt();
-        const line = await new Promise((resolve10, reject) => {
+        const line = await new Promise((resolve11, reject) => {
           const onLine = (data) => {
             cleanup();
-            resolve10(data);
+            resolve11(data);
           };
           const onClose = () => {
             cleanup();
@@ -876,7 +1015,7 @@ var Repl = class {
             this.lastInterruptTime = now;
             this.options.onInterrupt();
             console.log(chalk4.dim("\n(Press Ctrl+C again to exit)"));
-            resolve10("");
+            resolve11("");
           };
           const cleanup = () => {
             this.rl.removeListener("line", onLine);
@@ -889,6 +1028,17 @@ var Repl = class {
         });
         const trimmed = line.trim();
         if (!trimmed) continue;
+        {
+          const rlAny2 = this.rl;
+          const hist = rlAny2.history;
+          if (hist && hist.length > 0) {
+            if (!this.shouldSaveToHistory(trimmed)) {
+              hist.shift();
+            } else if (hist.length > 1 && hist[0] === hist[1]) {
+              hist.shift();
+            }
+          }
+        }
         if (trimmed.endsWith("\\")) {
           this.multilineBuffer.push(trimmed.slice(0, -1));
           this.inMultiline = true;
@@ -952,32 +1102,37 @@ var Repl = class {
       }
       return;
     }
-    let message = input3;
     const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
+    const MIME_MAP = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".bmp": "image/bmp",
+      ".svg": "image/svg+xml"
+    };
     const atMatches = input3.match(/@([\w.\/\\:~-]+)/g);
+    let hasImages = false;
+    const imageBlocks = [];
+    let message = input3;
     if (atMatches) {
       for (const match of atMatches) {
         const filePath = match.slice(1);
         try {
           const ext = path5.extname(filePath).toLowerCase();
           if (IMAGE_EXTS.has(ext)) {
-            const data = readFileSync3(filePath);
+            const data = readFileSync4(filePath);
             const base64 = data.toString("base64");
-            const mimeMap = {
-              ".png": "image/png",
-              ".jpg": "image/jpeg",
-              ".jpeg": "image/jpeg",
-              ".gif": "image/gif",
-              ".webp": "image/webp",
-              ".bmp": "image/bmp",
-              ".svg": "image/svg+xml"
-            };
-            const mime = mimeMap[ext] || "image/png";
-            message = message.replace(match, `
-[Image: ${filePath}](data:${mime};base64,${base64})
-`);
+            const mime = MIME_MAP[ext] || "image/png";
+            imageBlocks.push({
+              type: "image",
+              source: { type: "base64", media_type: mime, data: base64 }
+            });
+            message = message.replace(match, `[\uC774\uBBF8\uC9C0: ${path5.basename(filePath)}]`);
+            hasImages = true;
           } else {
-            const content = readFileSync3(filePath, "utf-8");
+            const content = readFileSync4(filePath, "utf-8");
             message = message.replace(match, `
 [File: ${filePath}]
 \`\`\`
@@ -989,7 +1144,15 @@ ${content}
         }
       }
     }
-    await this.options.onMessage(message);
+    if (hasImages) {
+      const blocks = [
+        { type: "text", text: message.trim() },
+        ...imageBlocks
+      ];
+      await this.options.onMessage(blocks);
+    } else {
+      await this.options.onMessage(message);
+    }
   }
   openEditor() {
     try {
@@ -1007,6 +1170,7 @@ ${content}
     }
   }
   async gracefulExit() {
+    this.saveHistory();
     this.stop();
     if (this.options.onExit) {
       await this.options.onExit();
@@ -1033,6 +1197,64 @@ init_esm_shims();
 
 // src/agent/conversation.ts
 init_esm_shims();
+
+// src/utils/tokenizer.ts
+init_esm_shims();
+import { getEncoding, encodingForModel } from "js-tiktoken";
+var encoderCache = /* @__PURE__ */ new Map();
+function getEncoder(model) {
+  const cacheKey = model ?? "cl100k_base";
+  const cached = encoderCache.get(cacheKey);
+  if (cached) return cached;
+  try {
+    const encoder = model ? encodingForModel(model) : getEncoding("cl100k_base");
+    encoderCache.set(cacheKey, encoder);
+    return encoder;
+  } catch {
+    const fallback = encoderCache.get("cl100k_base");
+    if (fallback) return fallback;
+    const encoder = getEncoding("cl100k_base");
+    encoderCache.set("cl100k_base", encoder);
+    return encoder;
+  }
+}
+function countTokens(text, model) {
+  if (!text) return 0;
+  try {
+    const encoder = getEncoder(model);
+    return encoder.encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+function countContentBlockTokens(blocks, model) {
+  let total = 0;
+  for (const block of blocks) {
+    if (block.type === "text") {
+      total += countTokens(block.text, model);
+    } else if (block.type === "tool_use") {
+      total += countTokens(block.name, model);
+      total += countTokens(JSON.stringify(block.input), model);
+    } else if (block.type === "tool_result") {
+      if (typeof block.content === "string") {
+        total += countTokens(block.content, model);
+      } else {
+        total += countTokens(JSON.stringify(block.content), model);
+      }
+    } else {
+      total += countTokens(JSON.stringify(block), model);
+    }
+  }
+  return total;
+}
+function countMessageTokens(content, model) {
+  if (typeof content === "string") {
+    return countTokens(content, model);
+  }
+  return countContentBlockTokens(content, model);
+}
+
+// src/agent/conversation.ts
 var Conversation = class _Conversation {
   messages = [];
   systemPrompt = "";
@@ -1118,24 +1340,14 @@ ${summary}` },
     return conv;
   }
   /**
-   * Estimate rough token count (very approximate).
+   * tiktoken을 사용하여 정확한 토큰 수를 계산한다.
    */
-  estimateTokens() {
-    let chars = this.systemPrompt.length;
+  estimateTokens(model) {
+    let tokens = countTokens(this.systemPrompt, model);
     for (const msg of this.messages) {
-      if (typeof msg.content === "string") {
-        chars += msg.content.length;
-      } else {
-        for (const block of msg.content) {
-          if (block.type === "text") chars += block.text.length;
-          else if (block.type === "tool_use") chars += JSON.stringify(block.input).length;
-          else if (block.type === "tool_result") {
-            chars += typeof block.content === "string" ? block.content.length : JSON.stringify(block.content).length;
-          }
-        }
-      }
+      tokens += countMessageTokens(msg.content, model);
     }
-    return Math.ceil(chars / 4);
+    return tokens;
   }
 };
 
@@ -1143,147 +1355,679 @@ ${summary}` },
 init_esm_shims();
 init_tool();
 init_renderer();
+
+// src/ui/spinner.ts
+init_esm_shims();
+import ora from "ora";
 import chalk5 from "chalk";
-var ToolExecutor = class {
-  constructor(registry, options = {}) {
-    this.registry = registry;
-    this.options = options;
+var currentSpinner = null;
+function startSpinner(text) {
+  stopSpinner();
+  currentSpinner = ora({
+    text: chalk5.dim(text),
+    spinner: "dots",
+    color: "cyan"
+  }).start();
+  return currentSpinner;
+}
+function updateSpinner(text) {
+  if (currentSpinner) {
+    currentSpinner.text = chalk5.dim(text);
   }
-  async executeOne(toolCall) {
-    const tool = this.registry.get(toolCall.name);
-    if (!tool) {
-      return {
-        toolUseId: toolCall.id,
-        toolName: toolCall.name,
-        result: makeToolError(`Unknown tool: ${toolCall.name}. Available tools: ${this.registry.listNames().join(", ")}`)
-      };
-    }
-    if (this.options.planMode && !tool.readOnly) {
-      return {
-        toolUseId: toolCall.id,
-        toolName: toolCall.name,
-        result: makeToolError(`Tool '${toolCall.name}' is not available in plan mode (read-only). Use only read-only tools.`)
-      };
-    }
-    if (tool.dangerous && this.options.permissionCheck) {
-      const allowed = await this.options.permissionCheck(tool, toolCall.input);
-      if (!allowed) {
-        return {
-          toolUseId: toolCall.id,
-          toolName: toolCall.name,
-          result: makeToolError(`Permission denied for tool: ${toolCall.name}`)
-        };
-      }
-    }
-    let input3 = toolCall.input;
-    if (this.options.preHook) {
-      try {
-        const hookResult = await this.options.preHook(toolCall.name, input3);
-        if (!hookResult.proceed) {
-          return {
-            toolUseId: toolCall.id,
-            toolName: toolCall.name,
-            result: makeToolError(`Tool execution blocked by hook for: ${toolCall.name}`)
-          };
-        }
-        if (hookResult.updatedInput) {
-          input3 = hookResult.updatedInput;
-        }
-      } catch (err) {
-        console.error(chalk5.yellow(`Hook error for ${toolCall.name}: ${err}`));
-      }
-    }
-    if (this.options.showToolCalls) {
-      console.log(renderToolCall(toolCall.name, input3));
+}
+function stopSpinner(symbol) {
+  if (currentSpinner) {
+    if (symbol) {
+      currentSpinner.stopAndPersist({ symbol });
+    } else {
+      currentSpinner.stop();
     }
-    let result;
+    currentSpinner = null;
+  }
+}
+
+// src/tools/bash.ts
+init_esm_shims();
+init_tool();
+import { spawn } from "child_process";
+import * as os5 from "os";
+import chalk7 from "chalk";
+
+// src/security/command-validator.ts
+init_esm_shims();
+
+// src/utils/logger.ts
+init_esm_shims();
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as os4 from "os";
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class _Logger {
+  static instance;
+  level;
+  logDir;
+  initialized = false;
+  constructor(logDir) {
+    const envLevel = process.env["CODI_LOG_LEVEL"]?.toLowerCase();
+    this.level = this.isValidLevel(envLevel) ? envLevel : "info";
+    this.logDir = logDir ?? path6.join(os4.homedir(), ".codi", "logs");
+  }
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  /** 테스트용: 커스텀 logDir로 새 인스턴스 생성 */
+  static createForTest(logDir, level = "debug") {
+    const instance = new _Logger(logDir);
+    instance.level = level;
+    return instance;
+  }
+  isValidLevel(val) {
+    return val !== void 0 && val in LOG_LEVEL_PRIORITY;
+  }
+  ensureDir() {
+    if (this.initialized) return;
     try {
-      result = await tool.execute(input3);
-    } catch (err) {
-      result = makeToolError(
-        `Tool '${toolCall.name}' threw an error: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    if (this.options.showToolCalls) {
-      console.log(renderToolResult(toolCall.name, result.output, !result.success));
+      fs5.mkdirSync(this.logDir, { recursive: true });
+      this.initialized = true;
+      this.rotateOldLogs();
+    } catch {
     }
-    if (this.options.postHook) {
-      try {
-        await this.options.postHook(toolCall.name, input3, result);
-      } catch {
+  }
+  /** 7일 이상 된 로그 파일 삭제 */
+  rotateOldLogs() {
+    try {
+      const files = fs5.readdirSync(this.logDir);
+      const now = Date.now();
+      const maxAge = 7 * 24 * 60 * 60 * 1e3;
+      for (const file of files) {
+        if (!file.startsWith("codi-") || !file.endsWith(".log")) continue;
+        const filePath = path6.join(this.logDir, file);
+        try {
+          const stat = fs5.statSync(filePath);
+          if (now - stat.mtimeMs > maxAge) {
+            fs5.unlinkSync(filePath);
+          }
+        } catch {
+        }
       }
+    } catch {
     }
-    return {
-      toolUseId: toolCall.id,
-      toolName: toolCall.name,
-      result
-    };
   }
-  async executeMany(toolCalls) {
-    const safeCalls = [];
-    const dangerousCalls = [];
-    for (const tc of toolCalls) {
-      const tool = this.registry.get(tc.name);
-      if (tool?.dangerous) {
-        dangerousCalls.push(tc);
-      } else {
-        safeCalls.push(tc);
-      }
+  getLogFilePath() {
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return path6.join(this.logDir, `codi-${date}.log`);
+  }
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+  }
+  write(level, message, context, error) {
+    if (!this.shouldLog(level)) return;
+    this.ensureDir();
+    if (!this.initialized) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message
+    };
+    if (context && Object.keys(context).length > 0) {
+      entry.context = context;
     }
-    const safePromises = safeCalls.map((tc) => this.executeOne(tc));
-    const dangerousResults = [];
-    for (const tc of dangerousCalls) {
-      const result = await this.executeOne(tc);
-      dangerousResults.push(result);
+    if (error) {
+      entry.error = {
+        message: error.message,
+        stack: error.stack
+      };
     }
-    const safeResults = await Promise.allSettled(safePromises);
-    const results = [];
-    for (let i = 0; i < safeResults.length; i++) {
-      const r = safeResults[i];
-      if (r.status === "fulfilled") {
-        results.push(r.value);
-      } else {
-        results.push({
-          toolUseId: safeCalls[i].id,
-          toolName: safeCalls[i].name,
-          result: makeToolError(`Tool execution failed: ${r.reason}`)
-        });
-      }
+    try {
+      fs5.appendFileSync(this.getLogFilePath(), JSON.stringify(entry) + "\n");
+    } catch {
     }
-    results.push(...dangerousResults);
-    const orderMap = new Map(toolCalls.map((tc, i) => [tc.id, i]));
-    results.sort((a, b) => (orderMap.get(a.toolUseId) ?? 0) - (orderMap.get(b.toolUseId) ?? 0));
-    return results;
   }
-  setOptions(options) {
-    Object.assign(this.options, options);
+  debug(message, context) {
+    this.write("debug", message, context);
+  }
+  info(message, context) {
+    this.write("info", message, context);
+  }
+  warn(message, context) {
+    this.write("warn", message, context);
+  }
+  error(message, context, error) {
+    this.write("error", message, context, error);
   }
 };
+var logger = Logger.getInstance();
 
-// src/agent/token-tracker.ts
-init_esm_shims();
+// src/security/command-validator.ts
+var BLOCKED_PATTERNS = [
+  // 광범위 삭제
+  { pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|(-[a-zA-Z]*f[a-zA-Z]*r))\s+[/~*]/, reason: "\uAD11\uBC94\uC704 \uC0AD\uC81C \uBA85\uB839\uC5B4(rm -rf /, ~, *)\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\brm\s+-rf\s*$/, reason: "\uB300\uC0C1 \uC5C6\uB294 rm -rf\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bRemove-Item\s+.*-Recurse.*[/\\]\s*$/, reason: "PowerShell \uAD11\uBC94\uC704 \uC0AD\uC81C\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bRemove-Item\s+.*-Recurse.*(\*|~|[A-Z]:\\)/, reason: "PowerShell \uAD11\uBC94\uC704 \uC0AD\uC81C\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 디스크 연산
+  { pattern: /\bmkfs\b/, reason: "\uD30C\uC77C\uC2DC\uC2A4\uD15C \uD3EC\uB9F7(mkfs) \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bformat\s+[A-Z]:/i, reason: "\uB514\uC2A4\uD06C \uD3EC\uB9F7(format) \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bdd\s+if=/, reason: "dd \uB514\uC2A4\uD06C \uC4F0\uAE30 \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 광범위 권한 변경
+  { pattern: /\bchmod\s+(-[a-zA-Z]*R[a-zA-Z]*\s+)?777\b/, reason: "\uAD11\uBC94\uC704 \uAD8C\uD55C \uBCC0\uACBD(chmod 777)\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bchown\s+-[a-zA-Z]*R/, reason: "\uC7AC\uADC0\uC801 \uC18C\uC720\uC790 \uBCC0\uACBD(chown -R)\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 포크 폭탄
+  { pattern: /:\(\)\s*\{.*\|.*&\s*\}\s*;?\s*:/, reason: "\uD3EC\uD06C \uD3ED\uD0C4\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bwhile\s+true\s*;\s*do\s+fork/, reason: "\uD3EC\uD06C \uD3ED\uD0C4 \uD328\uD134\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 디바이스 리디렉션
+  { pattern: />\s*\/dev\/sd[a-z]/, reason: "\uB514\uBC14\uC774\uC2A4 \uC9C1\uC811 \uC4F0\uAE30\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: />\s*\/dev\/nvme/, reason: "\uB514\uBC14\uC774\uC2A4 \uC9C1\uC811 \uC4F0\uAE30\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: />\s*\\\\\.\\PhysicalDrive/, reason: "Windows \uB514\uBC14\uC774\uC2A4 \uC9C1\uC811 \uC4F0\uAE30\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 인터넷에서 받아서 바로 실행
+  { pattern: /\bcurl\b.*\|\s*(sh|bash|zsh|powershell|pwsh)\b/, reason: "\uC6D0\uACA9 \uC2A4\uD06C\uB9BD\uD2B8 \uD30C\uC774\uD504 \uC2E4\uD589(curl | sh)\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bwget\b.*\|\s*(sh|bash|zsh|powershell|pwsh)\b/, reason: "\uC6D0\uACA9 \uC2A4\uD06C\uB9BD\uD2B8 \uD30C\uC774\uD504 \uC2E4\uD589(wget | sh)\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bInvoke-WebRequest\b.*\|\s*Invoke-Expression\b/, reason: "PowerShell \uC6D0\uACA9 \uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\biwr\b.*\|\s*iex\b/, reason: "PowerShell \uC6D0\uACA9 \uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589(iwr | iex)\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bIEX\s*\(\s*(New-Object|Invoke-WebRequest|iwr)\b/, reason: "PowerShell \uC6D0\uACA9 \uC2A4\uD06C\uB9BD\uD2B8 \uC2E4\uD589\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 시스템 종료/재부팅
+  { pattern: /\bshutdown\b/, reason: "\uC2DC\uC2A4\uD15C \uC885\uB8CC(shutdown) \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\breboot\b/, reason: "\uC2DC\uC2A4\uD15C \uC7AC\uBD80\uD305(reboot) \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bhalt\b/, reason: "\uC2DC\uC2A4\uD15C \uC911\uC9C0(halt) \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bStop-Computer\b/, reason: "PowerShell \uC2DC\uC2A4\uD15C \uC885\uB8CC\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bRestart-Computer\b/, reason: "PowerShell \uC2DC\uC2A4\uD15C \uC7AC\uBD80\uD305\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  // 프로세스 종료
+  { pattern: /\bkill\s+-9\s+1\b/, reason: "init \uD504\uB85C\uC138\uC2A4 \uC885\uB8CC(kill -9 1)\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bkillall\b/, reason: "\uC804\uCCB4 \uD504\uB85C\uC138\uC2A4 \uC885\uB8CC(killall)\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bStop-Process\s+.*-Id\s+1\b/, reason: "PowerShell init \uD504\uB85C\uC138\uC2A4 \uC885\uB8CC\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." }
+];
+var WARNED_PATTERNS = [
+  { pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|(-[a-zA-Z]*f[a-zA-Z]*r))\s+/, reason: "rm -rf \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uACBD\uB85C\uB97C \uD655\uC778\uD558\uC138\uC694." },
+  { pattern: /\bRemove-Item\s+.*-Recurse/, reason: "PowerShell \uC7AC\uADC0 \uC0AD\uC81C\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uACBD\uB85C\uB97C \uD655\uC778\uD558\uC138\uC694." },
+  { pattern: /\bsudo\b/, reason: "sudo \uBA85\uB839\uC5B4\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bRunAs\b/i, reason: "Windows \uAD00\uB9AC\uC790 \uAD8C\uD55C \uC2E4\uD589\uC774 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bnpm\s+publish\b/, reason: "npm \uD328\uD0A4\uC9C0 \uBC30\uD3EC(npm publish)\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bdocker\s+push\b/, reason: "Docker \uC774\uBBF8\uC9C0 \uD478\uC2DC(docker push)\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." },
+  { pattern: /\bgit\s+push\b/, reason: "git push\uAC00 \uAC10\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." }
+];
+function validateCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return { allowed: true, level: "allowed" };
+  }
+  for (const { pattern, reason } of BLOCKED_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      logger.warn("\uBA85\uB839\uC5B4 \uCC28\uB2E8\uB428", { command: trimmed, reason });
+      return { allowed: false, level: "blocked", reason };
+    }
+  }
+  for (const { pattern, reason } of WARNED_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      logger.info("\uBA85\uB839\uC5B4 \uACBD\uACE0", { command: trimmed, reason });
+      return { allowed: true, level: "warned", reason };
+    }
+  }
+  return { allowed: true, level: "allowed" };
+}
 
-// src/llm/types.ts
+// src/security/permission-manager.ts
 init_esm_shims();
-var MODEL_COSTS = {
+import * as readline3 from "readline/promises";
+import chalk6 from "chalk";
+
+// src/config/permissions.ts
+init_esm_shims();
+function parseRule(rule) {
+  const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
+  if (match) {
+    return { tool: match[1], pattern: match[2] };
+  }
+  return { tool: rule };
+}
+function matchesRule(rule, toolName, input3) {
+  if (rule.tool !== toolName) return false;
+  if (!rule.pattern) return true;
+  const pattern = new RegExp(rule.pattern.replace(/\*/g, ".*"));
+  for (const value of Object.values(input3)) {
+    if (typeof value === "string" && pattern.test(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function evaluatePermission(toolName, input3, rules) {
+  for (const rule of rules.deny) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "deny";
+    }
+  }
+  for (const rule of rules.ask) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "ask";
+    }
+  }
+  for (const rule of rules.allow) {
+    if (matchesRule(parseRule(rule), toolName, input3)) {
+      return "allow";
+    }
+  }
+  return "ask";
+}
+
+// src/security/permission-manager.ts
+var sessionAllowed = /* @__PURE__ */ new Set();
+var sessionDenied = /* @__PURE__ */ new Set();
+var currentMode = "default";
+function setPermissionMode(mode) {
+  currentMode = mode;
+}
+function getPermissionMode() {
+  return currentMode;
+}
+async function checkPermission(tool, input3) {
+  if (!tool.dangerous) return true;
+  if (currentMode === "yolo") return true;
+  if (currentMode === "acceptEdits" && ["write_file", "edit_file", "multi_edit"].includes(tool.name)) {
+    return true;
+  }
+  if (currentMode === "plan" && !tool.readOnly) {
+    return false;
+  }
+  const config = configManager.get();
+  const decision = evaluatePermission(tool.name, input3, config.permissions);
+  if (decision === "allow") return true;
+  if (decision === "deny") {
+    console.log(chalk6.red(`\u2717 Permission denied for ${tool.name} (denied by rule)`));
+    return false;
+  }
+  const key = `${tool.name}:${JSON.stringify(input3)}`;
+  if (sessionAllowed.has(tool.name)) return true;
+  if (sessionDenied.has(tool.name)) return false;
+  return promptUser(tool, input3);
+}
+async function promptUser(tool, input3) {
+  console.log("");
+  console.log(chalk6.yellow.bold(`\u26A0 Permission Required: ${tool.name}`));
+  const relevantParams = Object.entries(input3).filter(([, v]) => v !== void 0);
+  for (const [key, value] of relevantParams) {
+    const displayValue = typeof value === "string" && value.length > 200 ? value.slice(0, 200) + "..." : String(value);
+    console.log(chalk6.dim(`  ${key}: `) + displayValue);
+  }
+  console.log("");
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(
+      chalk6.yellow(`Allow? [${chalk6.bold("Y")}es / ${chalk6.bold("n")}o / ${chalk6.bold("a")}lways for this tool] `)
+    );
+    rl.close();
+    const choice = answer.trim().toLowerCase();
+    if (choice === "a" || choice === "always") {
+      sessionAllowed.add(tool.name);
+      return true;
+    }
+    if (choice === "n" || choice === "no") {
+      return false;
+    }
+    return true;
+  } catch {
+    rl.close();
+    return false;
+  }
+}
+
+// src/tools/bash.ts
+var _currentOnOutput = null;
+function setBashOutputCallback(cb) {
+  _currentOnOutput = cb;
+}
+function getDefaultShell() {
+  if (os5.platform() === "win32") {
+    return "powershell.exe";
+  }
+  return process.env["SHELL"] || "/bin/bash";
+}
+var backgroundTasks = /* @__PURE__ */ new Map();
+var taskCounter = 0;
+var bashTool = {
+  name: "bash",
+  description: `Execute a shell command. Supports timeout (max 600s, default 120s) and background execution. The working directory persists between calls. Uses the platform default shell (bash on Unix, PowerShell on Windows).`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: { type: "string", description: "The bash command to execute" },
+      description: { type: "string", description: "Brief description of what the command does" },
+      timeout: { type: "number", description: "Timeout in milliseconds (max 600000, default 120000)" },
+      run_in_background: { type: "boolean", description: "Run in background and return a task ID" }
+    },
+    required: ["command"]
+  },
+  dangerous: true,
+  readOnly: false,
+  async execute(input3) {
+    const command = String(input3["command"]);
+    const timeout = Math.min(Number(input3["timeout"]) || 12e4, 6e5);
+    const runInBackground = input3["run_in_background"] === true;
+    if (!command.trim()) {
+      return makeToolError("Command cannot be empty");
+    }
+    if (getPermissionMode() !== "yolo") {
+      const validation = validateCommand(command);
+      if (!validation.allowed) {
+        return makeToolError(`\uBA85\uB839\uC5B4\uAC00 \uCC28\uB2E8\uB418\uC5C8\uC2B5\uB2C8\uB2E4: ${validation.reason}`);
+      }
+      if (validation.level === "warned") {
+        console.log(chalk7.yellow(`\u26A0 \uACBD\uACE0: ${validation.reason}`));
+      }
+    }
+    if (runInBackground) {
+      return runBackgroundTask(command);
+    }
+    return new Promise((resolve11) => {
+      const finalCommand = os5.platform() === "win32" ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}` : command;
+      const startTime = Date.now();
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      const proc = spawn(finalCommand, {
+        shell: getDefaultShell(),
+        cwd: process.cwd(),
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+        setTimeout(() => proc.kill("SIGKILL"), 5e3);
+      }, timeout);
+      const onOutput = _currentOnOutput;
+      proc.stdout?.on("data", (data) => {
+        const chunk = data.toString();
+        stdout += chunk;
+        if (onOutput) {
+          onOutput(chunk);
+        }
+      });
+      proc.stderr?.on("data", (data) => {
+        const chunk = data.toString();
+        stderr += chunk;
+        if (onOutput) {
+          onOutput(chunk);
+        }
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const durationMs = Date.now() - startTime;
+        const exitCode = code ?? 1;
+        if (timedOut) {
+          logger.info("bash \uBA85\uB839\uC5B4 \uC2E4\uD589", { command, exitCode, durationMs, timedOut: true });
+          const output4 = [
+            stdout ? `stdout:
+${stdout}` : "",
+            stderr ? `stderr:
+${stderr}` : "",
+            `Exit code: ${exitCode}`
+          ].filter(Boolean).join("\n\n");
+          resolve11(makeToolError(`Command timed out after ${timeout / 1e3}s
+${output4}`));
+          return;
+        }
+        if (exitCode !== 0) {
+          logger.info("bash \uBA85\uB839\uC5B4 \uC2E4\uD589", { command, exitCode, durationMs, timedOut: false });
+          const output4 = [
+            stdout ? `stdout:
+${stdout}` : "",
+            stderr ? `stderr:
+${stderr}` : "",
+            `Exit code: ${exitCode}`
+          ].filter(Boolean).join("\n\n");
+          resolve11(makeToolResult(output4 || `Command failed with exit code ${exitCode}`));
+          return;
+        }
+        logger.info("bash \uBA85\uB839\uC5B4 \uC2E4\uD589", { command, exitCode: 0, durationMs });
+        const output3 = [
+          stdout ? stdout : "",
+          stderr ? `stderr:
+${stderr}` : ""
+        ].filter(Boolean).join("\n");
+        resolve11(makeToolResult(output3 || "(no output)"));
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        const durationMs = Date.now() - startTime;
+        logger.info("bash \uBA85\uB839\uC5B4 \uC2E4\uD589 \uC2E4\uD328", { command, durationMs, error: err.message });
+        resolve11(makeToolError(`Failed to execute command: ${err.message}`));
+      });
+    });
+  }
+};
+function runBackgroundTask(command) {
+  const taskId = `bg_${++taskCounter}`;
+  const bgCommand = os5.platform() === "win32" ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}` : command;
+  const proc = spawn(bgCommand, {
+    shell: getDefaultShell(),
+    cwd: process.cwd(),
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  const task = { process: proc, output: "", status: "running", exitCode: void 0 };
+  backgroundTasks.set(taskId, task);
+  proc.stdout?.on("data", (data) => {
+    task.output += data.toString();
+  });
+  proc.stderr?.on("data", (data) => {
+    task.output += data.toString();
+  });
+  proc.on("close", (code) => {
+    task.status = code === 0 ? "done" : "error";
+    task.exitCode = code ?? 1;
+  });
+  proc.on("error", (err) => {
+    task.status = "error";
+    task.output += `
+Process error: ${err.message}`;
+  });
+  return makeToolResult(`Background task started with ID: ${taskId}
+Use task_output tool to check results.`);
+}
+
+// src/tools/executor.ts
+import chalk8 from "chalk";
+var ToolExecutor = class {
+  constructor(registry, options = {}) {
+    this.registry = registry;
+    this.options = options;
+  }
+  async executeOne(toolCall) {
+    const tool = this.registry.get(toolCall.name);
+    if (!tool) {
+      return {
+        toolUseId: toolCall.id,
+        toolName: toolCall.name,
+        result: makeToolError(`Unknown tool: ${toolCall.name}. Available tools: ${this.registry.listNames().join(", ")}`)
+      };
+    }
+    if (this.options.planMode && !tool.readOnly) {
+      return {
+        toolUseId: toolCall.id,
+        toolName: toolCall.name,
+        result: makeToolError(`Tool '${toolCall.name}' is not available in plan mode (read-only). Use only read-only tools.`)
+      };
+    }
+    if (tool.dangerous && this.options.permissionCheck) {
+      const allowed = await this.options.permissionCheck(tool, toolCall.input);
+      if (!allowed) {
+        return {
+          toolUseId: toolCall.id,
+          toolName: toolCall.name,
+          result: makeToolError(`Permission denied for tool: ${toolCall.name}`)
+        };
+      }
+    }
+    let input3 = toolCall.input;
+    if (this.options.preHook) {
+      try {
+        const hookResult = await this.options.preHook(toolCall.name, input3);
+        if (!hookResult.proceed) {
+          return {
+            toolUseId: toolCall.id,
+            toolName: toolCall.name,
+            result: makeToolError(`Tool execution blocked by hook for: ${toolCall.name}`)
+          };
+        }
+        if (hookResult.updatedInput) {
+          input3 = hookResult.updatedInput;
+        }
+      } catch (err) {
+        console.error(chalk8.yellow(`Hook error for ${toolCall.name}: ${err}`));
+      }
+    }
+    if (this.options.showToolCalls) {
+      console.log(renderToolCall(toolCall.name, input3));
+    }
+    let result;
+    const execStart = Date.now();
+    let elapsedTimer = null;
+    if (this.options.showToolCalls) {
+      elapsedTimer = setInterval(() => {
+        const elapsed = ((Date.now() - execStart) / 1e3).toFixed(1);
+        updateSpinner(`${toolCall.name} (${elapsed}s...)`);
+      }, 200);
+      startSpinner(`${toolCall.name}...`);
+      if (toolCall.name === "bash") {
+        setBashOutputCallback((_chunk) => {
+          const elapsed = ((Date.now() - execStart) / 1e3).toFixed(1);
+          updateSpinner(`${toolCall.name} (${elapsed}s...) \u25B8 \uCD9C\uB825 \uC218\uC2E0 \uC911`);
+        });
+      }
+    }
+    try {
+      result = await tool.execute(input3);
+    } catch (err) {
+      result = makeToolError(
+        `Tool '${toolCall.name}' threw an error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    } finally {
+      if (elapsedTimer) {
+        clearInterval(elapsedTimer);
+      }
+      if (toolCall.name === "bash") {
+        setBashOutputCallback(null);
+      }
+      stopSpinner();
+    }
+    const execDuration = Date.now() - execStart;
+    logger.debug("\uB3C4\uAD6C \uC2E4\uD589 \uC644\uB8CC", {
+      tool: toolCall.name,
+      durationMs: execDuration,
+      success: result.success
+    });
+    if (this.options.showToolCalls) {
+      console.log(renderToolResult(toolCall.name, result.output, !result.success, execDuration));
+    }
+    if (this.options.postHook) {
+      try {
+        await this.options.postHook(toolCall.name, input3, result);
+      } catch {
+      }
+    }
+    return {
+      toolUseId: toolCall.id,
+      toolName: toolCall.name,
+      result
+    };
+  }
+  async executeMany(toolCalls) {
+    const safeCalls = [];
+    const dangerousCalls = [];
+    for (const tc of toolCalls) {
+      const tool = this.registry.get(tc.name);
+      if (tool?.dangerous) {
+        dangerousCalls.push(tc);
+      } else {
+        safeCalls.push(tc);
+      }
+    }
+    const safePromises = safeCalls.map((tc) => this.executeOne(tc));
+    const dangerousResults = [];
+    for (const tc of dangerousCalls) {
+      const result = await this.executeOne(tc);
+      dangerousResults.push(result);
+    }
+    const safeResults = await Promise.allSettled(safePromises);
+    const results = [];
+    for (let i = 0; i < safeResults.length; i++) {
+      const r = safeResults[i];
+      if (r.status === "fulfilled") {
+        results.push(r.value);
+      } else {
+        results.push({
+          toolUseId: safeCalls[i].id,
+          toolName: safeCalls[i].name,
+          result: makeToolError(`Tool execution failed: ${r.reason}`)
+        });
+      }
+    }
+    results.push(...dangerousResults);
+    const orderMap = new Map(toolCalls.map((tc, i) => [tc.id, i]));
+    results.sort((a, b) => (orderMap.get(a.toolUseId) ?? 0) - (orderMap.get(b.toolUseId) ?? 0));
+    return results;
+  }
+  setOptions(options) {
+    Object.assign(this.options, options);
+  }
+};
+
+// src/agent/token-tracker.ts
+init_esm_shims();
+
+// src/llm/types.ts
+init_esm_shims();
+var MODEL_COSTS = {
+  // Claude models
   "claude-sonnet-4-20250514": { input: 3e-3, output: 0.015 },
   "claude-opus-4-20250514": { input: 0.015, output: 0.075 },
   "claude-haiku-3-5-20241022": { input: 8e-4, output: 4e-3 },
+  // GPT models
   "gpt-4o": { input: 25e-4, output: 0.01 },
   "gpt-4o-mini": { input: 15e-5, output: 6e-4 },
   "gpt-4.1": { input: 2e-3, output: 8e-3 },
   "gpt-4.1-mini": { input: 4e-4, output: 16e-4 },
-  "gpt-4.1-nano": { input: 1e-4, output: 4e-4 }
+  "gpt-4.1-nano": { input: 1e-4, output: 4e-4 },
+  "o1": { input: 0.015, output: 0.06 },
+  "o1-mini": { input: 3e-3, output: 0.012 },
+  "o3-mini": { input: 11e-4, output: 44e-4 },
+  // Gemini models
+  "gemini-2.5-flash": { input: 15e-5, output: 6e-4 },
+  "gemini-2.5-pro": { input: 125e-5, output: 0.01 },
+  "gemini-2.0-flash": { input: 1e-4, output: 4e-4 },
+  "gemini-1.5-flash": { input: 75e-6, output: 3e-4 },
+  "gemini-1.5-pro": { input: 125e-5, output: 5e-3 }
 };
 function getModelCost(model) {
+  if (model.startsWith("ollama:") || model.startsWith("ollama/")) {
+    return { input: 0, output: 0 };
+  }
   return MODEL_COSTS[model] ?? { input: 0, output: 0 };
 }
 
 // src/agent/token-tracker.ts
 var TokenTracker = class {
+  // Global (accumulated) counters
   inputTokens = 0;
   outputTokens = 0;
   requests = 0;
+  // Per-session counters
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  sessionRequests = 0;
+  lastRequestCost = null;
   model = "";
   setModel(model) {
     this.model = model;
@@ -1292,6 +2036,17 @@ var TokenTracker = class {
     this.inputTokens += usage.input_tokens;
     this.outputTokens += usage.output_tokens;
     this.requests++;
+    this.sessionInputTokens += usage.input_tokens;
+    this.sessionOutputTokens += usage.output_tokens;
+    this.sessionRequests++;
+    const costs = getModelCost(this.model);
+    const reqCost = usage.input_tokens / 1e3 * costs.input + usage.output_tokens / 1e3 * costs.output;
+    this.lastRequestCost = {
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      cost: reqCost,
+      timestamp: Date.now()
+    };
   }
   getStats() {
     const costs = getModelCost(this.model);
@@ -1304,6 +2059,25 @@ var TokenTracker = class {
       requests: this.requests
     };
   }
+  getSessionStats() {
+    const costs = getModelCost(this.model);
+    const cost = this.sessionInputTokens / 1e3 * costs.input + this.sessionOutputTokens / 1e3 * costs.output;
+    return {
+      inputTokens: this.sessionInputTokens,
+      outputTokens: this.sessionOutputTokens,
+      totalTokens: this.sessionInputTokens + this.sessionOutputTokens,
+      cost,
+      requests: this.sessionRequests,
+      lastRequestCost: this.lastRequestCost,
+      avgCostPerRequest: this.sessionRequests > 0 ? cost / this.sessionRequests : 0
+    };
+  }
+  resetSession() {
+    this.sessionInputTokens = 0;
+    this.sessionOutputTokens = 0;
+    this.sessionRequests = 0;
+    this.lastRequestCost = null;
+  }
   getCost() {
     return this.getStats().cost;
   }
@@ -1333,39 +2107,9 @@ var TokenTracker = class {
 };
 var tokenTracker = new TokenTracker();
 
-// src/ui/spinner.ts
-init_esm_shims();
-import ora from "ora";
-import chalk6 from "chalk";
-var currentSpinner = null;
-function startSpinner(text) {
-  stopSpinner();
-  currentSpinner = ora({
-    text: chalk6.dim(text),
-    spinner: "dots",
-    color: "cyan"
-  }).start();
-  return currentSpinner;
-}
-function updateSpinner(text) {
-  if (currentSpinner) {
-    currentSpinner.text = chalk6.dim(text);
-  }
-}
-function stopSpinner(symbol) {
-  if (currentSpinner) {
-    if (symbol) {
-      currentSpinner.stopAndPersist({ symbol });
-    } else {
-      currentSpinner.stop();
-    }
-    currentSpinner = null;
-  }
-}
-
 // src/agent/agent-loop.ts
 init_renderer();
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 var MAX_RETRIES = 3;
 var RETRY_DELAYS = [1e3, 2e3, 4e3];
 async function agentLoop(userMessage, options) {
@@ -1399,8 +2143,9 @@ async function agentLoop(userMessage, options) {
     } catch (err) {
       stopSpinner();
       const errMsg = err instanceof Error ? err.message : String(err);
+      logger.error("LLM \uD638\uCD9C \uC2E4\uD328", { model: provider.model }, err instanceof Error ? err : new Error(errMsg));
       if (showOutput) {
-        console.error(chalk7.red(`
+        console.error(chalk9.red(`
 LLM Error: ${errMsg}`));
       }
       return `Error communicating with LLM: ${errMsg}`;
@@ -1414,6 +2159,13 @@ LLM Error: ${errMsg}`));
         outputTokens: stats.outputTokens,
         cost: stats.cost
       });
+      logger.debug("LLM \uC751\uB2F5 \uC218\uC2E0", {
+        model: provider.model,
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        stopReason: response.stopReason,
+        toolCalls: response.toolCalls?.length ?? 0
+      });
     }
     conversation.addAssistantMessage(response.content);
     const wasStreamed = response._streamed === true;
@@ -1434,7 +2186,7 @@ LLM Error: ${errMsg}`));
     }
     if (response.stopReason === "max_tokens") {
       if (showOutput) {
-        console.log(chalk7.yellow("\n\u26A0 Response truncated (max tokens reached)"));
+        console.log(chalk9.yellow("\n\u26A0 Response truncated (max tokens reached)"));
       }
     }
     if (response.toolCalls && response.toolCalls.length > 0) {
@@ -1442,17 +2194,37 @@ LLM Error: ${errMsg}`));
         console.log("");
       }
       const results = await executor.executeMany(response.toolCalls);
-      const toolResults = results.map((r) => ({
-        tool_use_id: r.toolUseId,
-        content: r.result.output,
-        is_error: !r.result.success
-      }));
+      const toolResults = results.map((r) => {
+        if (r.result.metadata?.isImage && r.result.metadata.imageData) {
+          const blocks = [
+            { type: "text", text: r.result.output },
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: r.result.metadata.imageMimeType || "image/png",
+                data: r.result.metadata.imageData
+              }
+            }
+          ];
+          return {
+            tool_use_id: r.toolUseId,
+            content: blocks,
+            is_error: !r.result.success
+          };
+        }
+        return {
+          tool_use_id: r.toolUseId,
+          content: r.result.output,
+          is_error: !r.result.success
+        };
+      });
       conversation.addToolResults(toolResults);
     }
   }
   if (iterations >= maxIterations) {
     if (showOutput) {
-      console.log(chalk7.yellow(`
+      console.log(chalk9.yellow(`
 \u26A0 Agent loop reached maximum iterations (${maxIterations})`));
     }
   }
@@ -1506,12 +2278,12 @@ async function callLlmWithRetry(provider, conversation, registry, stream, option
   throw lastError || new Error("Max retries exceeded");
 }
 function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 
 // src/agent/system-prompt.ts
 init_esm_shims();
-import * as os4 from "os";
+import * as os6 from "os";
 import { execSync as execSync2 } from "child_process";
 var ROLE_DEFINITION = `You are Codi (\uCF54\uB514), a terminal-based AI coding agent. You help users with software engineering tasks including writing code, debugging, refactoring, and explaining code. You have access to tools for file manipulation, code search, shell execution, and more.
 
@@ -1571,7 +2343,8 @@ var TOOL_HIERARCHY = `# Tool Usage Rules
 - Use grep instead of bash grep/rg for content search
 - Reserve bash for system commands that have no dedicated tool
 - Use sub_agent for complex multi-step exploration tasks
-- Call multiple tools in parallel when they are independent`;
+- Call multiple tools in parallel when they are independent
+- Use update_memory to persist important information (architecture, user preferences, patterns, decisions) across conversations. Proactively save useful context when you discover it.`;
 var WINDOWS_RULES = `# Windows Shell Rules
 You are running on Windows. The shell is PowerShell. Follow these rules:
 - Use PowerShell syntax, NOT bash/sh syntax
@@ -1623,7 +2396,7 @@ function buildSystemPrompt(context) {
   fragments.push(buildEnvironmentInfo(context));
   fragments.push(CONVERSATION_RULES);
   fragments.push(TOOL_HIERARCHY);
-  if (os4.platform() === "win32") {
+  if (os6.platform() === "win32") {
     fragments.push(WINDOWS_RULES);
   }
   fragments.push(CODE_RULES);
@@ -1654,8 +2427,8 @@ function buildEnvironmentInfo(context) {
   const lines = [
     "# Environment",
     `- Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
-    `- OS: ${os4.platform()} ${os4.release()}`,
-    `- Shell: ${os4.platform() === "win32" ? "PowerShell" : process.env["SHELL"] || "/bin/bash"}`,
+    `- OS: ${os6.platform()} ${os6.release()}`,
+    `- Shell: ${os6.platform() === "win32" ? "PowerShell" : process.env["SHELL"] || "/bin/bash"}`,
     `- Working Directory: ${context.cwd}`,
     `- Model: ${context.model}`,
     `- Provider: ${context.provider}`
@@ -1687,7 +2460,7 @@ var ContextCompressor = class {
     this.options = { ...DEFAULT_OPTIONS, ...options };
   }
   shouldCompress(conversation) {
-    const estimatedTokens = conversation.estimateTokens();
+    const estimatedTokens = conversation.estimateTokens(this.options.model);
     return estimatedTokens > this.options.maxContextTokens * this.options.threshold;
   }
   async compress(conversation, provider, focusHint) {
@@ -1725,58 +2498,58 @@ ${summaryContent}`;
 
 // src/agent/memory.ts
 init_esm_shims();
-import * as fs4 from "fs";
-import * as os5 from "os";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as os7 from "os";
+import * as path7 from "path";
 import * as crypto from "crypto";
 var MemoryManager = class {
   memoryDir;
   constructor() {
-    const home = process.env["HOME"] || process.env["USERPROFILE"] || os5.homedir();
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || os7.homedir();
     const projectHash = crypto.createHash("md5").update(process.cwd()).digest("hex").slice(0, 8);
-    const projectName = path6.basename(process.cwd());
-    this.memoryDir = path6.join(home, ".codi", "projects", `${projectName}-${projectHash}`, "memory");
+    const projectName = path7.basename(process.cwd());
+    this.memoryDir = path7.join(home, ".codi", "projects", `${projectName}-${projectHash}`, "memory");
   }
   ensureDir() {
-    if (!fs4.existsSync(this.memoryDir)) {
-      fs4.mkdirSync(this.memoryDir, { recursive: true });
+    if (!fs6.existsSync(this.memoryDir)) {
+      fs6.mkdirSync(this.memoryDir, { recursive: true });
     }
   }
   getMemoryDir() {
     return this.memoryDir;
   }
   loadIndex() {
-    const indexPath = path6.join(this.memoryDir, "MEMORY.md");
-    if (!fs4.existsSync(indexPath)) return "";
-    const content = fs4.readFileSync(indexPath, "utf-8");
+    const indexPath = path7.join(this.memoryDir, "MEMORY.md");
+    if (!fs6.existsSync(indexPath)) return "";
+    const content = fs6.readFileSync(indexPath, "utf-8");
     const lines = content.split("\n");
     return lines.slice(0, 200).join("\n");
   }
   saveIndex(content) {
     this.ensureDir();
-    const indexPath = path6.join(this.memoryDir, "MEMORY.md");
-    fs4.writeFileSync(indexPath, content, "utf-8");
+    const indexPath = path7.join(this.memoryDir, "MEMORY.md");
+    fs6.writeFileSync(indexPath, content, "utf-8");
   }
   loadTopic(name) {
-    const topicPath = path6.join(this.memoryDir, `${name}.md`);
-    if (!fs4.existsSync(topicPath)) return null;
-    return fs4.readFileSync(topicPath, "utf-8");
+    const topicPath = path7.join(this.memoryDir, `${name}.md`);
+    if (!fs6.existsSync(topicPath)) return null;
+    return fs6.readFileSync(topicPath, "utf-8");
   }
   saveTopic(name, content) {
     this.ensureDir();
-    const topicPath = path6.join(this.memoryDir, `${name}.md`);
-    fs4.writeFileSync(topicPath, content, "utf-8");
+    const topicPath = path7.join(this.memoryDir, `${name}.md`);
+    fs6.writeFileSync(topicPath, content, "utf-8");
   }
   listTopics() {
-    if (!fs4.existsSync(this.memoryDir)) return [];
-    return fs4.readdirSync(this.memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => f.replace(".md", ""));
+    if (!fs6.existsSync(this.memoryDir)) return [];
+    return fs6.readdirSync(this.memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => f.replace(".md", ""));
   }
   buildMemoryPrompt() {
     const index = this.loadIndex();
     if (!index) return "";
     const lines = [
       `You have a persistent memory directory at ${this.memoryDir}.`,
-      "Use write_file/edit_file to update memory files as you learn patterns.",
+      "Use the update_memory tool to save, delete, or list memory topics as you learn patterns.",
       "",
       "Current MEMORY.md:",
       index
@@ -1788,25 +2561,25 @@ var memoryManager = new MemoryManager();
 
 // src/agent/session.ts
 init_esm_shims();
-import * as fs5 from "fs";
-import * as os6 from "os";
-import * as path7 from "path";
+import * as fs7 from "fs";
+import * as os8 from "os";
+import * as path8 from "path";
 import * as crypto2 from "crypto";
 var SessionManager = class {
   sessionsDir;
   constructor() {
-    const home = process.env["HOME"] || process.env["USERPROFILE"] || os6.homedir();
-    this.sessionsDir = path7.join(home, ".codi", "sessions");
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || os8.homedir();
+    this.sessionsDir = path8.join(home, ".codi", "sessions");
   }
   ensureDir() {
-    if (!fs5.existsSync(this.sessionsDir)) {
-      fs5.mkdirSync(this.sessionsDir, { recursive: true });
+    if (!fs7.existsSync(this.sessionsDir)) {
+      fs7.mkdirSync(this.sessionsDir, { recursive: true });
     }
   }
   save(conversation, name, model) {
     this.ensureDir();
     const id = name || crypto2.randomUUID().slice(0, 8);
-    const filePath = path7.join(this.sessionsDir, `${id}.jsonl`);
+    const filePath = path8.join(this.sessionsDir, `${id}.jsonl`);
     const data = conversation.serialize();
     const meta = {
       id,
@@ -1822,13 +2595,13 @@ var SessionManager = class {
       JSON.stringify({ type: "system", content: data.systemPrompt }),
       ...data.messages.map((m) => JSON.stringify({ type: "message", ...m }))
     ];
-    fs5.writeFileSync(filePath, lines.join("\n") + "\n", "utf-8");
+    fs7.writeFileSync(filePath, lines.join("\n") + "\n", "utf-8");
     return id;
   }
   load(id) {
-    const filePath = path7.join(this.sessionsDir, `${id}.jsonl`);
-    if (!fs5.existsSync(filePath)) return null;
-    const content = fs5.readFileSync(filePath, "utf-8");
+    const filePath = path8.join(this.sessionsDir, `${id}.jsonl`);
+    if (!fs7.existsSync(filePath)) return null;
+    const content = fs7.readFileSync(filePath, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     let meta = null;
     let systemPrompt = "";
@@ -1853,12 +2626,12 @@ var SessionManager = class {
   }
   list() {
     this.ensureDir();
-    const files = fs5.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".jsonl"));
+    const files = fs7.readdirSync(this.sessionsDir).filter((f) => f.endsWith(".jsonl"));
     const sessions = [];
     for (const file of files) {
-      const filePath = path7.join(this.sessionsDir, file);
+      const filePath = path8.join(this.sessionsDir, file);
       try {
-        const firstLine = fs5.readFileSync(filePath, "utf-8").split("\n")[0];
+        const firstLine = fs7.readFileSync(filePath, "utf-8").split("\n")[0];
         if (firstLine) {
           const meta = JSON.parse(firstLine);
           if (meta.type === "meta") {
@@ -1876,9 +2649,9 @@ var SessionManager = class {
     return sessions[0] ?? null;
   }
   delete(id) {
-    const filePath = path7.join(this.sessionsDir, `${id}.jsonl`);
-    if (fs5.existsSync(filePath)) {
-      fs5.unlinkSync(filePath);
+    const filePath = path8.join(this.sessionsDir, `${id}.jsonl`);
+    if (fs7.existsSync(filePath)) {
+      fs7.unlinkSync(filePath);
       return true;
     }
     return false;
@@ -1900,25 +2673,79 @@ var sessionManager = new SessionManager();
 
 // src/agent/checkpoint.ts
 init_esm_shims();
+import * as fs8 from "fs";
+import * as os9 from "os";
+import * as path9 from "path";
+import * as crypto3 from "crypto";
 import { execSync as execSync3 } from "child_process";
+var MAX_CHECKPOINTS = 20;
 var CheckpointManager = class {
   checkpoints = [];
   nextId = 1;
   isGitRepo;
-  constructor() {
+  sessionId;
+  checkpointDir;
+  constructor(sessionId) {
+    this.sessionId = sessionId || crypto3.randomUUID().slice(0, 8);
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || os9.homedir();
+    this.checkpointDir = path9.join(home, ".codi", "checkpoints", this.sessionId);
     try {
       execSync3("git rev-parse --is-inside-work-tree", { stdio: "pipe" });
       this.isGitRepo = true;
     } catch {
       this.isGitRepo = false;
     }
+    this.loadFromDisk();
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  ensureDir() {
+    if (!fs8.existsSync(this.checkpointDir)) {
+      fs8.mkdirSync(this.checkpointDir, { recursive: true });
+    }
+  }
+  checkpointPath(id) {
+    return path9.join(this.checkpointDir, `checkpoint-${id}.json`);
+  }
+  saveToDisk(checkpoint) {
+    this.ensureDir();
+    const filePath = this.checkpointPath(checkpoint.id);
+    fs8.writeFileSync(filePath, JSON.stringify(checkpoint), "utf-8");
+  }
+  deleteFromDisk(id) {
+    const filePath = this.checkpointPath(id);
+    if (fs8.existsSync(filePath)) {
+      fs8.unlinkSync(filePath);
+    }
+  }
+  loadFromDisk() {
+    if (!fs8.existsSync(this.checkpointDir)) return;
+    const files = fs8.readdirSync(this.checkpointDir).filter((f) => f.startsWith("checkpoint-") && f.endsWith(".json")).sort((a, b) => {
+      const idA = parseInt(a.replace("checkpoint-", "").replace(".json", ""), 10);
+      const idB = parseInt(b.replace("checkpoint-", "").replace(".json", ""), 10);
+      return idA - idB;
+    });
+    for (const file of files) {
+      try {
+        const content = fs8.readFileSync(path9.join(this.checkpointDir, file), "utf-8");
+        const checkpoint = JSON.parse(content);
+        this.checkpoints.push(checkpoint);
+        if (checkpoint.id >= this.nextId) {
+          this.nextId = checkpoint.id + 1;
+        }
+      } catch {
+        continue;
+      }
+    }
   }
   create(conversation, description) {
     const checkpoint = {
       id: this.nextId++,
       timestamp: Date.now(),
       conversation: conversation.serialize(),
-      description
+      description,
+      messageCount: conversation.getMessageCount()
     };
     if (this.isGitRepo) {
       try {
@@ -1940,8 +2767,12 @@ var CheckpointManager = class {
       }
     }
     this.checkpoints.push(checkpoint);
-    if (this.checkpoints.length > 20) {
-      this.checkpoints = this.checkpoints.slice(-20);
+    this.saveToDisk(checkpoint);
+    if (this.checkpoints.length > MAX_CHECKPOINTS) {
+      const removed = this.checkpoints.splice(0, this.checkpoints.length - MAX_CHECKPOINTS);
+      for (const cp of removed) {
+        this.deleteFromDisk(cp.id);
+      }
     }
     return checkpoint.id;
   }
@@ -1961,7 +2792,10 @@ var CheckpointManager = class {
     }
     const idx = this.checkpoints.indexOf(checkpoint);
     if (idx >= 0) {
-      this.checkpoints = this.checkpoints.slice(0, idx + 1);
+      const removed = this.checkpoints.splice(idx + 1);
+      for (const cp of removed) {
+        this.deleteFromDisk(cp.id);
+      }
     }
     return {
       conversation: Conversation.deserialize(checkpoint.conversation),
@@ -1972,54 +2806,64 @@ var CheckpointManager = class {
     return this.checkpoints.map((cp) => ({
       id: cp.id,
       timestamp: cp.timestamp,
-      description: cp.description
+      description: cp.description,
+      messageCount: cp.messageCount
     }));
   }
+  /**
+   * 세션 종료 시 체크포인트 파일 정리
+   */
+  cleanup() {
+    if (fs8.existsSync(this.checkpointDir)) {
+      fs8.rmSync(this.checkpointDir, { recursive: true, force: true });
+    }
+    this.checkpoints = [];
+  }
 };
 var checkpointManager = new CheckpointManager();
 
 // src/agent/codi-md.ts
 init_esm_shims();
-import * as fs6 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function loadCodiMd() {
   const fragments = [];
   let dir = process.cwd();
-  const root = path8.parse(dir).root;
+  const root = path10.parse(dir).root;
   while (dir !== root) {
     loadFromDir(dir, fragments);
-    const parent = path8.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return fragments.join("\n\n---\n\n");
 }
 function loadFromDir(dir, fragments) {
-  const codiPath = path8.join(dir, "CODI.md");
-  if (fs6.existsSync(codiPath)) {
+  const codiPath = path10.join(dir, "CODI.md");
+  if (fs9.existsSync(codiPath)) {
     try {
-      let content = fs6.readFileSync(codiPath, "utf-8");
+      let content = fs9.readFileSync(codiPath, "utf-8");
       content = processImports(content, dir);
       fragments.push(`[CODI.md from ${dir}]
 ${content}`);
     } catch {
     }
   }
-  const localPath = path8.join(dir, "CODI.local.md");
-  if (fs6.existsSync(localPath)) {
+  const localPath = path10.join(dir, "CODI.local.md");
+  if (fs9.existsSync(localPath)) {
     try {
-      const content = fs6.readFileSync(localPath, "utf-8");
+      const content = fs9.readFileSync(localPath, "utf-8");
       fragments.push(`[CODI.local.md from ${dir}]
 ${content}`);
     } catch {
     }
   }
-  const rulesDir = path8.join(dir, ".codi", "rules");
-  if (fs6.existsSync(rulesDir)) {
+  const rulesDir = path10.join(dir, ".codi", "rules");
+  if (fs9.existsSync(rulesDir)) {
     try {
-      const files = fs6.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
+      const files = fs9.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort();
       for (const file of files) {
-        const content = fs6.readFileSync(path8.join(rulesDir, file), "utf-8");
+        const content = fs9.readFileSync(path10.join(rulesDir, file), "utf-8");
         fragments.push(`[Rule: ${file}]
 ${content}`);
       }
@@ -2029,10 +2873,10 @@ ${content}`);
 }
 function processImports(content, baseDir) {
   return content.replace(/@([\w./-]+)/g, (match, importPath) => {
-    const resolved = path8.resolve(baseDir, importPath);
-    if (fs6.existsSync(resolved)) {
+    const resolved = path10.resolve(baseDir, importPath);
+    if (fs9.existsSync(resolved)) {
       try {
-        return fs6.readFileSync(resolved, "utf-8");
+        return fs9.readFileSync(resolved, "utf-8");
       } catch {
         return match;
       }
@@ -2043,12 +2887,12 @@ function processImports(content, baseDir) {
 
 // src/agent/mode-manager.ts
 init_esm_shims();
-var currentMode = "execute";
+var currentMode2 = "execute";
 function getMode() {
-  return currentMode;
+  return currentMode2;
 }
 function setMode(mode) {
-  currentMode = mode;
+  currentMode2 = mode;
 }
 
 // src/tools/registry.ts
@@ -2087,140 +2931,35 @@ var ToolRegistry = class _ToolRegistry {
       const nameSet = new Set(options.names);
       tools = tools.filter((t) => nameSet.has(t.name));
     }
-    return tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.inputSchema
-    }));
-  }
-  clone() {
-    const newRegistry = new _ToolRegistry();
-    for (const [, tool] of this.tools) {
-      newRegistry.register(tool);
-    }
-    return newRegistry;
-  }
-  subset(names) {
-    const newRegistry = new _ToolRegistry();
-    for (const name of names) {
-      const tool = this.tools.get(name);
-      if (tool) newRegistry.register(tool);
-    }
-    return newRegistry;
-  }
-};
-
-// src/security/permission-manager.ts
-init_esm_shims();
-import * as readline3 from "readline/promises";
-import chalk8 from "chalk";
-
-// src/config/permissions.ts
-init_esm_shims();
-function parseRule(rule) {
-  const match = rule.match(/^(\w+)(?:\((.+)\))?$/);
-  if (match) {
-    return { tool: match[1], pattern: match[2] };
-  }
-  return { tool: rule };
-}
-function matchesRule(rule, toolName, input3) {
-  if (rule.tool !== toolName) return false;
-  if (!rule.pattern) return true;
-  const pattern = new RegExp(rule.pattern.replace(/\*/g, ".*"));
-  for (const value of Object.values(input3)) {
-    if (typeof value === "string" && pattern.test(value)) {
-      return true;
-    }
-  }
-  return false;
-}
-function evaluatePermission(toolName, input3, rules) {
-  for (const rule of rules.deny) {
-    if (matchesRule(parseRule(rule), toolName, input3)) {
-      return "deny";
-    }
-  }
-  for (const rule of rules.ask) {
-    if (matchesRule(parseRule(rule), toolName, input3)) {
-      return "ask";
-    }
-  }
-  for (const rule of rules.allow) {
-    if (matchesRule(parseRule(rule), toolName, input3)) {
-      return "allow";
-    }
-  }
-  return "ask";
-}
-
-// src/security/permission-manager.ts
-var sessionAllowed = /* @__PURE__ */ new Set();
-var sessionDenied = /* @__PURE__ */ new Set();
-var currentMode2 = "default";
-function setPermissionMode(mode) {
-  currentMode2 = mode;
-}
-async function checkPermission(tool, input3) {
-  if (!tool.dangerous) return true;
-  if (currentMode2 === "yolo") return true;
-  if (currentMode2 === "acceptEdits" && ["write_file", "edit_file", "multi_edit"].includes(tool.name)) {
-    return true;
-  }
-  if (currentMode2 === "plan" && !tool.readOnly) {
-    return false;
-  }
-  const config = configManager.get();
-  const decision = evaluatePermission(tool.name, input3, config.permissions);
-  if (decision === "allow") return true;
-  if (decision === "deny") {
-    console.log(chalk8.red(`\u2717 Permission denied for ${tool.name} (denied by rule)`));
-    return false;
-  }
-  const key = `${tool.name}:${JSON.stringify(input3)}`;
-  if (sessionAllowed.has(tool.name)) return true;
-  if (sessionDenied.has(tool.name)) return false;
-  return promptUser(tool, input3);
-}
-async function promptUser(tool, input3) {
-  console.log("");
-  console.log(chalk8.yellow.bold(`\u26A0 Permission Required: ${tool.name}`));
-  const relevantParams = Object.entries(input3).filter(([, v]) => v !== void 0);
-  for (const [key, value] of relevantParams) {
-    const displayValue = typeof value === "string" && value.length > 200 ? value.slice(0, 200) + "..." : String(value);
-    console.log(chalk8.dim(`  ${key}: `) + displayValue);
-  }
-  console.log("");
-  const rl = readline3.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  try {
-    const answer = await rl.question(
-      chalk8.yellow(`Allow? [${chalk8.bold("Y")}es / ${chalk8.bold("n")}o / ${chalk8.bold("a")}lways for this tool] `)
-    );
-    rl.close();
-    const choice = answer.trim().toLowerCase();
-    if (choice === "a" || choice === "always") {
-      sessionAllowed.add(tool.name);
-      return true;
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema
+    }));
+  }
+  clone() {
+    const newRegistry = new _ToolRegistry();
+    for (const [, tool] of this.tools) {
+      newRegistry.register(tool);
     }
-    if (choice === "n" || choice === "no") {
-      return false;
+    return newRegistry;
+  }
+  subset(names) {
+    const newRegistry = new _ToolRegistry();
+    for (const name of names) {
+      const tool = this.tools.get(name);
+      if (tool) newRegistry.register(tool);
     }
-    return true;
-  } catch {
-    rl.close();
-    return false;
+    return newRegistry;
   }
-}
+};
 
 // src/hooks/hook-manager.ts
 init_esm_shims();
 import { exec } from "child_process";
-import * as os7 from "os";
-function getDefaultShell() {
-  if (os7.platform() === "win32") {
+import * as os10 from "os";
+function getDefaultShell2() {
+  if (os10.platform() === "win32") {
     return "powershell.exe";
   }
   return void 0;
@@ -2250,41 +2989,41 @@ var HookManager = class {
     return { proceed: true };
   }
   async runCommandHook(command, context, timeout) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve11) => {
       const stdinData = JSON.stringify({
         tool: context["tool"],
         args: context["args"],
         session_id: context["sessionId"],
         cwd: context["cwd"] || process.cwd()
       });
-      const isWin = os7.platform() === "win32";
+      const isWin = os10.platform() === "win32";
       const finalCommand = isWin ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}` : command;
       const proc = exec(finalCommand, {
         timeout: timeout || 5e3,
         cwd: process.cwd(),
         env: { ...process.env },
-        shell: getDefaultShell()
+        shell: getDefaultShell2()
       }, (err, stdout, stderr) => {
         if (err) {
           if (err.code === 2) {
-            resolve10({
+            resolve11({
               proceed: false,
               reason: stderr || stdout || "Blocked by hook"
             });
             return;
           }
-          resolve10({ proceed: true });
+          resolve11({ proceed: true });
           return;
         }
         try {
           const output3 = JSON.parse(stdout);
-          resolve10({
+          resolve11({
             proceed: output3.decision !== "block",
             reason: output3.reason,
             updatedInput: output3.updatedInput
           });
         } catch {
-          resolve10({ proceed: true });
+          resolve11({ proceed: true });
         }
       });
       if (proc.stdin) {
@@ -2299,12 +3038,12 @@ var hookManager = new HookManager();
 // src/mcp/mcp-manager.ts
 init_esm_shims();
 init_tool();
-import * as fs7 from "fs";
-import * as os8 from "os";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as os11 from "os";
+import * as path11 from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 var McpManager = class {
   servers = /* @__PURE__ */ new Map();
   async initialize(registry) {
@@ -2315,21 +3054,21 @@ var McpManager = class {
       try {
         await this.connectServer(name, serverConfig, registry);
       } catch (err) {
-        console.error(chalk9.yellow(`  \u26A0 Failed to connect MCP server '${name}': ${err instanceof Error ? err.message : String(err)}`));
+        console.error(chalk10.yellow(`  \u26A0 Failed to connect MCP server '${name}': ${err instanceof Error ? err.message : String(err)}`));
       }
     }
   }
   loadMcpConfigs() {
     const configs = {};
-    const home = process.env["HOME"] || process.env["USERPROFILE"] || os8.homedir();
+    const home = process.env["HOME"] || process.env["USERPROFILE"] || os11.homedir();
     const paths = [
-      path9.join(home, ".codi", "mcp.json"),
-      path9.join(process.cwd(), ".codi", "mcp.json")
+      path11.join(home, ".codi", "mcp.json"),
+      path11.join(process.cwd(), ".codi", "mcp.json")
     ];
     for (const p of paths) {
       try {
-        if (fs7.existsSync(p)) {
-          const content = JSON.parse(fs7.readFileSync(p, "utf-8"));
+        if (fs10.existsSync(p)) {
+          const content = JSON.parse(fs10.readFileSync(p, "utf-8"));
           if (content.mcpServers) {
             Object.assign(configs, content.mcpServers);
           }
@@ -2381,7 +3120,7 @@ var McpManager = class {
       registry.register(tool);
     }
     this.servers.set(name, { name, client, transport, tools: toolNames });
-    console.log(chalk9.dim(`  \u2713 MCP server '${name}' connected (${toolNames.length} tools)`));
+    console.log(chalk10.dim(`  \u2713 MCP server '${name}' connected (${toolNames.length} tools)`));
   }
   async disconnect(name) {
     const server = this.servers.get(name);
@@ -2412,7 +3151,7 @@ var mcpManager = new McpManager();
 // src/agent/sub-agent.ts
 init_esm_shims();
 init_tool();
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var AGENT_PRESETS = {
   explore: {
     tools: ["read_file", "glob", "grep", "list_dir"],
@@ -2451,7 +3190,7 @@ function createSubAgentHandler(provider, mainRegistry) {
     }
     const conversation = new Conversation();
     const maxIterations = input3["maxIterations"] || preset.maxIterations;
-    console.log(chalk10.dim(`
+    console.log(chalk11.dim(`
   \u25B8 Launching ${type} agent: ${task.slice(0, 80)}...`));
     const runAgent = async () => {
       const result = await agentLoop(task, {
@@ -2480,7 +3219,7 @@ function createSubAgentHandler(provider, mainRegistry) {
     }
     try {
       const result = await runAgent();
-      console.log(chalk10.dim(`  \u25B8 ${type} agent completed.`));
+      console.log(chalk11.dim(`  \u25B8 ${type} agent completed.`));
       return makeToolResult(result);
     } catch (err) {
       return makeToolError(`Sub-agent failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -2524,10 +3263,10 @@ var subAgentTool = {
 
 // src/config/slash-commands.ts
 init_esm_shims();
-import * as fs8 from "fs";
-import * as os9 from "os";
-import * as path10 from "path";
-import chalk11 from "chalk";
+import * as fs12 from "fs";
+import * as os13 from "os";
+import * as path13 from "path";
+import chalk12 from "chalk";
 function createBuiltinCommands() {
   return [
     {
@@ -2535,14 +3274,14 @@ function createBuiltinCommands() {
       description: "Show available commands",
       handler: async () => {
         const commands = createBuiltinCommands();
-        console.log(chalk11.bold("\nAvailable Commands:\n"));
+        console.log(chalk12.bold("\nAvailable Commands:\n"));
         for (const cmd of commands) {
-          const aliases = cmd.aliases ? chalk11.dim(` (${cmd.aliases.join(", ")})`) : "";
-          console.log(`  ${chalk11.cyan(cmd.name)}${aliases} - ${cmd.description}`);
+          const aliases = cmd.aliases ? chalk12.dim(` (${cmd.aliases.join(", ")})`) : "";
+          console.log(`  ${chalk12.cyan(cmd.name)}${aliases} - ${cmd.description}`);
         }
         console.log("");
-        console.log(chalk11.dim("  Prefixes: ! (bash), @ (file reference)"));
-        console.log(chalk11.dim("  Use \\ at end of line for multiline input"));
+        console.log(chalk12.dim("  Prefixes: ! (bash), @ (file reference)"));
+        console.log(chalk12.dim("  Use \\ at end of line for multiline input"));
         console.log("");
         return true;
       }
@@ -2555,7 +3294,7 @@ function createBuiltinCommands() {
         if (ctx.exitFn) {
           await ctx.exitFn();
         }
-        console.log(chalk11.dim("\nGoodbye!\n"));
+        console.log(chalk12.dim("\nGoodbye!\n"));
         process.exit(0);
       }
     },
@@ -2566,7 +3305,7 @@ function createBuiltinCommands() {
       handler: async (_args, ctx) => {
         ctx.conversation.clear();
         ctx.reloadSystemPrompt();
-        console.log(chalk11.green("\u2713 Conversation cleared"));
+        console.log(chalk12.green("\u2713 Conversation cleared"));
         return true;
       }
     },
@@ -2576,7 +3315,7 @@ function createBuiltinCommands() {
       handler: async (args, ctx) => {
         if (!args) {
           const info = statusLine.getInfo();
-          console.log(chalk11.cyan(`Current model: ${info.model} (${info.provider})`));
+          console.log(chalk12.cyan(`Current model: ${info.model} (${info.provider})`));
           return true;
         }
         if (args.includes(":")) {
@@ -2585,7 +3324,7 @@ function createBuiltinCommands() {
         } else {
           ctx.setProvider("", args);
         }
-        console.log(chalk11.green(`\u2713 Model switched to: ${args}`));
+        console.log(chalk12.green(`\u2713 Model switched to: ${args}`));
         return true;
       }
     },
@@ -2593,10 +3332,10 @@ function createBuiltinCommands() {
       name: "/compact",
       description: "Compress conversation history (optional: focus hint)",
       handler: async (args, ctx) => {
-        console.log(chalk11.dim("Compressing conversation..."));
+        console.log(chalk12.dim("Compressing conversation..."));
         await ctx.compressor.compress(ctx.conversation, ctx.provider, args || void 0);
         ctx.reloadSystemPrompt();
-        console.log(chalk11.green("\u2713 Conversation compressed"));
+        console.log(chalk12.green("\u2713 Conversation compressed"));
         return true;
       }
     },
@@ -2604,9 +3343,31 @@ function createBuiltinCommands() {
       name: "/cost",
       description: "Show token usage and cost",
       handler: async () => {
-        console.log(chalk11.cyan(`
-${tokenTracker.format()}
-`));
+        const session = tokenTracker.getSessionStats();
+        const total = tokenTracker.getStats();
+        console.log(chalk12.bold("\nToken Usage & Cost:\n"));
+        console.log(chalk12.cyan("  [Current Session]"));
+        console.log(`    Requests:    ${session.requests}`);
+        console.log(`    Input:       ${formatTokens(session.inputTokens)}`);
+        console.log(`    Output:      ${formatTokens(session.outputTokens)}`);
+        console.log(`    Total:       ${formatTokens(session.totalTokens)}`);
+        console.log(`    Cost:        $${session.cost.toFixed(4)}`);
+        if (session.requests > 0) {
+          console.log(`    Avg/Request: $${session.avgCostPerRequest.toFixed(4)}`);
+        }
+        if (session.lastRequestCost) {
+          console.log(chalk12.dim(`    Last Request: $${session.lastRequestCost.cost.toFixed(4)} (${formatTokens(session.lastRequestCost.inputTokens)} in / ${formatTokens(session.lastRequestCost.outputTokens)} out)`));
+        }
+        if (total.requests !== session.requests) {
+          console.log("");
+          console.log(chalk12.cyan("  [Total Accumulated]"));
+          console.log(`    Requests:    ${total.requests}`);
+          console.log(`    Input:       ${formatTokens(total.inputTokens)}`);
+          console.log(`    Output:      ${formatTokens(total.outputTokens)}`);
+          console.log(`    Total:       ${formatTokens(total.totalTokens)}`);
+          console.log(`    Cost:        $${total.cost.toFixed(4)}`);
+        }
+        console.log("");
         return true;
       }
     },
@@ -2615,9 +3376,9 @@ ${tokenTracker.format()}
       description: "Show current configuration",
       handler: async () => {
         const config = configManager.get();
-        console.log(chalk11.bold("\nConfiguration:\n"));
-        console.log(chalk11.dim(JSON.stringify(config, null, 2)));
-        console.log(chalk11.dim(`
+        console.log(chalk12.bold("\nConfiguration:\n"));
+        console.log(chalk12.dim(JSON.stringify(config, null, 2)));
+        console.log(chalk12.dim(`
 Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
         console.log("");
         return true;
@@ -2628,10 +3389,10 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
       description: "Show permission rules",
       handler: async () => {
         const config = configManager.get();
-        console.log(chalk11.bold("\nPermission Rules:\n"));
-        console.log(chalk11.green("  Allow: ") + config.permissions.allow.join(", "));
-        console.log(chalk11.red("  Deny:  ") + (config.permissions.deny.join(", ") || "(none)"));
-        console.log(chalk11.yellow("  Ask:   ") + config.permissions.ask.join(", "));
+        console.log(chalk12.bold("\nPermission Rules:\n"));
+        console.log(chalk12.green("  Allow: ") + config.permissions.allow.join(", "));
+        console.log(chalk12.red("  Deny:  ") + (config.permissions.deny.join(", ") || "(none)"));
+        console.log(chalk12.yellow("  Ask:   ") + config.permissions.ask.join(", "));
         console.log("");
         return true;
       }
@@ -2642,7 +3403,7 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
       handler: async (args, ctx) => {
         const name = args || void 0;
         const id = sessionManager.save(ctx.conversation, name, statusLine.getInfo().model);
-        console.log(chalk11.green(`\u2713 Session saved: ${id}`));
+        console.log(chalk12.green(`\u2713 Session saved: ${id}`));
         return true;
       }
     },
@@ -2653,12 +3414,12 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
       handler: async (args, ctx) => {
         const id = args || sessionManager.getLatest()?.id;
         if (!id) {
-          console.log(chalk11.yellow("No sessions found. Use /save to save a session first."));
+          console.log(chalk12.yellow("No sessions found. Use /save to save a session first."));
           return true;
         }
         const session = sessionManager.load(id);
         if (!session) {
-          console.log(chalk11.red(`Session not found: ${id}`));
+          console.log(chalk12.red(`Session not found: ${id}`));
           return true;
         }
         const data = session.conversation.serialize();
@@ -2668,7 +3429,7 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
           if (msg.role === "user") ctx.conversation.addUserMessage(msg.content);
           else if (msg.role === "assistant") ctx.conversation.addAssistantMessage(msg.content);
         }
-        console.log(chalk11.green(`\u2713 Resumed session: ${id} (${session.meta.messageCount} messages)`));
+        console.log(chalk12.green(`\u2713 Resumed session: ${id} (${session.meta.messageCount} messages)`));
         return true;
       }
     },
@@ -2678,7 +3439,7 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
       handler: async (args, ctx) => {
         const name = args || `fork-${Date.now()}`;
         const id = sessionManager.save(ctx.conversation, name, statusLine.getInfo().model);
-        console.log(chalk11.green(`\u2713 Conversation forked: ${id}`));
+        console.log(chalk12.green(`\u2713 Conversation forked: ${id}`));
         return true;
       }
     },
@@ -2690,7 +3451,7 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
         const newMode = current === "plan" ? "execute" : "plan";
         setMode(newMode);
         statusLine.update({ mode: newMode });
-        console.log(chalk11.cyan(`Mode: ${newMode === "plan" ? "PLAN (read-only)" : "EXECUTE"}`));
+        console.log(chalk12.cyan(`Mode: ${newMode === "plan" ? "PLAN (read-only)" : "EXECUTE"}`));
         return true;
       }
     },
@@ -2700,16 +3461,16 @@ Config files: ${configManager.getConfigPaths().join(", ") || "(none)"}`));
       handler: async () => {
         const index = memoryManager.loadIndex();
         const topics = memoryManager.listTopics();
-        console.log(chalk11.bold("\nAuto Memory:\n"));
-        console.log(chalk11.dim(`Directory: ${memoryManager.getMemoryDir()}`));
+        console.log(chalk12.bold("\nAuto Memory:\n"));
+        console.log(chalk12.dim(`Directory: ${memoryManager.getMemoryDir()}`));
         if (index) {
-          console.log(chalk11.dim("\nMEMORY.md:"));
+          console.log(chalk12.dim("\nMEMORY.md:"));
           console.log(index);
         } else {
-          console.log(chalk11.dim("\nNo memory saved yet."));
+          console.log(chalk12.dim("\nNo memory saved yet."));
         }
         if (topics.length > 0) {
-          console.log(chalk11.dim(`
+          console.log(chalk12.dim(`
 Topics: ${topics.join(", ")}`));
         }
         console.log("");
@@ -2720,12 +3481,12 @@ Topics: ${topics.join(", ")}`));
       name: "/init",
       description: "Initialize CODI.md in the current project",
       handler: async () => {
-        const codiPath = path10.join(process.cwd(), "CODI.md");
-        if (fs8.existsSync(codiPath)) {
-          console.log(chalk11.yellow("CODI.md already exists"));
+        const codiPath = path13.join(process.cwd(), "CODI.md");
+        if (fs12.existsSync(codiPath)) {
+          console.log(chalk12.yellow("CODI.md already exists"));
           return true;
         }
-        const content = `# Project: ${path10.basename(process.cwd())}
+        const content = `# Project: ${path13.basename(process.cwd())}
 
 ## Overview
 <!-- Describe your project here -->
@@ -2739,8 +3500,8 @@ Topics: ${topics.join(", ")}`));
 ## Conventions
 <!-- Code style, naming conventions, etc. -->
 `;
-        fs8.writeFileSync(codiPath, content, "utf-8");
-        console.log(chalk11.green("\u2713 Created CODI.md"));
+        fs12.writeFileSync(codiPath, content, "utf-8");
+        console.log(chalk12.green("\u2713 Created CODI.md"));
         return true;
       }
     },
@@ -2768,8 +3529,8 @@ ${content}
 
 `;
         }
-        fs8.writeFileSync(filePath, md, "utf-8");
-        console.log(chalk11.green(`\u2713 Exported to ${filePath}`));
+        fs12.writeFileSync(filePath, md, "utf-8");
+        console.log(chalk12.green(`\u2713 Exported to ${filePath}`));
         return true;
       }
     },
@@ -2780,12 +3541,12 @@ ${content}
         const { taskManager: taskManager2 } = await Promise.resolve().then(() => (init_task_tools(), task_tools_exports));
         const tasks = taskManager2.list();
         if (tasks.length === 0) {
-          console.log(chalk11.dim("\nNo tasks.\n"));
+          console.log(chalk12.dim("\nNo tasks.\n"));
           return true;
         }
-        console.log(chalk11.bold("\nTasks:\n"));
+        console.log(chalk12.bold("\nTasks:\n"));
         for (const task of tasks) {
-          const statusIcon = task.status === "completed" ? chalk11.green("\u2713") : task.status === "in_progress" ? chalk11.yellow("\u27F3") : chalk11.dim("\u25CB");
+          const statusIcon = task.status === "completed" ? chalk12.green("\u2713") : task.status === "in_progress" ? chalk12.yellow("\u27F3") : chalk12.dim("\u25CB");
           console.log(`  ${statusIcon} #${task.id} ${task.subject} [${task.status}]`);
         }
         console.log("");
@@ -2800,7 +3561,7 @@ ${content}
         const info = statusLine.getInfo();
         const stats = tokenTracker.getStats();
         const mcpServers = mcpManager.listServers();
-        console.log(chalk11.bold("\nCodi Status:\n"));
+        console.log(chalk12.bold("\nCodi Status:\n"));
         console.log(`  Version:  0.1.0`);
         console.log(`  Model:    ${info.model}`);
         console.log(`  Provider: ${config.provider}`);
@@ -2822,7 +3583,7 @@ ${content}
         const max = 2e5;
         const pct = Math.round(estimated / max * 100);
         const bar = "\u2588".repeat(Math.round(pct / 5)) + "\u2591".repeat(20 - Math.round(pct / 5));
-        console.log(chalk11.bold("\nContext Window:\n"));
+        console.log(chalk12.bold("\nContext Window:\n"));
         console.log(`  ${bar} ${pct}%`);
         console.log(`  ~${estimated.toLocaleString()} / ${max.toLocaleString()} tokens`);
         console.log(`  Messages: ${ctx.conversation.getMessageCount()}`);
@@ -2836,12 +3597,12 @@ ${content}
       handler: async (_args, ctx) => {
         const checkpoints = checkpointManager.list();
         if (checkpoints.length === 0) {
-          console.log(chalk11.yellow("No checkpoints available."));
+          console.log(chalk12.yellow("No checkpoints available."));
           return true;
         }
         const result = checkpointManager.rewind();
         if (!result) {
-          console.log(chalk11.yellow("No checkpoint to rewind to."));
+          console.log(chalk12.yellow("No checkpoint to rewind to."));
           return true;
         }
         const data = result.conversation.serialize();
@@ -2851,7 +3612,7 @@ ${content}
           if (msg.role === "user") ctx.conversation.addUserMessage(msg.content);
           else if (msg.role === "assistant") ctx.conversation.addAssistantMessage(msg.content);
         }
-        console.log(chalk11.green(`\u2713 Rewound to checkpoint${result.description ? `: ${result.description}` : ""}`));
+        console.log(chalk12.green(`\u2713 Rewound to checkpoint${result.description ? `: ${result.description}` : ""}`));
         return true;
       }
     },
@@ -2863,13 +3624,13 @@ ${content}
           const { execSync: execSync5 } = await import("child_process");
           const diff = execSync5("git diff", { encoding: "utf-8", cwd: process.cwd() });
           if (!diff.trim()) {
-            console.log(chalk11.dim("\nNo changes.\n"));
+            console.log(chalk12.dim("\nNo changes.\n"));
           } else {
             const { renderDiff: renderDiff2 } = await Promise.resolve().then(() => (init_renderer(), renderer_exports));
             console.log("\n" + renderDiff2("", "", diff) + "\n");
           }
         } catch {
-          console.log(chalk11.yellow("Not a git repository or git not available."));
+          console.log(chalk12.yellow("Not a git repository or git not available."));
         }
         return true;
       }
@@ -2882,21 +3643,64 @@ ${content}
         try {
           const staged = execSync5("git diff --cached", { encoding: "utf-8", cwd: process.cwd() });
           const unstaged = execSync5("git diff", { encoding: "utf-8", cwd: process.cwd() });
-          const diff = staged + unstaged;
-          if (!diff.trim()) {
-            console.log(chalk11.dim("\nNo changes to commit.\n"));
+          if (!staged.trim() && unstaged.trim()) {
+            const untracked = execSync5("git ls-files --others --exclude-standard", {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+            if (untracked) {
+              console.log(chalk12.yellow(`
+\uC8FC\uC758: \uCD94\uC801\uB418\uC9C0 \uC54A\uB294 \uD30C\uC77C\uC774 \uC788\uC2B5\uB2C8\uB2E4 (\uC790\uB3D9 \uC2A4\uD14C\uC774\uC9D5 \uC548 \uB428):`));
+              for (const f of untracked.split("\n").slice(0, 10)) {
+                console.log(chalk12.dim(`  ${f}`));
+              }
+              if (untracked.split("\n").length > 10) {
+                console.log(chalk12.dim(`  ... \uC678 ${untracked.split("\n").length - 10}\uAC1C`));
+              }
+              console.log("");
+            }
+            console.log(chalk12.dim("\uC218\uC815\uB41C \uD30C\uC77C\uC744 \uC790\uB3D9 \uC2A4\uD14C\uC774\uC9D5\uD569\uB2C8\uB2E4..."));
+            execSync5("git add -u", { encoding: "utf-8", cwd: process.cwd() });
+          }
+          const finalDiff = execSync5("git diff --cached", { encoding: "utf-8", cwd: process.cwd() });
+          if (!finalDiff.trim()) {
+            console.log(chalk12.dim("\nNo changes to commit.\n"));
             return true;
           }
+          let conventionHint = "";
+          try {
+            const recentLog = execSync5("git log --oneline -10", {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+            if (recentLog) {
+              const conventionalPattern = /^[a-f0-9]+\s+(feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(\(.+\))?[!]?:/;
+              const lines = recentLog.split("\n");
+              const conventionalCount = lines.filter((l) => conventionalPattern.test(l)).length;
+              if (conventionalCount >= 3) {
+                conventionHint = `
+
+\uC774 \uD504\uB85C\uC81D\uD2B8\uB294 Conventional Commits \uD615\uC2DD\uC744 \uC0AC\uC6A9\uD569\uB2C8\uB2E4 (\uC608: feat:, fix:, chore: \uB4F1). \uAC19\uC740 \uD615\uC2DD\uC744 \uB530\uB77C\uC8FC\uC138\uC694.`;
+              }
+              conventionHint += `
+
+\uCD5C\uADFC \uCEE4\uBC0B \uCC38\uACE0:
+\`\`\`
+${recentLog}
+\`\`\``;
+            }
+          } catch {
+          }
           ctx.conversation.addUserMessage(
-            `\uB2E4\uC74C git diff\uB97C \uBD84\uC11D\uD574\uC11C \uC801\uC808\uD55C \uCEE4\uBC0B \uBA54\uC2DC\uC9C0\uB97C \uC0DD\uC131\uD558\uACE0, git \uB3C4\uAD6C\uB85C \uBCC0\uACBD\uB41C \uD30C\uC77C\uC744 add\uD558\uACE0 \uCEE4\uBC0B\uD574\uC918.
+            `\uB2E4\uC74C git diff\uB97C \uBD84\uC11D\uD574\uC11C \uC801\uC808\uD55C \uCEE4\uBC0B \uBA54\uC2DC\uC9C0\uB97C \uC0DD\uC131\uD558\uACE0, git \uB3C4\uAD6C\uB85C \uCEE4\uBC0B\uD574\uC918. \uC774\uBBF8 \uC2A4\uD14C\uC774\uC9D5 \uC644\uB8CC\uB418\uC5C8\uC73C\uBBC0\uB85C add \uC5C6\uC774 commit\uB9CC \uD558\uBA74 \uB429\uB2C8\uB2E4.${conventionHint}
 
 \`\`\`diff
-${diff}
+${finalDiff}
 \`\`\``
           );
           return false;
         } catch {
-          console.log(chalk11.yellow("Not a git repository or git not available."));
+          console.log(chalk12.yellow("Not a git repository or git not available."));
           return true;
         }
       }
@@ -2911,7 +3715,7 @@ ${diff}
           const unstaged = execSync5("git diff", { encoding: "utf-8", cwd: process.cwd() });
           const diff = staged + unstaged;
           if (!diff.trim()) {
-            console.log(chalk11.dim("\nNo changes to review.\n"));
+            console.log(chalk12.dim("\nNo changes to review.\n"));
             return true;
           }
           ctx.conversation.addUserMessage(
@@ -2923,7 +3727,7 @@ ${diff}
           );
           return false;
         } catch {
-          console.log(chalk11.yellow("Not a git repository or git not available."));
+          console.log(chalk12.yellow("Not a git repository or git not available."));
           return true;
         }
       }
@@ -2933,27 +3737,27 @@ ${diff}
       description: "Search past conversation sessions",
       handler: async (args) => {
         if (!args) {
-          console.log(chalk11.yellow("Usage: /search <keyword>"));
+          console.log(chalk12.yellow("Usage: /search <keyword>"));
           return true;
         }
-        const home = process.env["HOME"] || process.env["USERPROFILE"] || os9.homedir();
-        const sessionsDir = path10.join(home, ".codi", "sessions");
-        if (!fs8.existsSync(sessionsDir)) {
-          console.log(chalk11.dim("\nNo sessions found.\n"));
+        const home = process.env["HOME"] || process.env["USERPROFILE"] || os13.homedir();
+        const sessionsDir = path13.join(home, ".codi", "sessions");
+        if (!fs12.existsSync(sessionsDir)) {
+          console.log(chalk12.dim("\nNo sessions found.\n"));
           return true;
         }
-        const files = fs8.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        const files = fs12.readdirSync(sessionsDir).filter((f) => f.endsWith(".jsonl"));
         const results = [];
         const keyword = args.toLowerCase();
         for (const file of files) {
           if (results.length >= 10) break;
-          const filePath = path10.join(sessionsDir, file);
-          const lines = fs8.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+          const filePath = path13.join(sessionsDir, file);
+          const lines = fs12.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
           for (const line of lines) {
             if (results.length >= 10) break;
             if (line.toLowerCase().includes(keyword)) {
               const sessionId = file.replace(".jsonl", "");
-              const stat = fs8.statSync(filePath);
+              const stat = fs12.statSync(filePath);
               const date = stat.mtime.toISOString().split("T")[0];
               const preview = line.length > 100 ? line.slice(0, 100) + "..." : line;
               results.push({ sessionId, date, preview });
@@ -2962,16 +3766,16 @@ ${diff}
           }
         }
         if (results.length === 0) {
-          console.log(chalk11.dim(`
+          console.log(chalk12.dim(`
 No results for "${args}".
 `));
         } else {
-          console.log(chalk11.bold(`
+          console.log(chalk12.bold(`
 Search results for "${args}":
 `));
           for (const r of results) {
-            console.log(`  ${chalk11.cyan(r.sessionId)} ${chalk11.dim(r.date)}`);
-            console.log(`    ${chalk11.dim(r.preview)}`);
+            console.log(`  ${chalk12.cyan(r.sessionId)} ${chalk12.dim(r.date)}`);
+            console.log(`    ${chalk12.dim(r.preview)}`);
           }
           console.log("");
         }
@@ -2983,24 +3787,24 @@ Search results for "${args}":
       description: "Run a command and auto-fix errors (e.g., /fix npm run build)",
       handler: async (args, ctx) => {
         if (!args) {
-          console.log(chalk11.yellow("Usage: /fix <command>"));
+          console.log(chalk12.yellow("Usage: /fix <command>"));
           return true;
         }
         const { execSync: execSync5 } = await import("child_process");
         try {
-          const isWin = os9.platform() === "win32";
+          const isWin = os13.platform() === "win32";
           const shell = isWin ? "powershell.exe" : void 0;
           const fixCmd = isWin ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${args}` : args;
           const output3 = execSync5(fixCmd, { encoding: "utf-8", cwd: process.cwd(), stdio: "pipe", shell });
-          console.log(chalk11.green(`
+          console.log(chalk12.green(`
 \u2713 Command succeeded. No errors to fix.
 `));
-          if (output3.trim()) console.log(chalk11.dim(output3));
+          if (output3.trim()) console.log(chalk12.dim(output3));
           return true;
         } catch (err) {
           const error = err;
           const errorOutput = (error.stderr || "") + (error.stdout || "");
-          console.log(chalk11.red(`
+          console.log(chalk12.red(`
 Command failed: ${args}
 `));
           ctx.conversation.addUserMessage(
@@ -3016,21 +3820,236 @@ ${errorOutput}
         }
       }
     },
+    {
+      name: "/undo",
+      description: "Undo the most recent file edit (rollback from backup)",
+      handler: async (args) => {
+        const { getBackupHistory: getBackupHistory2, undoLast: undoLast2 } = await Promise.resolve().then(() => (init_file_backup(), file_backup_exports));
+        if (args === "list") {
+          const history = getBackupHistory2();
+          if (history.length === 0) {
+            console.log(chalk12.dim("\n\uB418\uB3CC\uB9B4 \uD30C\uC77C \uBCC0\uACBD \uC774\uB825\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+            return true;
+          }
+          console.log(chalk12.bold(`
+\uD30C\uC77C \uBCC0\uACBD \uC774\uB825 (\uCD5C\uADFC ${Math.min(history.length, 20)}\uAC1C):
+`));
+          const recent = history.slice(-20).reverse();
+          for (let i = 0; i < recent.length; i++) {
+            const entry2 = recent[i];
+            const time = new Date(entry2.timestamp).toLocaleTimeString();
+            const tag = entry2.wasNew ? chalk12.yellow("[\uC0C8 \uD30C\uC77C]") : chalk12.cyan("[\uC218\uC815]");
+            console.log(`  ${i + 1}. ${tag} ${entry2.originalPath} ${chalk12.dim(time)}`);
+          }
+          console.log("");
+          return true;
+        }
+        const entry = undoLast2();
+        if (!entry) {
+          console.log(chalk12.yellow("\n\uB418\uB3CC\uB9B4 \uBCC0\uACBD \uC0AC\uD56D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n"));
+          return true;
+        }
+        const action = entry.wasNew ? "\uC0AD\uC81C\uB428 (\uC0C8\uB85C \uC0DD\uC131\uB41C \uD30C\uC77C)" : "\uC774\uC804 \uC0C1\uD0DC\uB85C \uBCF5\uC6D0\uB428";
+        console.log(chalk12.green(`
+\u2713 \uB418\uB3CC\uB9AC\uAE30 \uC644\uB8CC: ${entry.originalPath}`));
+        console.log(chalk12.dim(`  ${action}`));
+        console.log("");
+        return true;
+      }
+    },
+    {
+      name: "/branch",
+      description: "Create and switch to a new branch, or show current branch",
+      handler: async (args) => {
+        const { execSync: execSync5 } = await import("child_process");
+        try {
+          if (!args) {
+            const current = execSync5("git branch --show-current", {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+            const branches = execSync5("git branch -a", {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+            console.log(chalk12.bold(`
+Current branch: ${chalk12.green(current || "(detached HEAD)")}
+`));
+            console.log(branches);
+            console.log("");
+          } else {
+            const name = args.trim();
+            execSync5(`git checkout -b ${name}`, {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            });
+            console.log(chalk12.green(`
+\u2713 Created and switched to branch: ${name}
+`));
+          }
+        } catch (err) {
+          const error = err;
+          const msg = error.stderr || error.message || "Unknown error";
+          console.log(chalk12.red(`
+Branch operation failed: ${msg.trim()}
+`));
+        }
+        return true;
+      }
+    },
+    {
+      name: "/stash",
+      description: "Git stash management (pop, list, drop, or save)",
+      handler: async (args) => {
+        const { execSync: execSync5 } = await import("child_process");
+        const sub = args.trim().split(/\s+/);
+        const action = sub[0] || "push";
+        const allowed = ["push", "pop", "list", "drop", "show", "apply", "clear"];
+        if (!allowed.includes(action)) {
+          console.log(chalk12.yellow(`Usage: /stash [${allowed.join("|")}]`));
+          return true;
+        }
+        try {
+          if (action === "clear") {
+            console.log(chalk12.yellow("\u26A0 This will drop all stashes permanently."));
+          }
+          const cmd = `git stash ${args.trim() || "push"}`;
+          const output3 = execSync5(cmd, {
+            encoding: "utf-8",
+            cwd: process.cwd()
+          });
+          console.log(output3.trim() ? `
+${output3.trim()}
+` : chalk12.dim("\n(no output)\n"));
+        } catch (err) {
+          const error = err;
+          const msg = error.stderr || error.stdout || error.message || "Unknown error";
+          console.log(chalk12.red(`
+Stash operation failed: ${msg.trim()}
+`));
+        }
+        return true;
+      }
+    },
+    {
+      name: "/pr",
+      description: "Generate a pull request description from current branch diff",
+      handler: async (_args, ctx) => {
+        const { execSync: execSync5 } = await import("child_process");
+        try {
+          const currentBranch = execSync5("git branch --show-current", {
+            encoding: "utf-8",
+            cwd: process.cwd()
+          }).trim();
+          if (!currentBranch) {
+            console.log(chalk12.yellow("Not on a branch (detached HEAD)."));
+            return true;
+          }
+          let baseBranch = "main";
+          try {
+            execSync5("git rev-parse --verify main", {
+              encoding: "utf-8",
+              cwd: process.cwd(),
+              stdio: "pipe"
+            });
+          } catch {
+            try {
+              execSync5("git rev-parse --verify master", {
+                encoding: "utf-8",
+                cwd: process.cwd(),
+                stdio: "pipe"
+              });
+              baseBranch = "master";
+            } catch {
+              console.log(chalk12.yellow("Cannot find base branch (main or master)."));
+              return true;
+            }
+          }
+          if (currentBranch === baseBranch) {
+            console.log(chalk12.yellow(`Already on ${baseBranch}. Switch to a feature branch first.`));
+            return true;
+          }
+          let commitLog = "";
+          try {
+            commitLog = execSync5(`git log ${baseBranch}..HEAD --oneline`, {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+          } catch {
+          }
+          if (!commitLog) {
+            console.log(chalk12.yellow(`No commits ahead of ${baseBranch}.`));
+            return true;
+          }
+          let diffStat = "";
+          try {
+            diffStat = execSync5(`git diff ${baseBranch}...HEAD --stat`, {
+              encoding: "utf-8",
+              cwd: process.cwd()
+            }).trim();
+          } catch {
+          }
+          let diff = "";
+          try {
+            diff = execSync5(`git diff ${baseBranch}...HEAD`, {
+              encoding: "utf-8",
+              cwd: process.cwd(),
+              maxBuffer: 10 * 1024 * 1024
+            });
+            if (diff.length > 5e4) {
+              diff = diff.slice(0, 5e4) + "\n\n... (diff truncated, too large)";
+            }
+          } catch {
+          }
+          console.log(chalk12.dim(`
+Analyzing ${commitLog.split("\n").length} commit(s) from ${currentBranch}...
+`));
+          ctx.conversation.addUserMessage(
+            `\uD604\uC7AC \uBE0C\uB79C\uCE58 \`${currentBranch}\`\uC5D0\uC11C \`${baseBranch}\`\uB85C \uBCF4\uB0BC Pull Request \uC124\uBA85\uC744 \uC0DD\uC131\uD574\uC918.
+
+\uB2E4\uC74C \uD615\uC2DD\uC758 \uB9C8\uD06C\uB2E4\uC6B4\uC73C\uB85C \uCD9C\uB825\uD574\uC918:
+- **Title**: PR \uC81C\uBAA9 (70\uC790 \uC774\uB0B4, \uC601\uBB38)
+- **## Summary**: \uBCC0\uACBD \uC0AC\uD56D \uC694\uC57D (1-3 bullet points)
+- **## Changes**: \uC8FC\uC694 \uBCC0\uACBD \uD30C\uC77C \uBC0F \uB0B4\uC6A9
+- **## Test Plan**: \uD14C\uC2A4\uD2B8 \uACC4\uD68D \uCCB4\uD06C\uB9AC\uC2A4\uD2B8
+
+### Commits:
+\`\`\`
+${commitLog}
+\`\`\`
+
+### Diff stat:
+\`\`\`
+${diffStat}
+\`\`\`
+
+### Full diff:
+\`\`\`diff
+${diff}
+\`\`\``
+          );
+          return false;
+        } catch {
+          console.log(chalk12.yellow("Not a git repository or git not available."));
+          return true;
+        }
+      }
+    },
     {
       name: "/mcp",
       description: "Show MCP server status",
       handler: async () => {
         const servers = mcpManager.listServers();
         if (servers.length === 0) {
-          console.log(chalk11.dim("\nNo MCP servers connected.\n"));
-          console.log(chalk11.dim("Add servers in .codi/mcp.json or ~/.codi/mcp.json"));
+          console.log(chalk12.dim("\nNo MCP servers connected.\n"));
+          console.log(chalk12.dim("Add servers in .codi/mcp.json or ~/.codi/mcp.json"));
           return true;
         }
-        console.log(chalk11.bold("\nMCP Servers:\n"));
+        console.log(chalk12.bold("\nMCP Servers:\n"));
         for (const s of servers) {
-          console.log(`  ${chalk11.green("\u25CF")} ${s.name}`);
+          console.log(`  ${chalk12.green("\u25CF")} ${s.name}`);
           for (const t of s.tools) {
-            console.log(chalk11.dim(`    - ${t}`));
+            console.log(chalk12.dim(`    - ${t}`));
           }
         }
         console.log("");
@@ -3039,24 +4058,29 @@ ${errorOutput}
     }
   ];
 }
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
 function loadCustomCommands() {
   const commands = [];
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || os9.homedir();
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || os13.homedir();
   const dirs = [
-    path10.join(home, ".codi", "commands"),
-    path10.join(process.cwd(), ".codi", "commands")
+    path13.join(home, ".codi", "commands"),
+    path13.join(process.cwd(), ".codi", "commands")
   ];
   for (const dir of dirs) {
-    if (!fs8.existsSync(dir)) continue;
-    const files = fs8.readdirSync(dir).filter((f) => f.endsWith(".md"));
+    if (!fs12.existsSync(dir)) continue;
+    const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const name = "/" + file.replace(".md", "");
-      const filePath = path10.join(dir, file);
+      const filePath = path13.join(dir, file);
       commands.push({
         name,
-        description: `Custom command from ${path10.relative(process.cwd(), filePath)}`,
+        description: `Custom command from ${path13.relative(process.cwd(), filePath)}`,
         handler: async (_args, ctx) => {
-          let content = fs8.readFileSync(filePath, "utf-8");
+          let content = fs12.readFileSync(filePath, "utf-8");
           content = content.replace(/\{\{cwd\}\}/g, process.cwd()).replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]).replace(/\{\{file_path\}\}/g, _args || "");
           await ctx.conversation.addUserMessage(content);
           return false;
@@ -3070,8 +4094,8 @@ function loadCustomCommands() {
 // src/tools/file-read.ts
 init_esm_shims();
 init_tool();
-import * as fs9 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 var fileReadTool = {
   name: "read_file",
   description: `Read a file from the filesystem. Supports text files with line numbers (cat -n format), PDF files, images (returns base64 for multimodal), and Jupyter notebooks (.ipynb). Use offset/limit for large files.`,
@@ -3091,17 +4115,17 @@ var fileReadTool = {
     const filePath = String(input3["file_path"]);
     const offset = input3["offset"];
     const limit = input3["limit"];
-    const resolved = path11.resolve(filePath);
-    if (!fs9.existsSync(resolved)) {
+    const resolved = path14.resolve(filePath);
+    if (!fs13.existsSync(resolved)) {
       return makeToolError(`File not found: ${resolved}`);
     }
-    const stat = fs9.statSync(resolved);
+    const stat = fs13.statSync(resolved);
     if (stat.isDirectory()) {
       return makeToolError(`Path is a directory, not a file: ${resolved}. Use list_dir instead.`);
     }
-    const ext = path11.extname(resolved).toLowerCase();
+    const ext = path14.extname(resolved).toLowerCase();
     if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"].includes(ext)) {
-      const data = fs9.readFileSync(resolved);
+      const data = fs13.readFileSync(resolved);
       const base64 = data.toString("base64");
       const mimeMap = {
         ".png": "image/png",
@@ -3112,7 +4136,7 @@ var fileReadTool = {
         ".bmp": "image/bmp",
         ".svg": "image/svg+xml"
       };
-      return makeToolResult(`[Image: ${path11.basename(resolved)}]`, {
+      return makeToolResult(`[Image: ${path14.basename(resolved)}]`, {
         filePath: resolved,
         isImage: true,
         imageData: base64,
@@ -3123,7 +4147,7 @@ var fileReadTool = {
       try {
         const pdfModule = await import("pdf-parse");
         const pdfParse = pdfModule.default || pdfModule;
-        const buffer = fs9.readFileSync(resolved);
+        const buffer = fs13.readFileSync(resolved);
         const data = await pdfParse(buffer);
         const pages = input3["pages"];
         let text = data.text;
@@ -3141,7 +4165,7 @@ var fileReadTool = {
     }
     if (ext === ".ipynb") {
       try {
-        const content = fs9.readFileSync(resolved, "utf-8");
+        const content = fs13.readFileSync(resolved, "utf-8");
         const nb = JSON.parse(content);
         const output3 = [];
         for (let i = 0; i < (nb.cells || []).length; i++) {
@@ -3169,7 +4193,7 @@ var fileReadTool = {
       }
     }
     try {
-      const raw = fs9.readFileSync(resolved, "utf-8");
+      const raw = fs13.readFileSync(resolved, "utf-8");
       const content = raw.replace(/\r\n/g, "\n");
       const lines = content.split("\n");
       const totalLines = lines.length;
@@ -3197,8 +4221,9 @@ var fileReadTool = {
 // src/tools/file-write.ts
 init_esm_shims();
 init_tool();
-import * as fs10 from "fs";
-import * as path12 from "path";
+init_file_backup();
+import * as fs14 from "fs";
+import * as path15 from "path";
 var fileWriteTool = {
   name: "write_file",
   description: `Create a new file or overwrite an existing file. Creates parent directories if needed. For modifying existing files, prefer edit_file instead.`,
@@ -3215,14 +4240,15 @@ var fileWriteTool = {
   async execute(input3) {
     const filePath = String(input3["file_path"]);
     const content = String(input3["content"]);
-    const resolved = path12.resolve(filePath);
+    const resolved = path15.resolve(filePath);
     try {
-      const dir = path12.dirname(resolved);
-      if (!fs10.existsSync(dir)) {
-        fs10.mkdirSync(dir, { recursive: true });
+      const dir = path15.dirname(resolved);
+      if (!fs14.existsSync(dir)) {
+        fs14.mkdirSync(dir, { recursive: true });
       }
-      const existed = fs10.existsSync(resolved);
-      fs10.writeFileSync(resolved, content, "utf-8");
+      const existed = fs14.existsSync(resolved);
+      backupFile(resolved);
+      fs14.writeFileSync(resolved, content, "utf-8");
       const lines = content.split("\n").length;
       const action = existed ? "Overwrote" : "Created";
       return makeToolResult(`${action} ${resolved} (${lines} lines)`, {
@@ -3238,8 +4264,9 @@ var fileWriteTool = {
 // src/tools/file-edit.ts
 init_esm_shims();
 init_tool();
-import * as fs11 from "fs";
-import * as path13 from "path";
+init_file_backup();
+import * as fs15 from "fs";
+import * as path16 from "path";
 var fileEditTool = {
   name: "edit_file",
   description: `Perform exact string replacement in a file. The old_string must be unique in the file unless replace_all is true. Preserves indentation exactly.`,
@@ -3260,12 +4287,12 @@ var fileEditTool = {
     const oldString = String(input3["old_string"]);
     const newString = String(input3["new_string"]);
     const replaceAll = input3["replace_all"] === true;
-    const resolved = path13.resolve(filePath);
-    if (!fs11.existsSync(resolved)) {
+    const resolved = path16.resolve(filePath);
+    if (!fs15.existsSync(resolved)) {
       return makeToolError(`File not found: ${resolved}`);
     }
     try {
-      const raw = fs11.readFileSync(resolved, "utf-8");
+      const raw = fs15.readFileSync(resolved, "utf-8");
       const hasCrlf = raw.includes("\r\n");
       let content = hasCrlf ? raw.replace(/\r\n/g, "\n") : raw;
       if (oldString === newString) {
@@ -3299,8 +4326,9 @@ Did you mean this line?
         const idx = content.indexOf(oldString);
         content = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
       }
+      backupFile(resolved);
       const output3 = hasCrlf ? content.replace(/\n/g, "\r\n") : content;
-      fs11.writeFileSync(resolved, output3, "utf-8");
+      fs15.writeFileSync(resolved, output3, "utf-8");
       const linesChanged = Math.max(
         oldString.split("\n").length,
         newString.split("\n").length
@@ -3318,8 +4346,9 @@ Did you mean this line?
 // src/tools/file-multi-edit.ts
 init_esm_shims();
 init_tool();
-import * as fs12 from "fs";
-import * as path14 from "path";
+init_file_backup();
+import * as fs16 from "fs";
+import * as path17 from "path";
 var fileMultiEditTool = {
   name: "multi_edit",
   description: `Apply multiple edits to a single file atomically. Each edit is an old_string \u2192 new_string replacement. All edits are validated before any are applied.`,
@@ -3347,15 +4376,15 @@ var fileMultiEditTool = {
   async execute(input3) {
     const filePath = String(input3["file_path"]);
     const edits = input3["edits"];
-    const resolved = path14.resolve(filePath);
-    if (!fs12.existsSync(resolved)) {
+    const resolved = path17.resolve(filePath);
+    if (!fs16.existsSync(resolved)) {
       return makeToolError(`File not found: ${resolved}`);
     }
     if (!Array.isArray(edits) || edits.length === 0) {
       return makeToolError("edits must be a non-empty array of {old_string, new_string} objects");
     }
     try {
-      const raw = fs12.readFileSync(resolved, "utf-8");
+      const raw = fs16.readFileSync(resolved, "utf-8");
       const hasCrlf = raw.includes("\r\n");
       let content = hasCrlf ? raw.replace(/\r\n/g, "\n") : raw;
       for (let i = 0; i < edits.length; i++) {
@@ -3379,8 +4408,9 @@ Searching for: ${edit2.old_string.slice(0, 100)}...`
           edit2.new_string.split("\n").length
         );
       }
+      backupFile(resolved);
       const output3 = hasCrlf ? content.replace(/\n/g, "\r\n") : content;
-      fs12.writeFileSync(resolved, output3, "utf-8");
+      fs16.writeFileSync(resolved, output3, "utf-8");
       return makeToolResult(`Applied ${edits.length} edits to ${resolved}`, {
         filePath: resolved,
         linesChanged: totalLinesChanged
@@ -3394,8 +4424,8 @@ Searching for: ${edit2.old_string.slice(0, 100)}...`
 // src/tools/glob.ts
 init_esm_shims();
 init_tool();
-import * as fs13 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import { globby } from "globby";
 var globTool = {
   name: "glob",
@@ -3413,7 +4443,7 @@ var globTool = {
   async execute(input3) {
     const pattern = String(input3["pattern"]);
     const searchPath = input3["path"] ? String(input3["path"]) : process.cwd();
-    const resolved = path15.resolve(searchPath);
+    const resolved = path18.resolve(searchPath);
     try {
       const files = await globby(pattern, {
         cwd: resolved,
@@ -3424,7 +4454,7 @@ var globTool = {
       });
       const withStats = files.map((f) => {
         try {
-          const stat = fs13.statSync(f);
+          const stat = fs17.statSync(f);
           return { path: f, mtime: stat.mtimeMs };
         } catch {
           return { path: f, mtime: 0 };
@@ -3449,8 +4479,8 @@ ${result.join("\n")}`
 init_esm_shims();
 init_tool();
 import { execFile } from "child_process";
-import * as fs14 from "fs";
-import * as path16 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 var grepTool = {
   name: "grep",
   description: `Search file contents using regex patterns. Uses ripgrep (rg) if available, falls back to grep, then to a built-in Node.js search. Supports context lines, file type filters, and multiple output modes.`,
@@ -3480,7 +4510,7 @@ var grepTool = {
   readOnly: true,
   async execute(input3) {
     const pattern = String(input3["pattern"]);
-    const searchPath = path16.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
+    const searchPath = path19.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
     const outputMode = input3["output_mode"] || "files_with_matches";
     const headLimit = input3["head_limit"] || 0;
     const hasRg = await hasCommand("rg");
@@ -3545,19 +4575,19 @@ var grepTool = {
 };
 function hasCommand(cmd) {
   const checkCmd = process.platform === "win32" ? "where" : "which";
-  return new Promise((resolve10) => {
-    execFile(checkCmd, [cmd], (err) => resolve10(!err));
+  return new Promise((resolve11) => {
+    execFile(checkCmd, [cmd], (err) => resolve11(!err));
   });
 }
 function runCommand(cmd, args) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve11, reject) => {
     execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024, timeout: 3e4 }, (err, stdout, stderr) => {
       if (err) {
         err.code = err.code;
         reject(err);
         return;
       }
-      resolve10(stdout);
+      resolve11(stdout);
     });
   });
 }
@@ -3600,7 +4630,7 @@ async function builtinSearch(pattern, searchPath, input3, outputMode, headLimit)
     if (headLimit > 0 && entryCount >= headLimit) break;
     let content;
     try {
-      content = fs14.readFileSync(filePath, "utf-8");
+      content = fs18.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -3653,158 +4683,53 @@ async function builtinSearch(pattern, searchPath, input3, outputMode, headLimit)
   }
   return makeToolResult(results.join("\n"));
 }
-function collectFiles(dirPath, typeFilter, globFilter) {
-  const files = [];
-  const allowedExtensions = typeFilter && TYPE_EXTENSIONS[typeFilter] ? new Set(TYPE_EXTENSIONS[typeFilter]) : null;
-  let globRegex = null;
-  if (globFilter) {
-    const escaped = globFilter.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-    globRegex = new RegExp(`^${escaped}$`);
-  }
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs14.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (IGNORE_DIRS.has(entry.name)) continue;
-      if (entry.name.startsWith(".") && entry.name !== ".") continue;
-      const fullPath = path16.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-      } else if (entry.isFile()) {
-        const ext = path16.extname(entry.name).toLowerCase();
-        if (BINARY_EXTENSIONS.has(ext)) continue;
-        if (allowedExtensions && !allowedExtensions.has(ext)) continue;
-        if (globRegex && !globRegex.test(entry.name)) continue;
-        files.push(fullPath);
-      }
-    }
-  }
-  try {
-    const stat = fs14.statSync(dirPath);
-    if (stat.isFile()) {
-      return [dirPath];
-    }
-  } catch {
-    return [];
-  }
-  walk(dirPath);
-  return files;
-}
-
-// src/tools/bash.ts
-init_esm_shims();
-init_tool();
-import { exec as exec2, spawn } from "child_process";
-import * as os10 from "os";
-function getDefaultShell2() {
-  if (os10.platform() === "win32") {
-    return "powershell.exe";
-  }
-  return process.env["SHELL"] || "/bin/bash";
-}
-var backgroundTasks = /* @__PURE__ */ new Map();
-var taskCounter = 0;
-var bashTool = {
-  name: "bash",
-  description: `Execute a shell command. Supports timeout (max 600s, default 120s) and background execution. The working directory persists between calls. Uses the platform default shell (bash on Unix, PowerShell on Windows).`,
-  inputSchema: {
-    type: "object",
-    properties: {
-      command: { type: "string", description: "The bash command to execute" },
-      description: { type: "string", description: "Brief description of what the command does" },
-      timeout: { type: "number", description: "Timeout in milliseconds (max 600000, default 120000)" },
-      run_in_background: { type: "boolean", description: "Run in background and return a task ID" }
-    },
-    required: ["command"]
-  },
-  dangerous: true,
-  readOnly: false,
-  async execute(input3) {
-    const command = String(input3["command"]);
-    const timeout = Math.min(Number(input3["timeout"]) || 12e4, 6e5);
-    const runInBackground = input3["run_in_background"] === true;
-    if (!command.trim()) {
-      return makeToolError("Command cannot be empty");
+function collectFiles(dirPath, typeFilter, globFilter) {
+  const files = [];
+  const allowedExtensions = typeFilter && TYPE_EXTENSIONS[typeFilter] ? new Set(TYPE_EXTENSIONS[typeFilter]) : null;
+  let globRegex = null;
+  if (globFilter) {
+    const escaped = globFilter.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    globRegex = new RegExp(`^${escaped}$`);
+  }
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
     }
-    if (runInBackground) {
-      return runBackgroundTask(command);
+    for (const entry of entries) {
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const fullPath = path19.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path19.extname(entry.name).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) continue;
+        if (allowedExtensions && !allowedExtensions.has(ext)) continue;
+        if (globRegex && !globRegex.test(entry.name)) continue;
+        files.push(fullPath);
+      }
     }
-    return new Promise((resolve10) => {
-      const finalCommand = os10.platform() === "win32" ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}` : command;
-      exec2(finalCommand, {
-        timeout,
-        maxBuffer: 10 * 1024 * 1024,
-        shell: getDefaultShell2(),
-        cwd: process.cwd(),
-        env: { ...process.env }
-      }, (err, stdout, stderr) => {
-        if (err) {
-          const exitCode = err.code;
-          const output4 = [
-            stdout ? `stdout:
-${stdout}` : "",
-            stderr ? `stderr:
-${stderr}` : "",
-            `Exit code: ${exitCode}`
-          ].filter(Boolean).join("\n\n");
-          if (err.killed) {
-            resolve10(makeToolError(`Command timed out after ${timeout / 1e3}s
-${output4}`));
-          } else {
-            resolve10(makeToolResult(output4 || `Command failed with exit code ${exitCode}`));
-          }
-          return;
-        }
-        const output3 = [
-          stdout ? stdout : "",
-          stderr ? `stderr:
-${stderr}` : ""
-        ].filter(Boolean).join("\n");
-        resolve10(makeToolResult(output3 || "(no output)"));
-      });
-    });
   }
-};
-function runBackgroundTask(command) {
-  const taskId = `bg_${++taskCounter}`;
-  const bgCommand = os10.platform() === "win32" ? `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; ${command}` : command;
-  const proc = spawn(bgCommand, {
-    shell: getDefaultShell2(),
-    cwd: process.cwd(),
-    env: { ...process.env },
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: false
-  });
-  const task = { process: proc, output: "", status: "running", exitCode: void 0 };
-  backgroundTasks.set(taskId, task);
-  proc.stdout?.on("data", (data) => {
-    task.output += data.toString();
-  });
-  proc.stderr?.on("data", (data) => {
-    task.output += data.toString();
-  });
-  proc.on("close", (code) => {
-    task.status = code === 0 ? "done" : "error";
-    task.exitCode = code ?? 1;
-  });
-  proc.on("error", (err) => {
-    task.status = "error";
-    task.output += `
-Process error: ${err.message}`;
-  });
-  return makeToolResult(`Background task started with ID: ${taskId}
-Use task_output tool to check results.`);
+  try {
+    const stat = fs18.statSync(dirPath);
+    if (stat.isFile()) {
+      return [dirPath];
+    }
+  } catch {
+    return [];
+  }
+  walk(dirPath);
+  return files;
 }
 
 // src/tools/list-dir.ts
 init_esm_shims();
 init_tool();
-import * as fs15 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path20 from "path";
 var listDirTool = {
   name: "list_dir",
   description: `List directory contents with file/folder distinction and basic metadata.`,
@@ -3818,16 +4743,16 @@ var listDirTool = {
   dangerous: false,
   readOnly: true,
   async execute(input3) {
-    const dirPath = path17.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
-    if (!fs15.existsSync(dirPath)) {
+    const dirPath = path20.resolve(input3["path"] ? String(input3["path"]) : process.cwd());
+    if (!fs19.existsSync(dirPath)) {
       return makeToolError(`Directory not found: ${dirPath}`);
     }
-    const stat = fs15.statSync(dirPath);
+    const stat = fs19.statSync(dirPath);
     if (!stat.isDirectory()) {
       return makeToolError(`Not a directory: ${dirPath}`);
     }
     try {
-      const entries = fs15.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs19.readdirSync(dirPath, { withFileTypes: true });
       const IGNORE = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "__pycache__", ".next", "dist", "build"]);
       const lines = [];
       const dirs = [];
@@ -3838,7 +4763,7 @@ var listDirTool = {
           dirs.push(`${entry.name}/`);
         } else if (entry.isSymbolicLink()) {
           try {
-            const target = fs15.readlinkSync(path17.join(dirPath, entry.name));
+            const target = fs19.readlinkSync(path20.join(dirPath, entry.name));
             files.push(`${entry.name} -> ${target}`);
           } catch {
             files.push(`${entry.name} -> (broken link)`);
@@ -3865,9 +4790,95 @@ ${lines.join("\n")}`);
 init_esm_shims();
 init_tool();
 import { execSync as execSync4 } from "child_process";
+function detectConflictFiles(cwd) {
+  try {
+    const output3 = execSync4("git diff --name-only --diff-filter=U", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 1e4
+    });
+    return output3.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function parseConflictMarkers(fileContent, filePath) {
+  const sections = [];
+  const lines = fileContent.split("\n");
+  let inConflict = false;
+  let startLine = 0;
+  let oursLines = [];
+  let theirsLines = [];
+  let inTheirs = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("<<<<<<<")) {
+      inConflict = true;
+      inTheirs = false;
+      startLine = i + 1;
+      oursLines = [];
+      theirsLines = [];
+    } else if (line.startsWith("=======") && inConflict) {
+      inTheirs = true;
+    } else if (line.startsWith(">>>>>>>") && inConflict) {
+      sections.push({
+        file: filePath,
+        startLine,
+        ours: oursLines.join("\n"),
+        theirs: theirsLines.join("\n")
+      });
+      inConflict = false;
+      inTheirs = false;
+    } else if (inConflict) {
+      if (inTheirs) {
+        theirsLines.push(line);
+      } else {
+        oursLines.push(line);
+      }
+    }
+  }
+  return sections;
+}
+function formatConflictReport(cwd) {
+  const conflictFiles = detectConflictFiles(cwd);
+  if (conflictFiles.length === 0) return null;
+  const fs22 = __require("fs");
+  const path23 = __require("path");
+  const lines = [
+    `\u26A0 Merge conflicts detected in ${conflictFiles.length} file(s):`,
+    ""
+  ];
+  for (const file of conflictFiles) {
+    const fullPath = path23.join(cwd, file);
+    let content;
+    try {
+      content = fs22.readFileSync(fullPath, "utf-8");
+    } catch {
+      lines.push(`  - ${file} (cannot read)`);
+      continue;
+    }
+    const sections = parseConflictMarkers(content, file);
+    lines.push(`  - ${file} (${sections.length} conflict(s))`);
+    for (let i = 0; i < sections.length; i++) {
+      const s = sections[i];
+      lines.push(`    [Conflict ${i + 1} at line ${s.startLine}]`);
+      lines.push(`      OURS:`);
+      for (const l of s.ours.split("\n").slice(0, 5)) {
+        lines.push(`        ${l}`);
+      }
+      if (s.ours.split("\n").length > 5) lines.push(`        ... (${s.ours.split("\n").length} lines)`);
+      lines.push(`      THEIRS:`);
+      for (const l of s.theirs.split("\n").slice(0, 5)) {
+        lines.push(`        ${l}`);
+      }
+      if (s.theirs.split("\n").length > 5) lines.push(`        ... (${s.theirs.split("\n").length} lines)`);
+    }
+  }
+  return lines.join("\n");
+}
 var gitTool = {
   name: "git",
-  description: `Execute git commands with safety checks. Blocks dangerous operations like force push, hard reset, and amend. Use for status, diff, log, commit, branch operations.`,
+  description: `Execute git commands with safety checks. Blocks dangerous operations like force push, hard reset, and amend. Use for status, diff, log, commit, branch operations. When merge/pull results in conflicts, automatically detects and reports them.`,
   inputSchema: {
     type: "object",
     properties: {
@@ -3896,7 +4907,9 @@ var gitTool = {
       }
     }
     const readOnlyPrefixes = ["status", "diff", "log", "show", "branch", "tag", "remote", "stash list", "ls-files"];
-    const isReadOnly = readOnlyPrefixes.some((p) => command.startsWith(p));
+    const _isReadOnly = readOnlyPrefixes.some((p) => command.startsWith(p));
+    const mergeCommands = /^(merge|pull|rebase|cherry-pick)\b/;
+    const isMergeCommand = mergeCommands.test(command);
     try {
       const result = execSync4(`git ${command}`, {
         encoding: "utf-8",
@@ -3904,9 +4917,26 @@ var gitTool = {
         timeout: 3e4,
         cwd: process.cwd()
       });
+      if (isMergeCommand) {
+        const conflictReport = formatConflictReport(process.cwd());
+        if (conflictReport) {
+          return makeToolResult(`${result}
+
+${conflictReport}`);
+        }
+      }
       return makeToolResult(result || "(no output)");
     } catch (err) {
       const output3 = [err.stdout, err.stderr].filter(Boolean).join("\n");
+      if (isMergeCommand) {
+        const conflictReport = formatConflictReport(process.cwd());
+        if (conflictReport) {
+          return makeToolError(`git ${command} failed with conflicts:
+${output3}
+
+${conflictReport}`);
+        }
+      }
       return makeToolError(`git ${command} failed:
 ${output3 || err.message}`);
     }
@@ -3917,15 +4947,92 @@ ${output3 || err.message}`);
 init_esm_shims();
 init_tool();
 var cache = /* @__PURE__ */ new Map();
-var CACHE_TTL = 15 * 60 * 1e3;
+var DEFAULT_CACHE_TTL = 15 * 60 * 1e3;
+var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+var MAX_TEXT_LEN = 5e4;
+var USER_AGENT = "Mozilla/5.0 (compatible; Codi/0.1; +https://github.com/gemdoq/codi)";
+function extractCharset(contentType) {
+  const match = contentType.match(/charset=([^\s;]+)/i);
+  return match && match[1] ? match[1].replace(/['"]/g, "") : null;
+}
+function parseCacheMaxAge(headers) {
+  const cc = headers.get("cache-control");
+  if (!cc) return null;
+  const match = cc.match(/max-age=(\d+)/);
+  if (!match || !match[1]) return null;
+  const seconds = parseInt(match[1], 10);
+  if (isNaN(seconds) || seconds <= 0) return null;
+  const clamped = Math.max(60, Math.min(seconds, 3600));
+  return clamped * 1e3;
+}
+function isPdf(url, contentType) {
+  return contentType.includes("application/pdf") || /\.pdf(\?|#|$)/i.test(url);
+}
+function isJson(contentType) {
+  return contentType.includes("application/json") || contentType.includes("+json");
+}
+async function extractHtmlText(html) {
+  const { load } = await import("cheerio");
+  const $ = load(html);
+  $('script, style, nav, header, footer, iframe, noscript, svg, [role="navigation"], [role="banner"], .sidebar, .ad, .ads, .advertisement').remove();
+  const main2 = $('main, article, .content, #content, .main, [role="main"]').first();
+  let text = main2.length ? main2.text() : $("body").text();
+  text = text.split("\n").map((line) => line.replace(/\s+/g, " ").trim()).filter((line) => line.length > 0).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  return text;
+}
+async function extractPdfText(buffer) {
+  const { PDFParse } = await import("pdf-parse");
+  const parser = new PDFParse({ data: new Uint8Array(buffer) });
+  try {
+    const textResult = await parser.getText();
+    const text = textResult.text?.trim() || "";
+    const totalPages = textResult.total ?? "unknown";
+    let infoStr = `Pages: ${totalPages}`;
+    try {
+      const info = await parser.getInfo();
+      if (info.info?.Title) infoStr += ` | Title: ${info.info.Title}`;
+      if (info.info?.Author) infoStr += ` | Author: ${info.info.Author}`;
+    } catch {
+    }
+    return `[PDF] ${infoStr}
+
+${text}`;
+  } finally {
+    await parser.destroy().catch(() => {
+    });
+  }
+}
+function formatJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return `[JSON Response]
+${JSON.stringify(parsed, null, 2)}`;
+  } catch {
+    return `[JSON Response - parse error]
+${raw}`;
+  }
+}
+async function decodeResponse(response, contentType) {
+  const charset = extractCharset(contentType);
+  if (charset && charset.toLowerCase() !== "utf-8" && charset.toLowerCase() !== "utf8") {
+    const buffer = await response.arrayBuffer();
+    const decoder = new TextDecoder(charset);
+    return decoder.decode(buffer);
+  }
+  return response.text();
+}
 var webFetchTool = {
   name: "web_fetch",
-  description: `Fetch content from a URL, convert HTML to text, and return the content. Includes a 15-minute cache. HTTP URLs are upgraded to HTTPS.`,
+  description: `Fetch content from a URL and return extracted text. Supports HTML (cheerio), PDF (pdf-parse), and JSON. Includes caching. HTTP URLs are upgraded to HTTPS.`,
   inputSchema: {
     type: "object",
     properties: {
       url: { type: "string", description: "URL to fetch" },
-      prompt: { type: "string", description: "What information to extract from the page" }
+      prompt: { type: "string", description: "What information to extract from the page" },
+      cache_ttl: {
+        type: "number",
+        description: "Cache TTL in seconds (default: 900, i.e. 15 minutes). Set to 0 to bypass cache."
+      }
     },
     required: ["url", "prompt"]
   },
@@ -3934,50 +5041,103 @@ var webFetchTool = {
   async execute(input3) {
     let url = String(input3["url"]);
     const prompt = String(input3["prompt"] || "");
+    const cacheTtlInput = input3["cache_ttl"];
+    const requestTtl = typeof cacheTtlInput === "number" ? cacheTtlInput * 1e3 : null;
+    const bypassCache = requestTtl === 0;
     if (url.startsWith("http://")) {
       url = url.replace("http://", "https://");
     }
-    const cached = cache.get(url);
-    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
-      return makeToolResult(`[Cached] ${prompt ? `Query: ${prompt}
+    if (!bypassCache) {
+      const cached = cache.get(url);
+      if (cached && Date.now() - cached.timestamp < cached.ttl) {
+        return makeToolResult(
+          `[Cached] ${prompt ? `Query: ${prompt}
 
-` : ""}${cached.content}`);
+` : ""}${cached.content}`
+        );
+      }
     }
     try {
       const response = await fetch(url, {
         headers: {
-          "User-Agent": "Codi/0.1 (AI Code Agent)",
-          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+          "User-Agent": USER_AGENT,
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,application/json;q=0.8,application/pdf;q=0.7,*/*;q=0.5"
         },
         redirect: "follow",
         signal: AbortSignal.timeout(3e4)
       });
       if (!response.ok) {
-        return makeToolError(`HTTP ${response.status}: ${response.statusText}`);
+        const status = response.status;
+        const statusText = response.statusText || "Unknown";
+        let detail = `HTTP ${status} ${statusText}`;
+        if (status === 403 || status === 401) {
+          detail += " - \uC811\uADFC\uC774 \uCC28\uB2E8\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uC778\uC99D\uC774 \uD544\uC694\uD558\uAC70\uB098 \uBD07 \uCC28\uB2E8\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4.";
+        } else if (status === 404) {
+          detail += " - \uD398\uC774\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+        } else if (status === 429) {
+          detail += " - \uC694\uCCAD\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4. \uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.";
+        } else if (status >= 500) {
+          detail += " - \uC11C\uBC84 \uC624\uB958\uC785\uB2C8\uB2E4.";
+        }
+        if (response.redirected) {
+          detail += `
+Redirected to: ${response.url}`;
+        }
+        return makeToolError(detail);
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+        return makeToolError(
+          `\uC751\uB2F5 \uD06C\uAE30\uAC00 \uB108\uBB34 \uD07D\uB2C8\uB2E4 (${(parseInt(contentLength, 10) / 1024 / 1024).toFixed(1)}MB). \uCD5C\uB300 5MB\uAE4C\uC9C0 \uC9C0\uC6D0\uD569\uB2C8\uB2E4.`
+        );
       }
       const contentType = response.headers.get("content-type") || "";
       let text;
-      if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
-        const html = await response.text();
-        const { load } = await import("cheerio");
-        const $ = load(html);
-        $("script, style, nav, header, footer, iframe, noscript").remove();
-        const main2 = $("main, article, .content, #content, .main").first();
-        text = (main2.length ? main2.text() : $("body").text()).replace(/\s+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+      if (isPdf(url, contentType)) {
+        const buffer = await response.arrayBuffer();
+        if (buffer.byteLength > MAX_RESPONSE_SIZE) {
+          return makeToolError(
+            `PDF \uD06C\uAE30\uAC00 \uB108\uBB34 \uD07D\uB2C8\uB2E4 (${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB). \uCD5C\uB300 5MB\uAE4C\uC9C0 \uC9C0\uC6D0\uD569\uB2C8\uB2E4.`
+          );
+        }
+        text = await extractPdfText(buffer);
+      } else if (isJson(contentType)) {
+        const raw = await decodeResponse(response, contentType);
+        text = formatJson(raw);
+      } else if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+        const html = await decodeResponse(response, contentType);
+        text = await extractHtmlText(html);
       } else {
-        text = await response.text();
+        text = await decodeResponse(response, contentType);
+      }
+      if (text.length > MAX_TEXT_LEN) {
+        text = text.slice(0, MAX_TEXT_LEN) + "\n\n... (truncated)";
       }
-      const MAX_LEN = 5e4;
-      if (text.length > MAX_LEN) {
-        text = text.slice(0, MAX_LEN) + "\n\n... (truncated)";
+      const effectiveTtl = requestTtl ?? parseCacheMaxAge(response.headers) ?? DEFAULT_CACHE_TTL;
+      if (!bypassCache) {
+        cache.set(url, { content: text, timestamp: Date.now(), ttl: effectiveTtl });
       }
-      cache.set(url, { content: text, timestamp: Date.now() });
-      return makeToolResult(prompt ? `URL: ${url}
-Query: ${prompt}
+      let prefix = `URL: ${url}`;
+      if (response.redirected && response.url !== url) {
+        prefix += `
+Redirected to: ${response.url}`;
+      }
+      if (prompt) {
+        prefix += `
+Query: ${prompt}`;
+      }
+      return makeToolResult(`${prefix}
 
-${text}` : text);
+${text}`);
     } catch (err) {
-      return makeToolError(`Failed to fetch URL: ${err instanceof Error ? err.message : String(err)}`);
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("TimeoutError") || message.includes("aborted")) {
+        return makeToolError(`\uC694\uCCAD \uC2DC\uAC04 \uCD08\uACFC (30\uCD08): ${url}`);
+      }
+      if (message.includes("ENOTFOUND") || message.includes("getaddrinfo")) {
+        return makeToolError(`\uB3C4\uBA54\uC778\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${url}`);
+      }
+      return makeToolError(`URL \uAC00\uC838\uC624\uAE30 \uC2E4\uD328: ${message}`);
     }
   }
 };
@@ -3985,73 +5145,181 @@ ${text}` : text);
 // src/tools/web-search.ts
 init_esm_shims();
 init_tool();
+var searchCache = /* @__PURE__ */ new Map();
+var SEARCH_CACHE_TTL = 10 * 60 * 1e3;
+var USER_AGENT2 = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+function extractRealUrl(href) {
+  try {
+    const urlObj = new URL(href, "https://duckduckgo.com");
+    return urlObj.searchParams.get("uddg") || href;
+  } catch {
+    return href;
+  }
+}
+function normalizeUrl(url) {
+  try {
+    const u = new URL(url);
+    const trackingParams = ["utm_source", "utm_medium", "utm_campaign", "utm_content", "utm_term", "ref", "fbclid", "gclid"];
+    for (const param of trackingParams) {
+      u.searchParams.delete(param);
+    }
+    let path23 = u.pathname.replace(/\/+$/, "") || "/";
+    return `${u.hostname}${path23}${u.search}`;
+  } catch {
+    return url;
+  }
+}
+function deduplicateResults(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const result of results) {
+    const normalized = normalizeUrl(result.url);
+    if (!seen.has(normalized) && result.title.length > 0) {
+      seen.add(normalized);
+      deduped.push(result);
+    }
+  }
+  return deduped;
+}
+async function searchDuckDuckGo(query, maxResults) {
+  const encoded = encodeURIComponent(query);
+  const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT2,
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.9"
+    },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`DuckDuckGo HTTP ${response.status} ${response.statusText}`);
+  }
+  const html = await response.text();
+  if (html.includes("If this error persists") || html.includes("blocked")) {
+    throw new Error("DuckDuckGo\uC5D0\uC11C \uC694\uCCAD\uC774 \uCC28\uB2E8\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+  }
+  const { load } = await import("cheerio");
+  const $ = load(html);
+  const results = [];
+  $(".result").each((_i, el) => {
+    const $el = $(el);
+    if ($el.hasClass("result--ad") || $el.find(".badge--ad").length > 0) {
+      return;
+    }
+    const titleEl = $el.find(".result__title a, .result__a");
+    const title = titleEl.text().trim();
+    const href = titleEl.attr("href") || "";
+    const snippet = $el.find(".result__snippet").text().trim();
+    if (title && href) {
+      const actualUrl = extractRealUrl(href);
+      if (actualUrl.startsWith("http://") || actualUrl.startsWith("https://")) {
+        results.push({ title, url: actualUrl, snippet });
+      }
+    }
+  });
+  return deduplicateResults(results).slice(0, maxResults);
+}
+async function searchDuckDuckGoLite(query, maxResults) {
+  const encoded = encodeURIComponent(query);
+  const url = `https://lite.duckduckgo.com/lite/?q=${encoded}`;
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": USER_AGENT2,
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+    },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`DuckDuckGo Lite HTTP ${response.status}`);
+  }
+  const html = await response.text();
+  const { load } = await import("cheerio");
+  const $ = load(html);
+  const results = [];
+  $("a.result-link").each((_i, el) => {
+    const $a = $(el);
+    const title = $a.text().trim();
+    const href = $a.attr("href") || "";
+    if (title && href) {
+      const actualUrl = extractRealUrl(href);
+      const $row = $a.closest("tr");
+      const snippet = $row.next("tr").find(".result-snippet").text().trim() || $row.next("tr").find("td").last().text().trim();
+      if (actualUrl.startsWith("http://") || actualUrl.startsWith("https://")) {
+        results.push({ title, url: actualUrl, snippet });
+      }
+    }
+  });
+  return deduplicateResults(results).slice(0, maxResults);
+}
 var webSearchTool = {
   name: "web_search",
-  description: `Search the web for information. Returns search results with titles, URLs, and snippets. Uses DuckDuckGo as the search engine.`,
+  description: `Search the web for information. Returns search results with titles, URLs, and snippets. Uses DuckDuckGo. Falls back to DuckDuckGo Lite if the main search fails.`,
   inputSchema: {
     type: "object",
     properties: {
-      query: { type: "string", description: "Search query" }
+      query: { type: "string", description: "Search query" },
+      max_results: {
+        type: "number",
+        description: "Maximum number of results (default: 10, max: 20)"
+      }
     },
     required: ["query"]
   },
   dangerous: true,
   readOnly: true,
   async execute(input3) {
-    const query = String(input3["query"]);
+    const query = String(input3["query"]).trim();
+    if (!query) {
+      return makeToolError("\uAC80\uC0C9\uC5B4\uAC00 \uBE44\uC5B4\uC788\uC2B5\uB2C8\uB2E4.");
+    }
+    const rawMax = typeof input3["max_results"] === "number" ? input3["max_results"] : 10;
+    const maxResults = Math.max(1, Math.min(20, Math.round(rawMax)));
+    const cacheKey = `${query}|${maxResults}`;
+    const cached = searchCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < SEARCH_CACHE_TTL) {
+      return makeToolResult(`[Cached] ${cached.results}`);
+    }
+    let results = [];
+    let fallbackUsed = false;
     try {
-      const encoded = encodeURIComponent(query);
-      const url = `https://html.duckduckgo.com/html/?q=${encoded}`;
-      const response = await fetch(url, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (compatible; Codi/0.1)"
-        },
-        signal: AbortSignal.timeout(15e3)
-      });
-      if (!response.ok) {
-        return makeToolError(`Search failed: HTTP ${response.status}`);
-      }
-      const html = await response.text();
-      const { load } = await import("cheerio");
-      const $ = load(html);
-      const results = [];
-      $(".result").each((i, el) => {
-        if (i >= 10) return false;
-        const $el = $(el);
-        const title = $el.find(".result__title a").text().trim();
-        const href = $el.find(".result__title a").attr("href") || "";
-        const snippet = $el.find(".result__snippet").text().trim();
-        if (title && href) {
-          let actualUrl = href;
-          try {
-            const urlObj = new URL(href, "https://duckduckgo.com");
-            actualUrl = urlObj.searchParams.get("uddg") || href;
-          } catch {
-            actualUrl = href;
-          }
-          results.push({ title, url: actualUrl, snippet });
-        }
-      });
-      if (results.length === 0) {
-        return makeToolResult(`No results found for: ${query}`);
+      results = await searchDuckDuckGo(query, maxResults);
+    } catch (primaryErr) {
+      try {
+        results = await searchDuckDuckGoLite(query, maxResults);
+        fallbackUsed = true;
+      } catch (fallbackErr) {
+        const primaryMsg = primaryErr instanceof Error ? primaryErr.message : String(primaryErr);
+        const fallbackMsg = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+        return makeToolError(
+          `\uAC80\uC0C9 \uC2E4\uD328:
+  Primary: ${primaryMsg}
+  Fallback: ${fallbackMsg}`
+        );
       }
-      const formatted = results.map((r, i) => `${i + 1}. ${r.title}
-   ${r.url}
-   ${r.snippet}`).join("\n\n");
-      return makeToolResult(`Search results for: ${query}
-
-${formatted}`);
-    } catch (err) {
-      return makeToolError(`Search failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (results.length === 0) {
+      return makeToolResult(`"${query}"\uC5D0 \uB300\uD55C \uAC80\uC0C9 \uACB0\uACFC\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+    }
+    const formatted = results.map(
+      (r, i) => `${i + 1}. ${r.title}
+   ${r.url}${r.snippet ? `
+   ${r.snippet}` : ""}`
+    ).join("\n\n");
+    const header = fallbackUsed ? `Search results for: ${query} (fallback engine used)` : `Search results for: ${query}`;
+    const output3 = `${header}
+
+${formatted}`;
+    searchCache.set(cacheKey, { results: output3, timestamp: Date.now() });
+    return makeToolResult(output3);
   }
 };
 
 // src/tools/notebook-edit.ts
 init_esm_shims();
 init_tool();
-import * as fs16 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path21 from "path";
 var notebookEditTool = {
   name: "notebook_edit",
   description: `Edit Jupyter notebook (.ipynb) cells. Supports replacing, inserting, and deleting cells.`,
@@ -4069,16 +5337,16 @@ var notebookEditTool = {
   dangerous: true,
   readOnly: false,
   async execute(input3) {
-    const nbPath = path18.resolve(String(input3["notebook_path"]));
+    const nbPath = path21.resolve(String(input3["notebook_path"]));
     const cellNumber = input3["cell_number"];
     const newSource = String(input3["new_source"]);
     const cellType = input3["cell_type"] || "code";
     const editMode = input3["edit_mode"] || "replace";
-    if (!fs16.existsSync(nbPath)) {
+    if (!fs20.existsSync(nbPath)) {
       return makeToolError(`Notebook not found: ${nbPath}`);
     }
     try {
-      const content = fs16.readFileSync(nbPath, "utf-8");
+      const content = fs20.readFileSync(nbPath, "utf-8");
       const nb = JSON.parse(content);
       if (!nb.cells || !Array.isArray(nb.cells)) {
         return makeToolError("Invalid notebook format: no cells array");
@@ -4123,7 +5391,7 @@ var notebookEditTool = {
         default:
           return makeToolError(`Unknown edit_mode: ${editMode}`);
       }
-      fs16.writeFileSync(nbPath, JSON.stringify(nb, null, 1), "utf-8");
+      fs20.writeFileSync(nbPath, JSON.stringify(nb, null, 1), "utf-8");
       return makeToolResult(`Notebook ${editMode}d cell in ${nbPath} (${nb.cells.length} cells total)`);
     } catch (err) {
       return makeToolError(`Notebook edit failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -4138,7 +5406,7 @@ init_task_tools();
 init_esm_shims();
 init_tool();
 import * as readline4 from "readline/promises";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 var askUserTool = {
   name: "ask_user",
   description: `Ask the user a question with optional choices. Use to gather preferences, clarify requirements, or get decisions.`,
@@ -4169,21 +5437,21 @@ var askUserTool = {
     const options = input3["options"];
     const multiSelect = input3["multiSelect"] === true;
     console.log("");
-    console.log(chalk12.cyan.bold("? ") + chalk12.bold(question));
+    console.log(chalk13.cyan.bold("? ") + chalk13.bold(question));
     if (options && options.length > 0) {
       console.log("");
       for (let i = 0; i < options.length; i++) {
         const opt = options[i];
-        console.log(chalk12.cyan(`  ${i + 1}.`) + ` ${opt.label}${opt.description ? chalk12.dim(` - ${opt.description}`) : ""}`);
+        console.log(chalk13.cyan(`  ${i + 1}.`) + ` ${opt.label}${opt.description ? chalk13.dim(` - ${opt.description}`) : ""}`);
       }
-      console.log(chalk12.dim(`  ${options.length + 1}. Other (type custom response)`));
+      console.log(chalk13.dim(`  ${options.length + 1}. Other (type custom response)`));
       console.log("");
       const rl2 = readline4.createInterface({
         input: process.stdin,
         output: process.stdout
       });
       try {
-        const prompt = multiSelect ? chalk12.dim("Enter numbers separated by commas: ") : chalk12.dim("Enter number or type response: ");
+        const prompt = multiSelect ? chalk13.dim("Enter numbers separated by commas: ") : chalk13.dim("Enter number or type response: ");
         const answer = await rl2.question(prompt);
         rl2.close();
         if (multiSelect) {
@@ -4209,7 +5477,7 @@ var askUserTool = {
       output: process.stdout
     });
     try {
-      const answer = await rl.question(chalk12.dim("> "));
+      const answer = await rl.question(chalk13.dim("> "));
       rl.close();
       return makeToolResult(`User response: ${answer}`);
     } catch {
@@ -4219,6 +5487,133 @@ var askUserTool = {
   }
 };
 
+// src/tools/memory-tool.ts
+init_esm_shims();
+init_tool();
+import * as fs21 from "fs";
+import * as path22 from "path";
+function buildFrontmatter(topic, description) {
+  return `---
+name: ${topic}
+description: ${description}
+type: project
+---
+`;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) return { body: content };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx !== -1) {
+      meta[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    }
+  }
+  return { name: meta["name"], description: meta["description"], body: match[2] };
+}
+function updateIndex(memoryDir) {
+  const indexPath = path22.join(memoryDir, "MEMORY.md");
+  const files = fs21.readdirSync(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").sort();
+  const lines = ["# Project Memory", ""];
+  if (files.length === 0) {
+    lines.push("No topics saved yet.");
+  } else {
+    lines.push("| Topic | Description |");
+    lines.push("|-------|-------------|");
+    for (const file of files) {
+      const content = fs21.readFileSync(path22.join(memoryDir, file), "utf-8");
+      const parsed = parseFrontmatter(content);
+      const topic = file.replace(".md", "");
+      const desc = parsed.description || "";
+      lines.push(`| [${topic}](${file}) | ${desc} |`);
+    }
+  }
+  lines.push("");
+  fs21.writeFileSync(indexPath, lines.join("\n"), "utf-8");
+}
+var updateMemoryTool = {
+  name: "update_memory",
+  description: `Save, delete, or list project memory topics. Use this to persist important information (architecture decisions, user preferences, patterns, etc.) across conversations.
+- save: Create or update a memory topic file with content
+- delete: Remove a memory topic file
+- list: List all existing memory topics with descriptions`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["save", "delete", "list"],
+        description: "Action to perform"
+      },
+      topic: {
+        type: "string",
+        description: 'Topic name (used as filename, e.g. "architecture" -> architecture.md). Required for save/delete.'
+      },
+      content: {
+        type: "string",
+        description: "Content to save. First line is used as description. Required for save."
+      }
+    },
+    required: ["action", "topic"]
+  },
+  dangerous: false,
+  readOnly: false,
+  async execute(input3) {
+    const action = String(input3["action"]);
+    const topic = String(input3["topic"] || "");
+    const content = input3["content"] != null ? String(input3["content"]) : void 0;
+    const memoryDir = memoryManager.getMemoryDir();
+    switch (action) {
+      case "save": {
+        if (!topic) return makeToolError("topic is required for save action");
+        if (!content) return makeToolError("content is required for save action");
+        memoryManager.ensureDir();
+        const firstLine = content.split("\n")[0].trim();
+        const description = firstLine.length > 100 ? firstLine.slice(0, 100) + "..." : firstLine;
+        const fileContent = buildFrontmatter(topic, description) + content;
+        const topicPath = path22.join(memoryDir, `${topic}.md`);
+        fs21.writeFileSync(topicPath, fileContent, "utf-8");
+        updateIndex(memoryDir);
+        return makeToolResult(`Memory topic "${topic}" saved to ${topicPath}`);
+      }
+      case "delete": {
+        if (!topic) return makeToolError("topic is required for delete action");
+        const topicPath = path22.join(memoryDir, `${topic}.md`);
+        if (!fs21.existsSync(topicPath)) {
+          return makeToolError(`Memory topic "${topic}" not found`);
+        }
+        fs21.unlinkSync(topicPath);
+        memoryManager.ensureDir();
+        updateIndex(memoryDir);
+        return makeToolResult(`Memory topic "${topic}" deleted`);
+      }
+      case "list": {
+        const topics = memoryManager.listTopics();
+        if (topics.length === 0) {
+          return makeToolResult("No memory topics saved yet.");
+        }
+        const lines = [];
+        for (const t of topics) {
+          const raw = memoryManager.loadTopic(t);
+          if (raw) {
+            const parsed = parseFrontmatter(raw);
+            lines.push(`- ${t}: ${parsed.description || "(no description)"}`);
+          } else {
+            lines.push(`- ${t}: (no description)`);
+          }
+        }
+        return makeToolResult(`Memory topics (${topics.length}):
+${lines.join("\n")}
+
+Memory dir: ${memoryDir}`);
+      }
+      default:
+        return makeToolError(`Unknown action: ${action}. Use save, delete, or list.`);
+    }
+  }
+};
+
 // src/llm/anthropic.ts
 init_esm_shims();
 import Anthropic from "@anthropic-ai/sdk";
@@ -4310,13 +5705,38 @@ var AnthropicProvider = class {
               name: block.name,
               input: block.input
             };
-          case "tool_result":
+          case "tool_result": {
+            let trContent;
+            if (typeof block.content === "string") {
+              trContent = block.content;
+            } else if (Array.isArray(block.content)) {
+              trContent = [];
+              for (const cb of block.content) {
+                if (cb.type === "text") {
+                  trContent.push({ type: "text", text: cb.text });
+                } else if (cb.type === "image") {
+                  trContent.push({
+                    type: "image",
+                    source: {
+                      type: "base64",
+                      media_type: cb.source.media_type,
+                      data: cb.source.data
+                    }
+                  });
+                } else {
+                  trContent.push({ type: "text", text: JSON.stringify(cb) });
+                }
+              }
+            } else {
+              trContent = JSON.stringify(block.content);
+            }
             return {
               type: "tool_result",
               tool_use_id: block.tool_use_id,
-              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+              content: trContent,
               ...block.is_error ? { is_error: true } : {}
             };
+          }
           default:
             return { type: "text", text: JSON.stringify(block) };
         }
@@ -4520,15 +5940,43 @@ var OpenAIProvider = class {
       }
       const hasToolResults = m.content.some((b) => b.type === "tool_result");
       if (hasToolResults) {
+        const pendingImages = [];
         for (const block of m.content) {
           if (block.type === "tool_result") {
-            result.push({
-              role: "tool",
-              tool_call_id: block.tool_use_id,
-              content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
-            });
+            if (Array.isArray(block.content)) {
+              const textParts = [];
+              for (const cb of block.content) {
+                if (cb.type === "text") textParts.push(cb.text);
+                else if (cb.type === "image") {
+                  pendingImages.push({
+                    type: "image_url",
+                    image_url: { url: `data:${cb.source.media_type};base64,${cb.source.data}` }
+                  });
+                }
+              }
+              result.push({
+                role: "tool",
+                tool_call_id: block.tool_use_id,
+                content: textParts.join("\n") || "(image)"
+              });
+            } else {
+              result.push({
+                role: "tool",
+                tool_call_id: block.tool_use_id,
+                content: block.content
+              });
+            }
           }
         }
+        if (pendingImages.length > 0) {
+          result.push({
+            role: "user",
+            content: [
+              { type: "text", text: "\uC704 \uB3C4\uAD6C\uAC00 \uBC18\uD658\uD55C \uC774\uBBF8\uC9C0\uC785\uB2C8\uB2E4. \uC774 \uC774\uBBF8\uC9C0\uB97C \uBD84\uC11D\uC5D0 \uD65C\uC6A9\uD558\uC138\uC694." },
+              ...pendingImages
+            ]
+          });
+        }
         continue;
       }
       const hasToolUse = m.content.some((b) => b.type === "tool_use");
@@ -4719,7 +6167,14 @@ var OllamaProvider = class {
         } else if (block.type === "image") {
           images.push(block.source.data);
         } else if (block.type === "tool_result") {
-          textParts.push(`[Tool Result: ${typeof block.content === "string" ? block.content : JSON.stringify(block.content)}]`);
+          if (Array.isArray(block.content)) {
+            for (const cb of block.content) {
+              if (cb.type === "text") textParts.push(cb.text);
+              else if (cb.type === "image") images.push(cb.source.data);
+            }
+          } else {
+            textParts.push(`[Tool Result: ${block.content}]`);
+          }
         } else if (block.type === "tool_use") {
           textParts.push(`[Tool Call: ${block.name}(${JSON.stringify(block.input)})]`);
         }
@@ -4814,12 +6269,12 @@ function parseArgs(argv) {
 }
 function printHelp() {
   console.log(`
-${chalk13.cyan.bold("Codi (\uCF54\uB514)")} - AI Code Agent for Terminal
+${chalk14.cyan.bold("Codi (\uCF54\uB514)")} - AI Code Agent for Terminal
 
-${chalk13.bold("Usage:")}
+${chalk14.bold("Usage:")}
   codi [options] [prompt]
 
-${chalk13.bold("Options:")}
+${chalk14.bold("Options:")}
   -m, --model <model>    Set the model (default: gemini-2.5-flash)
   --provider <name>      Set the provider (openai, anthropic, ollama)
   -p <prompt>            Run a single prompt and exit
@@ -4830,12 +6285,12 @@ ${chalk13.bold("Options:")}
   -h, --help             Show this help
   -v, --version          Show version
 
-${chalk13.bold("Environment:")}
+${chalk14.bold("Environment:")}
   GEMINI_API_KEY         Google Gemini API key (default provider)
   OPENAI_API_KEY         OpenAI API key
   ANTHROPIC_API_KEY      Anthropic API key
 
-${chalk13.bold("Examples:")}
+${chalk14.bold("Examples:")}
   codi                                   # Start interactive session
   codi -p "explain main.ts"              # Single prompt
   codi --provider anthropic              # Use Anthropic Claude
@@ -4851,11 +6306,11 @@ async function main() {
   }
   if (args.version) {
     try {
-      const { readFileSync: readFileSync14 } = await import("fs");
+      const { readFileSync: readFileSync17 } = await import("fs");
       const { fileURLToPath: fileURLToPath3 } = await import("url");
       const p = await import("path");
       const dir = p.dirname(fileURLToPath3(import.meta.url));
-      const pkg = JSON.parse(readFileSync14(p.join(dir, "..", "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync17(p.join(dir, "..", "package.json"), "utf-8"));
       console.log(`codi v${pkg.version}`);
     } catch {
       console.log("codi v0.1.8");
@@ -4919,7 +6374,8 @@ async function main() {
     taskUpdateTool,
     taskListTool,
     taskGetTool,
-    askUserTool
+    askUserTool,
+    updateMemoryTool
   ]);
   const subAgentHandler2 = createSubAgentHandler(provider, registry);
   setSubAgentHandler(subAgentHandler2);
@@ -4962,10 +6418,11 @@ async function main() {
           if (msg.role === "user") conversation.addUserMessage(msg.content);
           else if (msg.role === "assistant") conversation.addAssistantMessage(msg.content);
         }
-        console.log(chalk13.dim(`Resumed session: ${id}`));
+        console.log(chalk14.dim(`Resumed session: ${id}`));
       }
     }
   }
+  logger.info("\uC138\uC158 \uC2DC\uC791", { provider: providerName, model: modelName, cwd: process.cwd(), planMode: getMode() === "plan", yolo: !!args.yolo });
   await hookManager.runHooks("SessionStart", { cwd: process.cwd() });
   if (args.prompt) {
     await agentLoop(args.prompt, {
@@ -4980,6 +6437,7 @@ async function main() {
       },
       planMode: getMode() === "plan"
     });
+    logger.info("\uC138\uC158 \uC885\uB8CC (single prompt)");
     await hookManager.runHooks("SessionEnd", {});
     await mcpManager.disconnectAll();
     process.exit(0);
@@ -4991,7 +6449,7 @@ async function main() {
     compressor,
     exitFn: async () => {
       stopSpinner();
-      console.log(chalk13.dim("\nSaving session..."));
+      console.log(chalk14.dim("\nSaving session..."));
       sessionManager.save(conversation, void 0, provider.model);
       await hookManager.runHooks("SessionEnd", {});
       await mcpManager.disconnectAll();
@@ -5018,9 +6476,10 @@ async function main() {
   };
   const repl = new Repl({
     onMessage: async (message) => {
-      checkpointManager.create(conversation, message.slice(0, 50));
+      const preview = typeof message === "string" ? message.slice(0, 50) : message.find((b) => b.type === "text")?.text?.slice(0, 50) || "image";
+      checkpointManager.create(conversation, preview);
       if (compressor.shouldCompress(conversation)) {
-        console.log(chalk13.dim("Auto-compacting conversation..."));
+        console.log(chalk14.dim("Auto-compacting conversation..."));
         await compressor.compress(conversation, provider);
         conversation.setSystemPrompt(buildPrompt());
       }
@@ -5049,14 +6508,17 @@ async function main() {
     },
     onExit: async () => {
       stopSpinner();
-      console.log(chalk13.dim("\nSaving session..."));
+      logger.info("\uC138\uC158 \uC885\uB8CC (REPL exit)");
+      console.log(chalk14.dim("\nSaving session..."));
       sessionManager.save(conversation, void 0, provider.model);
+      checkpointManager.cleanup();
       await hookManager.runHooks("SessionEnd", {});
       await mcpManager.disconnectAll();
     }
   });
   process.on("SIGTERM", async () => {
     stopSpinner();
+    logger.info("\uC138\uC158 \uC885\uB8CC (SIGTERM)");
     sessionManager.save(conversation, void 0, provider.model);
     await hookManager.runHooks("SessionEnd", {});
     await mcpManager.disconnectAll();
@@ -5065,7 +6527,8 @@ async function main() {
   await repl.start();
 }
 main().catch((err) => {
-  console.error(chalk13.red(`Fatal error: ${err.message}`));
+  logger.error("\uCE58\uBA85\uC801 \uC624\uB958", {}, err instanceof Error ? err : new Error(String(err)));
+  console.error(chalk14.red(`Fatal error: ${err.message}`));
   console.error(err.stack);
   process.exit(1);
 });