hybrid 2.0.0 → 2.0.1

package/dist/server/index.cjs

@@ -7854,8 +7854,8 @@ async function listMemoryFiles(workspaceDir, extraPaths, userId, conversationId)
   const hybridMemoryDir = import_node_path.default.join(workspaceDir, ".hybrid", "memory");
   const addMarkdownFile = async (absPath) => {
     try {
-      const stat5 = await import_promises.default.lstat(absPath);
-      if (stat5.isSymbolicLink() || !stat5.isFile()) {
+      const stat2 = await import_promises.default.lstat(absPath);
+      if (stat2.isSymbolicLink() || !stat2.isFile()) {
         return;
       }
       if (!absPath.endsWith(".md")) {
@@ -7888,15 +7888,15 @@ async function listMemoryFiles(workspaceDir, extraPaths, userId, conversationId)
   if (normalizedExtraPaths.length > 0) {
     for (const inputPath of normalizedExtraPaths) {
       try {
-        const stat5 = await import_promises.default.lstat(inputPath);
-        if (stat5.isSymbolicLink()) {
+        const stat2 = await import_promises.default.lstat(inputPath);
+        if (stat2.isSymbolicLink()) {
           continue;
         }
-        if (stat5.isDirectory()) {
+        if (stat2.isDirectory()) {
           await walkDir(inputPath, result);
           continue;
         }
-        if (stat5.isFile() && inputPath.endsWith(".md")) {
+        if (stat2.isFile() && inputPath.endsWith(".md")) {
           result.push(inputPath);
         }
       } catch {
@@ -7940,9 +7940,9 @@ function extractUserIdFromPath(absPath, workspaceDir) {
   return null;
 }
 async function buildFileEntry(absPath, workspaceDir, userId, conversationId) {
-  let stat5;
+  let stat2;
   try {
-    stat5 = await import_promises.default.stat(absPath);
+    stat2 = await import_promises.default.stat(absPath);
   } catch (err) {
     if (isFileMissingError(err)) {
       return null;
@@ -7964,8 +7964,8 @@ async function buildFileEntry(absPath, workspaceDir, userId, conversationId) {
   return {
     path: import_node_path.default.relative(workspaceDir, absPath).replace(/\\/g, "/"),
     absPath,
-    mtimeMs: stat5.mtimeMs,
-    size: stat5.size,
+    mtimeMs: stat2.mtimeMs,
+    size: stat2.size,
     hash: hash2,
     userId: effectiveUserId,
     conversationId
@@ -8699,7 +8699,7 @@ var require_tr46 = __commonJS({
       TRANSITIONAL: 0,
       NONTRANSITIONAL: 1
     };
-    function normalize2(str2) {
+    function normalize(str2) {
       return str2.split("\0").map(function(s2) {
         return s2.normalize("NFC");
       }).join("\0");
@@ -8779,7 +8779,7 @@ var require_tr46 = __commonJS({
         processing_option = PROCESSING_OPTIONS.NONTRANSITIONAL;
       }
       var error48 = false;
-      if (normalize2(label) !== label || label[3] === "-" && label[4] === "-" || label[0] === "-" || label[label.length - 1] === "-" || label.indexOf(".") !== -1 || label.search(combiningMarksRegex) === 0) {
+      if (normalize(label) !== label || label[3] === "-" && label[4] === "-" || label[0] === "-" || label[label.length - 1] === "-" || label.indexOf(".") !== -1 || label.search(combiningMarksRegex) === 0) {
         error48 = true;
       }
       var len = countSymbols(label);
@@ -8797,7 +8797,7 @@ var require_tr46 = __commonJS({
     }
     function processing(domain_name, useSTD3, processing_option) {
       var result = mapChars(domain_name, useSTD3, processing_option);
-      result.string = normalize2(result.string);
+      result.string = normalize(result.string);
       var labels = result.string.split(".");
       for (var i2 = 0; i2 < labels.length; ++i2) {
         try {
@@ -9240,14 +9240,14 @@ var require_url_state_machine = __commonJS({
       return url2.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url2) {
-      const path6 = url2.path;
-      if (path6.length === 0) {
+      const path4 = url2.path;
+      if (path4.length === 0) {
         return;
       }
-      if (url2.scheme === "file" && path6.length === 1 && isNormalizedWindowsDriveLetter(path6[0])) {
+      if (url2.scheme === "file" && path4.length === 1 && isNormalizedWindowsDriveLetter(path4[0])) {
         return;
       }
-      path6.pop();
+      path4.pop();
     }
     function includesCredentials(url2) {
       return url2.username !== "" || url2.password !== "";
@@ -10291,7 +10291,7 @@ var require_lib2 = __commonJS({
     var whatwgUrl = _interopDefault(require_public_api());
     var https = _interopDefault(require("https"));
     var zlib = _interopDefault(require("zlib"));
-    var Readable3 = Stream2.Readable;
+    var Readable2 = Stream2.Readable;
     var BUFFER = /* @__PURE__ */ Symbol("buffer");
     var TYPE = /* @__PURE__ */ Symbol("type");
     var Blob3 = class _Blob {
@@ -10343,7 +10343,7 @@ var require_lib2 = __commonJS({
         return Promise.resolve(ab);
       }
       stream() {
-        const readable = new Readable3();
+        const readable = new Readable2();
         readable._read = function() {
         };
         readable.push(this[BUFFER]);
@@ -10567,7 +10567,7 @@ var require_lib2 = __commonJS({
       let accum = [];
       let accumBytes = 0;
       let abort = false;
-      return new Body.Promise(function(resolve6, reject) {
+      return new Body.Promise(function(resolve4, reject) {
         let resTimeout;
         if (_this4.timeout) {
           resTimeout = setTimeout(function() {
@@ -10601,7 +10601,7 @@ var require_lib2 = __commonJS({
           }
           clearTimeout(resTimeout);
           try {
-            resolve6(Buffer.concat(accum, accumBytes));
+            resolve4(Buffer.concat(accum, accumBytes));
           } catch (err) {
             reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
           }
@@ -11276,7 +11276,7 @@ var require_lib2 = __commonJS({
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
       Body.Promise = fetch3.Promise;
-      return new fetch3.Promise(function(resolve6, reject) {
+      return new fetch3.Promise(function(resolve4, reject) {
         const request = new Request3(url2, opts);
         const options = getNodeRequestOptions(request);
         const send = (options.protocol === "https:" ? https : http).request;
@@ -11409,7 +11409,7 @@ var require_lib2 = __commonJS({
                   requestOpts.body = void 0;
                   requestOpts.headers.delete("content-length");
                 }
-                resolve6(fetch3(new Request3(locationURL, requestOpts)));
+                resolve4(fetch3(new Request3(locationURL, requestOpts)));
                 finalize2();
                 return;
             }
@@ -11430,7 +11430,7 @@ var require_lib2 = __commonJS({
           const codings = headers.get("Content-Encoding");
           if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
             response = new Response4(body, response_options);
-            resolve6(response);
+            resolve4(response);
             return;
           }
           const zlibOptions = {
@@ -11440,7 +11440,7 @@ var require_lib2 = __commonJS({
           if (codings == "gzip" || codings == "x-gzip") {
             body = body.pipe(zlib.createGunzip(zlibOptions));
             response = new Response4(body, response_options);
-            resolve6(response);
+            resolve4(response);
             return;
           }
           if (codings == "deflate" || codings == "x-deflate") {
@@ -11452,12 +11452,12 @@ var require_lib2 = __commonJS({
                 body = body.pipe(zlib.createInflateRaw());
               }
               response = new Response4(body, response_options);
-              resolve6(response);
+              resolve4(response);
             });
             raw.on("end", function() {
               if (!response) {
                 response = new Response4(body, response_options);
-                resolve6(response);
+                resolve4(response);
               }
             });
             return;
@@ -11465,11 +11465,11 @@ var require_lib2 = __commonJS({
           if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
             body = body.pipe(zlib.createBrotliDecompress());
             response = new Response4(body, response_options);
-            resolve6(response);
+            resolve4(response);
             return;
           }
           response = new Response4(body, response_options);
-          resolve6(response);
+          resolve4(response);
         });
         writeToStream(req, request);
       });
@@ -15231,14 +15231,14 @@ __export(fileFromPath_exports, {
   fileFromPathSync: () => fileFromPathSync,
   isFile: () => isFile
 });
-function createFileFromPath(path6, { mtimeMs, size }, filenameOrOptions, options = {}) {
+function createFileFromPath(path4, { mtimeMs, size }, filenameOrOptions, options = {}) {
   let filename;
   if (isPlainObject_default2(filenameOrOptions)) {
     [options, filename] = [filenameOrOptions, void 0];
   } else {
     filename = filenameOrOptions;
   }
-  const file2 = new FileFromPath({ path: path6, size, lastModified: mtimeMs });
+  const file2 = new FileFromPath({ path: path4, size, lastModified: mtimeMs });
   if (!filename) {
     filename = file2.name;
   }
@@ -15247,13 +15247,13 @@ function createFileFromPath(path6, { mtimeMs, size }, filenameOrOptions, options
     lastModified: file2.lastModified
   });
 }
-function fileFromPathSync(path6, filenameOrOptions, options = {}) {
-  const stats = (0, import_fs2.statSync)(path6);
-  return createFileFromPath(path6, stats, filenameOrOptions, options);
+function fileFromPathSync(path4, filenameOrOptions, options = {}) {
+  const stats = (0, import_fs2.statSync)(path4);
+  return createFileFromPath(path4, stats, filenameOrOptions, options);
 }
-async function fileFromPath2(path6, filenameOrOptions, options) {
-  const stats = await import_fs2.promises.stat(path6);
-  return createFileFromPath(path6, stats, filenameOrOptions, options);
+async function fileFromPath2(path4, filenameOrOptions, options) {
+  const stats = await import_fs2.promises.stat(path4);
+  return createFileFromPath(path4, stats, filenameOrOptions, options);
 }
 var import_fs2, import_path2, import_node_domexception, __classPrivateFieldSet4, __classPrivateFieldGet5, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
 var init_fileFromPath = __esm({
@@ -15314,13 +15314,13 @@ var init_fileFromPath = __esm({
 });
 
 // ../../node_modules/.pnpm/openai@4.104.0_ws@8.18.3_bufferutil@4.0.9_utf-8-validate@5.0.10__zod@3.25.76/node_modules/openai/_shims/node-runtime.mjs
-async function fileFromPath3(path6, ...args) {
+async function fileFromPath3(path4, ...args) {
   const { fileFromPath: _fileFromPath } = await Promise.resolve().then(() => (init_fileFromPath(), fileFromPath_exports));
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path6)}) instead`);
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path4)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path6, ...args);
+  return await _fileFromPath(path4, ...args);
 }
 async function getMultipartRequestOptions2(form, opts) {
   const encoder = new FormDataEncoder(form);
@@ -16150,8 +16150,8 @@ var init_core = __esm({
     init();
     APIPromise = class _APIPromise extends Promise {
       constructor(responsePromise, parseResponse2 = defaultParseResponse) {
-        super((resolve6) => {
-          resolve6(null);
+        super((resolve4) => {
+          resolve4(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse2;
@@ -16253,29 +16253,29 @@ var init_core = __esm({
       defaultIdempotencyKey() {
         return `stainless-node-retry-${uuid42()}`;
       }
-      get(path6, opts) {
-        return this.methodRequest("get", path6, opts);
+      get(path4, opts) {
+        return this.methodRequest("get", path4, opts);
       }
-      post(path6, opts) {
-        return this.methodRequest("post", path6, opts);
+      post(path4, opts) {
+        return this.methodRequest("post", path4, opts);
       }
-      patch(path6, opts) {
-        return this.methodRequest("patch", path6, opts);
+      patch(path4, opts) {
+        return this.methodRequest("patch", path4, opts);
       }
-      put(path6, opts) {
-        return this.methodRequest("put", path6, opts);
+      put(path4, opts) {
+        return this.methodRequest("put", path4, opts);
       }
-      delete(path6, opts) {
-        return this.methodRequest("delete", path6, opts);
+      delete(path4, opts) {
+        return this.methodRequest("delete", path4, opts);
       }
-      methodRequest(method, path6, opts) {
+      methodRequest(method, path4, opts) {
         return this.request(Promise.resolve(opts).then(async (opts2) => {
           const body = opts2 && isBlobLike(opts2?.body) ? new DataView(await opts2.body.arrayBuffer()) : opts2?.body instanceof DataView ? opts2.body : opts2?.body instanceof ArrayBuffer ? new DataView(opts2.body) : opts2 && ArrayBuffer.isView(opts2?.body) ? new DataView(opts2.body.buffer) : opts2?.body;
-          return { method, path: path6, ...opts2, body };
+          return { method, path: path4, ...opts2, body };
         }));
       }
-      getAPIList(path6, Page2, opts) {
-        return this.requestAPIList(Page2, { method: "get", path: path6, ...opts });
+      getAPIList(path4, Page2, opts) {
+        return this.requestAPIList(Page2, { method: "get", path: path4, ...opts });
       }
       calculateContentLength(body) {
         if (typeof body === "string") {
@@ -16294,10 +16294,10 @@ var init_core = __esm({
       }
       buildRequest(inputOptions, { retryCount = 0 } = {}) {
         const options = { ...inputOptions };
-        const { method, path: path6, query: query2, headers = {} } = options;
+        const { method, path: path4, query: query2, headers = {} } = options;
         const body = ArrayBuffer.isView(options.body) || options.__binaryRequest && typeof options.body === "string" ? options.body : isMultipartBody(options.body) ? options.body.body : options.body ? JSON.stringify(options.body, null, 2) : null;
         const contentLength = this.calculateContentLength(body);
-        const url2 = this.buildURL(path6, query2);
+        const url2 = this.buildURL(path4, query2);
         if ("timeout" in options)
           validatePositiveInteger("timeout", options.timeout);
         options.timeout = options.timeout ?? this.timeout;
@@ -16413,8 +16413,8 @@ var init_core = __esm({
         const request = this.makeRequest(options, null);
         return new PagePromise(this, request, Page2);
       }
-      buildURL(path6, query2) {
-        const url2 = isAbsoluteURL(path6) ? new URL(path6) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path6.startsWith("/") ? path6.slice(1) : path6));
+      buildURL(path4, query2) {
+        const url2 = isAbsoluteURL(path4) ? new URL(path4) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path4.startsWith("/") ? path4.slice(1) : path4));
         const defaultQuery = this.defaultQuery();
         if (!isEmptyObj(defaultQuery)) {
           query2 = { ...defaultQuery, ...query2 };
@@ -16702,7 +16702,7 @@ var init_core = __esm({
     isAbsoluteURL = (url2) => {
       return startsWithSchemeRegexp.test(url2);
     };
-    sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+    sleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
     validatePositiveInteger = (name, n2) => {
       if (typeof n2 !== "number" || !Number.isInteger(n2)) {
         throw new OpenAIError(`${name} must be an integer`);
@@ -17163,12 +17163,12 @@ var init_EventStream = __esm({
         _EventStream_errored.set(this, false);
         _EventStream_aborted.set(this, false);
         _EventStream_catchingPromiseCreated.set(this, false);
-        __classPrivateFieldSet7(this, _EventStream_connectedPromise, new Promise((resolve6, reject) => {
-          __classPrivateFieldSet7(this, _EventStream_resolveConnectedPromise, resolve6, "f");
+        __classPrivateFieldSet7(this, _EventStream_connectedPromise, new Promise((resolve4, reject) => {
+          __classPrivateFieldSet7(this, _EventStream_resolveConnectedPromise, resolve4, "f");
           __classPrivateFieldSet7(this, _EventStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet7(this, _EventStream_endPromise, new Promise((resolve6, reject) => {
-          __classPrivateFieldSet7(this, _EventStream_resolveEndPromise, resolve6, "f");
+        __classPrivateFieldSet7(this, _EventStream_endPromise, new Promise((resolve4, reject) => {
+          __classPrivateFieldSet7(this, _EventStream_resolveEndPromise, resolve4, "f");
           __classPrivateFieldSet7(this, _EventStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet8(this, _EventStream_connectedPromise, "f").catch(() => {
@@ -17252,11 +17252,11 @@ var init_EventStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve4, reject) => {
           __classPrivateFieldSet7(this, _EventStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve6);
+          this.once(event, resolve4);
         });
       }
       async done() {
@@ -17398,7 +17398,7 @@ var init_AssistantStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve6, reject) => readQueue.push({ resolve: resolve6, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -19141,7 +19141,7 @@ var init_ChatCompletionStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve6, reject) => readQueue.push({ resolve: resolve6, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -20994,7 +20994,7 @@ var init_ResponseStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve6, reject) => readQueue.push({ resolve: resolve6, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve4, reject) => readQueue.push({ resolve: resolve4, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
             }
             const event = pushQueue.shift();
             return { value: event, done: false };
@@ -22863,1960 +22863,18 @@ var init_manager = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
-function readdirp(root, options = {}) {
-  let type = options.entryType || options.type;
-  if (type === "both")
-    type = EntryTypes.FILE_DIR_TYPE;
-  if (type)
-    options.type = type;
-  if (!root) {
-    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
-  } else if (typeof root !== "string") {
-    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-  } else if (type && !ALL_TYPES.includes(type)) {
-    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
-  }
-  options.root = root;
-  return new ReaddirpStream(options);
-}
-var import_promises3, import_node_stream2, import_node_path3, EntryTypes, defaultOptions2, RECURSIVE_ERROR_CODE, NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError, wantBigintFsStats, emptyFn, normalizeFilter, ReaddirpStream;
-var init_esm3 = __esm({
-  "../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js"() {
-    import_promises3 = require("node:fs/promises");
-    import_node_stream2 = require("node:stream");
-    import_node_path3 = require("node:path");
-    EntryTypes = {
-      FILE_TYPE: "files",
-      DIR_TYPE: "directories",
-      FILE_DIR_TYPE: "files_directories",
-      EVERYTHING_TYPE: "all"
-    };
-    defaultOptions2 = {
-      root: ".",
-      fileFilter: (_entryInfo) => true,
-      directoryFilter: (_entryInfo) => true,
-      type: EntryTypes.FILE_TYPE,
-      lstat: false,
-      depth: 2147483648,
-      alwaysStat: false,
-      highWaterMark: 4096
-    };
-    Object.freeze(defaultOptions2);
-    RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
-    NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
-    ALL_TYPES = [
-      EntryTypes.DIR_TYPE,
-      EntryTypes.EVERYTHING_TYPE,
-      EntryTypes.FILE_DIR_TYPE,
-      EntryTypes.FILE_TYPE
-    ];
-    DIR_TYPES = /* @__PURE__ */ new Set([
-      EntryTypes.DIR_TYPE,
-      EntryTypes.EVERYTHING_TYPE,
-      EntryTypes.FILE_DIR_TYPE
-    ]);
-    FILE_TYPES = /* @__PURE__ */ new Set([
-      EntryTypes.EVERYTHING_TYPE,
-      EntryTypes.FILE_DIR_TYPE,
-      EntryTypes.FILE_TYPE
-    ]);
-    isNormalFlowError = (error48) => NORMAL_FLOW_ERRORS.has(error48.code);
-    wantBigintFsStats = process.platform === "win32";
-    emptyFn = (_entryInfo) => true;
-    normalizeFilter = (filter) => {
-      if (filter === void 0)
-        return emptyFn;
-      if (typeof filter === "function")
-        return filter;
-      if (typeof filter === "string") {
-        const fl = filter.trim();
-        return (entry) => entry.basename === fl;
-      }
-      if (Array.isArray(filter)) {
-        const trItems = filter.map((item) => item.trim());
-        return (entry) => trItems.some((f2) => entry.basename === f2);
-      }
-      return emptyFn;
-    };
-    ReaddirpStream = class extends import_node_stream2.Readable {
-      constructor(options = {}) {
-        super({
-          objectMode: true,
-          autoDestroy: true,
-          highWaterMark: options.highWaterMark
-        });
-        const opts = { ...defaultOptions2, ...options };
-        const { root, type } = opts;
-        this._fileFilter = normalizeFilter(opts.fileFilter);
-        this._directoryFilter = normalizeFilter(opts.directoryFilter);
-        const statMethod = opts.lstat ? import_promises3.lstat : import_promises3.stat;
-        if (wantBigintFsStats) {
-          this._stat = (path6) => statMethod(path6, { bigint: true });
-        } else {
-          this._stat = statMethod;
-        }
-        this._maxDepth = opts.depth ?? defaultOptions2.depth;
-        this._wantsDir = type ? DIR_TYPES.has(type) : false;
-        this._wantsFile = type ? FILE_TYPES.has(type) : false;
-        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-        this._root = (0, import_node_path3.resolve)(root);
-        this._isDirent = !opts.alwaysStat;
-        this._statsProp = this._isDirent ? "dirent" : "stats";
-        this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
-        this.parents = [this._exploreDir(root, 1)];
-        this.reading = false;
-        this.parent = void 0;
-      }
-      async _read(batch) {
-        if (this.reading)
-          return;
-        this.reading = true;
-        try {
-          while (!this.destroyed && batch > 0) {
-            const par = this.parent;
-            const fil = par && par.files;
-            if (fil && fil.length > 0) {
-              const { path: path6, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
-              const awaited = await Promise.all(slice);
-              for (const entry of awaited) {
-                if (!entry)
-                  continue;
-                if (this.destroyed)
-                  return;
-                const entryType = await this._getEntryType(entry);
-                if (entryType === "directory" && this._directoryFilter(entry)) {
-                  if (depth <= this._maxDepth) {
-                    this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-                  }
-                  if (this._wantsDir) {
-                    this.push(entry);
-                    batch--;
-                  }
-                } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
-                  if (this._wantsFile) {
-                    this.push(entry);
-                    batch--;
-                  }
-                }
-              }
-            } else {
-              const parent = this.parents.pop();
-              if (!parent) {
-                this.push(null);
-                break;
-              }
-              this.parent = await parent;
-              if (this.destroyed)
-                return;
-            }
-          }
-        } catch (error48) {
-          this.destroy(error48);
-        } finally {
-          this.reading = false;
-        }
-      }
-      async _exploreDir(path6, depth) {
-        let files;
-        try {
-          files = await (0, import_promises3.readdir)(path6, this._rdOptions);
-        } catch (error48) {
-          this._onError(error48);
-        }
-        return { files, depth, path: path6 };
-      }
-      async _formatEntry(dirent, path6) {
-        let entry;
-        const basename4 = this._isDirent ? dirent.name : dirent;
-        try {
-          const fullPath = (0, import_node_path3.resolve)((0, import_node_path3.join)(path6, basename4));
-          entry = { path: (0, import_node_path3.relative)(this._root, fullPath), fullPath, basename: basename4 };
-          entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-        } catch (err) {
-          this._onError(err);
-          return;
-        }
-        return entry;
-      }
-      _onError(err) {
-        if (isNormalFlowError(err) && !this.destroyed) {
-          this.emit("warn", err);
-        } else {
-          this.destroy(err);
-        }
-      }
-      async _getEntryType(entry) {
-        if (!entry && this._statsProp in entry) {
-          return "";
-        }
-        const stats = entry[this._statsProp];
-        if (stats.isFile())
-          return "file";
-        if (stats.isDirectory())
-          return "directory";
-        if (stats && stats.isSymbolicLink()) {
-          const full = entry.fullPath;
-          try {
-            const entryRealPath = await (0, import_promises3.realpath)(full);
-            const entryRealPathStats = await (0, import_promises3.lstat)(entryRealPath);
-            if (entryRealPathStats.isFile()) {
-              return "file";
-            }
-            if (entryRealPathStats.isDirectory()) {
-              const len = entryRealPath.length;
-              if (full.startsWith(entryRealPath) && full.substr(len, 1) === import_node_path3.sep) {
-                const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-                recursiveError.code = RECURSIVE_ERROR_CODE;
-                return this._onError(recursiveError);
-              }
-              return "directory";
-            }
-          } catch (error48) {
-            this._onError(error48);
-            return "";
-          }
-        }
-      }
-      _includeAsFile(entry) {
-        const stats = entry && entry[this._statsProp];
-        return stats && this._wantsEverything && !stats.isDirectory();
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
-function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path6);
-    emitRaw(rawEvent, evPath, { watchedPath: path6 });
-    if (evPath && path6 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path6, evPath), KEY_LISTENERS, sysPath.join(path6, evPath));
-    }
-  };
-  try {
-    return (0, import_fs3.watch)(path6, {
-      persistent: options.persistent
-    }, handleEvent);
-  } catch (error48) {
-    errHandler(error48);
-    return void 0;
-  }
-}
-var import_fs3, import_promises4, sysPath, import_os, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
-var init_handler = __esm({
-  "../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js"() {
-    import_fs3 = require("fs");
-    import_promises4 = require("fs/promises");
-    sysPath = __toESM(require("path"), 1);
-    import_os = require("os");
-    STR_DATA = "data";
-    STR_END = "end";
-    STR_CLOSE = "close";
-    EMPTY_FN = () => {
-    };
-    pl = process.platform;
-    isWindows = pl === "win32";
-    isMacos = pl === "darwin";
-    isLinux = pl === "linux";
-    isFreeBSD = pl === "freebsd";
-    isIBMi = (0, import_os.type)() === "OS400";
-    EVENTS = {
-      ALL: "all",
-      READY: "ready",
-      ADD: "add",
-      CHANGE: "change",
-      ADD_DIR: "addDir",
-      UNLINK: "unlink",
-      UNLINK_DIR: "unlinkDir",
-      RAW: "raw",
-      ERROR: "error"
-    };
-    EV = EVENTS;
-    THROTTLE_MODE_WATCH = "watch";
-    statMethods = { lstat: import_promises4.lstat, stat: import_promises4.stat };
-    KEY_LISTENERS = "listeners";
-    KEY_ERR = "errHandlers";
-    KEY_RAW = "rawEmitters";
-    HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
-    binaryExtensions = /* @__PURE__ */ new Set([
-      "3dm",
-      "3ds",
-      "3g2",
-      "3gp",
-      "7z",
-      "a",
-      "aac",
-      "adp",
-      "afdesign",
-      "afphoto",
-      "afpub",
-      "ai",
-      "aif",
-      "aiff",
-      "alz",
-      "ape",
-      "apk",
-      "appimage",
-      "ar",
-      "arj",
-      "asf",
-      "au",
-      "avi",
-      "bak",
-      "baml",
-      "bh",
-      "bin",
-      "bk",
-      "bmp",
-      "btif",
-      "bz2",
-      "bzip2",
-      "cab",
-      "caf",
-      "cgm",
-      "class",
-      "cmx",
-      "cpio",
-      "cr2",
-      "cur",
-      "dat",
-      "dcm",
-      "deb",
-      "dex",
-      "djvu",
-      "dll",
-      "dmg",
-      "dng",
-      "doc",
-      "docm",
-      "docx",
-      "dot",
-      "dotm",
-      "dra",
-      "DS_Store",
-      "dsk",
-      "dts",
-      "dtshd",
-      "dvb",
-      "dwg",
-      "dxf",
-      "ecelp4800",
-      "ecelp7470",
-      "ecelp9600",
-      "egg",
-      "eol",
-      "eot",
-      "epub",
-      "exe",
-      "f4v",
-      "fbs",
-      "fh",
-      "fla",
-      "flac",
-      "flatpak",
-      "fli",
-      "flv",
-      "fpx",
-      "fst",
-      "fvt",
-      "g3",
-      "gh",
-      "gif",
-      "graffle",
-      "gz",
-      "gzip",
-      "h261",
-      "h263",
-      "h264",
-      "icns",
-      "ico",
-      "ief",
-      "img",
-      "ipa",
-      "iso",
-      "jar",
-      "jpeg",
-      "jpg",
-      "jpgv",
-      "jpm",
-      "jxr",
-      "key",
-      "ktx",
-      "lha",
-      "lib",
-      "lvp",
-      "lz",
-      "lzh",
-      "lzma",
-      "lzo",
-      "m3u",
-      "m4a",
-      "m4v",
-      "mar",
-      "mdi",
-      "mht",
-      "mid",
-      "midi",
-      "mj2",
-      "mka",
-      "mkv",
-      "mmr",
-      "mng",
-      "mobi",
-      "mov",
-      "movie",
-      "mp3",
-      "mp4",
-      "mp4a",
-      "mpeg",
-      "mpg",
-      "mpga",
-      "mxu",
-      "nef",
-      "npx",
-      "numbers",
-      "nupkg",
-      "o",
-      "odp",
-      "ods",
-      "odt",
-      "oga",
-      "ogg",
-      "ogv",
-      "otf",
-      "ott",
-      "pages",
-      "pbm",
-      "pcx",
-      "pdb",
-      "pdf",
-      "pea",
-      "pgm",
-      "pic",
-      "png",
-      "pnm",
-      "pot",
-      "potm",
-      "potx",
-      "ppa",
-      "ppam",
-      "ppm",
-      "pps",
-      "ppsm",
-      "ppsx",
-      "ppt",
-      "pptm",
-      "pptx",
-      "psd",
-      "pya",
-      "pyc",
-      "pyo",
-      "pyv",
-      "qt",
-      "rar",
-      "ras",
-      "raw",
-      "resources",
-      "rgb",
-      "rip",
-      "rlc",
-      "rmf",
-      "rmvb",
-      "rpm",
-      "rtf",
-      "rz",
-      "s3m",
-      "s7z",
-      "scpt",
-      "sgi",
-      "shar",
-      "snap",
-      "sil",
-      "sketch",
-      "slk",
-      "smv",
-      "snk",
-      "so",
-      "stl",
-      "suo",
-      "sub",
-      "swf",
-      "tar",
-      "tbz",
-      "tbz2",
-      "tga",
-      "tgz",
-      "thmx",
-      "tif",
-      "tiff",
-      "tlz",
-      "ttc",
-      "ttf",
-      "txz",
-      "udf",
-      "uvh",
-      "uvi",
-      "uvm",
-      "uvp",
-      "uvs",
-      "uvu",
-      "viv",
-      "vob",
-      "war",
-      "wav",
-      "wax",
-      "wbmp",
-      "wdp",
-      "weba",
-      "webm",
-      "webp",
-      "whl",
-      "wim",
-      "wm",
-      "wma",
-      "wmv",
-      "wmx",
-      "woff",
-      "woff2",
-      "wrm",
-      "wvx",
-      "xbm",
-      "xif",
-      "xla",
-      "xlam",
-      "xls",
-      "xlsb",
-      "xlsm",
-      "xlsx",
-      "xlt",
-      "xltm",
-      "xltx",
-      "xm",
-      "xmind",
-      "xpi",
-      "xpm",
-      "xwd",
-      "xz",
-      "z",
-      "zip",
-      "zipx"
-    ]);
-    isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
-    foreach = (val, fn) => {
-      if (val instanceof Set) {
-        val.forEach(fn);
-      } else {
-        fn(val);
-      }
-    };
-    addAndConvert = (main, prop, item) => {
-      let container = main[prop];
-      if (!(container instanceof Set)) {
-        main[prop] = container = /* @__PURE__ */ new Set([container]);
-      }
-      container.add(item);
-    };
-    clearItem = (cont) => (key) => {
-      const set2 = cont[key];
-      if (set2 instanceof Set) {
-        set2.clear();
-      } else {
-        delete cont[key];
-      }
-    };
-    delFromSet = (main, prop, item) => {
-      const container = main[prop];
-      if (container instanceof Set) {
-        container.delete(item);
-      } else if (container === item) {
-        delete main[prop];
-      }
-    };
-    isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-    FsWatchInstances = /* @__PURE__ */ new Map();
-    fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
-      const cont = FsWatchInstances.get(fullPath);
-      if (!cont)
-        return;
-      foreach(cont[listenerType], (listener) => {
-        listener(val1, val2, val3);
-      });
-    };
-    setFsWatchListener = (path6, fullPath, options, handlers) => {
-      const { listener, errHandler, rawEmitter } = handlers;
-      let cont = FsWatchInstances.get(fullPath);
-      let watcher;
-      if (!options.persistent) {
-        watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
-        if (!watcher)
-          return;
-        return watcher.close.bind(watcher);
-      }
-      if (cont) {
-        addAndConvert(cont, KEY_LISTENERS, listener);
-        addAndConvert(cont, KEY_ERR, errHandler);
-        addAndConvert(cont, KEY_RAW, rawEmitter);
-      } else {
-        watcher = createFsWatchInstance(
-          path6,
-          options,
-          fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
-          errHandler,
-          // no need to use broadcast here
-          fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
-        );
-        if (!watcher)
-          return;
-        watcher.on(EV.ERROR, async (error48) => {
-          const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
-          if (cont)
-            cont.watcherUnusable = true;
-          if (isWindows && error48.code === "EPERM") {
-            try {
-              const fd = await (0, import_promises4.open)(path6, "r");
-              await fd.close();
-              broadcastErr(error48);
-            } catch (err) {
-            }
-          } else {
-            broadcastErr(error48);
-          }
-        });
-        cont = {
-          listeners: listener,
-          errHandlers: errHandler,
-          rawEmitters: rawEmitter,
-          watcher
-        };
-        FsWatchInstances.set(fullPath, cont);
-      }
-      return () => {
-        delFromSet(cont, KEY_LISTENERS, listener);
-        delFromSet(cont, KEY_ERR, errHandler);
-        delFromSet(cont, KEY_RAW, rawEmitter);
-        if (isEmptySet(cont.listeners)) {
-          cont.watcher.close();
-          FsWatchInstances.delete(fullPath);
-          HANDLER_KEYS.forEach(clearItem(cont));
-          cont.watcher = void 0;
-          Object.freeze(cont);
-        }
-      };
-    };
-    FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path6, fullPath, options, handlers) => {
-      const { listener, rawEmitter } = handlers;
-      let cont = FsWatchFileInstances.get(fullPath);
-      const copts = cont && cont.options;
-      if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-        (0, import_fs3.unwatchFile)(fullPath);
-        cont = void 0;
-      }
-      if (cont) {
-        addAndConvert(cont, KEY_LISTENERS, listener);
-        addAndConvert(cont, KEY_RAW, rawEmitter);
-      } else {
-        cont = {
-          listeners: listener,
-          rawEmitters: rawEmitter,
-          options,
-          watcher: (0, import_fs3.watchFile)(fullPath, options, (curr, prev) => {
-            foreach(cont.rawEmitters, (rawEmitter2) => {
-              rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
-            });
-            const currmtime = curr.mtimeMs;
-            if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path6, curr));
-            }
-          })
-        };
-        FsWatchFileInstances.set(fullPath, cont);
-      }
-      return () => {
-        delFromSet(cont, KEY_LISTENERS, listener);
-        delFromSet(cont, KEY_RAW, rawEmitter);
-        if (isEmptySet(cont.listeners)) {
-          FsWatchFileInstances.delete(fullPath);
-          (0, import_fs3.unwatchFile)(fullPath);
-          cont.options = cont.watcher = void 0;
-          Object.freeze(cont);
-        }
-      };
-    };
-    NodeFsHandler = class {
-      constructor(fsW) {
-        this.fsw = fsW;
-        this._boundHandleError = (error48) => fsW._handleError(error48);
-      }
-      /**
-       * Watch file for changes with fs_watchFile or fs_watch.
-       * @param path to file or dir
-       * @param listener on fs change
-       * @returns closer for the watcher instance
-       */
-      _watchWithNodeFs(path6, listener) {
-        const opts = this.fsw.options;
-        const directory = sysPath.dirname(path6);
-        const basename4 = sysPath.basename(path6);
-        const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename4);
-        const absolutePath = sysPath.resolve(path6);
-        const options = {
-          persistent: opts.persistent
-        };
-        if (!listener)
-          listener = EMPTY_FN;
-        let closer;
-        if (opts.usePolling) {
-          const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path6, absolutePath, options, {
-            listener,
-            rawEmitter: this.fsw._emitRaw
-          });
-        } else {
-          closer = setFsWatchListener(path6, absolutePath, options, {
-            listener,
-            errHandler: this._boundHandleError,
-            rawEmitter: this.fsw._emitRaw
-          });
-        }
-        return closer;
-      }
-      /**
-       * Watch a file and emit add event if warranted.
-       * @returns closer for the watcher instance
-       */
-      _handleFile(file2, stats, initialAdd) {
-        if (this.fsw.closed) {
-          return;
-        }
-        const dirname7 = sysPath.dirname(file2);
-        const basename4 = sysPath.basename(file2);
-        const parent = this.fsw._getWatchedDir(dirname7);
-        let prevStats = stats;
-        if (parent.has(basename4))
-          return;
-        const listener = async (path6, newStats) => {
-          if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
-            return;
-          if (!newStats || newStats.mtimeMs === 0) {
-            try {
-              const newStats2 = await (0, import_promises4.stat)(file2);
-              if (this.fsw.closed)
-                return;
-              const at2 = newStats2.atimeMs;
-              const mt2 = newStats2.mtimeMs;
-              if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
-                this.fsw._emit(EV.CHANGE, file2, newStats2);
-              }
-              if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path6);
-                prevStats = newStats2;
-                const closer2 = this._watchWithNodeFs(file2, listener);
-                if (closer2)
-                  this.fsw._addPathCloser(path6, closer2);
-              } else {
-                prevStats = newStats2;
-              }
-            } catch (error48) {
-              this.fsw._remove(dirname7, basename4);
-            }
-          } else if (parent.has(basename4)) {
-            const at2 = newStats.atimeMs;
-            const mt2 = newStats.mtimeMs;
-            if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
-              this.fsw._emit(EV.CHANGE, file2, newStats);
-            }
-            prevStats = newStats;
-          }
-        };
-        const closer = this._watchWithNodeFs(file2, listener);
-        if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file2)) {
-          if (!this.fsw._throttle(EV.ADD, file2, 0))
-            return;
-          this.fsw._emit(EV.ADD, file2, stats);
-        }
-        return closer;
-      }
-      /**
-       * Handle symlinks encountered while reading a dir.
-       * @param entry returned by readdirp
-       * @param directory path of dir being read
-       * @param path of this item
-       * @param item basename of this item
-       * @returns true if no more processing is needed for this entry.
-       */
-      async _handleSymlink(entry, directory, path6, item) {
-        if (this.fsw.closed) {
-          return;
-        }
-        const full = entry.fullPath;
-        const dir = this.fsw._getWatchedDir(directory);
-        if (!this.fsw.options.followSymlinks) {
-          this.fsw._incrReadyCount();
-          let linkPath;
-          try {
-            linkPath = await (0, import_promises4.realpath)(path6);
-          } catch (e2) {
-            this.fsw._emitReady();
-            return true;
-          }
-          if (this.fsw.closed)
-            return;
-          if (dir.has(item)) {
-            if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-              this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path6, entry.stats);
-            }
-          } else {
-            dir.add(item);
-            this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path6, entry.stats);
-          }
-          this.fsw._emitReady();
-          return true;
-        }
-        if (this.fsw._symlinkPaths.has(full)) {
-          return true;
-        }
-        this.fsw._symlinkPaths.set(full, true);
-      }
-      _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-        directory = sysPath.join(directory, "");
-        throttler = this.fsw._throttle("readdir", directory, 1e3);
-        if (!throttler)
-          return;
-        const previous = this.fsw._getWatchedDir(wh.path);
-        const current = /* @__PURE__ */ new Set();
-        let stream = this.fsw._readdirp(directory, {
-          fileFilter: (entry) => wh.filterPath(entry),
-          directoryFilter: (entry) => wh.filterDir(entry)
-        });
-        if (!stream)
-          return;
-        stream.on(STR_DATA, async (entry) => {
-          if (this.fsw.closed) {
-            stream = void 0;
-            return;
-          }
-          const item = entry.path;
-          let path6 = sysPath.join(directory, item);
-          current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
-            return;
-          }
-          if (this.fsw.closed) {
-            stream = void 0;
-            return;
-          }
-          if (item === target || !target && !previous.has(item)) {
-            this.fsw._incrReadyCount();
-            path6 = sysPath.join(dir, sysPath.relative(dir, path6));
-            this._addToNodeFs(path6, initialAdd, wh, depth + 1);
-          }
-        }).on(EV.ERROR, this._boundHandleError);
-        return new Promise((resolve6, reject) => {
-          if (!stream)
-            return reject();
-          stream.once(STR_END, () => {
-            if (this.fsw.closed) {
-              stream = void 0;
-              return;
-            }
-            const wasThrottled = throttler ? throttler.clear() : false;
-            resolve6(void 0);
-            previous.getChildren().filter((item) => {
-              return item !== directory && !current.has(item);
-            }).forEach((item) => {
-              this.fsw._remove(directory, item);
-            });
-            stream = void 0;
-            if (wasThrottled)
-              this._handleRead(directory, false, wh, target, dir, depth, throttler);
-          });
-        });
-      }
-      /**
-       * Read directory to add / remove files from `@watched` list and re-read it on change.
-       * @param dir fs path
-       * @param stats
-       * @param initialAdd
-       * @param depth relative to user-supplied path
-       * @param target child path targeted for watch
-       * @param wh Common watch helpers for this path
-       * @param realpath
-       * @returns closer for the watcher instance.
-       */
-      async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
-        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-        const tracked = parentDir.has(sysPath.basename(dir));
-        if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-          this.fsw._emit(EV.ADD_DIR, dir, stats);
-        }
-        parentDir.add(sysPath.basename(dir));
-        this.fsw._getWatchedDir(dir);
-        let throttler;
-        let closer;
-        const oDepth = this.fsw.options.depth;
-        if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
-          if (!target) {
-            await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-            if (this.fsw.closed)
-              return;
-          }
-          closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
-            if (stats2 && stats2.mtimeMs === 0)
-              return;
-            this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-          });
-        }
-        return closer;
-      }
-      /**
-       * Handle added file, directory, or glob pattern.
-       * Delegates call to _handleFile / _handleDir after checks.
-       * @param path to file or ir
-       * @param initialAdd was the file added at watch instantiation?
-       * @param priorWh depth relative to user-supplied path
-       * @param depth Child path actually targeted for watch
-       * @param target Child path actually targeted for watch
-       */
-      async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
-        const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path6) || this.fsw.closed) {
-          ready();
-          return false;
-        }
-        const wh = this.fsw._getWatchHelpers(path6);
-        if (priorWh) {
-          wh.filterPath = (entry) => priorWh.filterPath(entry);
-          wh.filterDir = (entry) => priorWh.filterDir(entry);
-        }
-        try {
-          const stats = await statMethods[wh.statMethod](wh.watchPath);
-          if (this.fsw.closed)
-            return;
-          if (this.fsw._isIgnored(wh.watchPath, stats)) {
-            ready();
-            return false;
-          }
-          const follow = this.fsw.options.followSymlinks;
-          let closer;
-          if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path6);
-            const targetPath = follow ? await (0, import_promises4.realpath)(path6) : path6;
-            if (this.fsw.closed)
-              return;
-            closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-            if (this.fsw.closed)
-              return;
-            if (absPath !== targetPath && targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(absPath, targetPath);
-            }
-          } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises4.realpath)(path6) : path6;
-            if (this.fsw.closed)
-              return;
-            const parent = sysPath.dirname(wh.watchPath);
-            this.fsw._getWatchedDir(parent).add(wh.watchPath);
-            this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
-            if (this.fsw.closed)
-              return;
-            if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path6), targetPath);
-            }
-          } else {
-            closer = this._handleFile(wh.watchPath, stats, initialAdd);
-          }
-          ready();
-          if (closer)
-            this.fsw._addPathCloser(path6, closer);
-          return false;
-        } catch (error48) {
-          if (this.fsw._handleError(error48)) {
-            ready();
-            return path6;
-          }
-        }
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
-function arrify(item) {
-  return Array.isArray(item) ? item : [item];
-}
-function createPattern(matcher) {
-  if (typeof matcher === "function")
-    return matcher;
-  if (typeof matcher === "string")
-    return (string4) => matcher === string4;
-  if (matcher instanceof RegExp)
-    return (string4) => matcher.test(string4);
-  if (typeof matcher === "object" && matcher !== null) {
-    return (string4) => {
-      if (matcher.path === string4)
-        return true;
-      if (matcher.recursive) {
-        const relative3 = sysPath2.relative(matcher.path, string4);
-        if (!relative3) {
-          return false;
-        }
-        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
-      }
-      return false;
-    };
-  }
-  return () => false;
-}
-function normalizePath(path6) {
-  if (typeof path6 !== "string")
-    throw new Error("string expected");
-  path6 = sysPath2.normalize(path6);
-  path6 = path6.replace(/\\/g, "/");
-  let prepend = false;
-  if (path6.startsWith("//"))
-    prepend = true;
-  const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path6.match(DOUBLE_SLASH_RE2))
-    path6 = path6.replace(DOUBLE_SLASH_RE2, "/");
-  if (prepend)
-    path6 = "/" + path6;
-  return path6;
-}
-function matchPatterns(patterns, testString, stats) {
-  const path6 = normalizePath(testString);
-  for (let index = 0; index < patterns.length; index++) {
-    const pattern = patterns[index];
-    if (pattern(path6, stats)) {
-      return true;
-    }
-  }
-  return false;
-}
-function anymatch(matchers, testString) {
-  if (matchers == null) {
-    throw new TypeError("anymatch: specify first argument");
-  }
-  const matchersArray = arrify(matchers);
-  const patterns = matchersArray.map((matcher) => createPattern(matcher));
-  if (testString == null) {
-    return (testString2, stats) => {
-      return matchPatterns(patterns, testString2, stats);
-    };
-  }
-  return matchPatterns(patterns, testString);
-}
-function watch(paths, options = {}) {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths);
-  return watcher;
-}
-var import_fs4, import_promises5, import_events, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher, esm_default;
-var init_esm4 = __esm({
-  "../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js"() {
-    import_fs4 = require("fs");
-    import_promises5 = require("fs/promises");
-    import_events = require("events");
-    sysPath2 = __toESM(require("path"), 1);
-    init_esm3();
-    init_handler();
-    SLASH = "/";
-    SLASH_SLASH = "//";
-    ONE_DOT = ".";
-    TWO_DOTS = "..";
-    STRING_TYPE = "string";
-    BACK_SLASH_RE = /\\/g;
-    DOUBLE_SLASH_RE = /\/\//;
-    DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-    REPLACER_RE = /^\.[/\\]/;
-    isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
-    unifyPaths = (paths_) => {
-      const paths = arrify(paths_).flat();
-      if (!paths.every((p2) => typeof p2 === STRING_TYPE)) {
-        throw new TypeError(`Non-string provided as watch path: ${paths}`);
-      }
-      return paths.map(normalizePathToUnix);
-    };
-    toUnix = (string4) => {
-      let str2 = string4.replace(BACK_SLASH_RE, SLASH);
-      let prepend = false;
-      if (str2.startsWith(SLASH_SLASH)) {
-        prepend = true;
-      }
-      while (str2.match(DOUBLE_SLASH_RE)) {
-        str2 = str2.replace(DOUBLE_SLASH_RE, SLASH);
-      }
-      if (prepend) {
-        str2 = SLASH + str2;
-      }
-      return str2;
-    };
-    normalizePathToUnix = (path6) => toUnix(sysPath2.normalize(toUnix(path6)));
-    normalizeIgnored = (cwd = "") => (path6) => {
-      if (typeof path6 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path6) ? path6 : sysPath2.join(cwd, path6));
-      } else {
-        return path6;
-      }
-    };
-    getAbsolutePath = (path6, cwd) => {
-      if (sysPath2.isAbsolute(path6)) {
-        return path6;
-      }
-      return sysPath2.join(cwd, path6);
-    };
-    EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
-    DirEntry = class {
-      constructor(dir, removeWatcher) {
-        this.path = dir;
-        this._removeWatcher = removeWatcher;
-        this.items = /* @__PURE__ */ new Set();
-      }
-      add(item) {
-        const { items } = this;
-        if (!items)
-          return;
-        if (item !== ONE_DOT && item !== TWO_DOTS)
-          items.add(item);
-      }
-      async remove(item) {
-        const { items } = this;
-        if (!items)
-          return;
-        items.delete(item);
-        if (items.size > 0)
-          return;
-        const dir = this.path;
-        try {
-          await (0, import_promises5.readdir)(dir);
-        } catch (err) {
-          if (this._removeWatcher) {
-            this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
-          }
-        }
-      }
-      has(item) {
-        const { items } = this;
-        if (!items)
-          return;
-        return items.has(item);
-      }
-      getChildren() {
-        const { items } = this;
-        if (!items)
-          return [];
-        return [...items.values()];
-      }
-      dispose() {
-        this.items.clear();
-        this.path = "";
-        this._removeWatcher = EMPTY_FN;
-        this.items = EMPTY_SET;
-        Object.freeze(this);
-      }
-    };
-    STAT_METHOD_F = "stat";
-    STAT_METHOD_L = "lstat";
-    WatchHelper = class {
-      constructor(path6, follow, fsw) {
-        this.fsw = fsw;
-        const watchPath = path6;
-        this.path = path6 = path6.replace(REPLACER_RE, "");
-        this.watchPath = watchPath;
-        this.fullWatchPath = sysPath2.resolve(watchPath);
-        this.dirParts = [];
-        this.dirParts.forEach((parts) => {
-          if (parts.length > 1)
-            parts.pop();
-        });
-        this.followSymlinks = follow;
-        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
-      }
-      entryPath(entry) {
-        return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
-      }
-      filterPath(entry) {
-        const { stats } = entry;
-        if (stats && stats.isSymbolicLink())
-          return this.filterDir(entry);
-        const resolvedPath = this.entryPath(entry);
-        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
-      }
-      filterDir(entry) {
-        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
-      }
-    };
-    FSWatcher = class extends import_events.EventEmitter {
-      // Not indenting methods for history sake; for now.
-      constructor(_opts = {}) {
-        super();
-        this.closed = false;
-        this._closers = /* @__PURE__ */ new Map();
-        this._ignoredPaths = /* @__PURE__ */ new Set();
-        this._throttled = /* @__PURE__ */ new Map();
-        this._streams = /* @__PURE__ */ new Set();
-        this._symlinkPaths = /* @__PURE__ */ new Map();
-        this._watched = /* @__PURE__ */ new Map();
-        this._pendingWrites = /* @__PURE__ */ new Map();
-        this._pendingUnlinks = /* @__PURE__ */ new Map();
-        this._readyCount = 0;
-        this._readyEmitted = false;
-        const awf = _opts.awaitWriteFinish;
-        const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
-        const opts = {
-          // Defaults
-          persistent: true,
-          ignoreInitial: false,
-          ignorePermissionErrors: false,
-          interval: 100,
-          binaryInterval: 300,
-          followSymlinks: true,
-          usePolling: false,
-          // useAsync: false,
-          atomic: true,
-          // NOTE: overwritten later (depends on usePolling)
-          ..._opts,
-          // Change format
-          ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
-          awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
-        };
-        if (isIBMi)
-          opts.usePolling = true;
-        if (opts.atomic === void 0)
-          opts.atomic = !opts.usePolling;
-        const envPoll = process.env.CHOKIDAR_USEPOLLING;
-        if (envPoll !== void 0) {
-          const envLower = envPoll.toLowerCase();
-          if (envLower === "false" || envLower === "0")
-            opts.usePolling = false;
-          else if (envLower === "true" || envLower === "1")
-            opts.usePolling = true;
-          else
-            opts.usePolling = !!envLower;
-        }
-        const envInterval = process.env.CHOKIDAR_INTERVAL;
-        if (envInterval)
-          opts.interval = Number.parseInt(envInterval, 10);
-        let readyCalls = 0;
-        this._emitReady = () => {
-          readyCalls++;
-          if (readyCalls >= this._readyCount) {
-            this._emitReady = EMPTY_FN;
-            this._readyEmitted = true;
-            process.nextTick(() => this.emit(EVENTS.READY));
-          }
-        };
-        this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
-        this._boundRemove = this._remove.bind(this);
-        this.options = opts;
-        this._nodeFsHandler = new NodeFsHandler(this);
-        Object.freeze(opts);
-      }
-      _addIgnoredPath(matcher) {
-        if (isMatcherObject(matcher)) {
-          for (const ignored of this._ignoredPaths) {
-            if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
-              return;
-            }
-          }
-        }
-        this._ignoredPaths.add(matcher);
-      }
-      _removeIgnoredPath(matcher) {
-        this._ignoredPaths.delete(matcher);
-        if (typeof matcher === "string") {
-          for (const ignored of this._ignoredPaths) {
-            if (isMatcherObject(ignored) && ignored.path === matcher) {
-              this._ignoredPaths.delete(ignored);
-            }
-          }
-        }
-      }
-      // Public methods
-      /**
-       * Adds paths to be watched on an existing FSWatcher instance.
-       * @param paths_ file or file list. Other arguments are unused
-       */
-      add(paths_, _origAdd, _internal) {
-        const { cwd } = this.options;
-        this.closed = false;
-        this._closePromise = void 0;
-        let paths = unifyPaths(paths_);
-        if (cwd) {
-          paths = paths.map((path6) => {
-            const absPath = getAbsolutePath(path6, cwd);
-            return absPath;
-          });
-        }
-        paths.forEach((path6) => {
-          this._removeIgnoredPath(path6);
-        });
-        this._userIgnored = void 0;
-        if (!this._readyCount)
-          this._readyCount = 0;
-        this._readyCount += paths.length;
-        Promise.all(paths.map(async (path6) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, void 0, 0, _origAdd);
-          if (res)
-            this._emitReady();
-          return res;
-        })).then((results) => {
-          if (this.closed)
-            return;
-          results.forEach((item) => {
-            if (item)
-              this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
-          });
-        });
-        return this;
-      }
-      /**
-       * Close watchers or start ignoring events from specified paths.
-       */
-      unwatch(paths_) {
-        if (this.closed)
-          return this;
-        const paths = unifyPaths(paths_);
-        const { cwd } = this.options;
-        paths.forEach((path6) => {
-          if (!sysPath2.isAbsolute(path6) && !this._closers.has(path6)) {
-            if (cwd)
-              path6 = sysPath2.join(cwd, path6);
-            path6 = sysPath2.resolve(path6);
-          }
-          this._closePath(path6);
-          this._addIgnoredPath(path6);
-          if (this._watched.has(path6)) {
-            this._addIgnoredPath({
-              path: path6,
-              recursive: true
-            });
-          }
-          this._userIgnored = void 0;
-        });
-        return this;
-      }
-      /**
-       * Close watchers and remove all listeners from watched paths.
-       */
-      close() {
-        if (this._closePromise) {
-          return this._closePromise;
-        }
-        this.closed = true;
-        this.removeAllListeners();
-        const closers = [];
-        this._closers.forEach((closerList) => closerList.forEach((closer) => {
-          const promise2 = closer();
-          if (promise2 instanceof Promise)
-            closers.push(promise2);
-        }));
-        this._streams.forEach((stream) => stream.destroy());
-        this._userIgnored = void 0;
-        this._readyCount = 0;
-        this._readyEmitted = false;
-        this._watched.forEach((dirent) => dirent.dispose());
-        this._closers.clear();
-        this._watched.clear();
-        this._streams.clear();
-        this._symlinkPaths.clear();
-        this._throttled.clear();
-        this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
-        return this._closePromise;
-      }
-      /**
-       * Expose list of watched paths
-       * @returns for chaining
-       */
-      getWatched() {
-        const watchList = {};
-        this._watched.forEach((entry, dir) => {
-          const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
-          const index = key || ONE_DOT;
-          watchList[index] = entry.getChildren().sort();
-        });
-        return watchList;
-      }
-      emitWithAll(event, args) {
-        this.emit(event, ...args);
-        if (event !== EVENTS.ERROR)
-          this.emit(EVENTS.ALL, event, ...args);
-      }
-      // Common helpers
-      // --------------
-      /**
-       * Normalize and emit events.
-       * Calling _emit DOES NOT MEAN emit() would be called!
-       * @param event Type of event
-       * @param path File or directory path
-       * @param stats arguments to be passed with event
-       * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-       */
-      async _emit(event, path6, stats) {
-        if (this.closed)
-          return;
-        const opts = this.options;
-        if (isWindows)
-          path6 = sysPath2.normalize(path6);
-        if (opts.cwd)
-          path6 = sysPath2.relative(opts.cwd, path6);
-        const args = [path6];
-        if (stats != null)
-          args.push(stats);
-        const awf = opts.awaitWriteFinish;
-        let pw;
-        if (awf && (pw = this._pendingWrites.get(path6))) {
-          pw.lastChange = /* @__PURE__ */ new Date();
-          return this;
-        }
-        if (opts.atomic) {
-          if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path6, [event, ...args]);
-            setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path7) => {
-                this.emit(...entry);
-                this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path7);
-              });
-            }, typeof opts.atomic === "number" ? opts.atomic : 100);
-            return this;
-          }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
-            event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path6);
-          }
-        }
-        if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
-          const awfEmit = (err, stats2) => {
-            if (err) {
-              event = EVENTS.ERROR;
-              args[0] = err;
-              this.emitWithAll(event, args);
-            } else if (stats2) {
-              if (args.length > 1) {
-                args[1] = stats2;
-              } else {
-                args.push(stats2);
-              }
-              this.emitWithAll(event, args);
-            }
-          };
-          this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
-          return this;
-        }
-        if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
-          if (isThrottled)
-            return this;
-        }
-        if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path6) : path6;
-          let stats2;
-          try {
-            stats2 = await (0, import_promises5.stat)(fullPath);
-          } catch (err) {
-          }
-          if (!stats2 || this.closed)
-            return;
-          args.push(stats2);
-        }
-        this.emitWithAll(event, args);
-        return this;
-      }
-      /**
-       * Common handler for errors
-       * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-       */
-      _handleError(error48) {
-        const code = error48 && error48.code;
-        if (error48 && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
-          this.emit(EVENTS.ERROR, error48);
-        }
-        return error48 || this.closed;
-      }
-      /**
-       * Helper utility for throttling
-       * @param actionType type being throttled
-       * @param path being acted upon
-       * @param timeout duration of time to suppress duplicate actions
-       * @returns tracking object or false if action should be suppressed
-       */
-      _throttle(actionType, path6, timeout) {
-        if (!this._throttled.has(actionType)) {
-          this._throttled.set(actionType, /* @__PURE__ */ new Map());
-        }
-        const action = this._throttled.get(actionType);
-        if (!action)
-          throw new Error("invalid throttle");
-        const actionPath = action.get(path6);
-        if (actionPath) {
-          actionPath.count++;
-          return false;
-        }
-        let timeoutObject;
-        const clear = () => {
-          const item = action.get(path6);
-          const count = item ? item.count : 0;
-          action.delete(path6);
-          clearTimeout(timeoutObject);
-          if (item)
-            clearTimeout(item.timeoutObject);
-          return count;
-        };
-        timeoutObject = setTimeout(clear, timeout);
-        const thr = { timeoutObject, clear, count: 0 };
-        action.set(path6, thr);
-        return thr;
-      }
-      _incrReadyCount() {
-        return this._readyCount++;
-      }
-      /**
-       * Awaits write operation to finish.
-       * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
-       * @param path being acted upon
-       * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
-       * @param event
-       * @param awfEmit Callback to be called when ready for event to be emitted.
-       */
-      _awaitWriteFinish(path6, threshold, event, awfEmit) {
-        const awf = this.options.awaitWriteFinish;
-        if (typeof awf !== "object")
-          return;
-        const pollInterval = awf.pollInterval;
-        let timeoutHandler;
-        let fullPath = path6;
-        if (this.options.cwd && !sysPath2.isAbsolute(path6)) {
-          fullPath = sysPath2.join(this.options.cwd, path6);
-        }
-        const now = /* @__PURE__ */ new Date();
-        const writes = this._pendingWrites;
-        function awaitWriteFinishFn(prevStat) {
-          (0, import_fs4.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path6)) {
-              if (err && err.code !== "ENOENT")
-                awfEmit(err);
-              return;
-            }
-            const now2 = Number(/* @__PURE__ */ new Date());
-            if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path6).lastChange = now2;
-            }
-            const pw = writes.get(path6);
-            const df = now2 - pw.lastChange;
-            if (df >= threshold) {
-              writes.delete(path6);
-              awfEmit(void 0, curStat);
-            } else {
-              timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
-            }
-          });
-        }
-        if (!writes.has(path6)) {
-          writes.set(path6, {
-            lastChange: now,
-            cancelWait: () => {
-              writes.delete(path6);
-              clearTimeout(timeoutHandler);
-              return event;
-            }
-          });
-          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
-        }
-      }
-      /**
-       * Determines whether user has asked to ignore this path.
-       */
-      _isIgnored(path6, stats) {
-        if (this.options.atomic && DOT_RE.test(path6))
-          return true;
-        if (!this._userIgnored) {
-          const { cwd } = this.options;
-          const ign = this.options.ignored;
-          const ignored = (ign || []).map(normalizeIgnored(cwd));
-          const ignoredPaths = [...this._ignoredPaths];
-          const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
-          this._userIgnored = anymatch(list, void 0);
-        }
-        return this._userIgnored(path6, stats);
-      }
-      _isntIgnored(path6, stat5) {
-        return !this._isIgnored(path6, stat5);
-      }
-      /**
-       * Provides a set of common helpers and properties relating to symlink handling.
-       * @param path file or directory pattern being watched
-       */
-      _getWatchHelpers(path6) {
-        return new WatchHelper(path6, this.options.followSymlinks, this);
-      }
-      // Directory helpers
-      // -----------------
-      /**
-       * Provides directory tracking objects
-       * @param directory path of the directory
-       */
-      _getWatchedDir(directory) {
-        const dir = sysPath2.resolve(directory);
-        if (!this._watched.has(dir))
-          this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-        return this._watched.get(dir);
-      }
-      // File helpers
-      // ------------
-      /**
-       * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
-       */
-      _hasReadPermissions(stats) {
-        if (this.options.ignorePermissionErrors)
-          return true;
-        return Boolean(Number(stats.mode) & 256);
-      }
-      /**
-       * Handles emitting unlink events for
-       * files and directories, and via recursion, for
-       * files and directories within directories that are unlinked
-       * @param directory within which the following item is located
-       * @param item      base path of item/directory
-       */
-      _remove(directory, item, isDirectory) {
-        const path6 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path6);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path6, 100))
-          return;
-        if (!isDirectory && this._watched.size === 1) {
-          this.add(directory, item, true);
-        }
-        const wp = this._getWatchedDir(path6);
-        const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path6, nested));
-        const parent = this._getWatchedDir(directory);
-        const wasTracked = parent.has(item);
-        parent.remove(item);
-        if (this._symlinkPaths.has(fullPath)) {
-          this._symlinkPaths.delete(fullPath);
-        }
-        let relPath = path6;
-        if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path6);
-        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-          const event = this._pendingWrites.get(relPath).cancelWait();
-          if (event === EVENTS.ADD)
-            return;
-        }
-        this._watched.delete(path6);
-        this._watched.delete(fullPath);
-        const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path6))
-          this._emit(eventName, path6);
-        this._closePath(path6);
-      }
-      /**
-       * Closes all watchers for a path
-       */
-      _closePath(path6) {
-        this._closeFile(path6);
-        const dir = sysPath2.dirname(path6);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path6));
-      }
-      /**
-       * Closes only file-specific watchers
-       */
-      _closeFile(path6) {
-        const closers = this._closers.get(path6);
-        if (!closers)
-          return;
-        closers.forEach((closer) => closer());
-        this._closers.delete(path6);
-      }
-      _addPathCloser(path6, closer) {
-        if (!closer)
-          return;
-        let list = this._closers.get(path6);
-        if (!list) {
-          list = [];
-          this._closers.set(path6, list);
-        }
-        list.push(closer);
-      }
-      _readdirp(root, opts) {
-        if (this.closed)
-          return;
-        const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
-        let stream = readdirp(root, options);
-        this._streams.add(stream);
-        stream.once(STR_CLOSE, () => {
-          stream = void 0;
-        });
-        stream.once(STR_END, () => {
-          if (stream) {
-            this._streams.delete(stream);
-            stream = void 0;
-          }
-        });
-        return stream;
-      }
-    };
-    esm_default = { watch, FSWatcher };
-  }
-});
-
 // ../memory/src/watcher.ts
-function shouldIgnorePath(watchPath) {
-  const normalized = import_node_path4.default.normalize(watchPath);
-  const parts = normalized.split(import_node_path4.default.sep).map((s2) => s2.trim().toLowerCase());
-  return parts.some((s2) => IGNORED_DIRS.has(s2));
-}
-function createMemoryWatcher(params) {
-  const watchPaths = /* @__PURE__ */ new Set([
-    import_node_path4.default.join(params.workspaceDir, "MEMORY.md"),
-    import_node_path4.default.join(params.workspaceDir, "memory.md"),
-    import_node_path4.default.join(params.workspaceDir, "memory", "**", "*.md")
-  ]);
-  const normalizedExtra = normalizeExtraMemoryPaths(
-    params.workspaceDir,
-    params.extraPaths
-  );
-  for (const extra of normalizedExtra) {
-    watchPaths.add(extra);
-  }
-  const watcher = esm_default.watch(Array.from(watchPaths), {
-    ignoreInitial: true,
-    ignored: (p2) => shouldIgnorePath(String(p2)),
-    awaitWriteFinish: {
-      stabilityThreshold: params.debounceMs,
-      pollInterval: 100
-    }
-  });
-  let debounceTimer = null;
-  const markDirty = () => {
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-    debounceTimer = setTimeout(() => {
-      debounceTimer = null;
-      params.onChange();
-    }, params.debounceMs);
-  };
-  watcher.on("add", markDirty);
-  watcher.on("change", markDirty);
-  watcher.on("unlink", markDirty);
-  return watcher;
-}
-async function closeWatcher(watcher) {
-  if (!watcher) {
-    return;
-  }
-  await watcher.close();
-}
-function createWatcherHandle(watcher) {
-  return {
-    close: () => closeWatcher(watcher)
-  };
-}
-var import_node_path4, IGNORED_DIRS;
 var init_watcher = __esm({
   "../memory/src/watcher.ts"() {
     "use strict";
-    import_node_path4 = __toESM(require("node:path"), 1);
-    init_esm4();
     init_internal();
-    IGNORED_DIRS = /* @__PURE__ */ new Set([
-      ".git",
-      "node_modules",
-      ".pnpm-store",
-      ".venv",
-      "venv",
-      ".tox",
-      "__pycache__"
-    ]);
   }
 });
 
 // ../memory/src/conversations.ts
-async function saveConversation(params) {
-  const dir = import_node_path5.default.join(params.dir, "conversations", params.userId);
-  await import_promises6.default.mkdir(dir, { recursive: true });
-  const now = Date.now();
-  const entry = {
-    id: params.conversationId,
-    userId: params.userId,
-    conversationId: params.conversationId,
-    messages: params.messages,
-    createdAt: now,
-    updatedAt: now
-  };
-  const filePath = import_node_path5.default.join(dir, `${params.conversationId}.json`);
-  await import_promises6.default.writeFile(filePath, JSON.stringify(entry, null, 2), "utf-8");
-  return entry;
-}
-async function loadConversation(params) {
-  const filePath = import_node_path5.default.join(
-    params.dir,
-    "conversations",
-    params.userId,
-    `${params.conversationId}.json`
-  );
-  try {
-    const content = await import_promises6.default.readFile(filePath, "utf-8");
-    const entry = JSON.parse(content);
-    return entry;
-  } catch {
-    return null;
-  }
-}
-async function listConversations(params) {
-  const baseDir = params.userId ? import_node_path5.default.join(params.dir, "conversations", params.userId) : import_node_path5.default.join(params.dir, "conversations");
-  try {
-    const entries = await import_promises6.default.readdir(baseDir, { withFileTypes: true });
-    const conversations = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) {
-        continue;
-      }
-      const userDir = import_node_path5.default.join(baseDir, entry.name);
-      const files = await import_promises6.default.readdir(userDir);
-      for (const file2 of files) {
-        if (!file2.endsWith(".json")) {
-          continue;
-        }
-        try {
-          const content = await import_promises6.default.readFile(import_node_path5.default.join(userDir, file2), "utf-8");
-          const conv = JSON.parse(content);
-          conversations.push(conv);
-        } catch {
-        }
-      }
-    }
-    return conversations.sort((a2, b2) => b2.updatedAt - a2.updatedAt);
-  } catch {
-    return [];
-  }
-}
-function normalizeConversationText(content) {
-  if (typeof content === "string") {
-    const normalized = content.replace(/\s*\n+\s*/g, " ").replace(/\s+/g, " ").trim();
-    return normalized || null;
-  }
-  if (!Array.isArray(content)) {
-    return null;
-  }
-  const parts = [];
-  for (const block of content) {
-    if (!block || typeof block !== "object") {
-      continue;
-    }
-    const record2 = block;
-    if (record2.type !== "text" || typeof record2.text !== "string") {
-      continue;
-    }
-    const normalized = record2.text.replace(/\s*\n+\s*/g, " ").replace(/\s+/g, " ").trim();
-    if (normalized) {
-      parts.push(normalized);
-    }
-  }
-  if (parts.length === 0) {
-    return null;
-  }
-  return parts.join(" ");
-}
-function extractConversationContent(messages) {
-  const collected = [];
-  for (const msg of messages) {
-    const normalized = normalizeConversationText(msg.content);
-    if (!normalized) {
-      continue;
-    }
-    const label = msg.role === "user" ? "User" : "Assistant";
-    collected.push(`${label}: ${normalized}`);
-  }
-  return collected.join("\n");
-}
-function conversationToMemoryChunks(params) {
-  const content = extractConversationContent(params.entry.messages);
-  const lines = content.split("\n");
-  if (lines.length === 0) {
-    return [];
-  }
-  const maxChars = Math.max(32, params.chunking.tokens * 4);
-  const chunks = [];
-  let currentLines = [];
-  let startMsg = 0;
-  const flush = () => {
-    if (currentLines.length === 0) {
-      return;
-    }
-    const text = currentLines.join("\n");
-    chunks.push({
-      text,
-      hash: hashText(text),
-      startMessage: startMsg,
-      endMessage: startMsg + currentLines.length - 1
-    });
-    currentLines = [];
-  };
-  for (let i2 = 0; i2 < lines.length; i2++) {
-    const line = lines[i2];
-    const lineSize = line.length + 1;
-    if (currentLines.length > 0 && currentLines.join("\n").length + lineSize > maxChars) {
-      flush();
-      startMsg = i2;
-    }
-    currentLines.push(line);
-  }
-  flush();
-  return chunks;
-}
-function buildConversationEntry(absPath) {
-  try {
-    const raw = import_node_fs3.default.readFileSync(absPath, "utf-8");
-    const entry = JSON.parse(raw);
-    return entry;
-  } catch {
-    return null;
-  }
-}
-function conversationPathForFile(absPath, baseDir) {
-  return import_node_path5.default.relative(baseDir, absPath).replace(/\\/g, "/");
-}
-async function listConversationFiles(dir, userId) {
-  const baseDir = userId ? import_node_path5.default.join(dir, "conversations", userId) : import_node_path5.default.join(dir, "conversations");
-  const result = [];
-  async function walk(dirPath) {
-    try {
-      const entries = await import_promises6.default.readdir(dirPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const full = import_node_path5.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-          await walk(full);
-        } else if (entry.isFile() && entry.name.endsWith(".json")) {
-          result.push(full);
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    await walk(baseDir);
-  } catch {
-  }
-  return result;
-}
-var import_node_fs3, import_promises6, import_node_path5;
 var init_conversations = __esm({
   "../memory/src/conversations.ts"() {
     "use strict";
-    import_node_fs3 = __toESM(require("node:fs"), 1);
-    import_promises6 = __toESM(require("node:fs/promises"), 1);
-    import_node_path5 = __toESM(require("node:path"), 1);
     init_internal();
   }
 });
@@ -24826,13 +22884,13 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
 function resolveStorePath(agentId, raw) {
-  const stateDir = import_node_path6.default.join(import_node_os2.default.homedir(), ".hybrid", "memory");
-  const fallback = import_node_path6.default.join(stateDir, `${agentId}.sqlite`);
+  const stateDir = import_node_path3.default.join(import_node_os2.default.homedir(), ".hybrid", "memory");
+  const fallback = import_node_path3.default.join(stateDir, `${agentId}.sqlite`);
   if (!raw) {
     return fallback;
   }
   const withToken = raw.includes("{agentId}") ? raw.replaceAll("{agentId}", agentId) : raw;
-  return withToken.startsWith("~") ? import_node_path6.default.join(import_node_os2.default.homedir(), withToken.slice(1)) : import_node_path6.default.isAbsolute(withToken) ? withToken : import_node_path6.default.resolve(withToken);
+  return withToken.startsWith("~") ? import_node_path3.default.join(import_node_os2.default.homedir(), withToken.slice(1)) : import_node_path3.default.isAbsolute(withToken) ? withToken : import_node_path3.default.resolve(withToken);
 }
 function resolveMemoryConfig(input, agentId) {
   const enabled = input.enabled ?? true;
@@ -24944,15 +23002,12 @@ function resolveMemoryConfig(input, agentId) {
     cache
   };
 }
-function getDefaultMemoryConfig() {
-  return resolveMemoryConfig({}, "default");
-}
-var import_node_os2, import_node_path6, DEFAULT_CHUNK_TOKENS, DEFAULT_CHUNK_OVERLAP, DEFAULT_WATCH_DEBOUNCE_MS, DEFAULT_MAX_RESULTS, DEFAULT_MIN_SCORE, DEFAULT_HYBRID_ENABLED, DEFAULT_HYBRID_VECTOR_WEIGHT, DEFAULT_HYBRID_TEXT_WEIGHT, DEFAULT_CACHE_ENABLED;
+var import_node_os2, import_node_path3, DEFAULT_CHUNK_TOKENS, DEFAULT_CHUNK_OVERLAP, DEFAULT_WATCH_DEBOUNCE_MS, DEFAULT_MAX_RESULTS, DEFAULT_MIN_SCORE, DEFAULT_HYBRID_ENABLED, DEFAULT_HYBRID_VECTOR_WEIGHT, DEFAULT_HYBRID_TEXT_WEIGHT, DEFAULT_CACHE_ENABLED;
 var init_config = __esm({
   "../memory/src/config.ts"() {
     "use strict";
     import_node_os2 = __toESM(require("node:os"), 1);
-    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_path3 = __toESM(require("node:path"), 1);
     DEFAULT_CHUNK_TOKENS = 400;
     DEFAULT_CHUNK_OVERLAP = 80;
     DEFAULT_WATCH_DEBOUNCE_MS = 1500;
@@ -24967,16 +23022,10 @@ var init_config = __esm({
 
 // ../memory/src/paths.ts
 function getCredentialsPath(workspaceDir) {
-  return (0, import_node_path7.join)(workspaceDir, "credentials");
-}
-function getProjectHash(workspaceDir) {
-  return (0, import_node_crypto2.createHash)("sha256").update(workspaceDir).digest("hex").slice(0, 16);
+  return (0, import_node_path4.join)(workspaceDir, "credentials");
 }
 function getMemoryRoot(workspaceDir) {
-  return (0, import_node_path7.join)(workspaceDir, "memory");
-}
-function getSharedMemoryPath(workspaceDir) {
-  return getMemoryRoot(workspaceDir);
+  return (0, import_node_path4.join)(workspaceDir, "memory");
 }
 function sanitizeUserId(userId) {
   const sanitized = userId.replace(/[\/\\]/g, "_").replace(/\.\./g, "_").trim();
@@ -24987,39 +23036,36 @@ function sanitizeUserId(userId) {
 }
 function getUserMemoryPath(workspaceDir, userId) {
   const memoryRoot = getMemoryRoot(workspaceDir);
-  const usersDir = (0, import_node_path7.join)(memoryRoot, "users");
-  const result = (0, import_node_path7.join)(usersDir, sanitizeUserId(userId));
-  const resolved = (0, import_node_path7.resolve)(result);
-  const resolvedUsersDir = (0, import_node_path7.resolve)(usersDir);
+  const usersDir = (0, import_node_path4.join)(memoryRoot, "users");
+  const result = (0, import_node_path4.join)(usersDir, sanitizeUserId(userId));
+  const resolved = (0, import_node_path4.resolve)(result);
+  const resolvedUsersDir = (0, import_node_path4.resolve)(usersDir);
   if (!resolved.startsWith(resolvedUsersDir + "/") && resolved !== resolvedUsersDir) {
     throw new Error("Invalid userId: path traversal detected");
   }
   return result;
 }
-function getProjectMemoryPath(workspaceDir) {
-  return (0, import_node_path7.join)(workspaceDir, "memory");
-}
 function getParaRoot(workspaceDir) {
-  return (0, import_node_path7.join)(getMemoryRoot(workspaceDir), "life");
+  return (0, import_node_path4.join)(getMemoryRoot(workspaceDir), "life");
 }
 function getProjectsPath(workspaceDir) {
-  return (0, import_node_path7.join)(getParaRoot(workspaceDir), "projects");
+  return (0, import_node_path4.join)(getParaRoot(workspaceDir), "projects");
 }
 function getAreasPath(workspaceDir) {
-  return (0, import_node_path7.join)(getParaRoot(workspaceDir), "areas");
+  return (0, import_node_path4.join)(getParaRoot(workspaceDir), "areas");
 }
 function getResourcesPath(workspaceDir) {
-  return (0, import_node_path7.join)(getParaRoot(workspaceDir), "resources");
+  return (0, import_node_path4.join)(getParaRoot(workspaceDir), "resources");
 }
 function getArchivesPath(workspaceDir) {
-  return (0, import_node_path7.join)(getParaRoot(workspaceDir), "archives");
+  return (0, import_node_path4.join)(getParaRoot(workspaceDir), "archives");
 }
 function getLogsPath(workspaceDir) {
-  return (0, import_node_path7.join)(getMemoryRoot(workspaceDir), "logs");
+  return (0, import_node_path4.join)(getMemoryRoot(workspaceDir), "logs");
 }
 function getDailyLogPath(workspaceDir, date5) {
   const logDate = date5 || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return (0, import_node_path7.join)(getLogsPath(workspaceDir), `${logDate}.md`);
+  return (0, import_node_path4.join)(getLogsPath(workspaceDir), `${logDate}.md`);
 }
 function getMemoryPaths(workspaceDir, userId, role) {
   const userPath = getUserMemoryPath(workspaceDir, userId);
@@ -25034,30 +23080,29 @@ function getMemoryPaths(workspaceDir, userId, role) {
     write: userPath
   };
 }
-var import_node_crypto2, import_node_path7;
+var import_node_path4;
 var init_paths = __esm({
   "../memory/src/paths.ts"() {
     "use strict";
-    import_node_crypto2 = require("node:crypto");
-    import_node_path7 = require("node:path");
+    import_node_path4 = require("node:path");
   }
 });
 
 // ../memory/src/auto-memory.ts
 function ensureDir2(dir) {
-  if (!(0, import_node_fs4.existsSync)(dir)) {
-    (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs3.existsSync)(dir)) {
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
   }
 }
 async function appendToMemory(workspaceDir, entry, userId, role) {
   const paths = getMemoryPaths(workspaceDir, userId, role);
   const memoryDir = paths.write;
-  const memoryPath = (0, import_node_path8.join)(memoryDir, "MEMORY.md");
+  const memoryPath = (0, import_node_path5.join)(memoryDir, "MEMORY.md");
   ensureDir2(memoryDir);
-  if (!(0, import_node_fs4.existsSync)(memoryPath)) {
-    await (0, import_promises7.writeFile)(memoryPath, DEFAULT_TEMPLATE, "utf-8");
+  if (!(0, import_node_fs3.existsSync)(memoryPath)) {
+    await (0, import_promises3.writeFile)(memoryPath, DEFAULT_TEMPLATE, "utf-8");
   }
-  const content = await (0, import_promises7.readFile)(memoryPath, "utf-8");
+  const content = await (0, import_promises3.readFile)(memoryPath, "utf-8");
   const categoryHeader = CATEGORY_HEADERS[entry.category];
   const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const line = `- ${entry.content} (${timestamp})`;
@@ -25068,7 +23113,7 @@ ${categoryHeader}
 
 ${line}
 `;
-    await (0, import_promises7.writeFile)(memoryPath, updatedContent, "utf-8");
+    await (0, import_promises3.writeFile)(memoryPath, updatedContent, "utf-8");
     return { success: true, message: `Added to new section: ${entry.category}` };
   }
   const lines = content.split("\n");
@@ -25106,7 +23151,7 @@ ${afterInsertContent}`;
 ${line}
 ${afterInsertContent}`;
   }
-  await (0, import_promises7.writeFile)(memoryPath, newContent, "utf-8");
+  await (0, import_promises3.writeFile)(memoryPath, newContent, "utf-8");
   return { success: true, message: `Added to ${entry.category}` };
 }
 async function readMemorySection(workspaceDir, category, userId, role) {
@@ -25114,11 +23159,11 @@ async function readMemorySection(workspaceDir, category, userId, role) {
   const allEntries = [];
   const seen = /* @__PURE__ */ new Set();
   for (const memoryDir of paths.read) {
-    const memoryPath = (0, import_node_path8.join)(memoryDir, "MEMORY.md");
-    if (!(0, import_node_fs4.existsSync)(memoryPath)) {
+    const memoryPath = (0, import_node_path5.join)(memoryDir, "MEMORY.md");
+    if (!(0, import_node_fs3.existsSync)(memoryPath)) {
       continue;
     }
-    const content = await (0, import_promises7.readFile)(memoryPath, "utf-8");
+    const content = await (0, import_promises3.readFile)(memoryPath, "utf-8");
     const categoryHeader = CATEGORY_HEADERS[category];
     const lines = content.split("\n");
     let inTargetSection = false;
@@ -25141,40 +23186,13 @@ async function readMemorySection(workspaceDir, category, userId, role) {
   }
   return allEntries;
 }
-async function clearMemorySection(workspaceDir, category, userId, role) {
-  const paths = getMemoryPaths(workspaceDir, userId, role);
-  const memoryDir = paths.write;
-  const memoryPath = (0, import_node_path8.join)(memoryDir, "MEMORY.md");
-  if (!(0, import_node_fs4.existsSync)(memoryPath)) {
-    return;
-  }
-  const content = await (0, import_promises7.readFile)(memoryPath, "utf-8");
-  const categoryHeader = CATEGORY_HEADERS[category];
-  const lines = content.split("\n");
-  const newLines = [];
-  let inTargetSection = false;
-  for (const line of lines) {
-    if (line.trim() === categoryHeader) {
-      inTargetSection = true;
-      newLines.push(line);
-      continue;
-    }
-    if (inTargetSection && line.startsWith("## ")) {
-      inTargetSection = false;
-    }
-    if (!inTargetSection || !line.startsWith("- ")) {
-      newLines.push(line);
-    }
-  }
-  await (0, import_promises7.writeFile)(memoryPath, newLines.join("\n"), "utf-8");
-}
-var import_node_fs4, import_promises7, import_node_path8, CATEGORY_HEADERS, DEFAULT_TEMPLATE;
+var import_node_fs3, import_promises3, import_node_path5, CATEGORY_HEADERS, DEFAULT_TEMPLATE;
 var init_auto_memory = __esm({
   "../memory/src/auto-memory.ts"() {
     "use strict";
-    import_node_fs4 = require("node:fs");
-    import_promises7 = require("node:fs/promises");
-    import_node_path8 = require("node:path");
+    import_node_fs3 = require("node:fs");
+    import_promises3 = require("node:fs/promises");
+    import_node_path5 = require("node:path");
     init_paths();
     CATEGORY_HEADERS = {
       preferences: "## User Preferences",
@@ -25207,14 +23225,6 @@ function isValidWalletAddress(address) {
 function normalizeWalletAddress(address) {
   return address.toLowerCase();
 }
-function validateWalletAddress(address) {
-  if (!isValidWalletAddress(address)) {
-    throw new Error(
-      `Invalid wallet address: ${address}. Must be 0x followed by 40 hex characters.`
-    );
-  }
-  return normalizeWalletAddress(address);
-}
 var WALLET_REGEX;
 var init_validate = __esm({
   "../memory/src/validate.ts"() {
@@ -25225,15 +23235,15 @@ var init_validate = __esm({
 
 // ../memory/src/acl.ts
 function getAllowFromPath(workspaceDir) {
-  return (0, import_node_path9.join)(getCredentialsPath(workspaceDir), `${CHANNEL}-allowFrom.json`);
+  return (0, import_node_path6.join)(getCredentialsPath(workspaceDir), `${CHANNEL}-allowFrom.json`);
 }
 function getPairingPath(workspaceDir) {
-  return (0, import_node_path9.join)(getCredentialsPath(workspaceDir), `${CHANNEL}-pairing.json`);
+  return (0, import_node_path6.join)(getCredentialsPath(workspaceDir), `${CHANNEL}-pairing.json`);
 }
 function randomCode() {
   let out = "";
   for (let i2 = 0; i2 < PAIRING_CODE_LENGTH; i2++) {
-    const idx = (0, import_node_crypto3.randomInt)(0, PAIRING_CODE_ALPHABET.length);
+    const idx = (0, import_node_crypto2.randomInt)(0, PAIRING_CODE_ALPHABET.length);
     out += PAIRING_CODE_ALPHABET[idx];
   }
   return out;
@@ -25307,13 +23317,13 @@ function pruneExcessRequests(reqs, maxPending) {
   return { requests: sorted.slice(-maxPending), removed: true };
 }
 async function ensureDir3(dir) {
-  if (!(0, import_node_fs5.existsSync)(dir)) {
-    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs4.existsSync)(dir)) {
+    (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   }
 }
 async function readJsonFile(filePath, fallback) {
   try {
-    const raw = await (0, import_promises8.readFile)(filePath, "utf-8");
+    const raw = await (0, import_promises4.readFile)(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return { value: parsed, exists: true };
   } catch (err) {
@@ -25326,16 +23336,16 @@ async function readJsonFile(filePath, fallback) {
 }
 async function writeJsonFileAtomic(filePath, value) {
   const tempPath = `${filePath}.tmp`;
-  await (0, import_promises8.writeFile)(tempPath, JSON.stringify(value, null, 2), "utf-8");
-  await import("node:fs/promises").then((fs5) => fs5.rename(tempPath, filePath));
+  await (0, import_promises4.writeFile)(tempPath, JSON.stringify(value, null, 2), "utf-8");
+  await import("node:fs/promises").then((fs4) => fs4.rename(tempPath, filePath));
 }
 function parseACL(workspaceDir) {
   const aclPath = getAllowFromPath(workspaceDir);
-  if (!(0, import_node_fs5.existsSync)(aclPath)) {
+  if (!(0, import_node_fs4.existsSync)(aclPath)) {
     return null;
   }
   try {
-    const content = (0, import_node_fs5.readFileSync)(aclPath, "utf-8");
+    const content = (0, import_node_fs4.readFileSync)(aclPath, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed.version !== 1 || !Array.isArray(parsed.allowFrom)) {
       return null;
@@ -25416,7 +23426,7 @@ async function removeACLAllowFromEntry(workspaceDir, entry) {
 }
 async function listACLPendingRequests(workspaceDir) {
   const filePath = getPairingPath(workspaceDir);
-  if (!(0, import_node_fs5.existsSync)(filePath)) {
+  if (!(0, import_node_fs4.existsSync)(filePath)) {
     return [];
   }
   const { value } = await readJsonFile(filePath, {
@@ -25581,14 +23591,14 @@ async function removeOwner(workspaceDir, userId) {
     return { success: false, message: String(err) };
   }
 }
-var import_node_crypto3, import_node_fs5, import_promises8, import_node_path9, CHANNEL, PAIRING_CODE_LENGTH, PAIRING_CODE_ALPHABET, PAIRING_PENDING_TTL_MS, PAIRING_PENDING_MAX;
+var import_node_crypto2, import_node_fs4, import_promises4, import_node_path6, CHANNEL, PAIRING_CODE_LENGTH, PAIRING_CODE_ALPHABET, PAIRING_PENDING_TTL_MS, PAIRING_PENDING_MAX;
 var init_acl = __esm({
   "../memory/src/acl.ts"() {
     "use strict";
-    import_node_crypto3 = require("node:crypto");
-    import_node_fs5 = require("node:fs");
-    import_promises8 = require("node:fs/promises");
-    import_node_path9 = require("node:path");
+    import_node_crypto2 = require("node:crypto");
+    import_node_fs4 = require("node:fs");
+    import_promises4 = require("node:fs/promises");
+    import_node_path6 = require("node:path");
     init_paths();
     init_validate();
     CHANNEL = "xmtp";
@@ -25601,8 +23611,8 @@ var init_acl = __esm({
 
 // ../memory/src/para.ts
 function ensureDir4(dir) {
-  if (!(0, import_node_fs6.existsSync)(dir)) {
-    (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs5.existsSync)(dir)) {
+    (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
   }
 }
 function getBucketPath(workspaceDir, bucket) {
@@ -25622,8 +23632,8 @@ function generateId() {
 }
 async function createEntity(workspaceDir, name, bucket, category) {
   const bucketPath = getBucketPath(workspaceDir, bucket);
-  const entityPath = category ? (0, import_node_path10.join)(bucketPath, category, name) : (0, import_node_path10.join)(bucketPath, name);
-  if ((0, import_node_fs6.existsSync)(entityPath)) {
+  const entityPath = category ? (0, import_node_path7.join)(bucketPath, category, name) : (0, import_node_path7.join)(bucketPath, name);
+  if ((0, import_node_fs5.existsSync)(entityPath)) {
     return {
       success: false,
       message: `Entity already exists: ${name}`,
@@ -25641,13 +23651,13 @@ async function createEntity(workspaceDir, name, bucket, category) {
     updatedAt: now,
     items: []
   };
-  await (0, import_promises9.writeFile)(
-    (0, import_node_path10.join)(entityPath, "items.json"),
+  await (0, import_promises5.writeFile)(
+    (0, import_node_path7.join)(entityPath, "items.json"),
     JSON.stringify(itemsFile, null, 2),
     "utf-8"
   );
-  await (0, import_promises9.writeFile)(
-    (0, import_node_path10.join)(entityPath, "summary.md"),
+  await (0, import_promises5.writeFile)(
+    (0, import_node_path7.join)(entityPath, "summary.md"),
     `# ${name}
 
 *No active facts yet.*
@@ -25657,11 +23667,11 @@ async function createEntity(workspaceDir, name, bucket, category) {
   return { success: true, message: `Created entity: ${name}`, path: entityPath };
 }
 async function addFact(workspaceDir, entityPath, fact, category, relatedEntities = []) {
-  const itemsPath = (0, import_node_path10.join)(entityPath, "items.json");
-  if (!(0, import_node_fs6.existsSync)(itemsPath)) {
+  const itemsPath = (0, import_node_path7.join)(entityPath, "items.json");
+  if (!(0, import_node_fs5.existsSync)(itemsPath)) {
     return { success: false, message: "Entity not found", factId: "" };
   }
-  const content = await (0, import_promises9.readFile)(itemsPath, "utf-8");
+  const content = await (0, import_promises5.readFile)(itemsPath, "utf-8");
   const itemsFile = JSON.parse(content);
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const newFact = {
@@ -25677,50 +23687,9 @@ async function addFact(workspaceDir, entityPath, fact, category, relatedEntities
   };
   itemsFile.items.push(newFact);
   itemsFile.updatedAt = now;
-  await (0, import_promises9.writeFile)(itemsPath, JSON.stringify(itemsFile, null, 2), "utf-8");
+  await (0, import_promises5.writeFile)(itemsPath, JSON.stringify(itemsFile, null, 2), "utf-8");
   return { success: true, message: `Added fact to entity`, factId: newFact.id };
 }
-async function supersedeFact(workspaceDir, entityPath, factId, newFact) {
-  const itemsPath = (0, import_node_path10.join)(entityPath, "items.json");
-  if (!(0, import_node_fs6.existsSync)(itemsPath)) {
-    return { success: false, message: "Entity not found" };
-  }
-  const content = await (0, import_promises9.readFile)(itemsPath, "utf-8");
-  const itemsFile = JSON.parse(content);
-  const oldFactIndex = itemsFile.items.findIndex((f2) => f2.id === factId);
-  if (oldFactIndex === -1) {
-    return { success: false, message: "Fact not found" };
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const newFactRecord = {
-    id: generateId(),
-    fact: newFact,
-    category: itemsFile.items[oldFactIndex].category,
-    timestamp: now,
-    source: now,
-    status: "active",
-    relatedEntities: itemsFile.items[oldFactIndex].relatedEntities,
-    lastAccessed: now,
-    accessCount: 0
-  };
-  itemsFile.items[oldFactIndex].status = "superseded";
-  itemsFile.items[oldFactIndex].supersededBy = newFactRecord.id;
-  itemsFile.items.push(newFactRecord);
-  itemsFile.updatedAt = now;
-  await (0, import_promises9.writeFile)(itemsPath, JSON.stringify(itemsFile, null, 2), "utf-8");
-  return { success: true, message: "Fact superseded" };
-}
-async function accessFact(entityPath, factId) {
-  const itemsPath = (0, import_node_path10.join)(entityPath, "items.json");
-  if (!(0, import_node_fs6.existsSync)(itemsPath)) return;
-  const content = await (0, import_promises9.readFile)(itemsPath, "utf-8");
-  const itemsFile = JSON.parse(content);
-  const fact = itemsFile.items.find((f2) => f2.id === factId);
-  if (!fact) return;
-  fact.lastAccessed = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  fact.accessCount += 1;
-  await (0, import_promises9.writeFile)(itemsPath, JSON.stringify(itemsFile, null, 2), "utf-8");
-}
 function computeDecayTier(fact, now = /* @__PURE__ */ new Date()) {
   const lastAccessed = new Date(fact.lastAccessed);
   const daysSinceAccess = Math.floor(
@@ -25740,87 +23709,20 @@ function computeDecayTier(fact, now = /* @__PURE__ */ new Date()) {
   }
   return "cold";
 }
-async function generateSummary(entityPath, entityName) {
-  const itemsPath = (0, import_node_path10.join)(entityPath, "items.json");
-  if (!(0, import_node_fs6.existsSync)(itemsPath)) {
-    return `# ${entityName}
-
-*No facts recorded.*
-`;
-  }
-  const content = await (0, import_promises9.readFile)(itemsPath, "utf-8");
-  const itemsFile = JSON.parse(content);
-  const activeFacts = itemsFile.items.filter((f2) => f2.status === "active");
-  const hotFacts = [];
-  const warmFacts = [];
-  for (const fact of activeFacts) {
-    const tier = computeDecayTier(fact);
-    if (tier === "hot") hotFacts.push(fact);
-    else if (tier === "warm") warmFacts.push(fact);
-  }
-  hotFacts.sort((a2, b2) => b2.accessCount - a2.accessCount);
-  warmFacts.sort((a2, b2) => b2.accessCount - a2.accessCount);
-  let summary = `# ${entityName}
-
-`;
-  if (hotFacts.length > 0) {
-    summary += `## Current
-
-`;
-    for (const fact of hotFacts) {
-      summary += `- ${fact.fact}
-`;
-    }
-    summary += "\n";
-  }
-  if (warmFacts.length > 0) {
-    summary += `## Background
-
-`;
-    for (const fact of warmFacts) {
-      summary += `- ${fact.fact}
-`;
-    }
-    summary += "\n";
-  }
-  if (hotFacts.length === 0 && warmFacts.length === 0) {
-    summary += `*No active facts in current context.*
-`;
-  }
-  return summary;
-}
-async function rewriteSummaries(workspaceDir) {
-  const paraRoot = getParaRoot(workspaceDir);
-  let count = 0;
-  const buckets = ["projects", "areas", "resources", "archives"];
-  for (const bucket of buckets) {
-    const bucketPath = getBucketPath(workspaceDir, bucket);
-    if (!(0, import_node_fs6.existsSync)(bucketPath)) continue;
-    const entries = await (0, import_promises9.readdir)(bucketPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const entityPath = (0, import_node_path10.join)(bucketPath, entry.name);
-      const summary = await generateSummary(entityPath, entry.name);
-      await (0, import_promises9.writeFile)((0, import_node_path10.join)(entityPath, "summary.md"), summary, "utf-8");
-      count++;
-    }
-  }
-  return { count };
-}
 async function searchFacts(workspaceDir, query2, options) {
   const results = [];
   const buckets = options?.bucket ? [options.bucket] : ["projects", "areas", "resources", "archives"];
   const queryLower = query2.toLowerCase();
   for (const bucket of buckets) {
     const bucketPath = getBucketPath(workspaceDir, bucket);
-    if (!(0, import_node_fs6.existsSync)(bucketPath)) continue;
-    const entries = await (0, import_promises9.readdir)(bucketPath, { withFileTypes: true });
+    if (!(0, import_node_fs5.existsSync)(bucketPath)) continue;
+    const entries = await (0, import_promises5.readdir)(bucketPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const entityPath = (0, import_node_path10.join)(bucketPath, entry.name);
-      const itemsPath = (0, import_node_path10.join)(entityPath, "items.json");
-      if (!(0, import_node_fs6.existsSync)(itemsPath)) continue;
-      const content = await (0, import_promises9.readFile)(itemsPath, "utf-8");
+      const entityPath = (0, import_node_path7.join)(bucketPath, entry.name);
+      const itemsPath = (0, import_node_path7.join)(entityPath, "items.json");
+      if (!(0, import_node_fs5.existsSync)(itemsPath)) continue;
+      const content = await (0, import_promises5.readFile)(itemsPath, "utf-8");
       const itemsFile = JSON.parse(content);
       for (const fact of itemsFile.items) {
         if (fact.status !== "active") continue;
@@ -25838,21 +23740,21 @@ async function searchFacts(workspaceDir, query2, options) {
   }
   return results;
 }
-var import_node_fs6, import_promises9, import_node_path10;
+var import_node_fs5, import_promises5, import_node_path7;
 var init_para = __esm({
   "../memory/src/para.ts"() {
     "use strict";
-    import_node_fs6 = require("node:fs");
-    import_promises9 = require("node:fs/promises");
-    import_node_path10 = require("node:path");
+    import_node_fs5 = require("node:fs");
+    import_promises5 = require("node:fs/promises");
+    import_node_path7 = require("node:path");
     init_paths();
   }
 });
 
 // ../memory/src/daily-log.ts
 function ensureDir5(dir) {
-  if (!(0, import_node_fs7.existsSync)(dir)) {
-    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs6.existsSync)(dir)) {
+    (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
   }
 }
 function formatTime() {
@@ -25864,8 +23766,8 @@ async function appendToLog(workspaceDir, entry) {
   ensureDir5(logsPath);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const logPath = getDailyLogPath(workspaceDir, today);
-  if (!(0, import_node_fs7.existsSync)(logPath)) {
-    await (0, import_promises10.writeFile)(logPath, `# ${today}
+  if (!(0, import_node_fs6.existsSync)(logPath)) {
+    await (0, import_promises6.writeFile)(logPath, `# ${today}
 
 `, "utf-8");
   }
@@ -25875,14 +23777,7 @@ async function appendToLog(workspaceDir, entry) {
 - ${typeLabel} ${entry.content}
 
 `;
-  await (0, import_promises10.appendFile)(logPath, line, "utf-8");
-}
-async function logEvent(workspaceDir, content) {
-  await appendToLog(workspaceDir, {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "event",
-    content
-  });
+  await (0, import_promises6.appendFile)(logPath, line, "utf-8");
 }
 async function logFact(workspaceDir, content) {
   await appendToLog(workspaceDir, {
@@ -25898,124 +23793,17 @@ async function logDecision(workspaceDir, content) {
     content
   });
 }
-async function logAction(workspaceDir, content) {
-  await appendToLog(workspaceDir, {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "action",
-    content
-  });
-}
-async function readLog(workspaceDir, date5) {
-  const logPath = getDailyLogPath(workspaceDir, date5);
-  if (!(0, import_node_fs7.existsSync)(logPath)) {
-    return "";
-  }
-  return (0, import_promises10.readFile)(logPath, "utf-8");
-}
-async function extractFactsFromLog(workspaceDir, date5) {
-  const log = await readLog(workspaceDir, date5);
-  const facts = [];
-  const lines = log.split("\n");
-  for (const line of lines) {
-    if (line.includes("[FACT]")) {
-      const fact = line.replace(/\[FACT\]/, "").replace(/^- /, "").trim();
-      if (fact) facts.push(fact);
-    }
-  }
-  return facts;
-}
-async function extractDecisionsFromLog(workspaceDir, date5) {
-  const log = await readLog(workspaceDir, date5);
-  const decisions = [];
-  const lines = log.split("\n");
-  for (const line of lines) {
-    if (line.includes("[DECISION]")) {
-      const decision = line.replace(/\[DECISION\]/, "").replace(/^- /, "").trim();
-      if (decision) decisions.push(decision);
-    }
-  }
-  return decisions;
-}
-var import_node_fs7, import_promises10;
+var import_node_fs6, import_promises6;
 var init_daily_log = __esm({
   "../memory/src/daily-log.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_promises10 = require("node:fs/promises");
+    import_node_fs6 = require("node:fs");
+    import_promises6 = require("node:fs/promises");
     init_paths();
   }
 });
 
 // ../memory/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  MemoryIndexManager: () => MemoryIndexManager,
-  accessFact: () => accessFact,
-  addACLAllowFromEntry: () => addACLAllowFromEntry,
-  addFact: () => addFact,
-  addOwner: () => addOwner,
-  appendToLog: () => appendToLog,
-  appendToMemory: () => appendToMemory,
-  approveACLPairingCode: () => approveACLPairingCode,
-  buildConversationEntry: () => buildConversationEntry,
-  chunkMarkdown: () => chunkMarkdown,
-  clearMemorySection: () => clearMemorySection,
-  closeWatcher: () => closeWatcher,
-  computeDecayTier: () => computeDecayTier,
-  conversationPathForFile: () => conversationPathForFile,
-  conversationToMemoryChunks: () => conversationToMemoryChunks,
-  createEmbeddingProvider: () => createEmbeddingProvider,
-  createEntity: () => createEntity,
-  createMemoryWatcher: () => createMemoryWatcher,
-  createWatcherHandle: () => createWatcherHandle,
-  extractConversationContent: () => extractConversationContent,
-  extractDecisionsFromLog: () => extractDecisionsFromLog,
-  extractFactsFromLog: () => extractFactsFromLog,
-  generateSummary: () => generateSummary,
-  getArchivesPath: () => getArchivesPath,
-  getAreasPath: () => getAreasPath,
-  getDailyLogPath: () => getDailyLogPath,
-  getDefaultMemoryConfig: () => getDefaultMemoryConfig,
-  getLogsPath: () => getLogsPath,
-  getMemoryPaths: () => getMemoryPaths,
-  getMemoryRoot: () => getMemoryRoot,
-  getParaRoot: () => getParaRoot,
-  getProjectHash: () => getProjectHash,
-  getProjectMemoryPath: () => getProjectMemoryPath,
-  getProjectsPath: () => getProjectsPath,
-  getResourcesPath: () => getResourcesPath,
-  getRole: () => getRole,
-  getSharedMemoryPath: () => getSharedMemoryPath,
-  getUserMemoryPath: () => getUserMemoryPath,
-  hashText: () => hashText,
-  isValidWalletAddress: () => isValidWalletAddress,
-  listACLPendingRequests: () => listACLPendingRequests,
-  listConversationFiles: () => listConversationFiles,
-  listConversations: () => listConversations,
-  listMemoryFiles: () => listMemoryFiles,
-  listOwners: () => listOwners,
-  loadConversation: () => loadConversation,
-  logAction: () => logAction,
-  logDecision: () => logDecision,
-  logEvent: () => logEvent,
-  logFact: () => logFact,
-  normalizeConversationText: () => normalizeConversationText,
-  normalizeWalletAddress: () => normalizeWalletAddress,
-  parseACL: () => parseACL,
-  readACLAllowFrom: () => readACLAllowFrom,
-  readLog: () => readLog,
-  readMemorySection: () => readMemorySection,
-  rejectACLPairingCode: () => rejectACLPairingCode,
-  removeACLAllowFromEntry: () => removeACLAllowFromEntry,
-  removeOwner: () => removeOwner,
-  resolveMemoryConfig: () => resolveMemoryConfig,
-  rewriteSummaries: () => rewriteSummaries,
-  saveConversation: () => saveConversation,
-  searchFacts: () => searchFacts,
-  supersedeFact: () => supersedeFact,
-  upsertACLPendingRequest: () => upsertACLPendingRequest,
-  validateWalletAddress: () => validateWalletAddress
-});
 var init_src = __esm({
   "../memory/src/index.ts"() {
     "use strict";
@@ -26041,9 +23829,9 @@ var require_picocolors = __commonJS({
     var argv = p2.argv || [];
     var env = p2.env || {};
     var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-    var formatter = (open2, close, replace = open2) => (input) => {
-      let string4 = "" + input, index = string4.indexOf(close, open2.length);
-      return ~index ? open2 + replaceClose(string4, close, replace, index) + close : open2 + string4 + close;
+    var formatter = (open, close, replace = open) => (input) => {
+      let string4 = "" + input, index = string4.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string4, close, replace, index) + close : open + string4 + close;
     };
     var replaceClose = (string4, close, replace, index) => {
       let result = "", cursor = 0;
@@ -26260,16 +24048,16 @@ async function handleRemoveSkill(c2) {
   }
 }
 function getSkills() {
-  const skillsDir = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills");
-  if (!(0, import_node_fs12.existsSync)(skillsDir)) return [];
+  const skillsDir = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills");
+  if (!(0, import_node_fs11.existsSync)(skillsDir)) return [];
   const skills = [];
   const lockfile = loadLockfile();
-  const entries = (0, import_node_fs12.readdirSync)(skillsDir, { withFileTypes: true });
+  const entries = (0, import_node_fs11.readdirSync)(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    const skillMdPath = (0, import_node_path19.join)(skillsDir, entry.name, "SKILL.md");
-    if (!(0, import_node_fs12.existsSync)(skillMdPath)) continue;
+    const skillMdPath = (0, import_node_path16.join)(skillsDir, entry.name, "SKILL.md");
+    if (!(0, import_node_fs11.existsSync)(skillMdPath)) continue;
     const skillInfo = parseSkillMd(skillMdPath, entry.name);
     if (skillInfo) {
       const lockEntry = lockfile[entry.name];
@@ -26282,10 +24070,10 @@ function getSkills() {
   return skills;
 }
 function loadLockfile() {
-  const lockfilePath = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills-lock.json");
-  if (!(0, import_node_fs12.existsSync)(lockfilePath)) return {};
+  const lockfilePath = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills-lock.json");
+  if (!(0, import_node_fs11.existsSync)(lockfilePath)) return {};
   try {
-    const content = (0, import_node_fs12.readFileSync)(lockfilePath, "utf-8");
+    const content = (0, import_node_fs11.readFileSync)(lockfilePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -26293,7 +24081,7 @@ function loadLockfile() {
 }
 function parseSkillMd(filePath, defaultName) {
   try {
-    const content = (0, import_node_fs12.readFileSync)(filePath, "utf-8");
+    const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
     const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (!frontmatterMatch) return null;
     const frontmatter = frontmatterMatch[1];
@@ -26309,10 +24097,10 @@ function parseSkillMd(filePath, defaultName) {
   }
 }
 async function installSkill(source) {
-  const projectSkillsDir = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills");
-  const lockfilePath = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills-lock.json");
-  if (!(0, import_node_fs12.existsSync)(projectSkillsDir)) {
-    (0, import_node_fs12.mkdirSync)(projectSkillsDir, { recursive: true });
+  const projectSkillsDir = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills");
+  const lockfilePath = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills-lock.json");
+  if (!(0, import_node_fs11.existsSync)(projectSkillsDir)) {
+    (0, import_node_fs11.mkdirSync)(projectSkillsDir, { recursive: true });
   }
   let skillName;
   let skillDir = null;
@@ -26326,8 +24114,8 @@ async function installSkill(source) {
       return { success: false, error: "Invalid GitHub repository name" };
     }
     skillName = parts[2] || parts[1];
-    const tempDir = (0, import_node_path19.resolve)(projectSkillsDir, ".temp", "install");
-    (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    const tempDir = (0, import_node_path16.resolve)(projectSkillsDir, ".temp", "install");
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
     try {
       (0, import_node_child_process2.execFileSync)(
         "git",
@@ -26341,27 +24129,27 @@ async function installSkill(source) {
       return { success: false, error: "Failed to clone repository" };
     }
     skillDir = findSkillDir(tempDir, skillName);
-    if (!skillDir || !(0, import_node_fs12.existsSync)((0, import_node_path19.resolve)(skillDir, "SKILL.md"))) {
-      (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    if (!skillDir || !(0, import_node_fs11.existsSync)((0, import_node_path16.resolve)(skillDir, "SKILL.md"))) {
+      (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
       return { success: false, error: "No SKILL.md found in repository" };
     }
-    const destPath = (0, import_node_path19.resolve)(projectSkillsDir, skillName);
-    (0, import_node_fs12.cpSync)(skillDir, destPath, { recursive: true });
-    (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    const destPath = (0, import_node_path16.resolve)(projectSkillsDir, skillName);
+    (0, import_node_fs11.cpSync)(skillDir, destPath, { recursive: true });
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
   } else if (source.startsWith("./") || source.startsWith("../")) {
-    const localPath = (0, import_node_path19.resolve)(PROJECT_ROOT2, source);
-    if (!(0, import_node_fs12.existsSync)((0, import_node_path19.resolve)(localPath, "SKILL.md"))) {
+    const localPath = (0, import_node_path16.resolve)(PROJECT_ROOT2, source);
+    if (!(0, import_node_fs11.existsSync)((0, import_node_path16.resolve)(localPath, "SKILL.md"))) {
       return { success: false, error: "No SKILL.md found at local path" };
     }
     skillName = source.split("/").pop() || source;
-    const destPath = (0, import_node_path19.resolve)(projectSkillsDir, skillName);
-    (0, import_node_fs12.cpSync)(localPath, destPath, { recursive: true });
+    const destPath = (0, import_node_path16.resolve)(projectSkillsDir, skillName);
+    (0, import_node_fs11.cpSync)(localPath, destPath, { recursive: true });
   } else {
     if (!NPM_PACKAGE_RE.test(source)) {
       return { success: false, error: "Invalid npm package name" };
     }
     skillName = source.split("/").pop() || source;
-    const tempDir = (0, import_node_path19.resolve)(projectSkillsDir, ".temp", "npm-install");
+    const tempDir = (0, import_node_path16.resolve)(projectSkillsDir, ".temp", "npm-install");
     try {
       (0, import_node_child_process2.execFileSync)("npm", ["install", source, "--prefix", tempDir], {
         stdio: "pipe",
@@ -26370,36 +24158,36 @@ async function installSkill(source) {
     } catch {
       return { success: false, error: "Failed to install npm package" };
     }
-    const installedDir = (0, import_node_path19.resolve)(tempDir, "node_modules", source);
-    if (!(0, import_node_fs12.existsSync)((0, import_node_path19.resolve)(installedDir, "SKILL.md"))) {
-      (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    const installedDir = (0, import_node_path16.resolve)(tempDir, "node_modules", source);
+    if (!(0, import_node_fs11.existsSync)((0, import_node_path16.resolve)(installedDir, "SKILL.md"))) {
+      (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
       return { success: false, error: "No SKILL.md found in npm package" };
     }
-    const destPath = (0, import_node_path19.resolve)(projectSkillsDir, skillName);
-    (0, import_node_fs12.cpSync)(installedDir, destPath, { recursive: true });
-    (0, import_node_fs12.rmSync)(tempDir, { recursive: true, force: true });
+    const destPath = (0, import_node_path16.resolve)(projectSkillsDir, skillName);
+    (0, import_node_fs11.cpSync)(installedDir, destPath, { recursive: true });
+    (0, import_node_fs11.rmSync)(tempDir, { recursive: true, force: true });
   }
   const lockfile = loadLockfile();
   lockfile[skillName] = {
     source,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  (0, import_node_fs12.writeFileSync)(lockfilePath, JSON.stringify(lockfile, null, 2));
+  (0, import_node_fs11.writeFileSync)(lockfilePath, JSON.stringify(lockfile, null, 2));
   return { success: true, skill: skillName };
 }
 async function uninstallSkill(name) {
-  const projectSkillsDir = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills");
-  const lockfilePath = (0, import_node_path19.resolve)(PROJECT_ROOT2, "skills-lock.json");
-  const skillPath = (0, import_node_path19.resolve)(projectSkillsDir, name);
-  if (!(0, import_node_fs12.existsSync)(skillPath)) {
+  const projectSkillsDir = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills");
+  const lockfilePath = (0, import_node_path16.resolve)(PROJECT_ROOT2, "skills-lock.json");
+  const skillPath = (0, import_node_path16.resolve)(projectSkillsDir, name);
+  if (!(0, import_node_fs11.existsSync)(skillPath)) {
     return { success: false, error: `Skill '${name}' not found` };
   }
-  (0, import_node_fs12.rmSync)(skillPath, { recursive: true, force: true });
-  if ((0, import_node_fs12.existsSync)(lockfilePath)) {
+  (0, import_node_fs11.rmSync)(skillPath, { recursive: true, force: true });
+  if ((0, import_node_fs11.existsSync)(lockfilePath)) {
     try {
-      const parsed = JSON.parse((0, import_node_fs12.readFileSync)(lockfilePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs11.readFileSync)(lockfilePath, "utf-8"));
       delete parsed[name];
-      (0, import_node_fs12.writeFileSync)(lockfilePath, JSON.stringify(parsed, null, 2));
+      (0, import_node_fs11.writeFileSync)(lockfilePath, JSON.stringify(parsed, null, 2));
     } catch {
     }
   }
@@ -26408,24 +24196,24 @@ async function uninstallSkill(name) {
 function findSkillDir(baseDir, skillName) {
   const searchPaths = [
     baseDir,
-    (0, import_node_path19.resolve)(baseDir, "skills", skillName),
-    (0, import_node_path19.resolve)(baseDir, skillName),
-    (0, import_node_path19.resolve)(baseDir, ".agents", "skills", skillName)
+    (0, import_node_path16.resolve)(baseDir, "skills", skillName),
+    (0, import_node_path16.resolve)(baseDir, skillName),
+    (0, import_node_path16.resolve)(baseDir, ".agents", "skills", skillName)
   ];
-  for (const path6 of searchPaths) {
-    if ((0, import_node_fs12.existsSync)((0, import_node_path19.resolve)(path6, "SKILL.md"))) {
-      return path6;
+  for (const path4 of searchPaths) {
+    if ((0, import_node_fs11.existsSync)((0, import_node_path16.resolve)(path4, "SKILL.md"))) {
+      return path4;
     }
   }
   return null;
 }
-var import_node_child_process2, import_node_fs12, import_node_path19, PROJECT_ROOT2, GITHUB_REPO_RE, NPM_PACKAGE_RE;
+var import_node_child_process2, import_node_fs11, import_node_path16, PROJECT_ROOT2, GITHUB_REPO_RE, NPM_PACKAGE_RE;
 var init_skills = __esm({
   "../agent/src/server/routes/skills.ts"() {
     "use strict";
     import_node_child_process2 = require("node:child_process");
-    import_node_fs12 = require("node:fs");
-    import_node_path19 = require("node:path");
+    import_node_fs11 = require("node:fs");
+    import_node_path16 = require("node:path");
     init_registry2();
     init_auth();
     PROJECT_ROOT2 = process.env.AGENT_PROJECT_ROOT || process.cwd();
@@ -26440,8 +24228,8 @@ __export(index_exports, {
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs13 = require("node:fs");
-var import_node_path20 = require("node:path");
+var import_node_fs12 = require("node:fs");
+var import_node_path17 = require("node:path");
 var import_node_url = require("node:url");
 var import_claude_agent_sdk4 = require("@anthropic-ai/claude-agent-sdk");
 var import_node_server = require("@hono/node-server");
@@ -27221,10 +25009,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -27607,11 +25395,11 @@ function aborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -27794,7 +25582,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path6 = []) => {
+  const processError = (error49, path4 = []) => {
     var _a3, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -27804,7 +25592,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -27836,8 +25624,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -39814,13 +37602,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path4[0] === defsKey) {
+    const key = path4[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -41301,15 +39089,15 @@ var import_picocolors = __toESM(require_picocolors(), 1);
 var import_accounts = require("viem/accounts");
 
 // ../agent/src/lib/secret-store.ts
-var import_node_fs8 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path8 = require("node:path");
 var secrets = /* @__PURE__ */ new Map();
 function getSecretsDir() {
   const dataRoot = process.env.DATA_ROOT;
   if (!dataRoot) {
     return "";
   }
-  return (0, import_node_path11.join)(dataRoot, "secrets");
+  return (0, import_node_path8.join)(dataRoot, "secrets");
 }
 function getSecretPaths() {
   const secretsDir = getSecretsDir();
@@ -41319,14 +39107,14 @@ function getSecretPaths() {
     };
   }
   return {
-    AGENT_WALLET_KEY: (0, import_node_path11.join)(secretsDir, "wallet.key")
+    AGENT_WALLET_KEY: (0, import_node_path8.join)(secretsDir, "wallet.key")
   };
 }
 function loadSecrets() {
   const secretPaths = getSecretPaths();
-  for (const [name, path6] of Object.entries(secretPaths)) {
-    if ((0, import_node_fs8.existsSync)(path6)) {
-      const content = (0, import_node_fs8.readFileSync)(path6, "utf-8").trim();
+  for (const [name, path4] of Object.entries(secretPaths)) {
+    if ((0, import_node_fs7.existsSync)(path4)) {
+      const content = (0, import_node_fs7.readFileSync)(path4, "utf-8").trim();
       secrets.set(name, content);
     }
   }
@@ -41345,34 +39133,34 @@ function hasSecret(name) {
 }
 
 // ../agent/src/lib/workspace.ts
-var import_node_fs9 = require("node:fs");
-var import_promises11 = require("node:fs/promises");
-var import_node_path12 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_promises7 = require("node:fs/promises");
+var import_node_path9 = require("node:path");
 function getProjectRoot() {
   return process.env.AGENT_PROJECT_ROOT || process.cwd();
 }
-async function exists(path6) {
+async function exists(path4) {
   try {
-    await (0, import_promises11.access)(path6);
+    await (0, import_promises7.access)(path4);
     return true;
   } catch {
     return false;
   }
 }
 async function createSymlinkIfNotExists(target, link, type = "file") {
-  const linkDir = (0, import_node_path12.join)(link, "..");
-  await (0, import_promises11.mkdir)(linkDir, { recursive: true });
+  const linkDir = (0, import_node_path9.join)(link, "..");
+  await (0, import_promises7.mkdir)(linkDir, { recursive: true });
   try {
-    await (0, import_promises11.symlink)(target, link, type);
+    await (0, import_promises7.symlink)(target, link, type);
   } catch (err) {
     if (err.code !== "EEXIST") {
       throw err;
     }
   }
 }
-async function createDirIfNotExists(path6) {
-  if (!await exists(path6)) {
-    await (0, import_promises11.mkdir)(path6, { recursive: true });
+async function createDirIfNotExists(path4) {
+  if (!await exists(path4)) {
+    await (0, import_promises7.mkdir)(path4, { recursive: true });
   }
 }
 function sanitizeUserId2(userId) {
@@ -41381,15 +39169,15 @@ function sanitizeUserId2(userId) {
 async function getOrCreateUserWorkspace(userId) {
   const sanitizedUserId = sanitizeUserId2(userId);
   const projectRoot = getProjectRoot();
-  const workspaceDir = (0, import_node_path12.join)(projectRoot, "workspace", sanitizedUserId);
-  const userMemoryDir = (0, import_node_path12.join)(projectRoot, "memory", "users", sanitizedUserId);
+  const workspaceDir = (0, import_node_path9.join)(projectRoot, "workspace", sanitizedUserId);
+  const userMemoryDir = (0, import_node_path9.join)(projectRoot, "memory", "users", sanitizedUserId);
   const userWorkspaceDir = workspaceDir;
   await createDirIfNotExists(workspaceDir);
   await createDirIfNotExists(userMemoryDir);
   const readOnlyLinks = [
     {
-      target: (0, import_node_path12.join)(projectRoot, "dist"),
-      link: (0, import_node_path12.join)(workspaceDir, "dist"),
+      target: (0, import_node_path9.join)(projectRoot, "dist"),
+      link: (0, import_node_path9.join)(workspaceDir, "dist"),
       type: "dir"
     }
   ];
@@ -41398,17 +39186,17 @@ async function getOrCreateUserWorkspace(userId) {
   }
   await createSymlinkIfNotExists(
     userMemoryDir,
-    (0, import_node_path12.join)(workspaceDir, "memory"),
+    (0, import_node_path9.join)(workspaceDir, "memory"),
     "dir"
   );
   return { workspaceDir, userMemoryDir, userWorkspaceDir };
 }
 function validatePathInWorkspace(params) {
   const { workspaceRoot, userId, requestedPath } = params;
-  const userWorkspace = (0, import_node_path12.join)(workspaceRoot, "workspace", sanitizeUserId2(userId));
-  if ((0, import_node_fs9.existsSync)(userWorkspace)) {
+  const userWorkspace = (0, import_node_path9.join)(workspaceRoot, "workspace", sanitizeUserId2(userId));
+  if ((0, import_node_fs8.existsSync)(userWorkspace)) {
     try {
-      const realUserWorkspace = (0, import_node_fs9.realpathSync)(userWorkspace);
+      const realUserWorkspace = (0, import_node_fs8.realpathSync)(userWorkspace);
       if (realUserWorkspace !== userWorkspace) {
         return { valid: false, error: "Workspace cannot be a symlink" };
       }
@@ -41419,17 +39207,17 @@ function validatePathInWorkspace(params) {
   if (requestedPath.includes("..")) {
     return { valid: false, error: "Directory traversal not allowed" };
   }
-  if ((0, import_node_path12.isAbsolute)(requestedPath)) {
+  if ((0, import_node_path9.isAbsolute)(requestedPath)) {
     return { valid: false, error: "Only relative paths allowed" };
   }
-  const resolvedPath = (0, import_node_path12.resolve)(userWorkspace, requestedPath);
+  const resolvedPath = (0, import_node_path9.resolve)(userWorkspace, requestedPath);
   if (resolvedPath !== userWorkspace && !resolvedPath.startsWith(`${userWorkspace}/`)) {
     return { valid: false, error: "Path escapes workspace" };
   }
-  if ((0, import_node_fs9.existsSync)(resolvedPath)) {
+  if ((0, import_node_fs8.existsSync)(resolvedPath)) {
     try {
-      const realPath = (0, import_node_fs9.realpathSync)(resolvedPath);
-      const realWorkspace = (0, import_node_fs9.realpathSync)(userWorkspace);
+      const realPath = (0, import_node_fs8.realpathSync)(resolvedPath);
+      const realWorkspace = (0, import_node_fs8.realpathSync)(userWorkspace);
       if (!realPath.startsWith(`${realWorkspace}/`) && realPath !== realWorkspace) {
         return { valid: false, error: "Symlink escapes workspace" };
       }
@@ -41441,17 +39229,17 @@ function validatePathInWorkspace(params) {
 }
 
 // ../agent/src/lib/workspace-state.ts
-var import_node_fs10 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
 var WORKSPACE_STATE_VERSION = 1;
 var STATE_DIR = ".hybrid";
 var STATE_FILE = "workspace-state.json";
 function resolveWorkspaceStatePath(workspaceDir) {
-  return (0, import_node_path13.join)(workspaceDir, STATE_DIR, STATE_FILE);
+  return (0, import_node_path10.join)(workspaceDir, STATE_DIR, STATE_FILE);
 }
 function readWorkspaceState(statePath) {
   try {
-    const raw = (0, import_node_fs10.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_node_fs9.readFileSync)(statePath, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       version: parsed.version ?? WORKSPACE_STATE_VERSION,
@@ -41463,11 +39251,11 @@ function readWorkspaceState(statePath) {
   }
 }
 function writeWorkspaceState(statePath, state) {
-  const dir = (0, import_node_path13.dirname)(statePath);
-  if (!(0, import_node_fs10.existsSync)(dir)) {
-    (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path10.dirname)(statePath);
+  if (!(0, import_node_fs9.existsSync)(dir)) {
+    (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs10.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+  (0, import_node_fs9.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function isOnboardingComplete(workspaceDir, bootstrapExists) {
   const statePath = resolveWorkspaceStatePath(workspaceDir);
@@ -41502,18 +39290,18 @@ var import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
 init_src();
 
 // ../agent/src/tools/file.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path15 = require("node:path");
 var import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
 
 // ../agent/src/file-operations/edit.ts
-var import_promises12 = require("node:fs/promises");
-var import_node_path14 = require("node:path");
+var import_promises8 = require("node:fs/promises");
+var import_node_path11 = require("node:path");
 async function editFileInWorkspace(params) {
-  const filePath = (0, import_node_path14.join)(params.workspacePath, params.path);
+  const filePath = (0, import_node_path11.join)(params.workspacePath, params.path);
   let content;
   try {
-    content = await (0, import_promises12.readFile)(filePath, "utf-8");
+    content = await (0, import_promises8.readFile)(filePath, "utf-8");
   } catch {
     return {
       success: false,
@@ -41540,7 +39328,7 @@ async function editFileInWorkspace(params) {
     }
   }
   if (editsApplied.length > 0) {
-    await (0, import_promises12.writeFile)(filePath, content, "utf-8");
+    await (0, import_promises8.writeFile)(filePath, content, "utf-8");
   }
   return {
     success: editsFailed.length === 0,
@@ -41551,8 +39339,8 @@ async function editFileInWorkspace(params) {
 }
 
 // ../agent/src/file-operations/patch.ts
-var import_promises13 = require("node:fs/promises");
-var import_node_path15 = require("node:path");
+var import_promises9 = require("node:fs/promises");
+var import_node_path12 = require("node:path");
 function applyUnifiedDiff(content, patch) {
   const lines = content.split("\n");
   const patchLines = patch.split("\n");
@@ -41628,10 +39416,10 @@ function applyUnifiedDiff(content, patch) {
   };
 }
 async function applyPatchToWorkspace(params) {
-  const filePath = (0, import_node_path15.join)(params.workspacePath, params.path);
+  const filePath = (0, import_node_path12.join)(params.workspacePath, params.path);
   let content;
   try {
-    content = await (0, import_promises13.readFile)(filePath, "utf-8");
+    content = await (0, import_promises9.readFile)(filePath, "utf-8");
   } catch {
     return {
       success: false,
@@ -41642,7 +39430,7 @@ async function applyPatchToWorkspace(params) {
   }
   const result = applyUnifiedDiff(content, params.patch);
   if (result.success && result.result) {
-    await (0, import_promises13.writeFile)(filePath, result.result, "utf-8");
+    await (0, import_promises9.writeFile)(filePath, result.result, "utf-8");
   }
   return {
     success: result.success,
@@ -41653,8 +39441,8 @@ async function applyPatchToWorkspace(params) {
 }
 
 // ../agent/src/file-operations/read.ts
-var import_promises14 = require("node:fs/promises");
-var import_node_path16 = require("node:path");
+var import_promises10 = require("node:fs/promises");
+var import_node_path13 = require("node:path");
 
 // ../agent/src/file-operations/types.ts
 var DEFAULT_PAGE_SIZE = 50 * 1024;
@@ -41663,8 +39451,8 @@ var MAX_LINES = 2e3;
 var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
 
 // ../agent/src/file-operations/read.ts
-function isBinaryFileExtension(path6) {
-  const binaryExtensions2 = [
+function isBinaryFileExtension(path4) {
+  const binaryExtensions = [
     ".png",
     ".jpg",
     ".jpeg",
@@ -41684,11 +39472,11 @@ function isBinaryFileExtension(path6) {
     ".avi",
     ".mov"
   ];
-  const ext = path6.toLowerCase();
-  return binaryExtensions2.some((e2) => ext.endsWith(e2));
+  const ext = path4.toLowerCase();
+  return binaryExtensions.some((e2) => ext.endsWith(e2));
 }
 async function readFileWithPaging(filePath, offset, limit2) {
-  const content = await (0, import_promises14.readFile)(filePath, "utf-8");
+  const content = await (0, import_promises10.readFile)(filePath, "utf-8");
   const lines = content.split("\n");
   const startLine = (offset ?? 1) - 1;
   const maxLines = limit2 ?? MAX_LINES;
@@ -41714,8 +39502,8 @@ async function readFileWithPaging(filePath, offset, limit2) {
   };
 }
 async function readFileFromWorkspace(params) {
-  const filePath = (0, import_node_path16.join)(params.workspacePath, params.path);
-  const stats = await (0, import_promises14.stat)(filePath);
+  const filePath = (0, import_node_path13.join)(params.workspacePath, params.path);
+  const stats = await (0, import_promises10.stat)(filePath);
   if (isBinaryFileExtension(params.path)) {
     throw new Error(
       `Cannot read binary file: ${params.path}. Use appropriate tool for binary files.`
@@ -41725,7 +39513,7 @@ async function readFileFromWorkspace(params) {
   if (usePaging || params.offset || params.limit) {
     return readFileWithPaging(filePath, params.offset, params.limit);
   }
-  const content = await (0, import_promises14.readFile)(filePath, "utf-8");
+  const content = await (0, import_promises10.readFile)(filePath, "utf-8");
   const lines = content.split("\n");
   return {
     content,
@@ -41735,21 +39523,21 @@ async function readFileFromWorkspace(params) {
 }
 
 // ../agent/src/file-operations/write.ts
-var import_promises15 = require("node:fs/promises");
-var import_node_path17 = require("node:path");
+var import_promises11 = require("node:fs/promises");
+var import_node_path14 = require("node:path");
 async function writeFileToWorkspace(params) {
-  const filePath = (0, import_node_path17.join)(params.workspacePath, params.path);
+  const filePath = (0, import_node_path14.join)(params.workspacePath, params.path);
   const tempPath = `${filePath}.tmp`;
-  await (0, import_promises15.mkdir)((0, import_node_path17.dirname)(filePath), { recursive: true });
-  await (0, import_promises15.writeFile)(tempPath, params.content, "utf-8");
+  await (0, import_promises11.mkdir)((0, import_node_path14.dirname)(filePath), { recursive: true });
+  await (0, import_promises11.writeFile)(tempPath, params.content, "utf-8");
   try {
-    await (0, import_promises15.rename)(tempPath, filePath);
+    await (0, import_promises11.rename)(tempPath, filePath);
   } catch {
     try {
-      await (0, import_promises15.unlink)(filePath);
+      await (0, import_promises11.unlink)(filePath);
     } catch {
     }
-    await (0, import_promises15.rename)(tempPath, filePath);
+    await (0, import_promises11.rename)(tempPath, filePath);
   }
   const bytesWritten = Buffer.byteLength(params.content, "utf-8");
   return {
@@ -41803,7 +39591,7 @@ function createFileTools(params) {
           isError: true
         };
       }
-      const userWorkspacePath = (0, import_node_path18.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+      const userWorkspacePath = (0, import_node_path15.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
       try {
         const result = await readFileFromWorkspace({
           workspacePath: userWorkspacePath,
@@ -41849,8 +39637,8 @@ function createFileTools(params) {
       const baseName = args.path.split("/").pop();
       if (baseName && args.path === baseName && PROJECT_CONFIG_FILES.includes(baseName)) {
         try {
-          const configPath = (0, import_node_path18.join)(projectRoot, baseName);
-          (0, import_node_fs11.writeFileSync)(configPath, args.content, "utf-8");
+          const configPath = (0, import_node_path15.join)(projectRoot, baseName);
+          (0, import_node_fs10.writeFileSync)(configPath, args.content, "utf-8");
           return {
             content: [
               {
@@ -41882,7 +39670,7 @@ function createFileTools(params) {
           isError: true
         };
       }
-      const userWorkspacePath = (0, import_node_path18.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+      const userWorkspacePath = (0, import_node_path15.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
       try {
         const result = await writeFileToWorkspace({
           workspacePath: userWorkspacePath,
@@ -41937,8 +39725,8 @@ function createFileTools(params) {
       const baseName = args.path.split("/").pop();
       if (baseName && args.path === baseName && PROJECT_CONFIG_FILES.includes(baseName)) {
         try {
-          const configPath = (0, import_node_path18.join)(projectRoot, baseName);
-          if (!(0, import_node_fs11.existsSync)(configPath)) {
+          const configPath = (0, import_node_path15.join)(projectRoot, baseName);
+          if (!(0, import_node_fs10.existsSync)(configPath)) {
             return {
               content: [
                 {
@@ -41950,7 +39738,7 @@ function createFileTools(params) {
             };
           }
           let content = await import("node:fs/promises").then(
-            (fs5) => fs5.readFile(configPath, "utf-8")
+            (fs4) => fs4.readFile(configPath, "utf-8")
           );
           let applied = 0;
           const failed = [];
@@ -41963,7 +39751,7 @@ function createFileTools(params) {
               failed.push({ oldText: edit.oldText, reason: "Text not found" });
             }
           }
-          (0, import_node_fs11.writeFileSync)(configPath, content, "utf-8");
+          (0, import_node_fs10.writeFileSync)(configPath, content, "utf-8");
           if (failed.length > 0) {
             return {
               content: [
@@ -42006,7 +39794,7 @@ function createFileTools(params) {
           isError: true
         };
       }
-      const userWorkspacePath = (0, import_node_path18.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+      const userWorkspacePath = (0, import_node_path15.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
       try {
         const result = await editFileInWorkspace({
           workspacePath: userWorkspacePath,
@@ -42077,7 +39865,7 @@ ${failedText}`
           isError: true
         };
       }
-      const userWorkspacePath = (0, import_node_path18.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+      const userWorkspacePath = (0, import_node_path15.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
       try {
         const result = await applyPatchToWorkspace({
           workspacePath: userWorkspacePath,
@@ -42137,8 +39925,8 @@ ${failedText}`
       const baseName = args.path.split("/").pop();
       if (baseName && args.path === baseName && PROJECT_CONFIG_FILES.includes(baseName)) {
         try {
-          const configPath = (0, import_node_path18.join)(projectRoot, baseName);
-          if (!(0, import_node_fs11.existsSync)(configPath)) {
+          const configPath = (0, import_node_path15.join)(projectRoot, baseName);
+          if (!(0, import_node_fs10.existsSync)(configPath)) {
             return {
               content: [
                 {
@@ -42149,7 +39937,7 @@ ${failedText}`
               isError: true
             };
           }
-          (0, import_node_fs11.rmSync)(configPath, { force: true });
+          (0, import_node_fs10.rmSync)(configPath, { force: true });
           return {
             content: [
               {
@@ -42181,10 +39969,10 @@ ${failedText}`
           isError: true
         };
       }
-      const userWorkspacePath = (0, import_node_path18.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
-      const fullPath = (0, import_node_path18.join)(userWorkspacePath, args.path);
+      const userWorkspacePath = (0, import_node_path15.join)(projectRoot, "workspace", userId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+      const fullPath = (0, import_node_path15.join)(userWorkspacePath, args.path);
       try {
-        if (!(0, import_node_fs11.existsSync)(fullPath)) {
+        if (!(0, import_node_fs10.existsSync)(fullPath)) {
           return {
             content: [
               {
@@ -42196,8 +39984,8 @@ ${failedText}`
           };
         }
         const { statSync: statSync2 } = await import("node:fs");
-        const stat5 = statSync2(fullPath);
-        if (stat5.isDirectory()) {
+        const stat2 = statSync2(fullPath);
+        if (stat2.isDirectory()) {
           return {
             content: [
               {
@@ -42208,7 +39996,7 @@ ${failedText}`
             isError: true
           };
         }
-        (0, import_node_fs11.rmSync)(fullPath);
+        (0, import_node_fs10.rmSync)(fullPath);
         return {
           content: [
             {
@@ -42749,28 +40537,28 @@ Fact Categories:
         };
       }
       try {
-        const { join: join18 } = await import("node:path");
+        const { join: join16 } = await import("node:path");
         const {
           getProjectsPath: getProjectsPath2,
           getAreasPath: getAreasPath2,
           getResourcesPath: getResourcesPath2,
           getArchivesPath: getArchivesPath2
-        } = await Promise.resolve().then(() => (init_src(), src_exports));
+        } = await import("@hybrid/memory");
         let entityPath;
         if (args.bucket === "projects") {
-          entityPath = join18(getProjectsPath2(workspaceDir), args.entityName);
+          entityPath = join16(getProjectsPath2(workspaceDir), args.entityName);
         } else if (args.bucket === "areas" && args.category) {
-          entityPath = join18(
+          entityPath = join16(
             getAreasPath2(workspaceDir),
             args.category,
             args.entityName
           );
         } else if (args.bucket === "areas") {
-          entityPath = join18(getAreasPath2(workspaceDir), args.entityName);
+          entityPath = join16(getAreasPath2(workspaceDir), args.entityName);
         } else if (args.bucket === "resources") {
-          entityPath = join18(getResourcesPath2(workspaceDir), args.entityName);
+          entityPath = join16(getResourcesPath2(workspaceDir), args.entityName);
         } else {
-          entityPath = join18(getArchivesPath2(workspaceDir), args.entityName);
+          entityPath = join16(getArchivesPath2(workspaceDir), args.entityName);
         }
         const result = await addFact(
           workspaceDir,
@@ -43152,7 +40940,7 @@ Returns skills matching the query with descriptions.`,
 
 // ../agent/src/server/index.ts
 var import_meta = {};
-var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_node_path20.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_node_path17.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
 loadSecrets();
 var PROJECT_ROOT4 = process.env.AGENT_PROJECT_ROOT || process.cwd();
 if (process.env.OPENROUTER_API_KEY && (!process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY === "" || process.env.ANTHROPIC_API_KEY.includes("your_"))) {
@@ -43199,7 +40987,7 @@ function resolveClaudeCodeCliPath() {
   }
   const possiblePaths = [
     // Docker container: /app/server -> /app/node_modules
-    (0, import_node_path20.join)(
+    (0, import_node_path17.join)(
       _dirname,
       "..",
       "node_modules",
@@ -43209,7 +40997,7 @@ function resolveClaudeCodeCliPath() {
     ),
     // Dev/prod mode: from packages/agent/src/server or packages/agent/dist/server
     // both need 4 levels up to reach monorepo root node_modules
-    (0, import_node_path20.join)(
+    (0, import_node_path17.join)(
       _dirname,
       "..",
       "..",
@@ -43221,7 +41009,7 @@ function resolveClaudeCodeCliPath() {
       "cli.js"
     ),
     // pnpm hoisted location (dev)
-    (0, import_node_path20.join)(
+    (0, import_node_path17.join)(
       _dirname,
       "..",
       "..",
@@ -43240,7 +41028,7 @@ function resolveClaudeCodeCliPath() {
     "/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js"
   ];
   for (const p2 of possiblePaths) {
-    if ((0, import_node_fs13.existsSync)(p2)) {
+    if ((0, import_node_fs12.existsSync)(p2)) {
       return p2;
     }
   }
@@ -43251,7 +41039,7 @@ function resolveClaudeCodeCliPath() {
 function resolveClaudeCodeExecutable() {
   const realCliPath = resolveClaudeCodeCliPath();
   try {
-    (0, import_node_fs13.readFileSync)(CLAUDE_WRAPPER_PATH, "utf-8");
+    (0, import_node_fs12.readFileSync)(CLAUDE_WRAPPER_PATH, "utf-8");
     return {
       executablePath: CLAUDE_WRAPPER_PATH,
       realCliPath,
@@ -43265,10 +41053,10 @@ function resolveClaudeCodeExecutable() {
     };
   }
 }
-var SCHEDULER_DB_PATH = process.env.SCHEDULER_DB_PATH || (0, import_node_path20.join)(PROJECT_ROOT4, "data", "scheduler.db");
+var SCHEDULER_DB_PATH = process.env.SCHEDULER_DB_PATH || (0, import_node_path17.join)(PROJECT_ROOT4, "data", "scheduler.db");
 function loadMarkdownFile(relativePath) {
   try {
-    return (0, import_node_fs13.readFileSync)((0, import_node_path20.join)(PROJECT_ROOT4, relativePath), "utf-8").trim();
+    return (0, import_node_fs12.readFileSync)((0, import_node_path17.join)(PROJECT_ROOT4, relativePath), "utf-8").trim();
   } catch {
     return "";
   }
@@ -43276,7 +41064,7 @@ function loadMarkdownFile(relativePath) {
 function loadUserMarkdown(userId) {
   if (!userId) return loadMarkdownFile("USER.md");
   const sanitizedId = userId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  const userPath = (0, import_node_path20.join)("users", sanitizedId, "USER.md");
+  const userPath = (0, import_node_path17.join)("users", sanitizedId, "USER.md");
   const userFile = loadMarkdownFile(userPath);
   return userFile || loadMarkdownFile("USER.md");
 }
@@ -43332,8 +41120,8 @@ async function initScheduler() {
   }
   try {
     const { mkdirSync: mkdirSync7, existsSync: existsSync11 } = await import("node:fs");
-    const { dirname: dirname7 } = await import("node:path");
-    const dbDir = dirname7(SCHEDULER_DB_PATH);
+    const { dirname: dirname5 } = await import("node:path");
+    const dbDir = dirname5(SCHEDULER_DB_PATH);
     if (!existsSync11(dbDir)) {
       mkdirSync7(dbDir, { recursive: true });
     }
@@ -44033,7 +41821,4 @@ humanize-ms/index.js:
 
 node-domexception/index.js:
   (*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
-
-chokidar/esm/index.js:
-  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */