snow-ai 0.5.19 → 0.5.20

package/bundle/cli.mjs

@@ -28457,7 +28457,7 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "node_modules/ws/lib/websocket.js"(exports2, module2) {
     "use strict";
-    var EventEmitter9 = __require("events");
+    var EventEmitter10 = __require("events");
     var https2 = __require("https");
     var http2 = __require("http");
     var net = __require("net");
@@ -28489,7 +28489,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket3 = class _WebSocket extends EventEmitter9 {
+    var WebSocket3 = class _WebSocket extends EventEmitter10 {
       /**
        * Create a new `WebSocket`.
        *
@@ -29483,7 +29483,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "node_modules/ws/lib/websocket-server.js"(exports2, module2) {
     "use strict";
-    var EventEmitter9 = __require("events");
+    var EventEmitter10 = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash3 } = __require("crypto");
@@ -29496,7 +29496,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter9 {
+    var WebSocketServer2 = class extends EventEmitter10 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -33349,6 +33349,32 @@ var init_build2 = __esm({
   }
 });
 
+// dist/utils/ui/updateNotice.js
+import { EventEmitter as EventEmitter3 } from "events";
+function setUpdateNotice(notice) {
+  currentNotice = notice ? { ...notice, checkedAt: Date.now() } : null;
+  updateNoticeEmitter.emit(UPDATE_NOTICE_EVENT, currentNotice);
+}
+function getUpdateNotice() {
+  return currentNotice;
+}
+function onUpdateNotice(handler) {
+  updateNoticeEmitter.on(UPDATE_NOTICE_EVENT, handler);
+  return () => {
+    updateNoticeEmitter.off(UPDATE_NOTICE_EVENT, handler);
+  };
+}
+var UPDATE_NOTICE_EVENT, updateNoticeEmitter, currentNotice;
+var init_updateNotice = __esm({
+  "dist/utils/ui/updateNotice.js"() {
+    "use strict";
+    UPDATE_NOTICE_EVENT = "update-notice";
+    updateNoticeEmitter = new EventEmitter3();
+    updateNoticeEmitter.setMaxListeners(20);
+    currentNotice = null;
+  }
+});
+
 // node_modules/ink-spinner/node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS({
   "node_modules/ink-spinner/node_modules/cli-spinners/spinners.json"(exports2, module2) {
@@ -50507,10 +50533,10 @@ var require_wrap_handler = __commonJS({
 var require_dispatcher = __commonJS({
   "node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
     "use strict";
-    var EventEmitter9 = __require("node:events");
+    var EventEmitter10 = __require("node:events");
     var WrapHandler = require_wrap_handler();
     var wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler));
-    var Dispatcher = class extends EventEmitter9 {
+    var Dispatcher = class extends EventEmitter10 {
       dispatch() {
         throw new Error("not implemented");
       }
@@ -60380,11 +60406,11 @@ var require_snapshot_recorder = __commonJS({
         caseSensitive = false
       } = matchOptions;
       const filtered = {};
-      const { ignore: ignore3, exclude, match: match2 } = headerFilters;
+      const { ignore: ignore2, exclude, match: match2 } = headerFilters;
       for (const [key, value] of Object.entries(headers)) {
         const headerKey = caseSensitive ? key : key.toLowerCase();
         if (exclude.has(headerKey)) continue;
-        if (ignore3.has(headerKey)) continue;
+        if (ignore2.has(headerKey)) continue;
         if (match2.size !== 0) {
           if (!match2.has(headerKey)) continue;
         }
@@ -62913,9 +62939,9 @@ var require_memory_cache_store = __commonJS({
   "node_modules/undici/lib/cache/memory-cache-store.js"(exports2, module2) {
     "use strict";
     var { Writable } = __require("node:stream");
-    var { EventEmitter: EventEmitter9 } = __require("node:events");
+    var { EventEmitter: EventEmitter10 } = __require("node:events");
     var { assertCacheKey, assertCacheValue } = require_cache();
-    var MemoryCacheStore = class extends EventEmitter9 {
+    var MemoryCacheStore = class extends EventEmitter10 {
       #maxCount = 1024;
       #maxSize = 104857600;
       // 100MB
@@ -80978,6 +81004,11 @@ var init_en = __esm({
         themeSettingsInfo: "Configure theme and preview DiffViewer",
         hooksSettings: "Hooks Settings",
         hooksSettingsInfo: "Configure hooks for customizing AI workflow",
+        updateNoticeTitle: "Update available",
+        updateNoticeCurrent: "Current",
+        updateNoticeLatest: "Latest",
+        updateNoticeRun: "Run",
+        updateNoticeGithub: "GitHub",
         exit: "Exit",
         exitInfo: "Exit the application"
       },
@@ -81885,6 +81916,11 @@ var init_zh = __esm({
         themeSettingsInfo: "\u914D\u7F6E\u4E3B\u9898\u5E76\u9884\u89C8\u5DEE\u5F02\u67E5\u770B\u5668",
         hooksSettings: "Hooks \u8BBE\u7F6E",
         hooksSettingsInfo: "\u914D\u7F6E Hooks \u4EE5\u81EA\u5B9A\u4E49 AI \u5DE5\u4F5C\u6D41",
+        updateNoticeTitle: "\u53D1\u73B0\u65B0\u7248\u672C",
+        updateNoticeCurrent: "\u5F53\u524D\u7248\u672C",
+        updateNoticeLatest: "\u6700\u65B0\u7248\u672C",
+        updateNoticeRun: "\u66F4\u65B0\u547D\u4EE4",
+        updateNoticeGithub: "\u9879\u76EE\u5730\u5740",
         exit: "\u9000\u51FA",
         exitInfo: "\u9000\u51FA\u5E94\u7528\u7A0B\u5E8F"
       },
@@ -82792,6 +82828,11 @@ var init_zh_TW = __esm({
         themeSettingsInfo: "\u8A2D\u5B9A\u4E3B\u984C\u4E26\u9810\u89BD\u5DEE\u7570\u6AA2\u8996\u5668",
         hooksSettings: "Hooks \u8A2D\u5B9A",
         hooksSettingsInfo: "\u8A2D\u5B9A Hooks \u4EE5\u81EA\u8A02 AI \u5DE5\u4F5C\u6D41\u7A0B",
+        updateNoticeTitle: "\u6709\u65B0\u7248\u672C\u53EF\u7528",
+        updateNoticeCurrent: "\u76EE\u524D\u7248\u672C",
+        updateNoticeLatest: "\u6700\u65B0\u7248\u672C",
+        updateNoticeRun: "\u66F4\u65B0\u6307\u4EE4",
+        updateNoticeGithub: "\u5C08\u6848\u7DB2\u5740",
         exit: "\u9000\u51FA",
         exitInfo: "\u9000\u51FA\u61C9\u7528\u7A0B\u5F0F"
       },
@@ -83694,6 +83735,11 @@ var init_ja = __esm({
         themeSettingsInfo: "\u30C6\u30FC\u30DE\u3092\u8A2D\u5B9A\u3057\u3066\u5DEE\u5206\u30D3\u30E5\u30FC\u30EF\u30FC\u3092\u30D7\u30EC\u30D3\u30E5\u30FC",
         hooksSettings: "Hooks\u8A2D\u5B9A",
         hooksSettingsInfo: "AI\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC\u3092\u30AB\u30B9\u30BF\u30DE\u30A4\u30BA\u3059\u308B\u305F\u3081\u306EHooks\u3092\u8A2D\u5B9A",
+        updateNoticeTitle: "\u66F4\u65B0\u304C\u5229\u7528\u53EF\u80FD\u3067\u3059",
+        updateNoticeCurrent: "\u73FE\u5728",
+        updateNoticeLatest: "\u6700\u65B0",
+        updateNoticeRun: "\u5B9F\u884C",
+        updateNoticeGithub: "GitHub",
         exit: "\u7D42\u4E86",
         exitInfo: "\u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3\u3092\u7D42\u4E86"
       },
@@ -84596,6 +84642,11 @@ var init_ko = __esm({
         themeSettingsInfo: "\uD14C\uB9C8\uB97C \uAD6C\uC131\uD558\uACE0 \uCC28\uC774\uC810 \uBDF0\uC5B4\uB97C \uBBF8\uB9AC \uBCF4\uAE30",
         hooksSettings: "Hooks \uC124\uC815",
         hooksSettingsInfo: "AI \uC6CC\uD06C\uD50C\uB85C\uC6B0\uB97C \uC0AC\uC6A9\uC790 \uC815\uC758\uD558\uAE30 \uC704\uD55C Hooks \uAD6C\uC131",
+        updateNoticeTitle: "\uC5C5\uB370\uC774\uD2B8\uAC00 \uC788\uC2B5\uB2C8\uB2E4",
+        updateNoticeCurrent: "\uD604\uC7AC",
+        updateNoticeLatest: "\uCD5C\uC2E0",
+        updateNoticeRun: "\uC2E4\uD589",
+        updateNoticeGithub: "GitHub",
         exit: "\uC885\uB8CC",
         exitInfo: "\uC560\uD50C\uB9AC\uCF00\uC774\uC158 \uC885\uB8CC"
       },
@@ -85498,6 +85549,11 @@ var init_es = __esm({
         themeSettingsInfo: "Configurar tema y vista previa del visor de diferencias",
         hooksSettings: "Configuraci\xF3n de Hooks",
         hooksSettingsInfo: "Configurar hooks para personalizar el flujo de trabajo de IA",
+        updateNoticeTitle: "Actualizaci\xF3n disponible",
+        updateNoticeCurrent: "Actual",
+        updateNoticeLatest: "\xDAltima",
+        updateNoticeRun: "Ejecuta",
+        updateNoticeGithub: "GitHub",
         exit: "Salir",
         exitInfo: "Salir de la aplicaci\xF3n"
       },
@@ -86532,7 +86588,7 @@ var init_useGlobalExit = __esm({
 });
 
 // dist/hooks/integration/useGlobalNavigation.js
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 function navigateTo(destination) {
   navigationEmitter.emit(NAVIGATION_EVENT, { destination });
 }
@@ -86546,7 +86602,7 @@ var navigationEmitter, NAVIGATION_EVENT;
 var init_useGlobalNavigation = __esm({
   "dist/hooks/integration/useGlobalNavigation.js"() {
     "use strict";
-    navigationEmitter = new EventEmitter3();
+    navigationEmitter = new EventEmitter4();
     navigationEmitter.setMaxListeners(20);
     NAVIGATION_EVENT = "navigate";
   }
@@ -236029,7 +236085,7 @@ ${fromBody}`;
       "src/common/create-ignorer.js"(exports22, module22) {
         "use strict";
         var path49 = __require("path");
-        var ignore3 = require_ignore2().default;
+        var ignore2 = require_ignore2().default;
         var getFileContentOrNull = require_get_file_content_or_null();
         async function createIgnorer(ignorePath, withNodeModules) {
           const ignoreContent = ignorePath ? await getFileContentOrNull(path49.resolve(ignorePath)) : null;
@@ -236040,7 +236096,7 @@ ${fromBody}`;
           return _createIgnorer(ignoreContent, withNodeModules);
         };
         function _createIgnorer(ignoreContent, withNodeModules) {
-          const ignorer = ignore3({
+          const ignorer = ignore2({
             allowRelativePaths: true
           }).add(ignoreContent || "");
           if (!withNodeModules) {
@@ -236833,8 +236889,8 @@ ${fromBody}`;
           return utils2.pattern.getPositivePatterns(patterns);
         }
         exports22.getPositivePatterns = getPositivePatterns;
-        function getNegativePatternsAsPositive(patterns, ignore3) {
-          const negative = utils2.pattern.getNegativePatterns(patterns).concat(ignore3);
+        function getNegativePatternsAsPositive(patterns, ignore2) {
+          const negative = utils2.pattern.getNegativePatterns(patterns).concat(ignore2);
           const positive = negative.map(utils2.pattern.convertToPositivePattern);
           return positive;
         }
@@ -259452,7 +259508,7 @@ var require_util9 = __commonJS({
     function markAsOriginatingFromRejection(e) {
       try {
         notEnumerableProp(e, "isOperational", true);
-      } catch (ignore3) {
+      } catch (ignore2) {
       }
     }
     function originatesFromRejection(e) {
@@ -259489,7 +259545,7 @@ var require_util9 = __commonJS({
         if (filter3(key)) {
           try {
             es5.defineProperty(to, key, es5.getDescriptor(from2, key));
-          } catch (ignore3) {
+          } catch (ignore2) {
           }
         }
       }
@@ -353111,6 +353167,345 @@ var init_notebookManager = __esm({
   }
 });
 
+// dist/utils/codebase/conversationContext.js
+var conversationContext_exports = {};
+__export(conversationContext_exports, {
+  clearConversationContext: () => clearConversationContext,
+  getConversationContext: () => getConversationContext,
+  setConversationContext: () => setConversationContext
+});
+function setConversationContext(sessionId, messageIndex) {
+  currentSessionId = sessionId;
+  currentMessageIndex = messageIndex;
+}
+function getConversationContext() {
+  if (currentSessionId !== void 0 && currentMessageIndex !== void 0) {
+    return { sessionId: currentSessionId, messageIndex: currentMessageIndex };
+  }
+  return void 0;
+}
+function clearConversationContext() {
+  currentSessionId = void 0;
+  currentMessageIndex = void 0;
+}
+var currentSessionId, currentMessageIndex;
+var init_conversationContext = __esm({
+  "dist/utils/codebase/conversationContext.js"() {
+    "use strict";
+  }
+});
+
+// dist/utils/session/projectUtils.js
+import path17 from "path";
+import crypto3 from "crypto";
+function getProjectId(projectPath) {
+  const cwd2 = projectPath || process.cwd();
+  const dirName = path17.basename(cwd2);
+  const pathHash = crypto3.createHash("sha256").update(cwd2).digest("hex").slice(0, 6);
+  const safeDirName = sanitizeProjectName(dirName);
+  return `${safeDirName}-${pathHash}`;
+}
+function getProjectPath() {
+  return process.cwd();
+}
+function sanitizeProjectName(name) {
+  return name.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 100);
+}
+function formatDateCompact(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}${month}${day}`;
+}
+function isDateFolder(folderName) {
+  return /^\d{4}-?\d{2}-?\d{2}$/.test(folderName);
+}
+function isProjectFolder(folderName) {
+  return /^.+-[a-f0-9]{6}$/.test(folderName);
+}
+var init_projectUtils = __esm({
+  "dist/utils/session/projectUtils.js"() {
+    "use strict";
+  }
+});
+
+// dist/utils/codebase/hashBasedSnapshot.js
+var hashBasedSnapshot_exports = {};
+__export(hashBasedSnapshot_exports, {
+  hashBasedSnapshotManager: () => hashBasedSnapshotManager
+});
+import fs16 from "fs/promises";
+import path18 from "path";
+import os8 from "os";
+import crypto4 from "crypto";
+var HashBasedSnapshotManager, hashBasedSnapshotManager;
+var init_hashBasedSnapshot = __esm({
+  "dist/utils/codebase/hashBasedSnapshot.js"() {
+    "use strict";
+    init_logger();
+    init_projectUtils();
+    HashBasedSnapshotManager = class {
+      constructor() {
+        Object.defineProperty(this, "snapshotsDir", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        const projectId = getProjectId();
+        this.snapshotsDir = path18.join(os8.homedir(), ".snow", "snapshots", projectId);
+      }
+      /**
+       * Ensure snapshots directory exists
+       */
+      async ensureSnapshotsDir() {
+        await fs16.mkdir(this.snapshotsDir, { recursive: true });
+      }
+      /**
+       * Get snapshot file path
+       */
+      getSnapshotPath(sessionId, messageIndex) {
+        return path18.join(this.snapshotsDir, `${sessionId}_${messageIndex}.json`);
+      }
+      /**
+       * Backup a file before modification or creation
+       * @param sessionId Current session ID
+       * @param messageIndex Current message index
+       * @param filePath File path (relative to workspace root)
+       * @param workspaceRoot Workspace root directory
+       * @param existed Whether the file existed before (false for new files)
+       * @param originalContent Original file content (undefined for new files)
+       */
+      async backupFile(sessionId, messageIndex, filePath, workspaceRoot, existed, originalContent) {
+        try {
+          logger.info(`[Snapshot] backupFile called: sessionId=${sessionId}, messageIndex=${messageIndex}, filePath=${filePath}, existed=${existed}`);
+          await this.ensureSnapshotsDir();
+          const snapshotPath = this.getSnapshotPath(sessionId, messageIndex);
+          logger.info(`[Snapshot] snapshotPath=${snapshotPath}`);
+          const relativePath = path18.isAbsolute(filePath) ? path18.relative(workspaceRoot, filePath) : filePath;
+          const backup = {
+            path: relativePath,
+            content: existed ? originalContent ?? null : null,
+            existed,
+            hash: originalContent ? crypto4.createHash("sha256").update(originalContent).digest("hex") : ""
+          };
+          let metadata;
+          try {
+            const content = await fs16.readFile(snapshotPath, "utf-8");
+            metadata = JSON.parse(content);
+          } catch {
+            metadata = {
+              sessionId,
+              messageIndex,
+              timestamp: Date.now(),
+              workspaceRoot,
+              backups: []
+            };
+          }
+          const existingBackupIndex = metadata.backups.findIndex((b) => b.path === relativePath);
+          if (existingBackupIndex === -1) {
+            metadata.backups.push(backup);
+            await this.saveSnapshotMetadata(metadata);
+            logger.info(`[Snapshot] Backed up file ${relativePath} for session ${sessionId} message ${messageIndex}`);
+          }
+        } catch (error) {
+          logger.warn(`[Snapshot] Failed to backup file ${filePath}:`, error);
+        }
+      }
+      /**
+       * Remove a specific file backup from snapshot (for failed operations)
+       * @param sessionId Current session ID
+       * @param messageIndex Current message index
+       * @param filePath File path to remove from backup
+       */
+      async removeFileBackup(sessionId, messageIndex, filePath, workspaceRoot) {
+        try {
+          const snapshotPath = this.getSnapshotPath(sessionId, messageIndex);
+          try {
+            const content = await fs16.readFile(snapshotPath, "utf-8");
+            const metadata = JSON.parse(content);
+            const relativePath = path18.isAbsolute(filePath) ? path18.relative(workspaceRoot, filePath) : filePath;
+            const originalLength = metadata.backups.length;
+            metadata.backups = metadata.backups.filter((b) => b.path !== relativePath);
+            if (metadata.backups.length < originalLength) {
+              if (metadata.backups.length === 0) {
+                await fs16.unlink(snapshotPath);
+                logger.info(`[Snapshot] Deleted empty snapshot ${sessionId}_${messageIndex}`);
+              } else {
+                await this.saveSnapshotMetadata(metadata);
+                logger.info(`[Snapshot] Removed backup for ${relativePath} from snapshot ${sessionId}_${messageIndex}`);
+              }
+            }
+          } catch (error) {
+          }
+        } catch (error) {
+          logger.warn(`[Snapshot] Failed to remove file backup ${filePath}:`, error);
+        }
+      }
+      /**
+       * Save snapshot to disk
+       */
+      async saveSnapshotMetadata(metadata) {
+        await this.ensureSnapshotsDir();
+        const snapshotPath = this.getSnapshotPath(metadata.sessionId, metadata.messageIndex);
+        await fs16.writeFile(snapshotPath, JSON.stringify(metadata, null, 2));
+      }
+      /**
+       * List all snapshots for a session
+       */
+      async listSnapshots(sessionId) {
+        await this.ensureSnapshotsDir();
+        const snapshots = [];
+        try {
+          const files = await fs16.readdir(this.snapshotsDir);
+          for (const file of files) {
+            if (file.startsWith(sessionId) && file.endsWith(".json")) {
+              const snapshotPath = path18.join(this.snapshotsDir, file);
+              const content = await fs16.readFile(snapshotPath, "utf-8");
+              const metadata = JSON.parse(content);
+              snapshots.push({
+                messageIndex: metadata.messageIndex,
+                timestamp: metadata.timestamp,
+                fileCount: metadata.backups.length
+              });
+            }
+          }
+        } catch (error) {
+          logger.error("Failed to list snapshots:", error);
+        }
+        return snapshots.sort((a, b) => b.messageIndex - a.messageIndex);
+      }
+      /**
+       * Get list of files affected by rollback
+       */
+      async getFilesToRollback(sessionId, targetMessageIndex) {
+        await this.ensureSnapshotsDir();
+        try {
+          const files = await fs16.readdir(this.snapshotsDir);
+          const filesToRollback = /* @__PURE__ */ new Set();
+          for (const file of files) {
+            if (file.startsWith(sessionId) && file.endsWith(".json")) {
+              const snapshotPath = path18.join(this.snapshotsDir, file);
+              const content = await fs16.readFile(snapshotPath, "utf-8");
+              const metadata = JSON.parse(content);
+              if (metadata.messageIndex >= targetMessageIndex) {
+                for (const backup of metadata.backups) {
+                  filesToRollback.add(backup.path);
+                }
+              }
+            }
+          }
+          return Array.from(filesToRollback).sort();
+        } catch (error) {
+          logger.error("Failed to get files to rollback:", error);
+          return [];
+        }
+      }
+      /**
+       * Rollback to a specific message index
+       * Uses streaming approach to minimize memory usage
+       */
+      async rollbackToMessageIndex(sessionId, targetMessageIndex, selectedFiles) {
+        await this.ensureSnapshotsDir();
+        try {
+          const files = await fs16.readdir(this.snapshotsDir);
+          const snapshotFiles = [];
+          for (const file of files) {
+            if (file.startsWith(sessionId) && file.endsWith(".json")) {
+              const snapshotPath = path18.join(this.snapshotsDir, file);
+              const content = await fs16.readFile(snapshotPath, "utf-8");
+              const metadata = JSON.parse(content);
+              if (metadata.messageIndex >= targetMessageIndex) {
+                snapshotFiles.push({
+                  messageIndex: metadata.messageIndex,
+                  path: snapshotPath
+                });
+              }
+            }
+          }
+          snapshotFiles.sort((a, b) => b.messageIndex - a.messageIndex);
+          let totalFilesRolledBack = 0;
+          for (const snapshotFile of snapshotFiles) {
+            const content = await fs16.readFile(snapshotFile.path, "utf-8");
+            const metadata = JSON.parse(content);
+            for (const backup of metadata.backups) {
+              if (selectedFiles && selectedFiles.length > 0 && !selectedFiles.includes(backup.path)) {
+                continue;
+              }
+              const fullPath = path18.join(metadata.workspaceRoot, backup.path);
+              try {
+                if (backup.existed && backup.content !== null) {
+                  await fs16.writeFile(fullPath, backup.content, "utf-8");
+                  totalFilesRolledBack++;
+                } else if (!backup.existed) {
+                  try {
+                    await fs16.unlink(fullPath);
+                    totalFilesRolledBack++;
+                  } catch {
+                  }
+                }
+              } catch (error) {
+                logger.error(`Failed to restore file ${backup.path}:`, error);
+              }
+            }
+          }
+          return totalFilesRolledBack;
+        } catch (error) {
+          logger.error("Failed to rollback to message index:", error);
+          return 0;
+        }
+      }
+      /**
+       * Delete snapshots from a specific message index onwards
+       */
+      async deleteSnapshotsFromIndex(sessionId, targetMessageIndex) {
+        await this.ensureSnapshotsDir();
+        try {
+          const files = await fs16.readdir(this.snapshotsDir);
+          let deletedCount = 0;
+          for (const file of files) {
+            if (file.startsWith(sessionId) && file.endsWith(".json")) {
+              const snapshotPath = path18.join(this.snapshotsDir, file);
+              const content = await fs16.readFile(snapshotPath, "utf-8");
+              const metadata = JSON.parse(content);
+              if (metadata.messageIndex >= targetMessageIndex) {
+                try {
+                  await fs16.unlink(snapshotPath);
+                  deletedCount++;
+                } catch (error) {
+                  logger.error(`Failed to delete snapshot file ${snapshotPath}:`, error);
+                }
+              }
+            }
+          }
+          return deletedCount;
+        } catch (error) {
+          logger.error("Failed to delete snapshots from index:", error);
+          return 0;
+        }
+      }
+      /**
+       * Clear all snapshots for a session
+       */
+      async clearAllSnapshots(sessionId) {
+        await this.ensureSnapshotsDir();
+        try {
+          const files = await fs16.readdir(this.snapshotsDir);
+          for (const file of files) {
+            if (file.startsWith(sessionId) && file.endsWith(".json")) {
+              const filePath = path18.join(this.snapshotsDir, file);
+              await fs16.unlink(filePath);
+            }
+          }
+        } catch (error) {
+          logger.error("Failed to clear snapshots:", error);
+        }
+      }
+    };
+    hashBasedSnapshotManager = new HashBasedSnapshotManager();
+  }
+});
+
 // dist/mcp/filesystem.js
 var filesystem_exports = {};
 __export(filesystem_exports, {
@@ -353118,8 +353513,8 @@ __export(filesystem_exports, {
   filesystemService: () => filesystemService,
   mcpTools: () => mcpTools
 });
-import { promises as fs16 } from "fs";
-import * as path17 from "path";
+import { promises as fs17 } from "fs";
+import * as path19 from "path";
 var prettier, resolve4, dirname6, isAbsolute3, extname3, FilesystemMCPService, filesystemService, mcpTools;
 var init_filesystem = __esm({
   "dist/mcp/filesystem.js"() {
@@ -353136,7 +353531,7 @@ var init_filesystem = __esm({
     init_office_parser_utils();
     init_symbol_utils();
     init_notebookManager();
-    ({ resolve: resolve4, dirname: dirname6, isAbsolute: isAbsolute3, extname: extname3 } = path17);
+    ({ resolve: resolve4, dirname: dirname6, isAbsolute: isAbsolute3, extname: extname3 } = path19);
     FilesystemMCPService = class {
       constructor(basePath = process.cwd()) {
         Object.defineProperty(this, "basePath", {
@@ -353212,7 +353607,7 @@ var init_filesystem = __esm({
           if (ext === ".svg") {
             try {
               const sharp = (await import("sharp")).default;
-              const buffer2 = await fs16.readFile(fullPath);
+              const buffer2 = await fs17.readFile(fullPath);
               const pngBuffer = await sharp(buffer2).png().toBuffer();
               const base64Data2 = pngBuffer.toString("base64");
               return {
@@ -353222,7 +353617,7 @@ var init_filesystem = __esm({
                 // Return as PNG
               };
             } catch (svgError) {
-              const buffer2 = await fs16.readFile(fullPath);
+              const buffer2 = await fs17.readFile(fullPath);
               const base64Data2 = buffer2.toString("base64");
               return {
                 type: "image",
@@ -353231,7 +353626,7 @@ var init_filesystem = __esm({
               };
             }
           }
-          const buffer = await fs16.readFile(fullPath);
+          const buffer = await fs17.readFile(fullPath);
           const base64Data = buffer.toString("base64");
           return {
             type: "image",
@@ -353354,7 +353749,7 @@ ${exportList}`);
                 if (!isAbsolute3(file)) {
                   await this.validatePath(fullPath2);
                 }
-                const stats2 = await fs16.stat(fullPath2);
+                const stats2 = await fs17.stat(fullPath2);
                 if (stats2.isDirectory()) {
                   const dirFiles = await this.listFiles(file);
                   const fileList = dirFiles.join("\n");
@@ -353403,7 +353798,7 @@ ${fileList}`
                     continue;
                   }
                 }
-                const content2 = await fs16.readFile(fullPath2, "utf-8");
+                const content2 = await fs17.readFile(fullPath2, "utf-8");
                 const lines2 = content2.split("\n");
                 const totalLines2 = lines2.length;
                 const actualStartLine2 = fileStartLine ?? 1;
@@ -353474,7 +353869,7 @@ ${numberedLines3.join("\n")}`;
           if (!isAbsolute3(filePath)) {
             await this.validatePath(fullPath);
           }
-          const stats = await fs16.stat(fullPath);
+          const stats = await fs17.stat(fullPath);
           if (stats.isDirectory()) {
             const files = await this.listFiles(filePath);
             const fileList = files.join("\n");
@@ -353520,7 +353915,7 @@ ${fileList}`,
               };
             }
           }
-          const content = await fs16.readFile(fullPath, "utf-8");
+          const content = await fs17.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           const totalLines = lines.length;
           const actualStartLine = startLine ?? 1;
@@ -353563,7 +353958,7 @@ ${fileList}`,
             if (fixedPath && fixedPath !== filePath) {
               const fixedFullPath = this.resolvePath(fixedPath);
               try {
-                await fs16.access(fixedFullPath);
+                await fs17.access(fixedFullPath);
                 throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}
 \u{1F4A1} Tip: File not found. Did you mean "${fixedPath}"? Please use the correct path.`);
               } catch {
@@ -353585,18 +353980,35 @@ ${fileList}`,
         try {
           const fullPath = this.resolvePath(filePath);
           try {
-            await fs16.access(fullPath);
+            await fs17.access(fullPath);
             throw new Error(`File already exists: ${filePath}`);
           } catch (error) {
             if (error.code !== "ENOENT") {
               throw error;
             }
           }
+          try {
+            const { getConversationContext: getConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+            const context2 = getConversationContext2();
+            if (context2) {
+              const { hashBasedSnapshotManager: hashBasedSnapshotManager2 } = await Promise.resolve().then(() => (init_hashBasedSnapshot(), hashBasedSnapshot_exports));
+              await hashBasedSnapshotManager2.backupFile(
+                context2.sessionId,
+                context2.messageIndex,
+                filePath,
+                this.basePath,
+                false,
+                // File didn't exist
+                void 0
+              );
+            }
+          } catch (backupError) {
+          }
           if (createDirectories) {
             const dir = dirname6(fullPath);
-            await fs16.mkdir(dir, { recursive: true });
+            await fs17.mkdir(dir, { recursive: true });
           }
-          await fs16.writeFile(fullPath, content, "utf-8");
+          await fs17.writeFile(fullPath, content, "utf-8");
           return `File created successfully: ${filePath}`;
         } catch (error) {
           throw new Error(`Failed to create file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -353615,11 +354027,11 @@ ${fileList}`,
           if (!isAbsolute3(dirPath)) {
             await this.validatePath(fullPath);
           }
-          const stats = await fs16.stat(fullPath);
+          const stats = await fs17.stat(fullPath);
           if (!stats.isDirectory()) {
             throw new Error(`Path is not a directory: ${dirPath}`);
           }
-          const files = await fs16.readdir(fullPath);
+          const files = await fs17.readdir(fullPath);
           return files;
         } catch (error) {
           throw new Error(`Failed to list files in ${dirPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -353633,7 +354045,7 @@ ${fileList}`,
       async exists(filePath) {
         try {
           const fullPath = this.resolvePath(filePath);
-          await fs16.access(fullPath);
+          await fs17.access(fullPath);
           return true;
         } catch {
           return false;
@@ -353649,7 +354061,7 @@ ${fileList}`,
         try {
           const fullPath = this.resolvePath(filePath);
           await this.validatePath(fullPath);
-          const stats = await fs16.stat(fullPath);
+          const stats = await fs17.stat(fullPath);
           return {
             size: stats.size,
             isFile: stats.isFile(),
@@ -353695,8 +354107,25 @@ ${fileList}`,
           if (!isAbsolute3(filePath)) {
             await this.validatePath(fullPath);
           }
-          const content = await fs16.readFile(fullPath, "utf-8");
+          const content = await fs17.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
+          try {
+            const { getConversationContext: getConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+            const context2 = getConversationContext2();
+            if (context2) {
+              const { hashBasedSnapshotManager: hashBasedSnapshotManager2 } = await Promise.resolve().then(() => (init_hashBasedSnapshot(), hashBasedSnapshot_exports));
+              await hashBasedSnapshotManager2.backupFile(
+                context2.sessionId,
+                context2.messageIndex,
+                filePath,
+                this.basePath,
+                true,
+                // File existed
+                content
+              );
+            }
+          } catch (backupError) {
+          }
           let normalizedSearch = searchContent.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
           const normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
           let searchLines = normalizedSearch.split("\n");
@@ -353862,12 +354291,12 @@ ${diffMsg}
             const lineNum = contextStart + idx2;
             return `${lineNum}\u2192${normalizeForDisplay(line)}`;
           }).join("\n");
-          await fs16.writeFile(fullPath, modifiedContent, "utf-8");
+          await fs17.writeFile(fullPath, modifiedContent, "utf-8");
           let finalContent = modifiedContent;
           let finalLines = modifiedLines;
           let finalTotalLines = modifiedLines.length;
           let finalContextEnd = Math.min(finalTotalLines, contextEnd + lineDifference);
-          const fileExtension = path17.extname(fullPath).toLowerCase();
+          const fileExtension = path19.extname(fullPath).toLowerCase();
           const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
           if (shouldFormat) {
             try {
@@ -353876,7 +354305,7 @@ ${diffMsg}
                 filepath: fullPath,
                 ...prettierConfig
               });
-              await fs16.writeFile(fullPath, finalContent, "utf-8");
+              await fs17.writeFile(fullPath, finalContent, "utf-8");
               finalLines = finalContent.split("\n");
               finalTotalLines = finalLines.length;
               finalContextEnd = Math.min(finalTotalLines, contextStart + (contextEnd - contextStart) + lineDifference);
@@ -354018,9 +354447,26 @@ ${formattedDiagnostics}`;
           if (!isAbsolute3(filePath)) {
             await this.validatePath(fullPath);
           }
-          const content = await fs16.readFile(fullPath, "utf-8");
+          const content = await fs17.readFile(fullPath, "utf-8");
           const lines = content.split("\n");
           const totalLines = lines.length;
+          try {
+            const { getConversationContext: getConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+            const context2 = getConversationContext2();
+            if (context2) {
+              const { hashBasedSnapshotManager: hashBasedSnapshotManager2 } = await Promise.resolve().then(() => (init_hashBasedSnapshot(), hashBasedSnapshot_exports));
+              await hashBasedSnapshotManager2.backupFile(
+                context2.sessionId,
+                context2.messageIndex,
+                filePath,
+                this.basePath,
+                true,
+                // File existed
+                content
+              );
+            }
+          } catch (backupError) {
+          }
           if (startLine < 1 || endLine < 1) {
             throw new Error("Line numbers must be greater than 0");
           }
@@ -354055,12 +354501,12 @@ ${formattedDiagnostics}`;
             const lineNum = contextStart + idx2;
             return `${lineNum}\u2192${normalizeForDisplay(line)}`;
           }).join("\n");
-          await fs16.writeFile(fullPath, modifiedLines.join("\n"), "utf-8");
+          await fs17.writeFile(fullPath, modifiedLines.join("\n"), "utf-8");
           let finalLines = modifiedLines;
           let finalTotalLines = newTotalLines;
           let finalContextEnd = newContextEnd;
           let finalContextContent = newContextContent;
-          const fileExtension = path17.extname(fullPath).toLowerCase();
+          const fileExtension = path19.extname(fullPath).toLowerCase();
           const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
           if (shouldFormat) {
             try {
@@ -354070,7 +354516,7 @@ ${formattedDiagnostics}`;
                 filepath: fullPath,
                 ...prettierConfig
               });
-              await fs16.writeFile(fullPath, formattedContent, "utf-8");
+              await fs17.writeFile(fullPath, formattedContent, "utf-8");
               finalLines = formattedContent.split("\n");
               finalTotalLines = finalLines.length;
               finalContextEnd = Math.min(finalTotalLines, contextStart + (newContextEnd - contextStart));
@@ -354186,13 +354632,13 @@ ${formattedDiagnostics}`;
        * @private
        */
       resolvePath(filePath, contextPath) {
-        const isAbs = path17.isAbsolute(filePath);
+        const isAbs = path19.isAbsolute(filePath);
         if (isAbs) {
           return resolve4(filePath);
         }
         const relativePath = filePath.replace(/^[\/\\]+/, "");
-        if (contextPath && path17.isAbsolute(contextPath)) {
-          return resolve4(path17.dirname(contextPath), relativePath);
+        if (contextPath && path19.isAbsolute(contextPath)) {
+          return resolve4(path19.dirname(contextPath), relativePath);
         }
         return resolve4(this.basePath, relativePath);
       }
@@ -355607,8 +356053,8 @@ var init_fzf_es = __esm({
 });
 
 // dist/mcp/utils/aceCodeSearch/filesystem.utils.js
-import { promises as fs17 } from "fs";
-import * as path18 from "path";
+import { promises as fs18 } from "fs";
+import * as path20 from "path";
 function shouldExcludeDirectory(dirName, fullPath, basePath, customExcludes, regexCache) {
   if (DEFAULT_EXCLUDES.includes(dirName)) {
     return true;
@@ -355616,7 +356062,7 @@ function shouldExcludeDirectory(dirName, fullPath, basePath, customExcludes, reg
   if (dirName.startsWith(".")) {
     return true;
   }
-  const relativePath = path18.relative(basePath, fullPath);
+  const relativePath = path20.relative(basePath, fullPath);
   for (const pattern of customExcludes) {
     if (pattern.includes("*")) {
       let regex2 = regexCache.get(pattern);
@@ -355653,7 +356099,7 @@ function shouldExcludeFile(fileName, fullPath, basePath, customExcludes, regexCa
       return true;
     }
   }
-  const relativePath = path18.relative(basePath, fullPath);
+  const relativePath = path20.relative(basePath, fullPath);
   for (const pattern of customExcludes) {
     if (pattern.endsWith("/")) {
       continue;
@@ -355681,9 +356127,9 @@ function shouldExcludeFile(fileName, fullPath, basePath, customExcludes, regexCa
 }
 async function loadExclusionPatterns(basePath) {
   const patterns = [];
-  const gitignorePath = path18.join(basePath, ".gitignore");
+  const gitignorePath = path20.join(basePath, ".gitignore");
   try {
-    const gitignoreContent = await fs17.readFile(gitignorePath, "utf-8");
+    const gitignoreContent = await fs18.readFile(gitignorePath, "utf-8");
     const lines = gitignoreContent.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -355696,9 +356142,9 @@ async function loadExclusionPatterns(basePath) {
     }
   } catch {
   }
-  const snowignorePath = path18.join(basePath, ".snowignore");
+  const snowignorePath = path20.join(basePath, ".snowignore");
   try {
-    const snowignoreContent = await fs17.readFile(snowignorePath, "utf-8");
+    const snowignoreContent = await fs18.readFile(snowignorePath, "utf-8");
     const lines = snowignoreContent.split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
@@ -355714,13 +356160,13 @@ async function loadExclusionPatterns(basePath) {
   return patterns;
 }
 async function readFileWithCache(filePath, fileContentCache, maxCacheSize = 50) {
-  const stats = await fs17.stat(filePath);
+  const stats = await fs18.stat(filePath);
   const mtime = stats.mtimeMs;
   const cached = fileContentCache.get(filePath);
   if (cached && cached.mtime === mtime) {
     return cached.content;
   }
-  const content = await fs17.readFile(filePath, "utf-8");
+  const content = await fs18.readFile(filePath, "utf-8");
   if (fileContentCache.size >= maxCacheSize) {
     const firstKey = fileContentCache.keys().next().value;
     if (firstKey) {
@@ -355754,7 +356200,7 @@ var init_filesystem_utils = __esm({
 // dist/mcp/utils/aceCodeSearch/search.utils.js
 import { spawn as spawn2 } from "child_process";
 import { EOL } from "os";
-import * as path19 from "path";
+import * as path21 from "path";
 function isCommandAvailable(command) {
   return new Promise((resolve10) => {
     try {
@@ -355796,10 +356242,10 @@ function parseGrepOutput(output2, basePath) {
     const lineNumber = parseInt(lineNumberStr, 10);
     if (isNaN(lineNumber))
       continue;
-    const absoluteFilePath = path19.resolve(basePath, filePathRaw);
-    const relativeFilePath = path19.relative(basePath, absoluteFilePath);
+    const absoluteFilePath = path21.resolve(basePath, filePathRaw);
+    const relativeFilePath = path21.relative(basePath, absoluteFilePath);
     results.push({
-      filePath: relativeFilePath || path19.basename(absoluteFilePath),
+      filePath: relativeFilePath || path21.basename(absoluteFilePath),
       line: lineNumber,
       column: 1,
       // grep doesn't provide column info, default to 1
@@ -355842,8 +356288,8 @@ __export(aceCodeSearch_exports, {
   aceCodeSearchService: () => aceCodeSearchService,
   mcpTools: () => mcpTools3
 });
-import { promises as fs18 } from "fs";
-import * as path20 from "path";
+import { promises as fs19 } from "fs";
+import * as path22 from "path";
 import { spawn as spawn3 } from "child_process";
 var ACECodeSearchService, aceCodeSearchService, mcpTools3;
 var init_aceCodeSearch = __esm({
@@ -355918,7 +356364,7 @@ var init_aceCodeSearch = __esm({
           writable: true,
           value: /* @__PURE__ */ new Map()
         });
-        this.basePath = path20.resolve(basePath);
+        this.basePath = path22.resolve(basePath);
       }
       /**
        * Load custom exclusion patterns from .gitignore and .snowignore
@@ -355934,8 +356380,8 @@ var init_aceCodeSearch = __esm({
        */
       async isGitRepository(directory = this.basePath) {
         try {
-          const gitDir = path20.join(directory, ".git");
-          const stats = await fs18.stat(gitDir);
+          const gitDir = path22.join(directory, ".git");
+          const stats = await fs19.stat(gitDir);
           return stats.isDirectory();
         } catch {
           return false;
@@ -355959,9 +356405,9 @@ var init_aceCodeSearch = __esm({
         const filesToProcess = [];
         const searchInDirectory = async (dirPath) => {
           try {
-            const entries = await fs18.readdir(dirPath, { withFileTypes: true });
+            const entries = await fs19.readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
-              const fullPath = path20.join(dirPath, entry.name);
+              const fullPath = path22.join(dirPath, entry.name);
               if (entry.isDirectory()) {
                 if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                   continue;
@@ -355971,7 +356417,7 @@ var init_aceCodeSearch = __esm({
                 const language = detectLanguage(fullPath);
                 if (language) {
                   try {
-                    const stats = await fs18.stat(fullPath);
+                    const stats = await fs19.stat(fullPath);
                     const currentMtime = stats.mtimeMs;
                     const cachedMtime = this.fileModTimes.get(fullPath);
                     if (cachedMtime === void 0 || currentMtime > cachedMtime) {
@@ -356010,7 +356456,7 @@ var init_aceCodeSearch = __esm({
         }
         for (const cachedPath of Array.from(this.indexCache.keys())) {
           try {
-            await fs18.access(cachedPath);
+            await fs19.access(cachedPath);
           } catch {
             this.indexCache.delete(cachedPath);
             this.fileModTimes.delete(cachedPath);
@@ -356168,13 +356614,13 @@ var init_aceCodeSearch = __esm({
             return;
           }
           try {
-            const entries = await fs18.readdir(dirPath, { withFileTypes: true });
+            const entries = await fs19.readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
               if (shouldStop || references.length >= maxResults) {
                 shouldStop = true;
                 return;
               }
-              const fullPath = path20.join(dirPath, entry.name);
+              const fullPath = path22.join(dirPath, entry.name);
               if (entry.isDirectory()) {
                 if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                   continue;
@@ -356215,7 +356661,7 @@ var init_aceCodeSearch = __esm({
                         }
                         references.push({
                           symbol: symbolName,
-                          filePath: path20.relative(this.basePath, fullPath),
+                          filePath: path22.relative(this.basePath, fullPath),
                           line: i + 1,
                           column: match2.index + 1,
                           context: getContext(lines, i, 1),
@@ -356240,7 +356686,7 @@ var init_aceCodeSearch = __esm({
       async findDefinition(symbolName, contextFile) {
         await this.buildIndex();
         if (contextFile) {
-          const fullPath = path20.resolve(this.basePath, contextFile);
+          const fullPath = path22.resolve(this.basePath, contextFile);
           const fileSymbols = this.indexCache.get(fullPath);
           if (fileSymbols) {
             const symbol = fileSymbols.find((s) => s.name === symbolName && (s.type === "function" || s.type === "class" || s.type === "variable"));
@@ -356433,11 +356879,11 @@ var init_aceCodeSearch = __esm({
           if (results.length >= maxResults)
             return;
           try {
-            const entries = await fs18.readdir(dirPath, { withFileTypes: true });
+            const entries = await fs19.readdir(dirPath, { withFileTypes: true });
             for (const entry of entries) {
               if (results.length >= maxResults)
                 break;
-              const fullPath = path20.join(dirPath, entry.name);
+              const fullPath = path22.join(dirPath, entry.name);
               if (entry.isDirectory()) {
                 if (shouldExcludeDirectory(entry.name, fullPath, this.basePath, this.customExcludes, this.regexCache)) {
                   continue;
@@ -356445,17 +356891,17 @@ var init_aceCodeSearch = __esm({
                 await searchInDirectory(fullPath);
               } else if (entry.isFile()) {
                 if (globRegex) {
-                  const relativePath = path20.relative(this.basePath, fullPath).replace(/\\/g, "/");
+                  const relativePath = path22.relative(this.basePath, fullPath).replace(/\\/g, "/");
                   if (!globRegex.test(relativePath)) {
                     continue;
                   }
                 }
-                const ext = path20.extname(entry.name).toLowerCase();
+                const ext = path22.extname(entry.name).toLowerCase();
                 if (binaryExts.has(ext)) {
                   continue;
                 }
                 try {
-                  const content = await fs18.readFile(fullPath, "utf-8");
+                  const content = await fs19.readFile(fullPath, "utf-8");
                   const lines = content.split("\n");
                   for (let i = 0; i < lines.length; i++) {
                     if (results.length >= maxResults)
@@ -356467,7 +356913,7 @@ var init_aceCodeSearch = __esm({
                     const match2 = searchRegex.exec(line);
                     if (match2) {
                       results.push({
-                        filePath: path20.relative(this.basePath, fullPath),
+                        filePath: path22.relative(this.basePath, fullPath),
                         line: i + 1,
                         column: match2.index + 1,
                         content: line.trim()
@@ -356527,8 +356973,8 @@ var init_aceCodeSearch = __esm({
         const recentThreshold = 24 * 60 * 60 * 1e3;
         const uniqueFiles = Array.from(new Set(results.map((r) => r.filePath)));
         const statResults = await Promise.allSettled(uniqueFiles.map(async (filePath) => {
-          const fullPath = path20.resolve(this.basePath, filePath);
-          const stats = await fs18.stat(fullPath);
+          const fullPath = path22.resolve(this.basePath, filePath);
+          const stats = await fs19.stat(fullPath);
           return { filePath, mtimeMs: stats.mtimeMs };
         }));
         const fileModTimes = /* @__PURE__ */ new Map();
@@ -356557,9 +357003,9 @@ var init_aceCodeSearch = __esm({
        * Get code outline for a file (all symbols in the file)
        */
       async getFileOutline(filePath, options3) {
-        const fullPath = path20.resolve(this.basePath, filePath);
+        const fullPath = path22.resolve(this.basePath, filePath);
         try {
-          const content = await fs18.readFile(fullPath, "utf-8");
+          const content = await fs19.readFile(fullPath, "utf-8");
           let symbols = await parseFileSymbols(fullPath, content, this.basePath);
           if ((options3 == null ? void 0 : options3.symbolTypes) && options3.symbolTypes.length > 0) {
             symbols = symbols.filter((s) => options3.symbolTypes.includes(s.type));
@@ -359435,12 +359881,12 @@ var init_disposable = __esm({
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js
-var EventEmitter4;
+var EventEmitter5;
 var init_EventEmitter = __esm({
   "node_modules/puppeteer-core/lib/esm/puppeteer/common/EventEmitter.js"() {
     init_mitt();
     init_disposable();
-    EventEmitter4 = class {
+    EventEmitter5 = class {
       #emitter;
       #handlers = /* @__PURE__ */ new Map();
       /**
@@ -360743,7 +361189,7 @@ var init_Browser = __esm({
       // chrome-specific permissions we have.
       ["midi-sysex", "midiSysex"]
     ]);
-    Browser = class extends EventEmitter4 {
+    Browser = class extends EventEmitter5 {
       /**
        * @internal
        */
@@ -361015,7 +361461,7 @@ var init_BrowserContext = __esm({
     init_util2();
     init_disposable();
     init_Mutex();
-    BrowserContext = class extends EventEmitter4 {
+    BrowserContext = class extends EventEmitter5 {
       /**
        * @internal
        */
@@ -361168,7 +361614,7 @@ var init_CDPSession = __esm({
       CDPSessionEvent2.SessionAttached = "sessionattached";
       CDPSessionEvent2.SessionDetached = "sessiondetached";
     })(CDPSessionEvent || (CDPSessionEvent = {}));
-    CDPSession = class extends EventEmitter4 {
+    CDPSession = class extends EventEmitter5 {
       /**
        * @internal
        */
@@ -362849,7 +363295,7 @@ var init_locators = __esm({
     (function(LocatorEvent2) {
       LocatorEvent2["Action"] = "action";
     })(LocatorEvent || (LocatorEvent = {}));
-    Locator = class extends EventEmitter4 {
+    Locator = class extends EventEmitter5 {
       /**
        * Creates a race between multiple locators trying to locate elements in
        * parallel but ensures that only a single element receives the action.
@@ -364891,7 +365337,7 @@ var init_Frame = __esm({
     });
     Frame = (() => {
       var __document, _Frame_instances, document_fn, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _frameElement_decorators;
       let _evaluateHandle_decorators;
@@ -366317,7 +366763,7 @@ var init_Page = __esm({
     });
     Page = (() => {
       var _requestHandlers, _inflight$, _screencastSessionCount, _startScreencastPromise, _Page_instances, getNativePixelDimensions_fn, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _screenshot_decorators;
       return _a21 = class extends _classSuper {
@@ -367895,7 +368341,7 @@ var init_WebWorker = __esm({
     init_EventEmitter();
     init_TimeoutSettings();
     init_util2();
-    WebWorker = class extends EventEmitter4 {
+    WebWorker = class extends EventEmitter5 {
       /**
        * @internal
        */
@@ -369028,7 +369474,7 @@ var init_Connection = __esm({
     init_CdpSession();
     debugProtocolSend = debug("puppeteer:protocol:SEND \u25BA");
     debugProtocolReceive = debug("puppeteer:protocol:RECV \u25C0");
-    Connection = class extends EventEmitter4 {
+    Connection = class extends EventEmitter5 {
       #url;
       #transport;
       #delay;
@@ -369385,7 +369831,7 @@ var init_Coverage = __esm({
         this.#scriptURLs.clear();
         this.#scriptSources.clear();
         this.#subscriptions = new DisposableStack();
-        const clientEmitter = this.#subscriptions.use(new EventEmitter4(this.#client));
+        const clientEmitter = this.#subscriptions.use(new EventEmitter5(this.#client));
         clientEmitter.on("Debugger.scriptParsed", this.#onScriptParsed.bind(this));
         clientEmitter.on("Runtime.executionContextsCleared", this.#onExecutionContextsCleared.bind(this));
         await Promise.all([
@@ -369482,7 +369928,7 @@ var init_Coverage = __esm({
         this.#stylesheetURLs.clear();
         this.#stylesheetSources.clear();
         this.#eventListeners = new DisposableStack();
-        const clientEmitter = this.#eventListeners.use(new EventEmitter4(this.#client));
+        const clientEmitter = this.#eventListeners.use(new EventEmitter5(this.#client));
         clientEmitter.on("CSS.styleSheetAdded", this.#onStyleSheet.bind(this));
         clientEmitter.on("Runtime.executionContextsCleared", this.#onExecutionContextsCleared.bind(this));
         await Promise.all([
@@ -370747,7 +371193,7 @@ var init_ExecutionContext = __esm({
         return elements;
       }, ...await AsyncIterableUtil.collect(results));
     }), "");
-    ExecutionContext = class extends EventEmitter4 {
+    ExecutionContext = class extends EventEmitter5 {
       #client;
       #world;
       #id;
@@ -370761,7 +371207,7 @@ var init_ExecutionContext = __esm({
         if (contextPayload.name) {
           this.#name = contextPayload.name;
         }
-        const clientEmitter = this.#disposables.use(new EventEmitter4(this.#client));
+        const clientEmitter = this.#disposables.use(new EventEmitter5(this.#client));
         clientEmitter.on("Runtime.bindingCalled", this.#onBindingCalled.bind(this));
         clientEmitter.on("Runtime.executionContextDestroyed", async (event) => {
           if (event.executionContextId === this.#id) {
@@ -371129,7 +371575,7 @@ var init_IsolatedWorld = __esm({
     init_JSHandle2();
     IsolatedWorld = class extends Realm {
       #context;
-      #emitter = new EventEmitter4();
+      #emitter = new EventEmitter5();
       #frameOrWorker;
       constructor(frameOrWorker, timeoutSettings) {
         super(timeoutSettings);
@@ -371321,15 +371767,15 @@ var init_LifecycleWatcher = __esm({
         });
         this.#frame = frame;
         this.#timeout = timeout2;
-        const frameManagerEmitter = this.#subscriptions.use(new EventEmitter4(frame._frameManager));
+        const frameManagerEmitter = this.#subscriptions.use(new EventEmitter5(frame._frameManager));
         frameManagerEmitter.on(FrameManagerEvent.LifecycleEvent, this.#checkLifecycleComplete.bind(this));
-        const frameEmitter = this.#subscriptions.use(new EventEmitter4(frame));
+        const frameEmitter = this.#subscriptions.use(new EventEmitter5(frame));
         frameEmitter.on(FrameEvent.FrameNavigatedWithinDocument, this.#navigatedWithinDocument.bind(this));
         frameEmitter.on(FrameEvent.FrameNavigated, this.#navigated.bind(this));
         frameEmitter.on(FrameEvent.FrameSwapped, this.#frameSwapped.bind(this));
         frameEmitter.on(FrameEvent.FrameSwappedByActivation, this.#frameSwapped.bind(this));
         frameEmitter.on(FrameEvent.FrameDetached, this.#onFrameDetached.bind(this));
-        const networkManagerEmitter = this.#subscriptions.use(new EventEmitter4(networkManager));
+        const networkManagerEmitter = this.#subscriptions.use(new EventEmitter5(networkManager));
         networkManagerEmitter.on(NetworkManagerEvent.Request, this.#onRequest.bind(this));
         networkManagerEmitter.on(NetworkManagerEvent.Response, this.#onResponse.bind(this));
         networkManagerEmitter.on(NetworkManagerEvent.RequestFailed, this.#onRequestFailed.bind(this));
@@ -372381,7 +372827,7 @@ var init_NetworkManager = __esm({
     init_HTTPRequest2();
     init_HTTPResponse2();
     init_NetworkEventManager();
-    NetworkManager2 = class extends EventEmitter4 {
+    NetworkManager2 = class extends EventEmitter5 {
       #frameManager;
       #networkEventManager = new NetworkEventManager();
       #extraHTTPHeaders;
@@ -372422,7 +372868,7 @@ var init_NetworkManager = __esm({
         }
         const subscriptions = new DisposableStack();
         this.#clients.set(client, subscriptions);
-        const clientEmitter = subscriptions.use(new EventEmitter4(client));
+        const clientEmitter = subscriptions.use(new EventEmitter5(client));
         for (const [event, handler] of this.#handlers) {
           clientEmitter.on(event, (arg) => {
             return handler.bind(this)(client, arg);
@@ -372900,7 +373346,7 @@ var init_FrameManager = __esm({
     init_IsolatedWorlds();
     init_NetworkManager();
     TIME_FOR_WAITING_FOR_SWAP = 100;
-    FrameManager = class extends EventEmitter4 {
+    FrameManager = class extends EventEmitter5 {
       #page;
       #networkManager;
       #timeoutSettings;
@@ -374512,7 +374958,7 @@ var init_Page2 = __esm({
         this.#tracing = new Tracing(client);
         this.#coverage = new Coverage(client);
         this.#viewport = null;
-        const frameManagerEmitter = new EventEmitter4(this.#frameManager);
+        const frameManagerEmitter = new EventEmitter5(this.#frameManager);
         frameManagerEmitter.on(FrameManagerEvent.FrameAttached, (frame) => {
           this.emit("frameattached", frame);
         });
@@ -374528,7 +374974,7 @@ var init_Page2 = __esm({
         frameManagerEmitter.on(FrameManagerEvent.BindingCalled, ([world, event]) => {
           void this.#onBindingCalled(world, event);
         });
-        const networkManagerEmitter = new EventEmitter4(this.#frameManager.networkManager);
+        const networkManagerEmitter = new EventEmitter5(this.#frameManager.networkManager);
         networkManagerEmitter.on(NetworkManagerEvent.Request, (request3) => {
           this.emit("request", request3);
         });
@@ -374600,7 +375046,7 @@ var init_Page2 = __esm({
        * during a navigation to a prerended page.
        */
       #setupPrimaryTargetListeners() {
-        const clientEmitter = new EventEmitter4(this.#primaryTargetClient);
+        const clientEmitter = new EventEmitter5(this.#primaryTargetClient);
         clientEmitter.on(CDPSessionEvent.Ready, this.#onAttachedToTarget);
         clientEmitter.on(CDPSessionEvent.Disconnected, () => {
           this.#sessionCloseDeferred.reject(new TargetCloseError("Target closed"));
@@ -375669,7 +376115,7 @@ var init_TargetManager = __esm({
     init_Deferred();
     init_CdpSession();
     init_Target2();
-    TargetManager = class extends EventEmitter4 {
+    TargetManager = class extends EventEmitter5 {
       #connection;
       /**
        * Keeps track of the following events: 'Target.targetCreated',
@@ -377992,7 +378438,7 @@ var require_EventEmitter = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.EventEmitter = void 0;
     var mitt_1 = __importDefault2((init_mitt2(), __toCommonJS(mitt_exports)));
-    var EventEmitter9 = class {
+    var EventEmitter10 = class {
       #emitter = (0, mitt_1.default)();
       on(type, handler) {
         this.#emitter.on(type, handler);
@@ -378040,7 +378486,7 @@ var require_EventEmitter = __commonJS({
         return this;
       }
     };
-    exports2.EventEmitter = EventEmitter9;
+    exports2.EventEmitter = EventEmitter10;
   }
 });
 
@@ -389835,7 +390281,7 @@ var init_Connection2 = __esm({
     init_CDPSession2();
     debugProtocolSend2 = debug("puppeteer:webDriverBiDi:SEND \u25BA");
     debugProtocolReceive2 = debug("puppeteer:webDriverBiDi:RECV \u25C0");
-    BidiConnection = class extends EventEmitter4 {
+    BidiConnection = class extends EventEmitter5 {
       #url;
       #transport;
       #delay;
@@ -390144,7 +390590,7 @@ var init_Navigation = __esm({
     Navigation = (() => {
       var _request, _navigation, _browsingContext, _disposables, _id, _Navigation_instances, initialize_fn2, matches_fn, session_get, _a22;
       var _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       return _a22 = class extends _classSuper {
@@ -390181,7 +390627,7 @@ var init_Navigation = __esm({
           super[disposeSymbol]();
         }
       }, _request = new WeakMap(), _navigation = new WeakMap(), _browsingContext = new WeakMap(), _disposables = new WeakMap(), _id = new WeakMap(), _Navigation_instances = new WeakSet(), initialize_fn2 = function() {
-        const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _browsingContext)));
+        const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _browsingContext)));
         browsingContextEmitter.once("closed", () => {
           this.emit("failed", {
             url: __privateGet(this, _browsingContext).url,
@@ -390197,12 +390643,12 @@ var init_Navigation = __esm({
           }
           __privateSet(this, _request, request3);
           this.emit("request", request3);
-          const requestEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _request)));
+          const requestEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _request)));
           requestEmitter.on("redirect", (request4) => {
             __privateSet(this, _request, request4);
           });
         });
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _Navigation_instances, session_get)));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _Navigation_instances, session_get)));
         sessionEmitter.on("browsingContext.navigationStarted", (info2) => {
           if (info2.context !== __privateGet(this, _browsingContext).id || __privateGet(this, _navigation) !== void 0) {
             return;
@@ -390306,7 +390752,7 @@ var init_Realm2 = __esm({
     };
     Realm2 = (() => {
       var _reason, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       let _disown_decorators;
@@ -390404,11 +390850,11 @@ var init_Realm2 = __esm({
         this.sandbox = sandbox;
       }
       #initialize() {
-        const browsingContextEmitter = this.disposables.use(new EventEmitter4(this.browsingContext));
+        const browsingContextEmitter = this.disposables.use(new EventEmitter5(this.browsingContext));
         browsingContextEmitter.on("closed", ({ reason }) => {
           this.dispose(reason);
         });
-        const sessionEmitter = this.disposables.use(new EventEmitter4(this.session));
+        const sessionEmitter = this.disposables.use(new EventEmitter5(this.session));
         sessionEmitter.on("script.realmCreated", (info2) => {
           if (info2.type !== "window" || info2.context !== this.browsingContext.id || info2.sandbox !== this.sandbox) {
             return;
@@ -390427,7 +390873,7 @@ var init_Realm2 = __esm({
           }
           const realm = DedicatedWorkerRealm.from(this, info2.realm, info2.origin);
           this.#workers.set(realm.id, realm);
-          const realmEmitter = this.disposables.use(new EventEmitter4(realm));
+          const realmEmitter = this.disposables.use(new EventEmitter5(realm));
           realmEmitter.once("destroyed", () => {
             realmEmitter.removeAllListeners();
             this.#workers.delete(realm.id);
@@ -390455,7 +390901,7 @@ var init_Realm2 = __esm({
         this.owners = /* @__PURE__ */ new Set([owner]);
       }
       #initialize() {
-        const sessionEmitter = this.disposables.use(new EventEmitter4(this.session));
+        const sessionEmitter = this.disposables.use(new EventEmitter5(this.session));
         sessionEmitter.on("script.realmDestroyed", (info2) => {
           if (info2.realm !== this.id) {
             return;
@@ -390471,7 +390917,7 @@ var init_Realm2 = __esm({
           }
           const realm = _a18.from(this, info2.realm, info2.origin);
           this.#workers.set(realm.id, realm);
-          const realmEmitter = this.disposables.use(new EventEmitter4(realm));
+          const realmEmitter = this.disposables.use(new EventEmitter5(realm));
           realmEmitter.once("destroyed", () => {
             this.#workers.delete(realm.id);
           });
@@ -390496,7 +390942,7 @@ var init_Realm2 = __esm({
         this.browser = browser;
       }
       #initialize() {
-        const sessionEmitter = this.disposables.use(new EventEmitter4(this.session));
+        const sessionEmitter = this.disposables.use(new EventEmitter5(this.session));
         sessionEmitter.on("script.realmDestroyed", (info2) => {
           if (info2.realm !== this.id) {
             return;
@@ -390512,7 +390958,7 @@ var init_Realm2 = __esm({
           }
           const realm = DedicatedWorkerRealm.from(this, info2.realm, info2.origin);
           this.#workers.set(realm.id, realm);
-          const realmEmitter = this.disposables.use(new EventEmitter4(realm));
+          const realmEmitter = this.disposables.use(new EventEmitter5(realm));
           realmEmitter.once("destroyed", () => {
             this.#workers.delete(realm.id);
           });
@@ -390577,7 +391023,7 @@ var init_Request = __esm({
     Request = (() => {
       var _responseContentPromise, _requestBodyPromise, _error, _redirect, _response, _browsingContext, _disposables, _event, _Request_instances, initialize_fn2, session_get, _a22;
       var _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       return _a22 = class extends _classSuper {
@@ -390747,13 +391193,13 @@ var init_Request = __esm({
           return __privateGet(this, _event).request.timings;
         }
       }, _responseContentPromise = new WeakMap(), _requestBodyPromise = new WeakMap(), _error = new WeakMap(), _redirect = new WeakMap(), _response = new WeakMap(), _browsingContext = new WeakMap(), _disposables = new WeakMap(), _event = new WeakMap(), _Request_instances = new WeakSet(), initialize_fn2 = function() {
-        const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _browsingContext)));
+        const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _browsingContext)));
         browsingContextEmitter.once("closed", ({ reason }) => {
           __privateSet(this, _error, reason);
           this.emit("error", __privateGet(this, _error));
           this.dispose();
         });
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _Request_instances, session_get)));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _Request_instances, session_get)));
         sessionEmitter.on("network.beforeRequestSent", (event) => {
           if (event.context !== __privateGet(this, _browsingContext).id || event.request.request !== this.id) {
             return;
@@ -390858,7 +391304,7 @@ var init_UserPrompt = __esm({
     };
     UserPrompt = (() => {
       var _reason, _result, _disposables, _UserPrompt_instances, initialize_fn2, session_get, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       let _handle_decorators;
@@ -390915,11 +391361,11 @@ var init_UserPrompt = __esm({
           super[disposeSymbol]();
         }
       }, _reason = new WeakMap(), _result = new WeakMap(), _disposables = new WeakMap(), _UserPrompt_instances = new WeakSet(), initialize_fn2 = function() {
-        const browserContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(this.browsingContext));
+        const browserContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(this.browsingContext));
         browserContextEmitter.once("closed", ({ reason }) => {
           this.dispose(`User prompt already closed: ${reason}`);
         });
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _UserPrompt_instances, session_get)));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _UserPrompt_instances, session_get)));
         sessionEmitter.on("browsingContext.userPromptClosed", (parameters) => {
           if (parameters.context !== this.browsingContext.id) {
             return;
@@ -390993,7 +391439,7 @@ var init_BrowsingContext = __esm({
     BrowsingContext = (() => {
       var _navigation, _reason, _url2, _children, _disposables, _realms, _requests, _emulationState, _BrowsingContext_instances, initialize_fn2, session_get, createWindowRealm_fn, _a22;
       var _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       let _activate_decorators;
@@ -391321,11 +391767,11 @@ var init_BrowsingContext = __esm({
           return __privateGet(this, _emulationState).javaScriptEnabled;
         }
       }, _navigation = new WeakMap(), _reason = new WeakMap(), _url2 = new WeakMap(), _children = new WeakMap(), _disposables = new WeakMap(), _realms = new WeakMap(), _requests = new WeakMap(), _emulationState = new WeakMap(), _BrowsingContext_instances = new WeakSet(), initialize_fn2 = function() {
-        const userContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(this.userContext));
+        const userContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(this.userContext));
         userContextEmitter.once("closed", ({ reason }) => {
           this.dispose(`Browsing context already closed: ${reason}`);
         });
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _BrowsingContext_instances, session_get)));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _BrowsingContext_instances, session_get)));
         sessionEmitter.on("input.fileDialogOpened", (info2) => {
           if (this.id !== info2.context) {
             return;
@@ -391338,7 +391784,7 @@ var init_BrowsingContext = __esm({
           }
           const browsingContext = _a22.from(this.userContext, this, info2.context, info2.url, info2.originalOpener);
           __privateGet(this, _children).set(info2.context, browsingContext);
-          const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(browsingContext));
+          const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(browsingContext));
           browsingContextEmitter.once("closed", () => {
             browsingContextEmitter.removeAllListeners();
             __privateGet(this, _children).delete(browsingContext.id);
@@ -391385,7 +391831,7 @@ var init_BrowsingContext = __esm({
             return;
           }
           __privateSet(this, _navigation, Navigation.from(this));
-          const navigationEmitter2 = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _navigation)));
+          const navigationEmitter2 = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _navigation)));
           for (const eventName of ["fragment", "failed", "aborted"]) {
             navigationEmitter2.once(eventName, ({ url }) => {
               navigationEmitter2[disposeSymbol]();
@@ -391517,7 +391963,7 @@ var init_UserContext = __esm({
     };
     UserContext = (() => {
       var _a21, _reason, _browsingContexts, _disposables, _id, _UserContext_instances, initialize_fn2, session_get;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       let _createBrowsingContext_decorators;
@@ -391627,14 +392073,14 @@ var init_UserContext = __esm({
           super[disposeSymbol]();
         }
       }, _reason = new WeakMap(), _browsingContexts = new WeakMap(), _disposables = new WeakMap(), _id = new WeakMap(), _UserContext_instances = new WeakSet(), initialize_fn2 = function() {
-        const browserEmitter = __privateGet(this, _disposables).use(new EventEmitter4(this.browser));
+        const browserEmitter = __privateGet(this, _disposables).use(new EventEmitter5(this.browser));
         browserEmitter.once("closed", ({ reason }) => {
           this.dispose(`User context was closed: ${reason}`);
         });
         browserEmitter.once("disconnected", ({ reason }) => {
           this.dispose(`User context was closed: ${reason}`);
         });
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(__privateGet(this, _UserContext_instances, session_get)));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(__privateGet(this, _UserContext_instances, session_get)));
         sessionEmitter.on("browsingContext.contextCreated", (info2) => {
           if (info2.parent) {
             return;
@@ -391644,7 +392090,7 @@ var init_UserContext = __esm({
           }
           const browsingContext = BrowsingContext.from(this, void 0, info2.context, info2.url, info2.originalOpener);
           __privateGet(this, _browsingContexts).set(browsingContext.id, browsingContext);
-          const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(browsingContext));
+          const browsingContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(browsingContext));
           browsingContextEmitter.on("closed", () => {
             browsingContextEmitter.removeAllListeners();
             __privateGet(this, _browsingContexts).delete(browsingContext.id);
@@ -392151,7 +392597,7 @@ var init_ExposedFunction = __esm({
             ownership: "root"
           }
         };
-        const connectionEmitter = this.#disposables.use(new EventEmitter4(connection));
+        const connectionEmitter = this.#disposables.use(new EventEmitter5(connection));
         connectionEmitter.on("script.message", this.#handleMessage);
         const functionDeclaration = stringifyFunction(interpolateFunction((callback) => {
           Object.assign(globalThis, {
@@ -394553,7 +394999,7 @@ var init_Page3 = __esm({
         constructor(browserContext, browsingContext) {
           super();
           __privateAdd(this, _BidiPage_instances);
-          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers17(this, _trustedEmitter_initializers, new EventEmitter4()));
+          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers17(this, _trustedEmitter_initializers, new EventEmitter5()));
           __privateAdd(this, _browserContext, __runInitializers17(this, _trustedEmitter_extraInitializers));
           __privateAdd(this, _frame);
           __privateAdd(this, _viewport, null);
@@ -395454,7 +395900,7 @@ var init_BrowserContext3 = __esm({
         constructor(browser, userContext, options3) {
           super();
           __privateAdd(this, _BidiBrowserContext_instances);
-          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers18(this, _trustedEmitter_initializers, new EventEmitter4()));
+          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers18(this, _trustedEmitter_initializers, new EventEmitter5()));
           __privateAdd(this, _browser, __runInitializers18(this, _trustedEmitter_extraInitializers));
           __privateAdd(this, _defaultViewport);
           // This is public because of cookies.
@@ -395786,7 +396232,7 @@ var init_Browser3 = __esm({
     });
     Browser2 = (() => {
       var _closed, _reason, _disposables, _userContexts, _sharedWorkers, _Browser_instances, initialize_fn2, syncUserContexts_fn, syncBrowsingContexts_fn, createUserContext_fn, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _dispose_decorators;
       let _close_decorators;
@@ -395929,7 +396375,7 @@ var init_Browser3 = __esm({
           super[disposeSymbol]();
         }
       }, _closed = new WeakMap(), _reason = new WeakMap(), _disposables = new WeakMap(), _userContexts = new WeakMap(), _sharedWorkers = new WeakMap(), _Browser_instances = new WeakSet(), initialize_fn2 = async function() {
-        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter4(this.session));
+        const sessionEmitter = __privateGet(this, _disposables).use(new EventEmitter5(this.session));
         sessionEmitter.once("ended", ({ reason }) => {
           this.dispose(reason);
         });
@@ -395952,7 +396398,7 @@ var init_Browser3 = __esm({
         {
           const env_1 = { stack: [], error: void 0, hasError: false };
           try {
-            const sessionEmitter = __addDisposableResource19(env_1, new EventEmitter4(this.session), false);
+            const sessionEmitter = __addDisposableResource19(env_1, new EventEmitter5(this.session), false);
             sessionEmitter.on("browsingContext.contextCreated", (info2) => {
               contextIds.add(info2.context);
             });
@@ -395976,7 +396422,7 @@ var init_Browser3 = __esm({
       }, createUserContext_fn = function(id) {
         const userContext = UserContext.create(this, id);
         __privateGet(this, _userContexts).set(userContext.id, userContext);
-        const userContextEmitter = __privateGet(this, _disposables).use(new EventEmitter4(userContext));
+        const userContextEmitter = __privateGet(this, _disposables).use(new EventEmitter5(userContext));
         userContextEmitter.once("closed", () => {
           userContextEmitter.removeAllListeners();
           __privateGet(this, _userContexts).delete(userContext.id);
@@ -396047,7 +396493,7 @@ var init_Session = __esm({
     };
     Session = (() => {
       var _reason, _disposables, _info, _connection_accessor_storage, _Session_instances, initialize_fn2, _a21;
-      let _classSuper = EventEmitter4;
+      let _classSuper = EventEmitter5;
       let _instanceExtraInitializers = [];
       let _connection_decorators;
       let _connection_initializers = [];
@@ -396242,7 +396688,7 @@ var init_Browser4 = __esm({
           super();
           __privateAdd(this, _BidiBrowser_instances);
           __publicField(this, "protocol", "webDriverBiDi");
-          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers21(this, _private_trustedEmitter_initializers, new EventEmitter4()));
+          __privateAdd(this, _trustedEmitter_accessor_storage, __runInitializers21(this, _private_trustedEmitter_initializers, new EventEmitter5()));
           __privateAdd(this, _process, __runInitializers21(this, _private_trustedEmitter_extraInitializers));
           __privateAdd(this, _closeCallback);
           __privateAdd(this, _browserCore);
@@ -424380,7 +424826,7 @@ var init_httpUtil = __esm({
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome.js
 import { execSync as execSync2 } from "node:child_process";
-import path21 from "node:path";
+import path23 from "node:path";
 function folder(platform5) {
   switch (platform5) {
     case BrowserPlatform.LINUX_ARM:
@@ -424406,13 +424852,13 @@ function relativeExecutablePath(platform5, _buildId) {
   switch (platform5) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path21.join("chrome-" + folder(platform5), "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing");
+      return path23.join("chrome-" + folder(platform5), "Google Chrome for Testing.app", "Contents", "MacOS", "Google Chrome for Testing");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      return path21.join("chrome-linux64", "chrome");
+      return path23.join("chrome-linux64", "chrome");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path21.join("chrome-" + folder(platform5), "chrome.exe");
+      return path23.join("chrome-" + folder(platform5), "chrome.exe");
   }
 }
 async function getLastKnownGoodReleaseForChannel(channel) {
@@ -424464,7 +424910,7 @@ function getChromeWindowsLocation(channel, locationsPrefixes) {
       break;
   }
   return [...locationsPrefixes.values()].map((l2) => {
-    return path21.win32.join(l2, suffix);
+    return path23.win32.join(l2, suffix);
   });
 }
 function getWslLocation(channel) {
@@ -424592,7 +425038,7 @@ var init_chrome = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chrome-headless-shell.js
-import path22 from "node:path";
+import path24 from "node:path";
 function folder2(platform5) {
   switch (platform5) {
     case BrowserPlatform.LINUX_ARM:
@@ -424622,13 +425068,13 @@ function relativeExecutablePath2(platform5, _buildId) {
   switch (platform5) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path22.join("chrome-headless-shell-" + folder2(platform5), "chrome-headless-shell");
+      return path24.join("chrome-headless-shell-" + folder2(platform5), "chrome-headless-shell");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      return path22.join("chrome-headless-shell-linux64", "chrome-headless-shell");
+      return path24.join("chrome-headless-shell-linux64", "chrome-headless-shell");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path22.join("chrome-headless-shell-" + folder2(platform5), "chrome-headless-shell.exe");
+      return path24.join("chrome-headless-shell-" + folder2(platform5), "chrome-headless-shell.exe");
   }
 }
 var init_chrome_headless_shell = __esm({
@@ -424639,7 +425085,7 @@ var init_chrome_headless_shell = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chromedriver.js
-import path23 from "node:path";
+import path25 from "node:path";
 function folder3(platform5) {
   switch (platform5) {
     case BrowserPlatform.LINUX_ARM:
@@ -424665,13 +425111,13 @@ function relativeExecutablePath3(platform5, _buildId) {
   switch (platform5) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path23.join("chromedriver-" + folder3(platform5), "chromedriver");
+      return path25.join("chromedriver-" + folder3(platform5), "chromedriver");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      return path23.join("chromedriver-linux64", "chromedriver");
+      return path25.join("chromedriver-linux64", "chromedriver");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path23.join("chromedriver-" + folder3(platform5), "chromedriver.exe");
+      return path25.join("chromedriver-" + folder3(platform5), "chromedriver.exe");
   }
 }
 var init_chromedriver = __esm({
@@ -424682,7 +425128,7 @@ var init_chromedriver = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/chromium.js
-import path24 from "node:path";
+import path26 from "node:path";
 function archive(platform5, buildId) {
   switch (platform5) {
     case BrowserPlatform.LINUX_ARM:
@@ -424721,13 +425167,13 @@ function relativeExecutablePath4(platform5, _buildId) {
   switch (platform5) {
     case BrowserPlatform.MAC:
     case BrowserPlatform.MAC_ARM:
-      return path24.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
+      return path26.join("chrome-mac", "Chromium.app", "Contents", "MacOS", "Chromium");
     case BrowserPlatform.LINUX_ARM:
     case BrowserPlatform.LINUX:
-      return path24.join("chrome-linux", "chrome");
+      return path26.join("chrome-linux", "chrome");
     case BrowserPlatform.WIN32:
     case BrowserPlatform.WIN64:
-      return path24.join("chrome-win", "chrome.exe");
+      return path26.join("chrome-win", "chrome.exe");
   }
 }
 async function resolveBuildId2(platform5) {
@@ -424744,8 +425190,8 @@ var init_chromium = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/browser-data/firefox.js
-import fs19 from "node:fs";
-import path25 from "node:path";
+import fs20 from "node:fs";
+import path27 from "node:path";
 function getFormat(buildId) {
   const majorVersion = Number(buildId.split(".").shift());
   return majorVersion >= 135 ? "xz" : "bz2";
@@ -424841,13 +425287,13 @@ function relativeExecutablePath5(platform5, buildId) {
       switch (platform5) {
         case BrowserPlatform.MAC_ARM:
         case BrowserPlatform.MAC:
-          return path25.join("Firefox Nightly.app", "Contents", "MacOS", "firefox");
+          return path27.join("Firefox Nightly.app", "Contents", "MacOS", "firefox");
         case BrowserPlatform.LINUX_ARM:
         case BrowserPlatform.LINUX:
-          return path25.join("firefox", "firefox");
+          return path27.join("firefox", "firefox");
         case BrowserPlatform.WIN32:
         case BrowserPlatform.WIN64:
-          return path25.join("firefox", "firefox.exe");
+          return path27.join("firefox", "firefox.exe");
       }
     case FirefoxChannel.BETA:
     case FirefoxChannel.DEVEDITION:
@@ -424856,13 +425302,13 @@ function relativeExecutablePath5(platform5, buildId) {
       switch (platform5) {
         case BrowserPlatform.MAC_ARM:
         case BrowserPlatform.MAC:
-          return path25.join("Firefox.app", "Contents", "MacOS", "firefox");
+          return path27.join("Firefox.app", "Contents", "MacOS", "firefox");
         case BrowserPlatform.LINUX_ARM:
         case BrowserPlatform.LINUX:
-          return path25.join("firefox", "firefox");
+          return path27.join("firefox", "firefox");
         case BrowserPlatform.WIN32:
         case BrowserPlatform.WIN64:
-          return path25.join("core", "firefox.exe");
+          return path27.join("core", "firefox.exe");
       }
   }
 }
@@ -424882,8 +425328,8 @@ async function resolveBuildId3(channel = FirefoxChannel.NIGHTLY) {
   return channel + "_" + version2;
 }
 async function createProfile2(options3) {
-  if (!fs19.existsSync(options3.path)) {
-    await fs19.promises.mkdir(options3.path, {
+  if (!fs20.existsSync(options3.path)) {
+    await fs20.promises.mkdir(options3.path, {
       recursive: true
     });
   }
@@ -425060,20 +425506,20 @@ function defaultProfilePreferences(extraPrefs) {
   return Object.assign(defaultPrefs, extraPrefs);
 }
 async function backupFile(input2) {
-  if (!fs19.existsSync(input2)) {
+  if (!fs20.existsSync(input2)) {
     return;
   }
-  await fs19.promises.copyFile(input2, input2 + ".puppeteer");
+  await fs20.promises.copyFile(input2, input2 + ".puppeteer");
 }
 async function syncPreferences(options3) {
-  const prefsPath = path25.join(options3.path, "prefs.js");
-  const userPath = path25.join(options3.path, "user.js");
+  const prefsPath = path27.join(options3.path, "prefs.js");
+  const userPath = path27.join(options3.path, "user.js");
   const lines = Object.entries(options3.preferences).map(([key, value]) => {
     return `user_pref(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
   });
   const result2 = await Promise.allSettled([
     backupFile(userPath).then(async () => {
-      await fs19.promises.writeFile(userPath, lines.join("\n"));
+      await fs20.promises.writeFile(userPath, lines.join("\n"));
     }),
     backupFile(prefsPath)
   ]);
@@ -425284,10 +425730,10 @@ var init_browser_data = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/detectPlatform.js
-import os8 from "node:os";
+import os9 from "node:os";
 function detectBrowserPlatform() {
-  const platform5 = os8.platform();
-  const arch = os8.arch();
+  const platform5 = os9.platform();
+  const arch = os9.arch();
   switch (platform5) {
     case "darwin":
       return arch === "arm64" ? BrowserPlatform.MAC_ARM : BrowserPlatform.MAC;
@@ -425295,7 +425741,7 @@ function detectBrowserPlatform() {
       return arch === "arm64" ? BrowserPlatform.LINUX_ARM : BrowserPlatform.LINUX;
     case "win32":
       return arch === "x64" || // Windows 11 for ARM supports x64 emulation
-      arch === "arm64" && isWindows11(os8.release()) ? BrowserPlatform.WIN64 : BrowserPlatform.WIN32;
+      arch === "arm64" && isWindows11(os9.release()) ? BrowserPlatform.WIN64 : BrowserPlatform.WIN32;
     default:
       return void 0;
   }
@@ -425317,11 +425763,11 @@ var init_detectPlatform = __esm({
 });
 
 // node_modules/@puppeteer/browsers/lib/esm/Cache.js
-import fs20 from "node:fs";
-import os9 from "node:os";
-import path26 from "node:path";
+import fs21 from "node:fs";
+import os10 from "node:os";
+import path28 from "node:path";
 function parseFolderPath(folderPath) {
-  const name = path26.basename(folderPath);
+  const name = path28.basename(folderPath);
   const splits = name.split("-");
   if (splits.length !== 2) {
     return;
@@ -425385,17 +425831,17 @@ var init_Cache = __esm({
         return this.#rootDir;
       }
       browserRoot(browser) {
-        return path26.join(this.#rootDir, browser);
+        return path28.join(this.#rootDir, browser);
       }
       metadataFile(browser) {
-        return path26.join(this.browserRoot(browser), ".metadata");
+        return path28.join(this.browserRoot(browser), ".metadata");
       }
       readMetadata(browser) {
         const metatadaPath = this.metadataFile(browser);
-        if (!fs20.existsSync(metatadaPath)) {
+        if (!fs21.existsSync(metatadaPath)) {
           return { aliases: {} };
         }
-        const data = JSON.parse(fs20.readFileSync(metatadaPath, "utf8"));
+        const data = JSON.parse(fs21.readFileSync(metatadaPath, "utf8"));
         if (typeof data !== "object") {
           throw new Error(".metadata is not an object");
         }
@@ -425403,8 +425849,8 @@ var init_Cache = __esm({
       }
       writeMetadata(browser, metadata) {
         const metatadaPath = this.metadataFile(browser);
-        fs20.mkdirSync(path26.dirname(metatadaPath), { recursive: true });
-        fs20.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
+        fs21.mkdirSync(path28.dirname(metatadaPath), { recursive: true });
+        fs21.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
       }
       resolveAlias(browser, alias) {
         const metadata = this.readMetadata(browser);
@@ -425414,10 +425860,10 @@ var init_Cache = __esm({
         return metadata.aliases[alias];
       }
       installationDir(browser, platform5, buildId) {
-        return path26.join(this.browserRoot(browser), `${platform5}-${buildId}`);
+        return path28.join(this.browserRoot(browser), `${platform5}-${buildId}`);
       }
       clear() {
-        fs20.rmSync(this.#rootDir, {
+        fs21.rmSync(this.#rootDir, {
           force: true,
           recursive: true,
           maxRetries: 10,
@@ -425431,7 +425877,7 @@ var init_Cache = __esm({
             delete metadata.aliases[alias];
           }
         }
-        fs20.rmSync(this.installationDir(browser, platform5, buildId), {
+        fs21.rmSync(this.installationDir(browser, platform5, buildId), {
           force: true,
           recursive: true,
           maxRetries: 10,
@@ -425439,17 +425885,17 @@ var init_Cache = __esm({
         });
       }
       getInstalledBrowsers() {
-        if (!fs20.existsSync(this.#rootDir)) {
+        if (!fs21.existsSync(this.#rootDir)) {
           return [];
         }
-        const types = fs20.readdirSync(this.#rootDir);
+        const types = fs21.readdirSync(this.#rootDir);
         const browsers = types.filter((t) => {
           return Object.values(Browser3).includes(t);
         });
         return browsers.flatMap((browser) => {
-          const files = fs20.readdirSync(this.browserRoot(browser));
+          const files = fs21.readdirSync(this.browserRoot(browser));
           return files.map((file) => {
-            const result2 = parseFolderPath(path26.join(this.browserRoot(browser), file));
+            const result2 = parseFolderPath(path28.join(this.browserRoot(browser), file));
             if (!result2) {
               return null;
             }
@@ -425462,7 +425908,7 @@ var init_Cache = __esm({
       computeExecutablePath(options3) {
         options3.platform ??= detectBrowserPlatform();
         if (!options3.platform) {
-          throw new Error(`Cannot download a binary for the provided platform: ${os9.platform()} (${os9.arch()})`);
+          throw new Error(`Cannot download a binary for the provided platform: ${os10.platform()} (${os10.arch()})`);
         }
         try {
           options3.buildId = this.resolveAlias(options3.browser, options3.buildId) ?? options3.buildId;
@@ -425470,7 +425916,7 @@ var init_Cache = __esm({
           debugCache("could not read .metadata file for the browser");
         }
         const installationDir = this.installationDir(options3.browser, options3.platform, options3.buildId);
-        return path26.join(installationDir, executablePathByBrowser[options3.browser](options3.platform, options3.buildId));
+        return path28.join(installationDir, executablePathByBrowser[options3.browser](options3.platform, options3.buildId));
       }
     };
   }
@@ -425486,9 +425932,9 @@ var init_debug = __esm({
 
 // node_modules/@puppeteer/browsers/lib/esm/launch.js
 import childProcess from "node:child_process";
-import { EventEmitter as EventEmitter6 } from "node:events";
+import { EventEmitter as EventEmitter7 } from "node:events";
 import { accessSync } from "node:fs";
-import os10 from "node:os";
+import os11 from "node:os";
 import readline from "node:readline";
 function computeExecutablePath(options3) {
   if (options3.cacheDir === null) {
@@ -425503,7 +425949,7 @@ function computeExecutablePath(options3) {
 function computeSystemExecutablePath(options3) {
   options3.platform ??= detectBrowserPlatform();
   if (!options3.platform) {
-    throw new Error(`Cannot download a binary for the provided platform: ${os10.platform()} (${os10.arch()})`);
+    throw new Error(`Cannot download a binary for the provided platform: ${os11.platform()} (${os11.arch()})`);
   }
   const paths = resolveSystemExecutablePaths2(options3.browser, options3.platform, options3.channel);
   for (const path49 of paths) {
@@ -425610,7 +426056,7 @@ var init_launch = __esm({
       #browserProcessExiting;
       #logs = [];
       #maxLogLinesSize = 1e3;
-      #lineEmitter = new EventEmitter6();
+      #lineEmitter = new EventEmitter7();
       constructor(opts) {
         var _a21, _b14;
         this.#executablePath = opts.executablePath;
@@ -425966,7 +426412,7 @@ var require_progress = __commonJS({
 import { spawnSync, spawn as spawn4 } from "node:child_process";
 import { createReadStream } from "node:fs";
 import { mkdir as mkdir3, readdir as readdir2 } from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path29 from "node:path";
 import { Stream as Stream2 } from "node:stream";
 var import_debug4, debugFileUtil;
 var init_fileUtil = __esm({
@@ -425981,12 +426427,12 @@ import assert3 from "node:assert";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync14 } from "node:fs";
 import { mkdir as mkdir4, unlink as unlink2 } from "node:fs/promises";
-import os11 from "node:os";
-import path28 from "node:path";
+import os12 from "node:os";
+import path30 from "node:path";
 async function uninstall(options3) {
   options3.platform ??= detectBrowserPlatform();
   if (!options3.platform) {
-    throw new Error(`Cannot detect the browser platform for: ${os11.platform()} (${os11.arch()})`);
+    throw new Error(`Cannot detect the browser platform for: ${os12.platform()} (${os12.arch()})`);
   }
   new Cache(options3.cacheDir).uninstall(options3.browser, options3.platform, options3.buildId);
 }
@@ -426053,7 +426499,7 @@ var init_PipeTransport = __esm({
         const pipeReadEmitter = this.#subscriptions.use(
           // NodeJS event emitters don't support `*` so we need to typecast
           // As long as we don't use it we should be OK.
-          new EventEmitter4(pipeRead)
+          new EventEmitter5(pipeRead)
         );
         pipeReadEmitter.on("data", (buffer) => {
           return this.#dispatch(buffer);
@@ -426067,7 +426513,7 @@ var init_PipeTransport = __esm({
         const pipeWriteEmitter = this.#subscriptions.use(
           // NodeJS event emitters don't support `*` so we need to typecast
           // As long as we don't use it we should be OK.
-          new EventEmitter4(pipeWrite)
+          new EventEmitter5(pipeWrite)
         );
         pipeWriteEmitter.on("error", debugError);
       }
@@ -426416,9 +426862,9 @@ For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/util/fs.js
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 async function rm(path49) {
-  await fs21.promises.rm(path49, rmOptions);
+  await fs22.promises.rm(path49, rmOptions);
 }
 var rmOptions;
 var init_fs = __esm({
@@ -426433,8 +426879,8 @@ var init_fs = __esm({
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/ChromeLauncher.js
 import { mkdtemp } from "node:fs/promises";
-import os12 from "node:os";
-import path29 from "node:path";
+import os13 from "node:os";
+import path31 from "node:path";
 function convertPuppeteerChannelToBrowsersChannel(channel) {
   switch (channel) {
     case "chrome":
@@ -426484,7 +426930,7 @@ var init_ChromeLauncher = __esm({
       launch(options3 = {}) {
         var _a21;
         if (this.puppeteer.configuration.logLevel === "warn" && process.platform === "darwin" && process.arch === "x64") {
-          const cpus = os12.cpus();
+          const cpus = os13.cpus();
           if ((_a21 = cpus[0]) == null ? void 0 : _a21.model.includes("Apple")) {
             console.warn([
               "\x1B[1m\x1B[43m\x1B[30m",
@@ -426629,7 +427075,7 @@ var init_ChromeLauncher = __esm({
         });
         const { devtools = false, headless = !devtools, args: args2 = [], userDataDir, enableExtensions = false } = options3;
         if (userDataDir) {
-          chromeArguments.push(`--user-data-dir=${path29.resolve(userDataDir)}`);
+          chromeArguments.push(`--user-data-dir=${path31.resolve(userDataDir)}`);
         }
         if (devtools) {
           chromeArguments.push("--auto-open-devtools-for-tabs");
@@ -426661,10 +427107,10 @@ var init_ChromeLauncher = __esm({
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/FirefoxLauncher.js
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import { rename, unlink as unlink3, mkdtemp as mkdtemp2 } from "node:fs/promises";
-import os13 from "node:os";
-import path30 from "node:path";
+import os14 from "node:os";
+import path32 from "node:path";
 var FirefoxLauncher;
 var init_FirefoxLauncher = __esm({
   "node_modules/puppeteer-core/lib/esm/puppeteer/node/FirefoxLauncher.js"() {
@@ -426759,9 +427205,9 @@ var init_FirefoxLauncher = __esm({
             const backupSuffix = ".puppeteer";
             const backupFiles = ["prefs.js", "user.js"];
             const results = await Promise.allSettled(backupFiles.map(async (file) => {
-              const prefsBackupPath = path30.join(userDataDir, file + backupSuffix);
-              if (fs22.existsSync(prefsBackupPath)) {
-                const prefsPath = path30.join(userDataDir, file);
+              const prefsBackupPath = path32.join(userDataDir, file + backupSuffix);
+              if (fs23.existsSync(prefsBackupPath)) {
+                const prefsPath = path32.join(userDataDir, file);
                 await unlink3(prefsPath);
                 await rename(prefsBackupPath, prefsPath);
               }
@@ -426786,7 +427232,7 @@ var init_FirefoxLauncher = __esm({
       defaultArgs(options3 = {}) {
         const { devtools = false, headless = !devtools, args: args2 = [], userDataDir = null } = options3;
         const firefoxArguments = [];
-        switch (os13.platform()) {
+        switch (os14.platform()) {
           case "darwin":
             firefoxArguments.push("--foreground");
             break;
@@ -427074,8 +427520,8 @@ var init_PuppeteerNode = __esm({
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js
 import { spawn as spawn5, spawnSync as spawnSync3 } from "node:child_process";
-import fs23 from "node:fs";
-import os14 from "node:os";
+import fs24 from "node:fs";
+import os15 from "node:os";
 import { dirname as dirname7 } from "node:path";
 import { PassThrough as PassThrough3 } from "node:stream";
 var import_debug6, __runInitializers23, __esDecorate23, __setFunctionName6, CRF_VALUE, DEFAULT_FPS, debugFfmpeg, ScreenRecorder;
@@ -427184,7 +427630,7 @@ var init_ScreenRecorder = __esm({
             filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
           }
           if (path49) {
-            fs23.mkdirSync(dirname7(path49), { recursive: overwrite });
+            fs24.mkdirSync(dirname7(path49), { recursive: overwrite });
           }
           __privateSet(this, _process, spawn5(
             ffmpegPath,
@@ -427288,7 +427734,7 @@ var init_ScreenRecorder = __esm({
             "-deadline",
             "realtime",
             "-cpu-used",
-            `${Math.min(os14.cpus().length / 2, 8)}`
+            `${Math.min(os15.cpus().length / 2, 8)}`
           ]
         ];
         switch (format4) {
@@ -427369,8 +427815,8 @@ var init_puppeteer = __esm({
 });
 
 // node_modules/puppeteer-core/lib/esm/puppeteer/puppeteer-core.js
-import fs24 from "node:fs";
-import path31 from "node:path";
+import fs25 from "node:fs";
+import path33 from "node:path";
 var puppeteer, connect, defaultArgs, executablePath, launch2, puppeteer_core_default;
 var init_puppeteer_core = __esm({
   "node_modules/puppeteer-core/lib/esm/puppeteer/puppeteer-core.js"() {
@@ -427378,8 +427824,8 @@ var init_puppeteer_core = __esm({
     init_environment2();
     init_puppeteer();
     environment.value = {
-      fs: fs24,
-      path: path31,
+      fs: fs25,
+      path: path33,
       ScreenRecorder
     };
     puppeteer = new PuppeteerNode({
@@ -430011,8 +430457,8 @@ var codebaseDatabase_exports = {};
 __export(codebaseDatabase_exports, {
   CodebaseDatabase: () => CodebaseDatabase
 });
-import path32 from "node:path";
-import fs25 from "node:fs";
+import path34 from "node:path";
+import fs26 from "node:fs";
 var import_sql, CodebaseDatabase;
 var init_codebaseDatabase = __esm({
   "dist/utils/codebase/codebaseDatabase.js"() {
@@ -430039,11 +430485,11 @@ var init_codebaseDatabase = __esm({
           writable: true,
           value: false
         });
-        const snowDir = path32.join(projectRoot, ".snow", "codebase");
-        if (!fs25.existsSync(snowDir)) {
-          fs25.mkdirSync(snowDir, { recursive: true });
+        const snowDir = path34.join(projectRoot, ".snow", "codebase");
+        if (!fs26.existsSync(snowDir)) {
+          fs26.mkdirSync(snowDir, { recursive: true });
         }
-        this.dbPath = path32.join(snowDir, "embeddings.db");
+        this.dbPath = path34.join(snowDir, "embeddings.db");
       }
       /**
        * Initialize database and create tables
@@ -430053,8 +430499,8 @@ var init_codebaseDatabase = __esm({
           return;
         try {
           const SQL = await (0, import_sql.default)();
-          if (fs25.existsSync(this.dbPath)) {
-            const buffer = fs25.readFileSync(this.dbPath);
+          if (fs26.existsSync(this.dbPath)) {
+            const buffer = fs26.readFileSync(this.dbPath);
             this.db = new SQL.Database(buffer);
           } else {
             this.db = new SQL.Database();
@@ -430113,7 +430559,7 @@ var init_codebaseDatabase = __esm({
         if (!this.db)
           return;
         const data = this.db.export();
-        fs25.writeFileSync(this.dbPath, data);
+        fs26.writeFileSync(this.dbPath, data);
       }
       /**
        * Insert or update code chunks (batch operation)
@@ -430590,12 +431036,12 @@ var init_embedding = __esm({
 });
 
 // dist/utils/codebase/codebaseSearchEvents.js
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 var CodebaseSearchEventEmitter, codebaseSearchEvents;
 var init_codebaseSearchEvents = __esm({
   "dist/utils/codebase/codebaseSearchEvents.js"() {
     "use strict";
-    CodebaseSearchEventEmitter = class extends EventEmitter7 {
+    CodebaseSearchEventEmitter = class extends EventEmitter8 {
       emitSearchEvent(event) {
         this.emit("codebase-search", event);
       }
@@ -430610,48 +431056,14 @@ var init_codebaseSearchEvents = __esm({
   }
 });
 
-// dist/utils/session/projectUtils.js
-import path33 from "path";
-import crypto3 from "crypto";
-function getProjectId(projectPath) {
-  const cwd2 = projectPath || process.cwd();
-  const dirName = path33.basename(cwd2);
-  const pathHash = crypto3.createHash("sha256").update(cwd2).digest("hex").slice(0, 6);
-  const safeDirName = sanitizeProjectName(dirName);
-  return `${safeDirName}-${pathHash}`;
-}
-function getProjectPath() {
-  return process.cwd();
-}
-function sanitizeProjectName(name) {
-  return name.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 100);
-}
-function formatDateCompact(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${year}${month}${day}`;
-}
-function isDateFolder(folderName) {
-  return /^\d{4}-?\d{2}-?\d{2}$/.test(folderName);
-}
-function isProjectFolder(folderName) {
-  return /^.+-[a-f0-9]{6}$/.test(folderName);
-}
-var init_projectUtils = __esm({
-  "dist/utils/session/projectUtils.js"() {
-    "use strict";
-  }
-});
-
 // dist/utils/session/sessionManager.js
 var sessionManager_exports = {};
 __export(sessionManager_exports, {
   sessionManager: () => sessionManager
 });
-import fs26 from "fs/promises";
-import path34 from "path";
-import os15 from "os";
+import fs27 from "fs/promises";
+import path35 from "path";
+import os16 from "os";
 import { randomUUID as randomUUID3 } from "crypto";
 var SessionManager, sessionManager;
 var init_sessionManager = __esm({
@@ -430699,7 +431111,7 @@ var init_sessionManager = __esm({
           writable: true,
           value: void 0
         });
-        this.sessionsDir = path34.join(os15.homedir(), ".snow", "sessions");
+        this.sessionsDir = path35.join(os16.homedir(), ".snow", "sessions");
         this.currentProjectId = getProjectId();
         this.currentProjectPath = getProjectPath();
       }
@@ -430708,17 +431120,17 @@ var init_sessionManager = __esm({
        * 路径结构: ~/.snow/sessions/项目名/YYYYMMDD/
        */
       getProjectSessionsDir() {
-        return path34.join(this.sessionsDir, this.currentProjectId);
+        return path35.join(this.sessionsDir, this.currentProjectId);
       }
       async ensureSessionsDir(date) {
         try {
-          await fs26.mkdir(this.sessionsDir, { recursive: true });
+          await fs27.mkdir(this.sessionsDir, { recursive: true });
           const projectDir = this.getProjectSessionsDir();
-          await fs26.mkdir(projectDir, { recursive: true });
+          await fs27.mkdir(projectDir, { recursive: true });
           if (date) {
             const dateFolder = formatDateCompact(date);
-            const sessionDir = path34.join(projectDir, dateFolder);
-            await fs26.mkdir(sessionDir, { recursive: true });
+            const sessionDir = path35.join(projectDir, dateFolder);
+            await fs27.mkdir(sessionDir, { recursive: true });
           }
         } catch (error) {
         }
@@ -430731,8 +431143,8 @@ var init_sessionManager = __esm({
         const sessionDate = date || /* @__PURE__ */ new Date();
         const dateFolder = formatDateCompact(sessionDate);
         const targetProjectId = projectId || this.currentProjectId;
-        const sessionDir = path34.join(this.sessionsDir, targetProjectId, dateFolder);
-        return path34.join(sessionDir, `${sessionId}.json`);
+        const sessionDir = path35.join(this.sessionsDir, targetProjectId, dateFolder);
+        return path35.join(sessionDir, `${sessionId}.json`);
       }
       /**
        * 获取当前项目ID
@@ -430801,7 +431213,7 @@ var init_sessionManager = __esm({
         const sessionDate = new Date(session.createdAt);
         await this.ensureSessionsDir(sessionDate);
         const sessionPath = this.getSessionPath(session.id, sessionDate, session.projectId);
-        await fs26.writeFile(sessionPath, JSON.stringify(session, null, 2));
+        await fs27.writeFile(sessionPath, JSON.stringify(session, null, 2));
       }
       /**
        * 清理未完成的 tool_calls
@@ -430850,8 +431262,8 @@ var init_sessionManager = __esm({
         this.lastLoadHookError = void 0;
         this.lastLoadHookWarning = void 0;
         try {
-          const oldSessionPath = path34.join(this.sessionsDir, `${sessionId}.json`);
-          const data = await fs26.readFile(oldSessionPath, "utf-8");
+          const oldSessionPath = path35.join(this.sessionsDir, `${sessionId}.json`);
+          const data = await fs27.readFile(oldSessionPath, "utf-8");
           const session = JSON.parse(data);
           this.cleanIncompleteToolCalls(session);
           const hookResult = await this.executeSessionStartHook(session.messages);
@@ -430894,15 +431306,15 @@ var init_sessionManager = __esm({
        */
       async findSessionInDateFolders(sessionId) {
         try {
-          const files = await fs26.readdir(this.sessionsDir);
+          const files = await fs27.readdir(this.sessionsDir);
           const currentProjectDir = this.getProjectSessionsDir();
           const sessionFromCurrentProject = await this.findSessionInProjectDir(currentProjectDir, sessionId);
           if (sessionFromCurrentProject) {
             return sessionFromCurrentProject;
           }
           for (const file of files) {
-            const filePath = path34.join(this.sessionsDir, file);
-            const stat4 = await fs26.stat(filePath);
+            const filePath = path35.join(this.sessionsDir, file);
+            const stat4 = await fs27.stat(filePath);
             if (!stat4.isDirectory())
               continue;
             if (file === this.currentProjectId)
@@ -430913,9 +431325,9 @@ var init_sessionManager = __esm({
                 return session;
             }
             if (isDateFolder(file)) {
-              const sessionPath = path34.join(filePath, `${sessionId}.json`);
+              const sessionPath = path35.join(filePath, `${sessionId}.json`);
               try {
-                const data = await fs26.readFile(sessionPath, "utf-8");
+                const data = await fs27.readFile(sessionPath, "utf-8");
                 const session = JSON.parse(data);
                 return session;
               } catch (error) {
@@ -430932,13 +431344,13 @@ var init_sessionManager = __esm({
        */
       async findSessionInProjectDir(projectDir, sessionId) {
         try {
-          const dateFolders = await fs26.readdir(projectDir);
+          const dateFolders = await fs27.readdir(projectDir);
           for (const dateFolder of dateFolders) {
             if (!isDateFolder(dateFolder))
               continue;
-            const sessionPath = path34.join(projectDir, dateFolder, `${sessionId}.json`);
+            const sessionPath = path35.join(projectDir, dateFolder, `${sessionId}.json`);
             try {
-              const data = await fs26.readFile(sessionPath, "utf-8");
+              const data = await fs27.readFile(sessionPath, "utf-8");
               const session = JSON.parse(data);
               return session;
             } catch (error) {
@@ -430961,11 +431373,11 @@ var init_sessionManager = __esm({
         try {
           const projectDir = this.getProjectSessionsDir();
           try {
-            const dateFolders = await fs26.readdir(projectDir);
+            const dateFolders = await fs27.readdir(projectDir);
             for (const dateFolder of dateFolders) {
               if (!isDateFolder(dateFolder))
                 continue;
-              const datePath = path34.join(projectDir, dateFolder);
+              const datePath = path35.join(projectDir, dateFolder);
               await this.readSessionsFromDir(datePath, sessions);
             }
             for (const s of sessions) {
@@ -430975,10 +431387,10 @@ var init_sessionManager = __esm({
           }
           if (sessions.length === 0) {
             try {
-              const files = await fs26.readdir(this.sessionsDir);
+              const files = await fs27.readdir(this.sessionsDir);
               for (const file of files) {
-                const filePath = path34.join(this.sessionsDir, file);
-                const stat4 = await fs26.stat(filePath);
+                const filePath = path35.join(this.sessionsDir, file);
+                const stat4 = await fs27.stat(filePath);
                 if (stat4.isDirectory() && isDateFolder(file) && !isProjectFolder(file)) {
                   await this.readLegacySessionsFromDir(filePath, sessions, seenIds);
                 }
@@ -430999,11 +431411,11 @@ var init_sessionManager = __esm({
        */
       async readLegacySessionsFromDir(dirPath, sessions, seenIds) {
         try {
-          const files = await fs26.readdir(dirPath);
+          const files = await fs27.readdir(dirPath);
           for (const file of files) {
             if (!file.endsWith(".json"))
               continue;
-            const filePath = path34.join(dirPath, file);
+            const filePath = path35.join(dirPath, file);
             await this.readLegacySessionFile(filePath, sessions, seenIds);
           }
         } catch (error) {
@@ -431014,7 +431426,7 @@ var init_sessionManager = __esm({
        */
       async readLegacySessionFile(filePath, sessions, seenIds) {
         try {
-          const data = await fs26.readFile(filePath, "utf-8");
+          const data = await fs27.readFile(filePath, "utf-8");
           const session = JSON.parse(data);
           if (seenIds.has(session.id)) {
             return;
@@ -431066,12 +431478,12 @@ var init_sessionManager = __esm({
       }
       async readSessionsFromDir(dirPath, sessions) {
         try {
-          const files = await fs26.readdir(dirPath);
+          const files = await fs27.readdir(dirPath);
           for (const file of files) {
             if (file.endsWith(".json")) {
               try {
-                const sessionPath = path34.join(dirPath, file);
-                const data = await fs26.readFile(sessionPath, "utf-8");
+                const sessionPath = path35.join(dirPath, file);
+                const data = await fs27.readFile(sessionPath, "utf-8");
                 const session = JSON.parse(data);
                 sessions.push({
                   id: session.id,
@@ -431184,8 +431596,8 @@ var init_sessionManager = __esm({
       async deleteSession(sessionId) {
         let sessionDeleted = false;
         try {
-          const oldSessionPath = path34.join(this.sessionsDir, `${sessionId}.json`);
-          await fs26.unlink(oldSessionPath);
+          const oldSessionPath = path35.join(this.sessionsDir, `${sessionId}.json`);
+          await fs27.unlink(oldSessionPath);
           sessionDeleted = true;
         } catch (error) {
         }
@@ -431194,12 +431606,12 @@ var init_sessionManager = __esm({
         }
         if (!sessionDeleted) {
           try {
-            const files = await fs26.readdir(this.sessionsDir);
+            const files = await fs27.readdir(this.sessionsDir);
             for (const file of files) {
               if (sessionDeleted)
                 break;
-              const filePath = path34.join(this.sessionsDir, file);
-              const stat4 = await fs26.stat(filePath);
+              const filePath = path35.join(this.sessionsDir, file);
+              const stat4 = await fs27.stat(filePath);
               if (!stat4.isDirectory())
                 continue;
               if (file === this.currentProjectId)
@@ -431210,9 +431622,9 @@ var init_sessionManager = __esm({
                   break;
               }
               if (isDateFolder(file)) {
-                const sessionPath = path34.join(filePath, `${sessionId}.json`);
+                const sessionPath = path35.join(filePath, `${sessionId}.json`);
                 try {
-                  await fs26.unlink(sessionPath);
+                  await fs27.unlink(sessionPath);
                   sessionDeleted = true;
                   break;
                 } catch (error) {
@@ -431238,13 +431650,13 @@ var init_sessionManager = __esm({
        */
       async deleteSessionFromProjectDir(projectDir, sessionId) {
         try {
-          const dateFolders = await fs26.readdir(projectDir);
+          const dateFolders = await fs27.readdir(projectDir);
           for (const dateFolder of dateFolders) {
             if (!isDateFolder(dateFolder))
               continue;
-            const sessionPath = path34.join(projectDir, dateFolder, `${sessionId}.json`);
+            const sessionPath = path35.join(projectDir, dateFolder, `${sessionId}.json`);
             try {
-              await fs26.unlink(sessionPath);
+              await fs27.unlink(sessionPath);
               return true;
             } catch (error) {
               continue;
@@ -431320,8 +431732,8 @@ __export(codebaseSearch_exports, {
   codebaseSearchService: () => codebaseSearchService,
   mcpTools: () => mcpTools6
 });
-import path35 from "node:path";
-import fs27 from "node:fs";
+import path36 from "node:path";
+import fs28 from "node:fs";
 var CodebaseSearchService, codebaseSearchService, mcpTools6;
 var init_codebaseSearch = __esm({
   "dist/mcp/codebaseSearch.js"() {
@@ -431340,8 +431752,8 @@ var init_codebaseSearch = __esm({
       async isCodebaseIndexAvailable() {
         try {
           const projectRoot = process.cwd();
-          const dbPath = path35.join(projectRoot, ".snow", "codebase", "embeddings.db");
-          if (!fs27.existsSync(dbPath)) {
+          const dbPath = path36.join(projectRoot, ".snow", "codebase", "embeddings.db");
+          if (!fs28.existsSync(dbPath)) {
             return {
               available: false,
               reason: "Codebase index not found. Please run codebase indexing first."
@@ -431659,8 +432071,8 @@ var init_date_utils = __esm({
 });
 
 // dist/mcp/todo.js
-import fs28 from "fs/promises";
-import path36 from "path";
+import fs29 from "fs/promises";
+import path37 from "path";
 var TodoService;
 var init_todo = __esm({
   "dist/mcp/todo.js"() {
@@ -431684,21 +432096,21 @@ var init_todo = __esm({
         this.getCurrentSessionId = getCurrentSessionId;
       }
       async initialize() {
-        await fs28.mkdir(this.todoDir, { recursive: true });
+        await fs29.mkdir(this.todoDir, { recursive: true });
       }
       getTodoPath(sessionId, date) {
         const sessionDate = date || /* @__PURE__ */ new Date();
         const dateFolder = formatDateForFolder(sessionDate);
-        const todoDir = path36.join(this.todoDir, dateFolder);
-        return path36.join(todoDir, `${sessionId}.json`);
+        const todoDir = path37.join(this.todoDir, dateFolder);
+        return path37.join(todoDir, `${sessionId}.json`);
       }
       async ensureTodoDir(date) {
         try {
-          await fs28.mkdir(this.todoDir, { recursive: true });
+          await fs29.mkdir(this.todoDir, { recursive: true });
           if (date) {
             const dateFolder = formatDateForFolder(date);
-            const todoDir = path36.join(this.todoDir, dateFolder);
-            await fs28.mkdir(todoDir, { recursive: true });
+            const todoDir = path37.join(this.todoDir, dateFolder);
+            await fs29.mkdir(todoDir, { recursive: true });
           }
         } catch (error) {
         }
@@ -431712,7 +432124,7 @@ var init_todo = __esm({
         await this.ensureTodoDir(sessionDate);
         const todoPath = this.getTodoPath(sessionId, sessionDate);
         try {
-          const content = await fs28.readFile(todoPath, "utf-8");
+          const content = await fs29.readFile(todoPath, "utf-8");
           existingList = JSON.parse(content);
         } catch {
         }
@@ -431723,7 +432135,7 @@ var init_todo = __esm({
           createdAt: (existingList == null ? void 0 : existingList.createdAt) ?? now,
           updatedAt: now
         };
-        await fs28.writeFile(todoPath, JSON.stringify(todoList, null, 2));
+        await fs29.writeFile(todoPath, JSON.stringify(todoList, null, 2));
         return todoList;
       }
       /**
@@ -431731,8 +432143,8 @@ var init_todo = __esm({
        */
       async getTodoList(sessionId) {
         try {
-          const oldTodoPath = path36.join(this.todoDir, `${sessionId}.json`);
-          const content = await fs28.readFile(oldTodoPath, "utf-8");
+          const oldTodoPath = path37.join(this.todoDir, `${sessionId}.json`);
+          const content = await fs29.readFile(oldTodoPath, "utf-8");
           return JSON.parse(content);
         } catch (error) {
         }
@@ -431745,14 +432157,14 @@ var init_todo = __esm({
       }
       async findTodoInDateFolders(sessionId) {
         try {
-          const files = await fs28.readdir(this.todoDir);
+          const files = await fs29.readdir(this.todoDir);
           for (const file of files) {
-            const filePath = path36.join(this.todoDir, file);
-            const stat4 = await fs28.stat(filePath);
+            const filePath = path37.join(this.todoDir, file);
+            const stat4 = await fs29.stat(filePath);
             if (stat4.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(file)) {
-              const todoPath = path36.join(filePath, `${sessionId}.json`);
+              const todoPath = path37.join(filePath, `${sessionId}.json`);
               try {
-                const content = await fs28.readFile(todoPath, "utf-8");
+                const content = await fs29.readFile(todoPath, "utf-8");
                 return JSON.parse(content);
               } catch (error) {
                 continue;
@@ -431829,20 +432241,20 @@ var init_todo = __esm({
        */
       async deleteTodoList(sessionId) {
         try {
-          const oldTodoPath = path36.join(this.todoDir, `${sessionId}.json`);
-          await fs28.unlink(oldTodoPath);
+          const oldTodoPath = path37.join(this.todoDir, `${sessionId}.json`);
+          await fs29.unlink(oldTodoPath);
           return true;
         } catch (error) {
         }
         try {
-          const files = await fs28.readdir(this.todoDir);
+          const files = await fs29.readdir(this.todoDir);
           for (const file of files) {
-            const filePath = path36.join(this.todoDir, file);
-            const stat4 = await fs28.stat(filePath);
+            const filePath = path37.join(this.todoDir, file);
+            const stat4 = await fs29.stat(filePath);
             if (stat4.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(file)) {
-              const todoPath = path36.join(filePath, `${sessionId}.json`);
+              const todoPath = path37.join(filePath, `${sessionId}.json`);
               try {
-                await fs28.unlink(todoPath);
+                await fs29.unlink(todoPath);
                 return true;
               } catch (error) {
                 continue;
@@ -438493,12 +438905,12 @@ __export(mcpToolsManager_exports, {
   reconnectMCPService: () => reconnectMCPService,
   refreshMCPToolsCache: () => refreshMCPToolsCache
 });
-import os16 from "os";
-import path37 from "path";
+import os17 from "os";
+import path38 from "path";
 function getTodoService() {
   if (!todoService) {
     const projectId = sessionManager.getProjectId();
-    const basePath = path37.join(os16.homedir(), ".snow", "todos", projectId);
+    const basePath = path38.join(os17.homedir(), ".snow", "todos", projectId);
     todoService = new TodoService(basePath, () => {
       const session = sessionManager.getCurrentSession();
       return session ? session.id : null;
@@ -438787,7 +439199,7 @@ async function refreshToolsCache() {
     const codebaseConfig = loadCodebaseConfig2();
     if (codebaseConfig.enabled) {
       const projectRoot2 = process.cwd();
-      const dbPath = path37.join(projectRoot2, ".snow", "codebase", "embeddings.db");
+      const dbPath = path38.join(projectRoot2, ".snow", "codebase", "embeddings.db");
       const fs41 = await import("node:fs");
       if (fs41.existsSync(dbPath)) {
         const { CodebaseDatabase: CodebaseDatabase2 } = await Promise.resolve().then(() => (init_codebaseDatabase(), codebaseDatabase_exports));
@@ -444198,6 +444610,7 @@ function WelcomeScreen({ version: version2 = "1.0.0", onMenuSelect, defaultMenuI
   const { t } = useI18n();
   const [infoText, setInfoText] = (0, import_react76.useState)(t.welcome.startChatInfo);
   const [inlineView, setInlineView] = (0, import_react76.useState)("menu");
+  const [updateNotice, setUpdateNoticeState] = (0, import_react76.useState)(getUpdateNotice());
   const [editingAgentId, setEditingAgentId] = (0, import_react76.useState)();
   const { columns: terminalWidth } = useTerminalSize();
   const { stdout } = use_stdout_default();
@@ -444208,6 +444621,12 @@ function WelcomeScreen({ version: version2 = "1.0.0", onMenuSelect, defaultMenuI
   (0, import_react76.useEffect)(() => {
     setCurrentMenuIndex(defaultMenuIndex);
   }, [defaultMenuIndex]);
+  (0, import_react76.useEffect)(() => {
+    const unsubscribe = onUpdateNotice((notice) => {
+      setUpdateNoticeState(notice);
+    });
+    return unsubscribe;
+  }, []);
   const menuOptions = (0, import_react76.useMemo)(() => [
     {
       label: t.welcome.startChat,
@@ -444402,6 +444821,51 @@ function WelcomeScreen({ version: version2 = "1.0.0", onMenuSelect, defaultMenuI
         )
       )
     ] }, (item) => item),
+    inlineView === "menu" && updateNotice && import_react76.default.createElement(
+      Box_default,
+      { paddingX: 1, marginBottom: 1 },
+      import_react76.default.createElement(
+        Box_default,
+        { borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1, width: terminalWidth - 2 },
+        import_react76.default.createElement(
+          Box_default,
+          { flexDirection: "column" },
+          import_react76.default.createElement(Text, { bold: true, color: "cyan" }, t.welcome.updateNoticeTitle),
+          import_react76.default.createElement(
+            Text,
+            { color: "gray", dimColor: true },
+            t.welcome.updateNoticeCurrent,
+            ":",
+            " ",
+            import_react76.default.createElement(Text, { color: "gray" }, updateNotice.currentVersion)
+          ),
+          import_react76.default.createElement(
+            Text,
+            { color: "gray", dimColor: true },
+            t.welcome.updateNoticeLatest,
+            ":",
+            " ",
+            import_react76.default.createElement(Text, { color: "yellow", bold: true }, updateNotice.latestVersion)
+          ),
+          import_react76.default.createElement(
+            Text,
+            { color: "gray", dimColor: true },
+            t.welcome.updateNoticeRun,
+            ":",
+            " ",
+            import_react76.default.createElement(Text, { color: "yellow", bold: true }, "snow --update")
+          ),
+          import_react76.default.createElement(
+            Text,
+            { color: "gray", dimColor: true },
+            t.welcome.updateNoticeGithub,
+            ":",
+            " ",
+            "https://github.com/MayDay-wpf/snow-cli"
+          )
+        )
+      )
+    ),
     onMenuSelect && inlineView === "menu" && import_react76.default.createElement(
       Box_default,
       { paddingX: 1 },
@@ -444535,6 +444999,7 @@ var init_WelcomeScreen = __esm({
     await init_Menu();
     init_useTerminalSize();
     init_i18n();
+    init_updateNotice();
     ConfigScreen2 = import_react76.default.lazy(() => init_ConfigScreen().then(() => ConfigScreen_exports));
     ProxyConfigScreen2 = import_react76.default.lazy(() => init_ProxyConfigScreen().then(() => ProxyConfigScreen_exports));
     SubAgentConfigScreen2 = import_react76.default.lazy(() => init_SubAgentConfigScreen().then(() => SubAgentConfigScreen_exports));
@@ -445137,9 +445602,9 @@ var init_useInputBuffer = __esm({
 });
 
 // dist/utils/session/commandUsageManager.js
-import fs29 from "fs/promises";
-import path38 from "path";
-import os17 from "os";
+import fs30 from "fs/promises";
+import path39 from "path";
+import os18 from "os";
 var CommandUsageManager, commandUsageManager;
 var init_commandUsageManager = __esm({
   "dist/utils/session/commandUsageManager.js"() {
@@ -445177,16 +445642,16 @@ var init_commandUsageManager = __esm({
           writable: true,
           value: 1e3
         });
-        const snowDir = path38.join(os17.homedir(), ".snow");
-        this.usageFile = path38.join(snowDir, "command-usage.json");
+        const snowDir = path39.join(os18.homedir(), ".snow");
+        this.usageFile = path39.join(snowDir, "command-usage.json");
       }
       /**
        * 确保 .snow 目录存在
        */
       async ensureSnowDir() {
         try {
-          const snowDir = path38.dirname(this.usageFile);
-          await fs29.mkdir(snowDir, { recursive: true });
+          const snowDir = path39.dirname(this.usageFile);
+          await fs30.mkdir(snowDir, { recursive: true });
         } catch {
         }
       }
@@ -445198,7 +445663,7 @@ var init_commandUsageManager = __esm({
           return;
         try {
           await this.ensureSnowDir();
-          const data = await fs29.readFile(this.usageFile, "utf-8");
+          const data = await fs30.readFile(this.usageFile, "utf-8");
           this.usageData = JSON.parse(data);
         } catch {
           this.usageData = {
@@ -445227,7 +445692,7 @@ var init_commandUsageManager = __esm({
         try {
           await this.ensureSnowDir();
           this.usageData.lastUpdated = Date.now();
-          await fs29.writeFile(this.usageFile, JSON.stringify(this.usageData, null, 2), "utf-8");
+          await fs30.writeFile(this.usageFile, JSON.stringify(this.usageData, null, 2), "utf-8");
           this.isDirty = false;
         } catch (error) {
           logger.error("Failed to save command usage:", error);
@@ -445683,16 +446148,16 @@ __export(fileUtils_exports, {
   getFileLineCount: () => getFileLineCount,
   parseAndValidateFileReferences: () => parseAndValidateFileReferences
 });
-import fs30 from "fs";
-import path39 from "path";
+import fs31 from "fs";
+import path40 from "path";
 function getFileLineCount(filePath) {
   return new Promise((resolve10) => {
     try {
-      if (!fs30.existsSync(filePath)) {
+      if (!fs31.existsSync(filePath)) {
         resolve10(0);
         return;
       }
-      const content = fs30.readFileSync(filePath, "utf-8");
+      const content = fs31.readFileSync(filePath, "utf-8");
       const lines = content.split("\n").length;
       resolve10(lines);
     } catch (error) {
@@ -445710,11 +446175,11 @@ function isImageFile(filePath) {
     ".bmp",
     ".svg"
   ];
-  const ext = path39.extname(filePath).toLowerCase();
+  const ext = path40.extname(filePath).toLowerCase();
   return imageExtensions.includes(ext);
 }
 function getMimeType(filePath) {
-  const ext = path39.extname(filePath).toLowerCase();
+  const ext = path40.extname(filePath).toLowerCase();
   const mimeTypes = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -445731,16 +446196,16 @@ async function getFileInfo(filePath) {
     const pathsToTry = [
       filePath,
       // Original path as provided
-      path39.resolve(process.cwd(), filePath),
+      path40.resolve(process.cwd(), filePath),
       // Relative to current working directory
-      path39.resolve(filePath)
+      path40.resolve(filePath)
       // Absolute resolution
     ];
     const uniquePaths = [...new Set(pathsToTry)];
     let actualPath = filePath;
     let exists = false;
     for (const tryPath of uniquePaths) {
-      if (fs30.existsSync(tryPath)) {
+      if (fs31.existsSync(tryPath)) {
         actualPath = tryPath;
         exists = true;
         break;
@@ -445752,7 +446217,7 @@ async function getFileInfo(filePath) {
     let lineCount = 0;
     if (exists) {
       if (isImage) {
-        const buffer = fs30.readFileSync(actualPath);
+        const buffer = fs31.readFileSync(actualPath);
         const base64 = buffer.toString("base64");
         mimeType = getMimeType(actualPath);
         imageData = `data:${mimeType};base64,${base64}`;
@@ -445880,9 +446345,9 @@ var init_fileUtils = __esm({
 });
 
 // dist/utils/session/historyManager.js
-import fs31 from "fs/promises";
-import path40 from "path";
-import os18 from "os";
+import fs32 from "fs/promises";
+import path41 from "path";
+import os19 from "os";
 var HistoryManager, historyManager;
 var init_historyManager = __esm({
   "dist/utils/session/historyManager.js"() {
@@ -445933,18 +446398,18 @@ var init_historyManager = __esm({
           writable: true,
           value: []
         });
-        const snowDir = path40.join(os18.homedir(), ".snow");
+        const snowDir = path41.join(os19.homedir(), ".snow");
         this.currentProjectId = getProjectId();
-        this.historyDir = path40.join(snowDir, "history", this.currentProjectId);
-        this.historyFile = path40.join(this.historyDir, "history.json");
+        this.historyDir = path41.join(snowDir, "history", this.currentProjectId);
+        this.historyFile = path41.join(this.historyDir, "history.json");
       }
       /**
        * Ensure the .snow directory exists
        */
       async ensureSnowDir() {
         try {
-          const snowDir = path40.dirname(this.historyFile);
-          await fs31.mkdir(snowDir, { recursive: true });
+          const snowDir = path41.dirname(this.historyFile);
+          await fs32.mkdir(snowDir, { recursive: true });
         } catch (error) {
         }
       }
@@ -445957,16 +446422,16 @@ var init_historyManager = __esm({
         try {
           await this.ensureSnowDir();
           try {
-            const data = await fs31.readFile(this.historyFile, "utf-8");
+            const data = await fs32.readFile(this.historyFile, "utf-8");
             this.historyData = JSON.parse(data);
             await this.cleanupOldEntries();
             return this.historyData.entries;
           } catch (error) {
           }
-          const snowDir = path40.join(os18.homedir(), ".snow");
-          const oldHistoryFile = path40.join(snowDir, "history.json");
+          const snowDir = path41.join(os19.homedir(), ".snow");
+          const oldHistoryFile = path41.join(snowDir, "history.json");
           try {
-            const data = await fs31.readFile(oldHistoryFile, "utf-8");
+            const data = await fs32.readFile(oldHistoryFile, "utf-8");
             const oldData = JSON.parse(data);
             this.legacyEntries = oldData.entries;
             logger.debug(`Loaded ${this.legacyEntries.length} legacy history entries as read-only backup`);
@@ -446051,7 +446516,7 @@ var init_historyManager = __esm({
         }
         try {
           await this.ensureSnowDir();
-          await fs31.writeFile(this.historyFile, JSON.stringify(this.historyData, null, 2), "utf-8");
+          await fs32.writeFile(this.historyFile, JSON.stringify(this.historyData, null, 2), "utf-8");
         } catch (error) {
           logger.error("Failed to save history:", error);
         }
@@ -447186,8 +447651,8 @@ var init_useAgentPicker = __esm({
 });
 
 // dist/utils/core/todoScanner.js
-import fs32 from "fs";
-import path41 from "path";
+import fs33 from "fs";
+import path42 from "path";
 function shouldIgnore(filePath) {
   const relativePath = filePath;
   return IGNORE_PATTERNS.some((pattern) => {
@@ -447200,7 +447665,7 @@ function shouldIgnore(filePath) {
 }
 function scanFileForTodos(filePath, rootDir) {
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const todos = [];
     lines.forEach((line, index) => {
@@ -447209,7 +447674,7 @@ function scanFileForTodos(filePath, rootDir) {
         const match2 = line.match(pattern);
         if (match2) {
           const todoContent = ((_a21 = match2[1]) == null ? void 0 : _a21.trim()) || "";
-          const relativePath = path41.relative(rootDir, filePath);
+          const relativePath = path42.relative(rootDir, filePath);
           todos.push({
             id: `${relativePath}:${index + 1}`,
             file: relativePath,
@@ -447229,17 +447694,17 @@ function scanFileForTodos(filePath, rootDir) {
 function scanDirectory(dir, rootDir) {
   let todos = [];
   try {
-    const entries = fs32.readdirSync(dir, { withFileTypes: true });
+    const entries = fs33.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path41.join(dir, entry.name);
-      const relativePath = path41.relative(rootDir, fullPath);
+      const fullPath = path42.join(dir, entry.name);
+      const relativePath = path42.relative(rootDir, fullPath);
       if (shouldIgnore(relativePath)) {
         continue;
       }
       if (entry.isDirectory()) {
         todos = todos.concat(scanDirectory(fullPath, rootDir));
       } else if (entry.isFile()) {
-        const ext = path41.extname(entry.name).toLowerCase();
+        const ext = path42.extname(entry.name).toLowerCase();
         const textExtensions = [
           ".ts",
           ".tsx",
@@ -447727,8 +448192,8 @@ var FileList_exports = {};
 __export(FileList_exports, {
   default: () => FileList_default
 });
-import fs33 from "fs";
-import path42 from "path";
+import fs34 from "fs";
+import path43 from "path";
 var import_react88, FileList, FileList_default;
 var init_FileList = __esm({
   async "dist/ui/components/tools/FileList.js"() {
@@ -447757,10 +448222,10 @@ var init_FileList = __esm({
         let globalMaxDepth = 0;
         for (const workingDir of workingDirs) {
           const dirPath = workingDir.path;
-          const gitignorePath = path42.join(dirPath, ".gitignore");
+          const gitignorePath = path43.join(dirPath, ".gitignore");
           let gitignorePatterns = [];
           try {
-            const content = await fs33.promises.readFile(gitignorePath, "utf-8");
+            const content = await fs34.promises.readFile(gitignorePath, "utf-8");
             gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/\/$/, ""));
           } catch {
           }
@@ -447769,7 +448234,7 @@ var init_FileList = __esm({
               return { files: [], maxDepthReached: depth - 1 };
             }
             try {
-              const entries = await fs33.promises.readdir(dir, {
+              const entries = await fs34.promises.readdir(dir, {
                 withFileTypes: true
               });
               let result2 = [];
@@ -447808,17 +448273,17 @@ var init_FileList = __esm({
                 if (entry.name.startsWith(".") || ignorePatterns.includes(entry.name)) {
                   continue;
                 }
-                const fullPath = path42.join(dir, entry.name);
+                const fullPath = path43.join(dir, entry.name);
                 try {
-                  const stats = await fs33.promises.stat(fullPath);
+                  const stats = await fs34.promises.stat(fullPath);
                   if (!entry.isDirectory() && stats.size > 10 * 1024 * 1024) {
                     continue;
                   }
                 } catch {
                   continue;
                 }
-                let relativePath = path42.relative(dirPath, fullPath);
-                if (!relativePath.startsWith(".") && !path42.isAbsolute(relativePath)) {
+                let relativePath = path43.relative(dirPath, fullPath);
+                if (!relativePath.startsWith(".") && !path43.isAbsolute(relativePath)) {
                   relativePath = "./" + relativePath;
                 }
                 relativePath = relativePath.replace(/\\/g, "/");
@@ -447911,7 +448376,7 @@ var init_FileList = __esm({
         const filesToSearch = files.filter((f) => {
           if (f.isDirectory)
             return false;
-          const ext = path42.extname(f.path).toLowerCase();
+          const ext = path43.extname(f.path).toLowerCase();
           return textExtensions.has(ext);
         });
         const batchSize = 10;
@@ -447924,8 +448389,8 @@ var init_FileList = __esm({
             const fileResults = [];
             try {
               const baseDir = file.sourceDir || rootPath;
-              const fullPath = path42.join(baseDir, file.path);
-              const content = await fs33.promises.readFile(fullPath, "utf-8");
+              const fullPath = path43.join(baseDir, file.path);
+              const content = await fs34.promises.readFile(fullPath, "utf-8");
               const lines = content.split("\n");
               for (let i = 0; i < lines.length; i++) {
                 if (fileResults.length >= 10) {
@@ -448038,7 +448503,7 @@ var init_FileList = __esm({
           if (allFilteredFiles.length > 0 && selectedIndex < allFilteredFiles.length && allFilteredFiles[selectedIndex]) {
             const selectedFile = allFilteredFiles[selectedIndex];
             const baseDir = selectedFile.sourceDir || rootPath;
-            const fullPath = path42.join(baseDir, selectedFile.path);
+            const fullPath = path43.join(baseDir, selectedFile.path);
             if (selectedFile.lineNumber !== void 0) {
               return `${fullPath}:${selectedFile.lineNumber}`;
             }
@@ -449520,7 +449985,7 @@ var init_build6 = __esm({
 });
 
 // dist/ui/components/tools/ToolConfirmation.js
-import fs34 from "fs";
+import fs35 from "fs";
 function formatArgumentValue(value, maxLength = 100) {
   if (value === null || value === void 0) {
     return String(value);
@@ -449644,16 +450109,16 @@ Output: ${combinedOutput}`);
             for (const fileConfig of filePathData) {
               const filePath = typeof fileConfig === "string" ? fileConfig : fileConfig.path;
               const newContent = typeof fileConfig === "string" ? parsed.newContent : fileConfig.newContent;
-              if (typeof filePath === "string" && newContent && fs34.existsSync(filePath)) {
-                const originalContent = fs34.readFileSync(filePath, "utf-8");
+              if (typeof filePath === "string" && newContent && fs35.existsSync(filePath)) {
+                const originalContent = fs35.readFileSync(filePath, "utf-8");
                 promises.push(vscodeConnection.showDiff(filePath, originalContent, newContent, "Edit").catch(() => {
                 }));
               }
             }
           } else if (typeof parsed.filePath === "string" && parsed.newContent) {
             const filePath = parsed.filePath;
-            if (fs34.existsSync(filePath)) {
-              const originalContent = fs34.readFileSync(filePath, "utf-8");
+            if (fs35.existsSync(filePath)) {
+              const originalContent = fs35.readFileSync(filePath, "utf-8");
               promises.push(vscodeConnection.showDiff(filePath, originalContent, parsed.newContent, "Edit").catch(() => {
               }));
             }
@@ -449672,8 +450137,8 @@ Output: ${combinedOutput}`);
               const filePath = typeof fileConfig === "string" ? fileConfig : fileConfig.path;
               const searchContent = typeof fileConfig === "string" ? parsed.searchContent : fileConfig.searchContent;
               const replaceContent = typeof fileConfig === "string" ? parsed.replaceContent : fileConfig.replaceContent;
-              if (typeof filePath === "string" && searchContent && replaceContent && fs34.existsSync(filePath)) {
-                const originalContent = fs34.readFileSync(filePath, "utf-8");
+              if (typeof filePath === "string" && searchContent && replaceContent && fs35.existsSync(filePath)) {
+                const originalContent = fs35.readFileSync(filePath, "utf-8");
                 const newContent = originalContent.replace(searchContent, replaceContent);
                 promises.push(vscodeConnection.showDiff(filePath, originalContent, newContent, "Search & Replace").catch(() => {
                 }));
@@ -449681,8 +450146,8 @@ Output: ${combinedOutput}`);
             }
           } else if (typeof parsed.filePath === "string" && parsed.searchContent && parsed.replaceContent) {
             const filePath = parsed.filePath;
-            if (fs34.existsSync(filePath)) {
-              const originalContent = fs34.readFileSync(filePath, "utf-8");
+            if (fs35.existsSync(filePath)) {
+              const originalContent = fs35.readFileSync(filePath, "utf-8");
               const newContent = originalContent.replace(parsed.searchContent, parsed.replaceContent);
               promises.push(vscodeConnection.showDiff(filePath, originalContent, newContent, "Search & Replace").catch(() => {
               }));
@@ -527427,9 +527892,9 @@ var UsagePanel_exports = {};
 __export(UsagePanel_exports, {
   default: () => UsagePanel
 });
-import fs35 from "fs/promises";
-import path43 from "path";
-import os19 from "os";
+import fs36 from "fs/promises";
+import path44 from "path";
+import os20 from "os";
 function getModelShortName(modelName, maxLength = 20) {
   let name = modelName;
   name = name.replace(/-?\d{8}$/g, "");
@@ -527492,22 +527957,22 @@ function getModelShortName(modelName, maxLength = 20) {
   return result2.length > maxLength ? result2.slice(0, maxLength) : result2;
 }
 async function loadUsageData() {
-  const homeDir = os19.homedir();
-  const usageDir = path43.join(homeDir, ".snow", "usage");
+  const homeDir = os20.homedir();
+  const usageDir = path44.join(homeDir, ".snow", "usage");
   try {
     const entries = [];
-    const dateDirs = await fs35.readdir(usageDir);
+    const dateDirs = await fs36.readdir(usageDir);
     for (const dateDir of dateDirs) {
-      const datePath = path43.join(usageDir, dateDir);
-      const stats = await fs35.stat(datePath);
+      const datePath = path44.join(usageDir, dateDir);
+      const stats = await fs36.stat(datePath);
       if (!stats.isDirectory())
         continue;
-      const files = await fs35.readdir(datePath);
+      const files = await fs36.readdir(datePath);
       for (const file of files) {
         if (!file.endsWith(".jsonl"))
           continue;
-        const filePath = path43.join(datePath, file);
-        const content = await fs35.readFile(filePath, "utf-8");
+        const filePath = path44.join(datePath, file);
+        const content = await fs36.readFile(filePath, "utf-8");
         const lines = content.trim().split("\n").filter((l2) => l2.trim());
         for (const line of lines) {
           try {
@@ -528942,844 +529407,6 @@ var init_toolDisplayConfig = __esm({
   }
 });
 
-// node_modules/ignore/index.js
-var require_ignore = __commonJS({
-  "node_modules/ignore/index.js"(exports2, module2) {
-    function makeArray(subject) {
-      return Array.isArray(subject) ? subject : [subject];
-    }
-    var UNDEFINED = void 0;
-    var EMPTY2 = "";
-    var SPACE = " ";
-    var ESCAPE = "\\";
-    var REGEX_TEST_BLANK_LINE = /^\s+$/;
-    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
-    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
-    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
-    var REGEX_SPLITALL_CRLF = /\r?\n/g;
-    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
-    var REGEX_TEST_TRAILING_SLASH = /\/$/;
-    var SLASH2 = "/";
-    var TMP_KEY_IGNORE = "node-ignore";
-    if (typeof Symbol !== "undefined") {
-      TMP_KEY_IGNORE = Symbol.for("node-ignore");
-    }
-    var KEY_IGNORE = TMP_KEY_IGNORE;
-    var define2 = (object2, key, value) => {
-      Object.defineProperty(object2, key, { value });
-      return value;
-    };
-    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
-    var RETURN_FALSE = () => false;
-    var sanitizeRange = (range2) => range2.replace(
-      REGEX_REGEXP_RANGE,
-      (match2, from2, to) => from2.charCodeAt(0) <= to.charCodeAt(0) ? match2 : EMPTY2
-    );
-    var cleanRangeBackSlash = (slashes) => {
-      const { length } = slashes;
-      return slashes.slice(0, length - length % 2);
-    };
-    var REPLACERS = [
-      [
-        // Remove BOM
-        // TODO:
-        // Other similar zero-width characters?
-        /^\uFEFF/,
-        () => EMPTY2
-      ],
-      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-      [
-        // (a\ ) -> (a )
-        // (a  ) -> (a)
-        // (a ) -> (a)
-        // (a \ ) -> (a  )
-        /((?:\\\\)*?)(\\?\s+)$/,
-        (_3, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY2)
-      ],
-      // Replace (\ ) with ' '
-      // (\ ) -> ' '
-      // (\\ ) -> '\\ '
-      // (\\\ ) -> '\\ '
-      [
-        /(\\+?)\s/g,
-        (_3, m1) => {
-          const { length } = m1;
-          return m1.slice(0, length - length % 2) + SPACE;
-        }
-      ],
-      // Escape metacharacters
-      // which is written down by users but means special for regular expressions.
-      // > There are 12 characters with special meanings:
-      // > - the backslash \,
-      // > - the caret ^,
-      // > - the dollar sign $,
-      // > - the period or dot .,
-      // > - the vertical bar or pipe symbol |,
-      // > - the question mark ?,
-      // > - the asterisk or star *,
-      // > - the plus sign +,
-      // > - the opening parenthesis (,
-      // > - the closing parenthesis ),
-      // > - and the opening square bracket [,
-      // > - the opening curly brace {,
-      // > These special characters are often called "metacharacters".
-      [
-        /[\\$.|*+(){^]/g,
-        (match2) => `\\${match2}`
-      ],
-      [
-        // > a question mark (?) matches a single character
-        /(?!\\)\?/g,
-        () => "[^/]"
-      ],
-      // leading slash
-      [
-        // > A leading slash matches the beginning of the pathname.
-        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
-        // A leading slash matches the beginning of the pathname
-        /^\//,
-        () => "^"
-      ],
-      // replace special metacharacter slash after the leading slash
-      [
-        /\//g,
-        () => "\\/"
-      ],
-      [
-        // > A leading "**" followed by a slash means match in all directories.
-        // > For example, "**/foo" matches file or directory "foo" anywhere,
-        // > the same as pattern "foo".
-        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
-        // >   under directory "foo".
-        // Notice that the '*'s have been replaced as '\\*'
-        /^\^*\\\*\\\*\\\//,
-        // '**/foo' <-> 'foo'
-        () => "^(?:.*\\/)?"
-      ],
-      // starting
-      [
-        // there will be no leading '/'
-        //   (which has been replaced by section "leading slash")
-        // If starts with '**', adding a '^' to the regular expression also works
-        /^(?=[^^])/,
-        function startingReplacer() {
-          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
-        }
-      ],
-      // two globstars
-      [
-        // Use lookahead assertions so that we could match more than one `'/**'`
-        /\\\/\\\*\\\*(?=\\\/|$)/g,
-        // Zero, one or several directories
-        // should not use '*', or it will be replaced by the next replacer
-        // Check if it is not the last `'/**'`
-        (_3, index, str2) => index + 6 < str2.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
-      ],
-      // normal intermediate wildcards
-      [
-        // Never replace escaped '*'
-        // ignore rule '\*' will match the path '*'
-        // 'abc.*/' -> go
-        // 'abc.*'  -> skip this rule,
-        //    coz trailing single wildcard will be handed by [trailing wildcard]
-        /(^|[^\\]+)(\\\*)+(?=.+)/g,
-        // '*.js' matches '.js'
-        // '*.js' doesn't match 'abc'
-        (_3, p1, p2) => {
-          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
-          return p1 + unescaped;
-        }
-      ],
-      [
-        // unescape, revert step 3 except for back slash
-        // For example, if a user escape a '\\*',
-        // after step 3, the result will be '\\\\\\*'
-        /\\\\\\(?=[$.|*+(){^])/g,
-        () => ESCAPE
-      ],
-      [
-        // '\\\\' -> '\\'
-        /\\\\/g,
-        () => ESCAPE
-      ],
-      [
-        // > The range notation, e.g. [a-zA-Z],
-        // > can be used to match one of the characters in a range.
-        // `\` is escaped by step 3
-        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match2, leadEscape, range2, endEscape, close) => leadEscape === ESCAPE ? `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range2)}${endEscape}]` : "[]" : "[]"
-      ],
-      // ending
-      [
-        // 'js' will not match 'js.'
-        // 'ab' will not match 'abc'
-        /(?:[^*])$/,
-        // WTF!
-        // https://git-scm.com/docs/gitignore
-        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
-        // which re-fixes #24, #38
-        // > If there is a separator at the end of the pattern then the pattern
-        // > will only match directories, otherwise the pattern can match both
-        // > files and directories.
-        // 'js*' will not match 'a.js'
-        // 'js/' will not match 'a.js'
-        // 'js' will match 'a.js' and 'a.js/'
-        (match2) => /\/$/.test(match2) ? `${match2}$` : `${match2}(?=$|\\/$)`
-      ]
-    ];
-    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
-    var MODE_IGNORE = "regex";
-    var MODE_CHECK_IGNORE = "checkRegex";
-    var UNDERSCORE = "_";
-    var TRAILING_WILD_CARD_REPLACERS = {
-      [MODE_IGNORE](_3, p1) {
-        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
-      },
-      [MODE_CHECK_IGNORE](_3, p1) {
-        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
-        return `${prefix}(?=$|\\/$)`;
-      }
-    };
-    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
-      (prev, [matcher2, replacer]) => prev.replace(matcher2, replacer.bind(pattern)),
-      pattern
-    );
-    var isString4 = (subject) => typeof subject === "string";
-    var checkPattern = (pattern) => pattern && isString4(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
-    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
-    var IgnoreRule = class {
-      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
-        this.pattern = pattern;
-        this.mark = mark;
-        this.negative = negative;
-        define2(this, "body", body);
-        define2(this, "ignoreCase", ignoreCase);
-        define2(this, "regexPrefix", prefix);
-      }
-      get regex() {
-        const key = UNDERSCORE + MODE_IGNORE;
-        if (this[key]) {
-          return this[key];
-        }
-        return this._make(MODE_IGNORE, key);
-      }
-      get checkRegex() {
-        const key = UNDERSCORE + MODE_CHECK_IGNORE;
-        if (this[key]) {
-          return this[key];
-        }
-        return this._make(MODE_CHECK_IGNORE, key);
-      }
-      _make(mode, key) {
-        const str2 = this.regexPrefix.replace(
-          REGEX_REPLACE_TRAILING_WILDCARD,
-          // It does not need to bind pattern
-          TRAILING_WILD_CARD_REPLACERS[mode]
-        );
-        const regex2 = this.ignoreCase ? new RegExp(str2, "i") : new RegExp(str2);
-        return define2(this, key, regex2);
-      }
-    };
-    var createRule = ({
-      pattern,
-      mark
-    }, ignoreCase) => {
-      let negative = false;
-      let body = pattern;
-      if (body.indexOf("!") === 0) {
-        negative = true;
-        body = body.substr(1);
-      }
-      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
-      const regexPrefix = makeRegexPrefix(body);
-      return new IgnoreRule(
-        pattern,
-        mark,
-        body,
-        ignoreCase,
-        negative,
-        regexPrefix
-      );
-    };
-    var RuleManager = class {
-      constructor(ignoreCase) {
-        this._ignoreCase = ignoreCase;
-        this._rules = [];
-      }
-      _add(pattern) {
-        if (pattern && pattern[KEY_IGNORE]) {
-          this._rules = this._rules.concat(pattern._rules._rules);
-          this._added = true;
-          return;
-        }
-        if (isString4(pattern)) {
-          pattern = {
-            pattern
-          };
-        }
-        if (checkPattern(pattern.pattern)) {
-          const rule = createRule(pattern, this._ignoreCase);
-          this._added = true;
-          this._rules.push(rule);
-        }
-      }
-      // @param {Array<string> | string | Ignore} pattern
-      add(pattern) {
-        this._added = false;
-        makeArray(
-          isString4(pattern) ? splitPattern(pattern) : pattern
-        ).forEach(this._add, this);
-        return this._added;
-      }
-      // Test one single path without recursively checking parent directories
-      //
-      // - checkUnignored `boolean` whether should check if the path is unignored,
-      //   setting `checkUnignored` to `false` could reduce additional
-      //   path matching.
-      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
-      // @returns {TestResult} true if a file is ignored
-      test(path49, checkUnignored, mode) {
-        let ignored = false;
-        let unignored = false;
-        let matchedRule;
-        this._rules.forEach((rule) => {
-          const { negative } = rule;
-          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
-            return;
-          }
-          const matched = rule[mode].test(path49);
-          if (!matched) {
-            return;
-          }
-          ignored = !negative;
-          unignored = negative;
-          matchedRule = negative ? UNDEFINED : rule;
-        });
-        const ret2 = {
-          ignored,
-          unignored
-        };
-        if (matchedRule) {
-          ret2.rule = matchedRule;
-        }
-        return ret2;
-      }
-    };
-    var throwError = (message, Ctor) => {
-      throw new Ctor(message);
-    };
-    var checkPath = (path49, originalPath, doThrow) => {
-      if (!isString4(path49)) {
-        return doThrow(
-          `path must be a string, but got \`${originalPath}\``,
-          TypeError
-        );
-      }
-      if (!path49) {
-        return doThrow(`path must not be empty`, TypeError);
-      }
-      if (checkPath.isNotRelative(path49)) {
-        const r = "`path.relative()`d";
-        return doThrow(
-          `path should be a ${r} string, but got "${originalPath}"`,
-          RangeError
-        );
-      }
-      return true;
-    };
-    var isNotRelative = (path49) => REGEX_TEST_INVALID_PATH.test(path49);
-    checkPath.isNotRelative = isNotRelative;
-    checkPath.convert = (p) => p;
-    var Ignore = class {
-      constructor({
-        ignorecase = true,
-        ignoreCase = ignorecase,
-        allowRelativePaths = false
-      } = {}) {
-        define2(this, KEY_IGNORE, true);
-        this._rules = new RuleManager(ignoreCase);
-        this._strictPathCheck = !allowRelativePaths;
-        this._initCache();
-      }
-      _initCache() {
-        this._ignoreCache = /* @__PURE__ */ Object.create(null);
-        this._testCache = /* @__PURE__ */ Object.create(null);
-      }
-      add(pattern) {
-        if (this._rules.add(pattern)) {
-          this._initCache();
-        }
-        return this;
-      }
-      // legacy
-      addPattern(pattern) {
-        return this.add(pattern);
-      }
-      // @returns {TestResult}
-      _test(originalPath, cache4, checkUnignored, slices) {
-        const path49 = originalPath && checkPath.convert(originalPath);
-        checkPath(
-          path49,
-          originalPath,
-          this._strictPathCheck ? throwError : RETURN_FALSE
-        );
-        return this._t(path49, cache4, checkUnignored, slices);
-      }
-      checkIgnore(path49) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path49)) {
-          return this.test(path49);
-        }
-        const slices = path49.split(SLASH2).filter(Boolean);
-        slices.pop();
-        if (slices.length) {
-          const parent = this._t(
-            slices.join(SLASH2) + SLASH2,
-            this._testCache,
-            true,
-            slices
-          );
-          if (parent.ignored) {
-            return parent;
-          }
-        }
-        return this._rules.test(path49, false, MODE_CHECK_IGNORE);
-      }
-      _t(path49, cache4, checkUnignored, slices) {
-        if (path49 in cache4) {
-          return cache4[path49];
-        }
-        if (!slices) {
-          slices = path49.split(SLASH2).filter(Boolean);
-        }
-        slices.pop();
-        if (!slices.length) {
-          return cache4[path49] = this._rules.test(path49, checkUnignored, MODE_IGNORE);
-        }
-        const parent = this._t(
-          slices.join(SLASH2) + SLASH2,
-          cache4,
-          checkUnignored,
-          slices
-        );
-        return cache4[path49] = parent.ignored ? parent : this._rules.test(path49, checkUnignored, MODE_IGNORE);
-      }
-      ignores(path49) {
-        return this._test(path49, this._ignoreCache, false).ignored;
-      }
-      createFilter() {
-        return (path49) => !this.ignores(path49);
-      }
-      filter(paths) {
-        return makeArray(paths).filter(this.createFilter());
-      }
-      // @returns {TestResult}
-      test(path49) {
-        return this._test(path49, this._testCache, true);
-      }
-    };
-    var factory = (options3) => new Ignore(options3);
-    var isPathValid = (path49) => checkPath(path49 && checkPath.convert(path49), path49, RETURN_FALSE);
-    var setupWindows = () => {
-      const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
-      checkPath.convert = makePosix;
-      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path49) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path49) || isNotRelative(path49);
-    };
-    if (
-      // Detect `process` so that it can run in browsers.
-      typeof process !== "undefined" && process.platform === "win32"
-    ) {
-      setupWindows();
-    }
-    module2.exports = factory;
-    factory.default = factory;
-    module2.exports.isPathValid = isPathValid;
-    define2(module2.exports, Symbol.for("setupWindows"), setupWindows);
-  }
-});
-
-// dist/utils/codebase/hashBasedSnapshot.js
-import fs36 from "fs/promises";
-import fssync from "fs";
-import path44 from "path";
-import os20 from "os";
-import crypto4 from "crypto";
-var import_ignore, HashBasedSnapshotManager, hashBasedSnapshotManager;
-var init_hashBasedSnapshot = __esm({
-  "dist/utils/codebase/hashBasedSnapshot.js"() {
-    "use strict";
-    import_ignore = __toESM(require_ignore(), 1);
-    init_logger();
-    init_projectUtils();
-    HashBasedSnapshotManager = class {
-      constructor() {
-        Object.defineProperty(this, "snapshotsDir", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        Object.defineProperty(this, "activeSnapshots", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: /* @__PURE__ */ new Map()
-        });
-        Object.defineProperty(this, "ignoreFilter", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: void 0
-        });
-        const projectId = getProjectId();
-        this.snapshotsDir = path44.join(os20.homedir(), ".snow", ".git", "snapshots", projectId);
-        this.ignoreFilter = (0, import_ignore.default)();
-        this.loadIgnorePatterns();
-      }
-      /**
-       * Load .gitignore patterns
-       */
-      loadIgnorePatterns() {
-        const workspaceRoot = process.cwd();
-        const gitignorePath = path44.join(workspaceRoot, ".gitignore");
-        if (fssync.existsSync(gitignorePath)) {
-          try {
-            const content = fssync.readFileSync(gitignorePath, "utf-8");
-            this.ignoreFilter.add(content);
-          } catch (error) {
-            logger.warn("Failed to load .gitignore:", error);
-          }
-        }
-      }
-      /**
-       * Scan directory recursively and collect file states (metadata only, no content)
-       */
-      async scanDirectory(dirPath, workspaceRoot, fileStates, includeContent = false) {
-        try {
-          const entries = await fs36.readdir(dirPath, { withFileTypes: true });
-          for (const entry of entries) {
-            const fullPath = path44.join(dirPath, entry.name);
-            const relativePath = path44.relative(workspaceRoot, fullPath);
-            if (relativePath && this.ignoreFilter.ignores(relativePath)) {
-              continue;
-            }
-            if (entry.isDirectory()) {
-              await this.scanDirectory(fullPath, workspaceRoot, fileStates, includeContent);
-            } else if (entry.isFile()) {
-              try {
-                const stats = await fs36.stat(fullPath);
-                let content = "";
-                let hash = "";
-                if (includeContent) {
-                  content = await fs36.readFile(fullPath, "utf-8");
-                  hash = crypto4.createHash("sha256").update(content).digest("hex");
-                } else {
-                  const buffer = await fs36.readFile(fullPath);
-                  hash = crypto4.createHash("sha256").update(buffer).digest("hex");
-                }
-                fileStates.set(relativePath, {
-                  path: relativePath,
-                  hash,
-                  size: stats.size,
-                  mtime: stats.mtimeMs,
-                  content: includeContent ? content : ""
-                  // Only store content if requested
-                });
-              } catch (error) {
-              }
-            }
-          }
-        } catch (error) {
-        }
-      }
-      /**
-       * Scan workspace and build file state map
-       */
-      async scanWorkspace(workspaceRoot = process.cwd()) {
-        const fileStates = /* @__PURE__ */ new Map();
-        await this.scanDirectory(workspaceRoot, workspaceRoot, fileStates);
-        return fileStates;
-      }
-      /**
-       * Ensure snapshots directory exists
-       */
-      async ensureSnapshotsDir() {
-        await fs36.mkdir(this.snapshotsDir, { recursive: true });
-      }
-      /**
-       * Get snapshot file path
-       */
-      getSnapshotPath(sessionId, messageIndex) {
-        return path44.join(this.snapshotsDir, `${sessionId}_${messageIndex}.json`);
-      }
-      /**
-       * Create snapshot before message processing
-       * Captures current workspace state by hash
-       */
-      async createSnapshot(sessionId, messageIndex, workspaceRoot = process.cwd()) {
-        const beforeStateMap = await this.scanWorkspace(workspaceRoot);
-        const snapshotKey = `${sessionId}:${messageIndex}`;
-        this.activeSnapshots.set(snapshotKey, {
-          metadata: {
-            sessionId,
-            messageIndex,
-            timestamp: Date.now(),
-            workspaceRoot,
-            backups: []
-          },
-          beforeStateMap
-        });
-        logger.info(`[Snapshot] Created snapshot for session ${sessionId} message ${messageIndex}`);
-      }
-      /**
-       * Commit snapshot after message processing
-       * Compares current workspace state with snapshot and saves changes
-       * @param sessionId The session ID (required for session isolation)
-       * @param messageIndex The message index to commit (if not provided, commits the oldest snapshot for this session)
-       * @returns Object with fileCount and messageIndex, or null if no active snapshot
-       */
-      async commitSnapshot(sessionId, messageIndex) {
-        if (messageIndex === void 0) {
-          const keys2 = Array.from(this.activeSnapshots.keys());
-          const sessionKeys = keys2.filter((key) => key.startsWith(`${sessionId}:`)).map((key) => {
-            const parts = key.split(":");
-            return parseInt(parts[1] || "0", 10);
-          }).filter((index) => !isNaN(index));
-          if (sessionKeys.length === 0) {
-            return null;
-          }
-          messageIndex = Math.min(...sessionKeys);
-        }
-        const snapshotKey = `${sessionId}:${messageIndex}`;
-        const snapshot = this.activeSnapshots.get(snapshotKey);
-        if (!snapshot) {
-          logger.warn(`[Snapshot] No active snapshot found for session ${sessionId} message ${messageIndex}`);
-          return null;
-        }
-        const { metadata, beforeStateMap } = snapshot;
-        const workspaceRoot = metadata.workspaceRoot;
-        const afterStateMap = await this.scanWorkspace(workspaceRoot);
-        const changedFiles = [];
-        for (const [relativePath, beforeState] of beforeStateMap) {
-          const afterState = afterStateMap.get(relativePath);
-          const fullPath = path44.join(workspaceRoot, relativePath);
-          if (!afterState) {
-            try {
-              const content = await fs36.readFile(fullPath, "utf-8");
-              changedFiles.push({
-                path: relativePath,
-                content,
-                existed: true,
-                hash: beforeState.hash
-              });
-            } catch {
-              changedFiles.push({
-                path: relativePath,
-                content: null,
-                existed: true,
-                hash: beforeState.hash
-              });
-            }
-          } else if (beforeState.hash !== afterState.hash) {
-            try {
-              const content = await fs36.readFile(fullPath, "utf-8");
-              changedFiles.push({
-                path: relativePath,
-                content,
-                existed: true,
-                hash: beforeState.hash
-              });
-            } catch (error) {
-              logger.warn(`Failed to read modified file ${relativePath}:`, error);
-            }
-          }
-        }
-        for (const [relativePath, afterState] of afterStateMap) {
-          if (!beforeStateMap.has(relativePath)) {
-            changedFiles.push({
-              path: relativePath,
-              content: null,
-              // No need to store content for new files
-              existed: false,
-              hash: afterState.hash
-            });
-          }
-        }
-        if (changedFiles.length > 0) {
-          metadata.backups = changedFiles;
-          await this.saveSnapshotMetadata(metadata);
-          logger.info(`[Snapshot] Committed: ${changedFiles.length} files changed for session ${sessionId} message ${messageIndex}`);
-        } else {
-          logger.info(`[Snapshot] No changes detected for session ${sessionId} message ${messageIndex}`);
-        }
-        this.activeSnapshots.delete(snapshotKey);
-        return { fileCount: changedFiles.length, messageIndex };
-      }
-      /**
-       * Save snapshot to disk
-       */
-      async saveSnapshotMetadata(metadata) {
-        await this.ensureSnapshotsDir();
-        const snapshotPath = this.getSnapshotPath(metadata.sessionId, metadata.messageIndex);
-        await fs36.writeFile(snapshotPath, JSON.stringify(metadata, null, 2));
-      }
-      /**
-       * List all snapshots for a session
-       */
-      async listSnapshots(sessionId) {
-        await this.ensureSnapshotsDir();
-        const snapshots = [];
-        try {
-          const files = await fs36.readdir(this.snapshotsDir);
-          for (const file of files) {
-            if (file.startsWith(sessionId) && file.endsWith(".json")) {
-              const snapshotPath = path44.join(this.snapshotsDir, file);
-              const content = await fs36.readFile(snapshotPath, "utf-8");
-              const metadata = JSON.parse(content);
-              snapshots.push({
-                messageIndex: metadata.messageIndex,
-                timestamp: metadata.timestamp,
-                fileCount: metadata.backups.length
-              });
-            }
-          }
-        } catch (error) {
-          logger.error("Failed to list snapshots:", error);
-        }
-        return snapshots.sort((a, b) => b.messageIndex - a.messageIndex);
-      }
-      /**
-       * Get list of files affected by rollback
-       */
-      async getFilesToRollback(sessionId, targetMessageIndex) {
-        await this.ensureSnapshotsDir();
-        try {
-          const files = await fs36.readdir(this.snapshotsDir);
-          const filesToRollback = /* @__PURE__ */ new Set();
-          for (const file of files) {
-            if (file.startsWith(sessionId) && file.endsWith(".json")) {
-              const snapshotPath = path44.join(this.snapshotsDir, file);
-              const content = await fs36.readFile(snapshotPath, "utf-8");
-              const metadata = JSON.parse(content);
-              if (metadata.messageIndex >= targetMessageIndex) {
-                for (const backup of metadata.backups) {
-                  filesToRollback.add(backup.path);
-                }
-              }
-            }
-          }
-          return Array.from(filesToRollback).sort();
-        } catch (error) {
-          logger.error("Failed to get files to rollback:", error);
-          return [];
-        }
-      }
-      /**
-       * Rollback to a specific message index
-       * Uses streaming approach to minimize memory usage
-       */
-      async rollbackToMessageIndex(sessionId, targetMessageIndex, selectedFiles) {
-        await this.ensureSnapshotsDir();
-        try {
-          const files = await fs36.readdir(this.snapshotsDir);
-          const snapshotFiles = [];
-          for (const file of files) {
-            if (file.startsWith(sessionId) && file.endsWith(".json")) {
-              const snapshotPath = path44.join(this.snapshotsDir, file);
-              const content = await fs36.readFile(snapshotPath, "utf-8");
-              const metadata = JSON.parse(content);
-              if (metadata.messageIndex >= targetMessageIndex) {
-                snapshotFiles.push({
-                  messageIndex: metadata.messageIndex,
-                  path: snapshotPath
-                });
-              }
-            }
-          }
-          snapshotFiles.sort((a, b) => b.messageIndex - a.messageIndex);
-          let totalFilesRolledBack = 0;
-          for (const snapshotFile of snapshotFiles) {
-            const content = await fs36.readFile(snapshotFile.path, "utf-8");
-            const metadata = JSON.parse(content);
-            for (const backup of metadata.backups) {
-              if (selectedFiles && selectedFiles.length > 0 && !selectedFiles.includes(backup.path)) {
-                continue;
-              }
-              const fullPath = path44.join(metadata.workspaceRoot, backup.path);
-              try {
-                if (backup.existed && backup.content !== null) {
-                  await fs36.writeFile(fullPath, backup.content, "utf-8");
-                  totalFilesRolledBack++;
-                } else if (!backup.existed) {
-                  try {
-                    await fs36.unlink(fullPath);
-                    totalFilesRolledBack++;
-                  } catch {
-                  }
-                }
-              } catch (error) {
-                logger.error(`Failed to restore file ${backup.path}:`, error);
-              }
-            }
-          }
-          return totalFilesRolledBack;
-        } catch (error) {
-          logger.error("Failed to rollback to message index:", error);
-          return 0;
-        }
-      }
-      /**
-       * Delete snapshots from a specific message index onwards
-       */
-      async deleteSnapshotsFromIndex(sessionId, targetMessageIndex) {
-        await this.ensureSnapshotsDir();
-        try {
-          const files = await fs36.readdir(this.snapshotsDir);
-          let deletedCount = 0;
-          for (const file of files) {
-            if (file.startsWith(sessionId) && file.endsWith(".json")) {
-              const snapshotPath = path44.join(this.snapshotsDir, file);
-              const content = await fs36.readFile(snapshotPath, "utf-8");
-              const metadata = JSON.parse(content);
-              if (metadata.messageIndex >= targetMessageIndex) {
-                try {
-                  await fs36.unlink(snapshotPath);
-                  deletedCount++;
-                } catch (error) {
-                  logger.error(`Failed to delete snapshot file ${snapshotPath}:`, error);
-                }
-              }
-            }
-          }
-          return deletedCount;
-        } catch (error) {
-          logger.error("Failed to delete snapshots from index:", error);
-          return 0;
-        }
-      }
-      /**
-       * Clear all snapshots for a session
-       */
-      async clearAllSnapshots(sessionId) {
-        await this.ensureSnapshotsDir();
-        try {
-          const files = await fs36.readdir(this.snapshotsDir);
-          for (const file of files) {
-            if (file.startsWith(sessionId) && file.endsWith(".json")) {
-              const filePath = path44.join(this.snapshotsDir, file);
-              await fs36.unlink(filePath);
-            }
-          }
-        } catch (error) {
-          logger.error("Failed to clear snapshots:", error);
-        }
-      }
-    };
-    hashBasedSnapshotManager = new HashBasedSnapshotManager();
-  }
-});
-
 // dist/utils/core/contextCompressor.js
 function findPreserveStartIndex(messages) {
   if (messages.length === 0) {
@@ -531052,6 +530679,15 @@ async function handleConversationWithTools(options3) {
   } catch (error) {
     console.error("Failed to save user message:", error);
   }
+  try {
+    const { setConversationContext: setConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+    const updatedSession = sessionManager.getCurrentSession();
+    if (updatedSession) {
+      setConversationContext2(updatedSession.id, updatedSession.messages.length);
+    }
+  } catch (error) {
+    console.error("Failed to set conversation context:", error);
+  }
   let encoder;
   let encoderFreed = false;
   const freeEncoder = () => {
@@ -531925,8 +531561,8 @@ async function handleConversationWithTools(options3) {
                   streaming: false
                 };
                 setMessages((prev) => [...prev, compressingMessage]);
-                const session3 = sessionManager.getCurrentSession();
-                const compressionResult = await performAutoCompression(session3 == null ? void 0 : session3.id);
+                const session2 = sessionManager.getCurrentSession();
+                const compressionResult = await performAutoCompression(session2 == null ? void 0 : session2.id);
                 if (compressionResult && compressionResult.hookFailed) {
                   setMessages((prev) => [
                     ...prev,
@@ -531955,9 +531591,9 @@ async function handleConversationWithTools(options3) {
                     accumulatedUsage = compressionResult.usage;
                   }
                   conversationMessages = [];
-                  const session4 = sessionManager.getCurrentSession();
-                  if (session4 && session4.messages.length > 0) {
-                    conversationMessages.push(...session4.messages);
+                  const session3 = sessionManager.getCurrentSession();
+                  if (session3 && session3.messages.length > 0) {
+                    conversationMessages.push(...session3.messages);
                   }
                 }
               } catch (error) {
@@ -531971,15 +531607,6 @@ async function handleConversationWithTools(options3) {
               data: img.data,
               mimeType: img.mimeType
             }));
-            const session2 = sessionManager.getCurrentSession();
-            let pendingMessageIndex = 0;
-            if (session2) {
-              options3.setMessages((prev) => {
-                pendingMessageIndex = prev.length;
-                return prev;
-              });
-              await hashBasedSnapshotManager.createSnapshot(session2.id, pendingMessageIndex);
-            }
             const userMessage = {
               role: "user",
               content: combinedMessage,
@@ -531991,13 +531618,20 @@ async function handleConversationWithTools(options3) {
               content: combinedMessage,
               images: allPendingImages.length > 0 ? allPendingImages : void 0
             });
-            saveMessage({
-              role: "user",
-              content: combinedMessage,
-              images: allPendingImages.length > 0 ? allPendingImages : void 0
-            }).catch((error) => {
+            try {
+              await saveMessage({
+                role: "user",
+                content: combinedMessage,
+                images: allPendingImages.length > 0 ? allPendingImages : void 0
+              });
+              const { setConversationContext: setConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+              const updatedSession = sessionManager.getCurrentSession();
+              if (updatedSession) {
+                setConversationContext2(updatedSession.id, updatedSession.messages.length);
+              }
+            } catch (error) {
               console.error("Failed to save pending user message:", error);
-            });
+            }
           }
         }
         continue;
@@ -532098,20 +531732,10 @@ async function handleConversationWithTools(options3) {
     if (options3.setIsStreaming) {
       options3.setIsStreaming(false);
     }
-    const session2 = sessionManager.getCurrentSession();
-    if (session2) {
-      while (true) {
-        const result2 = await hashBasedSnapshotManager.commitSnapshot(session2.id);
-        if (!result2)
-          break;
-        if (result2.fileCount > 0 && options3.setSnapshotFileCount) {
-          options3.setSnapshotFileCount((prev) => {
-            const newCounts = new Map(prev);
-            newCounts.set(result2.messageIndex, result2.fileCount);
-            return newCounts;
-          });
-        }
-      }
+    try {
+      const { clearConversationContext: clearConversationContext2 } = await Promise.resolve().then(() => (init_conversationContext(), conversationContext_exports));
+      clearConversationContext2();
+    } catch (error) {
     }
     freeEncoder();
   }
@@ -532137,7 +531761,6 @@ var init_useConversation = __esm({
     init_messageFormatter();
     init_resourceMonitor();
     init_toolDisplayConfig();
-    init_hashBasedSnapshot();
     await init_autoCompress();
   }
 });
@@ -532545,8 +532168,8 @@ function useChatLogic(props) {
           streaming: false
         };
         setMessages((prev) => [...prev, compressingMessage]);
-        const session2 = sessionManager.getCurrentSession();
-        const compressionResult = await performAutoCompression(session2 == null ? void 0 : session2.id);
+        const session = sessionManager.getCurrentSession();
+        const compressionResult = await performAutoCompression(session == null ? void 0 : session.id);
         if (compressionResult) {
           clearSavedMessages();
           setMessages(compressionResult.uiMessages);
@@ -532606,12 +532229,6 @@ ${errorMsg}`,
       setMessages((prev) => [...prev, userMessage]);
     }
     streamingState.setIsStreaming(true);
-    const session = sessionManager.getCurrentSession();
-    if (session) {
-      hashBasedSnapshotManager.createSnapshot(session.id, messages.length).catch((error) => {
-        logger.warn("Failed to create snapshot:", error);
-      });
-    }
     const controller = new AbortController();
     streamingState.setAbortController(controller);
     let originalMessage = message;
@@ -532676,18 +532293,6 @@ ${errorMsg}`,
           setCurrentModel: streamingState.setCurrentModel
         });
       } finally {
-        const session2 = sessionManager.getCurrentSession();
-        let result2 = null;
-        if (session2) {
-          result2 = await hashBasedSnapshotManager.commitSnapshot(session2.id, messages.length);
-        }
-        if (result2 && result2.fileCount > 0) {
-          if (session2) {
-            const newCounts = new Map(snapshotState.snapshotFileCount);
-            newCounts.set(result2.messageIndex, result2.fileCount);
-            snapshotState.setSnapshotFileCount(newCounts);
-          }
-        }
       }
     } catch (error) {
       if (!controller.signal.aborted && !userInterruptedRef.current) {
@@ -532701,11 +532306,11 @@ ${errorMsg}`,
       }
     } finally {
       if (userInterruptedRef.current) {
-        const session2 = sessionManager.getCurrentSession();
-        if (session2 && session2.messages.length > 0) {
+        const session = sessionManager.getCurrentSession();
+        if (session && session.messages.length > 0) {
           (async () => {
             try {
-              const messages2 = session2.messages;
+              const messages2 = session.messages;
               let truncateIndex = messages2.length;
               for (let i = messages2.length - 1; i >= 0; i--) {
                 const msg = messages2[i];
@@ -532862,18 +532467,6 @@ ${errorMsg}`,
           setCurrentModel: streamingState.setCurrentModel
         });
       } finally {
-        const session = sessionManager.getCurrentSession();
-        let result2 = null;
-        if (session) {
-          result2 = await hashBasedSnapshotManager.commitSnapshot(session.id);
-        }
-        if (result2 && result2.fileCount > 0) {
-          if (session) {
-            const newCounts = new Map(snapshotState.snapshotFileCount);
-            newCounts.set(result2.messageIndex, result2.fileCount);
-            snapshotState.setSnapshotFileCount(newCounts);
-          }
-        }
       }
     } catch (error) {
       if (!controller.signal.aborted && !userInterruptedRef.current) {
@@ -533515,6 +533108,463 @@ var init_gitignoreValidator = __esm({
   }
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports2, module2) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY2 = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH2 = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define2 = (object2, key, value) => {
+      Object.defineProperty(object2, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range2) => range2.replace(
+      REGEX_REGEXP_RANGE,
+      (match2, from2, to) => from2.charCodeAt(0) <= to.charCodeAt(0) ? match2 : EMPTY2
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY2
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_3, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY2)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_3, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match2) => `\\${match2}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_3, index, str2) => index + 6 < str2.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_3, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match2, leadEscape, range2, endEscape, close) => leadEscape === ESCAPE ? `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range2)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match2) => /\/$/.test(match2) ? `${match2}$` : `${match2}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_3, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_3, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher2, replacer]) => prev.replace(matcher2, replacer.bind(pattern)),
+      pattern
+    );
+    var isString4 = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString4(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define2(this, "body", body);
+        define2(this, "ignoreCase", ignoreCase);
+        define2(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str2 = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex2 = this.ignoreCase ? new RegExp(str2, "i") : new RegExp(str2);
+        return define2(this, key, regex2);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString4(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString4(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path49, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path49);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret2 = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret2.rule = matchedRule;
+        }
+        return ret2;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path49, originalPath, doThrow) => {
+      if (!isString4(path49)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path49) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path49)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path49) => REGEX_TEST_INVALID_PATH.test(path49);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define2(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache4, checkUnignored, slices) {
+        const path49 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path49,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path49, cache4, checkUnignored, slices);
+      }
+      checkIgnore(path49) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path49)) {
+          return this.test(path49);
+        }
+        const slices = path49.split(SLASH2).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH2) + SLASH2,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path49, false, MODE_CHECK_IGNORE);
+      }
+      _t(path49, cache4, checkUnignored, slices) {
+        if (path49 in cache4) {
+          return cache4[path49];
+        }
+        if (!slices) {
+          slices = path49.split(SLASH2).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache4[path49] = this._rules.test(path49, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH2) + SLASH2,
+          cache4,
+          checkUnignored,
+          slices
+        );
+        return cache4[path49] = parent.ignored ? parent : this._rules.test(path49, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path49) {
+        return this._test(path49, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path49) => !this.ignores(path49);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path49) {
+        return this._test(path49, this._testCache, true);
+      }
+    };
+    var factory = (options3) => new Ignore(options3);
+    var isPathValid = (path49) => checkPath(path49 && checkPath.convert(path49), path49, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path49) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path49) || isNotRelative(path49);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module2.exports = factory;
+    factory.default = factory;
+    module2.exports.isPathValid = isPathValid;
+    define2(module2.exports, Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
 // node_modules/readdirp/esm/index.js
 import { stat, lstat, readdir as readdir3, realpath } from "node:fs/promises";
 import { Readable } from "node:stream";
@@ -534503,7 +534553,7 @@ var init_handler = __esm({
 // node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
 import { stat as stat3, readdir as readdir4 } from "fs/promises";
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter9 } from "events";
 import * as sysPath2 from "path";
 function arrify(item) {
   return Array.isArray(item) ? item : [item];
@@ -534705,7 +534755,7 @@ var init_esm4 = __esm({
         return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
       }
     };
-    FSWatcher = class extends EventEmitter8 {
+    FSWatcher = class extends EventEmitter9 {
       // Not indenting methods for history sake; for now.
       constructor(_opts = {}) {
         super();
@@ -535225,11 +535275,11 @@ var init_esm4 = __esm({
 import path47 from "node:path";
 import fs39 from "node:fs";
 import crypto5 from "node:crypto";
-var import_ignore2, CodebaseIndexAgent;
+var import_ignore, CodebaseIndexAgent;
 var init_codebaseIndexAgent = __esm({
   "dist/agents/codebaseIndexAgent.js"() {
     "use strict";
-    import_ignore2 = __toESM(require_ignore(), 1);
+    import_ignore = __toESM(require_ignore(), 1);
     init_esm4();
     init_logger();
     init_codebaseDatabase();
@@ -535307,7 +535357,7 @@ var init_codebaseIndexAgent = __esm({
         this.projectRoot = projectRoot;
         this.config = loadCodebaseConfig();
         this.db = new CodebaseDatabase(projectRoot);
-        this.ignoreFilter = (0, import_ignore2.default)();
+        this.ignoreFilter = (0, import_ignore.default)();
         this.loadGitignore();
         this.addDefaultIgnorePatterns();
       }
@@ -537303,7 +537353,7 @@ function HeadlessModeScreen({ prompt, sessionId, onComplete }) {
   const processMessage = async () => {
     try {
       let loadedMessages = [];
-      let currentSessionId = sessionId;
+      let currentSessionId2 = sessionId;
       if (sessionId) {
         console.log(`
 \x1B[96m Loading session: ${sessionId}\x1B[0m`);
@@ -537325,7 +537375,7 @@ function HeadlessModeScreen({ prompt, sessionId, onComplete }) {
         } else {
           console.log(`\x1B[33m\u26A0 Session not found, starting new session\x1B[0m
 `);
-          currentSessionId = void 0;
+          currentSessionId2 = void 0;
         }
       }
       const { cleanContent, validFiles } = await parseAndValidateFileReferences(prompt);
@@ -537347,7 +537397,7 @@ function HeadlessModeScreen({ prompt, sessionId, onComplete }) {
       if (loadedMessages.length > 0) {
         console.log(`
 \x1B[36m\u250C\u2500 Continuing Session\x1B[0m`);
-        console.log(`\x1B[90m\u2502  Session ID: ${currentSessionId}\x1B[0m`);
+        console.log(`\x1B[90m\u2502  Session ID: ${currentSessionId2}\x1B[0m`);
         console.log(`\x1B[90m\u2502  Previous messages: ${loadedMessages.length}\x1B[0m`);
       }
       console.log(`
@@ -538860,6 +538910,7 @@ var init_taskExecutor = __esm({
 // dist/cli.js
 var import_react133 = __toESM(require_react(), 1);
 await init_build2();
+init_updateNotice();
 await init_build3();
 
 // node_modules/meow/index.js
@@ -539716,13 +539767,12 @@ async function checkForUpdates(currentVersion2) {
     });
     const latestVersion = stdout.trim();
     if (latestVersion && latestVersion !== currentVersion2) {
-      console.log("\n\u{1F514} Update available!");
-      console.log(`   Current version: ${currentVersion2}`);
-      console.log(`   Latest version:  ${latestVersion}`);
-      console.log('   Run "snow --update" to update\n');
-      console.log("   Github: https://github.com/MayDay-wpf/snow-cli");
+      setUpdateNotice({ currentVersion: currentVersion2, latestVersion });
+    } else {
+      setUpdateNotice(null);
     }
-  } catch (error) {
+  } catch {
+    setUpdateNotice(null);
   }
 }
 var cli = meow_default(`
@@ -539823,6 +539873,7 @@ var Startup = ({ version: version2, skipWelcome, autoResume, headlessPrompt, hea
     const init = async () => {
       const deps = await loadDependencies();
       execAsync2 = deps.promisify(deps.exec);
+      setUpdateNotice(null);
       try {
         deps.initializeProfiles();
       } catch (error) {