@polka-codes/cli 0.9.88 → 0.9.89

package/dist/index.js

@@ -16483,10 +16483,28 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// ../core/src/config/memory.ts
+function resolveHomePath(path) {
+  if (path.startsWith("~")) {
+    return `${process.env.HOME}${path.slice(1)}`;
+  }
+  return path;
+}
+var memoryConfigSchema;
+var init_memory = __esm(() => {
+  init_zod();
+  memoryConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().optional().default(true),
+    type: exports_external.enum(["sqlite", "memory"]).optional().default("sqlite"),
+    path: exports_external.string().optional().default("~/.config/polka-codes/memory.sqlite")
+  }).strict().optional();
+});
+
 // ../core/src/config.ts
 var ruleSchema, providerConfigSchema, providerModelSchema, scriptSchema, mcpServerConfigSchema, agentContinuousImprovementSchema, agentDiscoverySchema, agentSafetySchema, agentHealthCheckSchema, agentApprovalSchema, agentSchema, configSchema;
 var init_config = __esm(() => {
   init_zod();
+  init_memory();
   ruleSchema = exports_external.union([
     exports_external.string(),
     exports_external.object({ path: exports_external.string() }).strict(),
@@ -16618,7 +16636,8 @@ var init_config = __esm(() => {
     mcpServers: exports_external.record(exports_external.string(), mcpServerConfigSchema).optional(),
     rules: exports_external.array(ruleSchema).optional().or(exports_external.string()).optional(),
     excludeFiles: exports_external.array(exports_external.string()).optional(),
-    agent: agentSchema
+    agent: agentSchema,
+    memory: memoryConfigSchema
   }).strict().nullish();
 });
 
@@ -16671,6 +16690,8 @@ var init_node_provider = () => {};
 var init_fs = __esm(() => {
   init_node_provider();
 });
+// ../core/src/memory/index.ts
+var init_memory2 = () => {};
 
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS, IGNORED_DIRECTORIES, SUSPICIOUS_PATTERNS, SKILL_ERROR_MESSAGES, SOURCE_ICONS;
@@ -24611,15 +24632,39 @@ var toolInfo6, handler6 = async (provider, args) => {
   if (!provider.readFile) {
     return createProviderErrorResponse("read file");
   }
-  const { path: paths, includeIgnored } = toolInfo6.parameters.parse(args);
+  const parsed = toolInfo6.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      success: false,
+      message: {
+        type: "error-text",
+        value: `Invalid arguments for readFile: ${parsed.error.message}`
+      }
+    };
+  }
+  const { path: paths, offset, limit, includeIgnored } = parsed.data;
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path, includeIgnored ?? false);
     if (!fileContent) {
       resp.push(createFileElement("read_file_file_content", path, undefined, { file_not_found: "true" }));
-    } else {
-      resp.push(createFileElement("read_file_file_content", path, fileContent));
+      continue;
     }
+    let lines = fileContent.split(`
+`);
+    const start = offset ?? 0;
+    const end = limit ? start + limit : lines.length;
+    if (offset !== undefined || limit !== undefined) {
+      lines = lines.slice(start, end);
+    }
+    const lineOffset = offset ?? 0;
+    const numberedContent = lines.map((line, i) => {
+      const lineNumber = lineOffset + i + 1;
+      const paddedNumber = String(lineNumber).padStart(6, " ");
+      return `${paddedNumber}→${line}`;
+    }).join(`
+`);
+    resp.push(createFileElement("read_file_file_content", path, numberedContent));
   }
   return {
     success: true,
@@ -24635,14 +24680,40 @@ var init_readFile = __esm(() => {
   init_utils();
   toolInfo6 = {
     name: "readFile",
-    description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
+    description: `Request to read the contents of one or multiple files at the specified paths.
+
+When to use:
+- Examining file contents you don't know
+- Analyzing code, reviewing text files, extracting configuration info
+- Reading multiple files at once (use comma-separated paths)
+- Understanding file structure before editing
+
+When NOT to use:
+- For file existence checks: Use listFiles instead
+- For searching within files: Use grep instead
+- For file name searches: Use searchFiles instead
+- Prefer this tool over executeCommand with cat/head/tail
+
+Features:
+- Supports comma-separated paths for multiple files
+- Line numbers included for easy reference
+- Optional offset/limit for partial file reading
+- Automatically handles different file types
+
+IMPORTANT:
+- Line numbers are included for easy reference
+- Use offset/limit for large files to read specific sections`,
     parameters: exports_external.object({
       path: exports_external.preprocess((val) => {
         if (!val)
           return [];
-        const values = Array.isArray(val) ? val : [val];
-        return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+        if (Array.isArray(val)) {
+          return val.filter((s) => typeof s === "string" && s.length > 0);
+        }
+        return val.split(",").filter((s) => s.length > 0);
       }, exports_external.array(exports_external.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" }),
+      offset: exports_external.number().optional().describe("Skip first N lines (for partial file reading)").meta({ usageValue: "100" }),
+      limit: exports_external.number().optional().describe("Read at most N lines (for partial file reading)").meta({ usageValue: "50" }),
       includeIgnored: exports_external.preprocess(preprocessBoolean, exports_external.boolean().nullish().default(false)).describe("Whether to include ignored files. Use true to include files ignored by .gitignore.").meta({ usageValue: "true or false (optional)" })
     }).meta({
       examples: [
@@ -24657,6 +24728,14 @@ var init_readFile = __esm(() => {
           input: {
             path: "src/main.js,src/index.js"
           }
+        },
+        {
+          description: "Read partial file (lines 100-150)",
+          input: {
+            path: "src/large-file.ts",
+            offset: 100,
+            limit: 50
+          }
         }
       ]
     })
@@ -24933,7 +25012,43 @@ var init_replaceInFile = __esm(() => {
   init_zod();
   toolInfo9 = {
     name: "replaceInFile",
-    description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+    description: `Request to replace sections of content in an existing file using
+SEARCH/REPLACE blocks.
+
+When to use:
+- Making targeted changes to specific parts of a file
+- Replacing variable names, function signatures, imports
+- Fixing bugs in existing code
+- When you know the exact content to replace
+
+When NOT to use:
+- For creating new files: Use writeToFile instead
+- For completely replacing file contents: Use writeToFile instead
+- When you don't know the exact content: Read file first
+
+SEARCH/REPLACE FORMAT:
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+Critical rules:
+1. SEARCH content must match EXACTLY (character-for-character including whitespace)
+2. Each block replaces only first occurrence
+3. Include just enough lines for uniqueness (not too many, not too few)
+4. Keep blocks concise (don't include long unchanged sections)
+5. List blocks in order they appear in file
+6. Use multiple blocks for multiple independent changes
+
+Special operations:
+- Move code: Two blocks (delete from original + insert at new location)
+- Delete code: Empty REPLACE section
+
+IMPORTANT CONSTRAINTS:
+- SEARCH text must match file content exactly
+- Each block is independent (doesn't affect other blocks)
+- Cannot use for appending or inserting without SEARCH context`,
     parameters: exports_external.object({
       path: exports_external.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
       diff: exports_external.string().describe(`One or more SEARCH/REPLACE blocks following this exact format:
@@ -24959,7 +25074,7 @@ Critical rules:
     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
 4. Special operations:
     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-    * To delete code: Use empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
+    * To delete code: Empty REPLACE section`).meta({ usageValue: "Search and replace blocks here" })
     }).meta({
       examples: [
         {
@@ -25241,10 +25356,7 @@ var toolInfo12, handler12 = async (provider, args) => {
       }
     };
   }
-  let { path, content } = parsed.data;
-  const trimmedContent = content.trim();
-  if (trimmedContent.startsWith("<![CDATA[") && trimmedContent.endsWith("]]>"))
-    content = trimmedContent.slice(9, -3);
+  const { path, content } = parsed.data;
   await provider.writeFile(path, content);
   return {
     success: true,
@@ -25259,7 +25371,27 @@ var init_writeToFile = __esm(() => {
   init_utils();
   toolInfo12 = {
     name: "writeToFile",
-    description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
+    description: `Request to write content to a file at the specified path.
+
+When to use:
+- Creating new files
+- Completely replacing file contents
+- When you have the complete intended content
+
+When NOT to use:
+- For modifying existing files: Use replaceInFile instead
+- For appending content: Use executeCommand with echo >> instead
+- For targeted edits: Use replaceInFile instead
+
+Features:
+- Automatically creates any directories needed
+- Overwrites existing files completely
+- Must provide complete file content (no truncation)
+
+IMPORTANT CONSTRAINT:
+- Always provide COMPLETE intended content (no omissions)
+- Ensure no incorrect escape sequences (&lt;, &gt;, &amp;)
+- Ensure no unwanted CDATA tags in content`,
     parameters: exports_external.object({
       path: exports_external.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
       content: exports_external.string().describe("The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.").meta({ usageValue: "Your file content here" })
@@ -28503,9 +28635,9 @@ var init_types2 = __esm(() => {
       return this._def.options;
     }
   };
-  ZodUnion2.create = (types2, params) => {
+  ZodUnion2.create = (types3, params) => {
     return new ZodUnion2({
-      options: types2,
+      options: types3,
       typeName: ZodFirstPartyTypeKind2.ZodUnion,
       ...processCreateParams(params)
     });
@@ -30606,15 +30738,15 @@ function parseNullDef() {
 function parseUnionDef(def, refs) {
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
-    const types3 = options.reduce((types22, x) => {
+    const types4 = options.reduce((types22, x) => {
       const type = primitiveMappings[x._def.typeName];
       return type && !types22.includes(type) ? [...types22, type] : types22;
     }, []);
     return {
-      type: types3.length > 1 ? types3 : types3[0]
+      type: types4.length > 1 ? types4 : types4[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types3 = options.reduce((acc, x) => {
+    const types4 = options.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -30633,8 +30765,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types3.length === options.length) {
-      const uniqueTypes = types3.filter((x, i, a) => a.indexOf(x) === i);
+    if (types4.length === options.length) {
+      const uniqueTypes = types4.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -39696,9 +39828,9 @@ function convertJsonSchemaToZod(schema) {
     return exports_external.union([literals[0], literals[1], ...literals.slice(2)]);
   }
   if (Array.isArray(schema.type)) {
-    const types3 = schema.type;
-    if (types3.includes("null") && types3.length === 2) {
-      const nonNullType = types3.find((t) => t !== "null");
+    const types4 = schema.type;
+    if (types4.includes("null") && types4.length === 2) {
+      const nonNullType = types4.find((t) => t !== "null");
       if (nonNullType === "string")
         return exports_external.string().nullable();
       if (nonNullType === "number")
@@ -40656,6 +40788,7 @@ var init_src = __esm(() => {
   init_Agent();
   init_config();
   init_fs();
+  init_memory2();
   init_skills();
   init_tools();
   init_tools2();
@@ -41361,9 +41494,9 @@ var init__nodeUtil = __esm(() => {
   freeProcess = moduleExports2 && _freeGlobal_default.process;
   nodeUtil = function() {
     try {
-      var types4 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
-      if (types4) {
-        return types4;
+      var types5 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+      if (types5) {
+        return types5;
       }
       return freeProcess && freeProcess.binding && freeProcess.binding("util");
     } catch (e) {}
@@ -42489,6 +42622,38 @@ var init_config2 = __esm(() => {
   init_zod();
 });
 
+// ../cli-shared/src/memory-manager.ts
+class MemoryManager {
+  store;
+  constructor(store, _cwd) {
+    this.store = store;
+  }
+  async readMemory(topic) {
+    return this.store.readMemory(topic);
+  }
+  async updateMemory(operation, topic, content, metadata) {
+    return this.store.updateMemory(operation, topic, content, metadata);
+  }
+  async queryMemory(query = {}, options) {
+    const finalQuery = {
+      ...query
+    };
+    if (!options?.operation && !finalQuery.limit) {
+      finalQuery.limit = 1000;
+    }
+    return this.store.queryMemory(finalQuery, options);
+  }
+  async batchUpdateMemory(operations) {
+    return this.store.batchUpdateMemory(operations);
+  }
+  async getStats() {
+    return this.store.getStats();
+  }
+  close() {
+    this.store.close();
+  }
+}
+
 // ../../node_modules/extend/index.js
 var require_extend = __commonJS((exports, module) => {
   var hasOwn = Object.prototype.hasOwnProperty;
@@ -49087,7 +49252,7 @@ var init_multipart_parser = __esm(() => {
 
 // ../../node_modules/node-fetch/src/body.js
 import Stream, { PassThrough } from "node:stream";
-import { types as types4, deprecate, promisify } from "node:util";
+import { types as types5, deprecate, promisify } from "node:util";
 import { Buffer as Buffer4 } from "node:buffer";
 
 class Body {
@@ -49099,7 +49264,7 @@ class Body {
       body = null;
     } else if (isURLSearchParameters(body)) {
       body = Buffer4.from(body.toString());
-    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types4.isAnyArrayBuffer(body)) {
+    } else if (isBlob(body)) {} else if (Buffer4.isBuffer(body)) {} else if (types5.isAnyArrayBuffer(body)) {
       body = Buffer4.from(body);
     } else if (ArrayBuffer.isView(body)) {
       body = Buffer4.from(body.buffer, body.byteOffset, body.byteLength);
@@ -49245,7 +49410,7 @@ var pipeline, INTERNALS, clone2 = (instance, highWaterMark) => {
   if (isBlob(body)) {
     return body.type || null;
   }
-  if (Buffer4.isBuffer(body) || types4.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+  if (Buffer4.isBuffer(body) || types5.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
     return null;
   }
   if (body instanceof FormData2) {
@@ -49302,7 +49467,7 @@ var init_body = __esm(() => {
 });
 
 // ../../node_modules/node-fetch/src/headers.js
-import { types as types5 } from "node:util";
+import { types as types6 } from "node:util";
 import http from "node:http";
 function fromRawHeaders(headers = []) {
   return new Headers2(headers.reduce((result, value, index, array2) => {
@@ -49344,7 +49509,7 @@ var init_headers = __esm(() => {
         for (const [name17, values] of Object.entries(raw)) {
           result.push(...values.map((value) => [name17, value]));
         }
-      } else if (init == null) {} else if (typeof init === "object" && !types5.isBoxedPrimitive(init)) {
+      } else if (init == null) {} else if (typeof init === "object" && !types6.isBoxedPrimitive(init)) {
         const method = init[Symbol.iterator];
         if (method == null) {
           result.push(...Object.entries(init));
@@ -49353,7 +49518,7 @@ var init_headers = __esm(() => {
             throw new TypeError("Header pairs must be iterable");
           }
           result = [...init].map((pair) => {
-            if (typeof pair !== "object" || types5.isBoxedPrimitive(pair)) {
+            if (typeof pair !== "object" || types6.isBoxedPrimitive(pair)) {
               throw new TypeError("Each header pair must be an iterable object");
             }
             return [...pair];
@@ -72581,7 +72746,7 @@ function lookup(path) {
   }
   return $types[extension2] || false;
 }
-function populateMaps(extensions, types6) {
+function populateMaps(extensions, types7) {
   Object.keys(db).forEach(function forEachMimeType(type) {
     var mime = db[type];
     var exts = mime.extensions;
@@ -72591,10 +72756,10 @@ function populateMaps(extensions, types6) {
     extensions[type] = exts;
     for (var i2 = 0;i2 < exts.length; i2++) {
       var extension2 = exts[i2];
-      types6[extension2] = _preferredType(extension2, types6[extension2], type);
-      const legacyType = _preferredTypeLegacy(extension2, types6[extension2], type);
-      if (legacyType !== types6[extension2]) {
-        $_extensionConflicts.push([extension2, legacyType, types6[extension2]]);
+      types7[extension2] = _preferredType(extension2, types7[extension2], type);
+      const legacyType = _preferredTypeLegacy(extension2, types7[extension2], type);
+      if (legacyType !== types7[extension2]) {
+        $_extensionConflicts.push([extension2, legacyType, types7[extension2]]);
       }
     }
   });
@@ -72931,35 +73096,35 @@ var import_ignore2, getProvider = (options = {}) => {
       }
     },
     listMemoryTopics: async () => {
-      const memory = await memoryStore.read() ?? {};
-      return Object.keys(memory);
+      const memory2 = await memoryStore.read() ?? {};
+      return Object.keys(memory2);
     },
     readMemory: async (topic = defaultMemoryTopic) => {
-      const memory = await memoryStore.read() ?? {};
-      return memory[topic];
+      const memory2 = await memoryStore.read() ?? {};
+      return memory2[topic];
     },
     updateMemory: async (operation, topic, content) => {
       const memoryTopic = topic ?? defaultMemoryTopic;
-      const memory = await memoryStore.read() ?? {};
+      const memory2 = await memoryStore.read() ?? {};
       switch (operation) {
         case "append":
           if (content === undefined) {
             throw new Error("Content is required for append operation.");
           }
-          memory[memoryTopic] = `${memory[memoryTopic] || ""}
+          memory2[memoryTopic] = `${memory2[memoryTopic] || ""}
 ${content}`;
           break;
         case "replace":
           if (content === undefined) {
             throw new Error("Content is required for replace operation.");
           }
-          memory[memoryTopic] = content;
+          memory2[memoryTopic] = content;
           break;
         case "remove":
-          delete memory[memoryTopic];
+          delete memory2[memoryTopic];
           break;
       }
-      await memoryStore.write(memory);
+      await memoryStore.write(memory2);
     },
     readFile: async (path, includeIgnored) => {
       if (!includeIgnored && ig.ignores(path)) {
@@ -73137,6 +73302,1177 @@ var init_provider = __esm(() => {
   import_ignore2 = __toESM(require_ignore(), 1);
 });
 
+// ../../node_modules/better-sqlite3/lib/util.js
+var require_util3 = __commonJS((exports) => {
+  exports.getBooleanOption = (options, key) => {
+    let value = false;
+    if (key in options && typeof (value = options[key]) !== "boolean") {
+      throw new TypeError(`Expected the "${key}" option to be a boolean`);
+    }
+    return value;
+  };
+  exports.cppdb = Symbol();
+  exports.inspect = Symbol.for("nodejs.util.inspect.custom");
+});
+
+// ../../node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS((exports, module) => {
+  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+  function SqliteError(message, code) {
+    if (new.target !== SqliteError) {
+      return new SqliteError(message, code);
+    }
+    if (typeof code !== "string") {
+      throw new TypeError("Expected second argument to be a string");
+    }
+    Error.call(this, message);
+    descriptor.value = "" + message;
+    Object.defineProperty(this, "message", descriptor);
+    Error.captureStackTrace(this, SqliteError);
+    this.code = code;
+  }
+  Object.setPrototypeOf(SqliteError, Error);
+  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+  Object.defineProperty(SqliteError.prototype, "name", descriptor);
+  module.exports = SqliteError;
+});
+
+// ../../node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS((exports, module) => {
+  var sep = __require("path").sep || "/";
+  module.exports = fileUriToPath;
+  function fileUriToPath(uri) {
+    if (typeof uri != "string" || uri.length <= 7 || uri.substring(0, 7) != "file://") {
+      throw new TypeError("must pass in a file:// URI to convert to a file path");
+    }
+    var rest = decodeURI(uri.substring(7));
+    var firstSlash = rest.indexOf("/");
+    var host = rest.substring(0, firstSlash);
+    var path = rest.substring(firstSlash + 1);
+    if (host == "localhost")
+      host = "";
+    if (host) {
+      host = sep + sep + host;
+    }
+    path = path.replace(/^(.+)\|/, "$1:");
+    if (sep == "\\") {
+      path = path.replace(/\//g, "\\");
+    }
+    if (/^.+\:/.test(path)) {} else {
+      path = sep + path;
+    }
+    return host + path;
+  }
+});
+
+// ../../node_modules/bindings/bindings.js
+var require_bindings = __commonJS((exports, module) => {
+  var __filename = "/Users/xiliangchen/projects/polka-codes/node_modules/bindings/bindings.js";
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var fileURLToPath = require_file_uri_to_path();
+  var join5 = path.join;
+  var dirname2 = path.dirname;
+  var exists = fs4.accessSync && function(path2) {
+    try {
+      fs4.accessSync(path2);
+    } catch (e2) {
+      return false;
+    }
+    return true;
+  } || fs4.existsSync || path.existsSync;
+  var defaults = {
+    arrow: process.env.NODE_BINDINGS_ARROW || " → ",
+    compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+    platform: process.platform,
+    arch: process.arch,
+    nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+    version: process.versions.node,
+    bindings: "bindings.node",
+    try: [
+      ["module_root", "build", "bindings"],
+      ["module_root", "build", "Debug", "bindings"],
+      ["module_root", "build", "Release", "bindings"],
+      ["module_root", "out", "Debug", "bindings"],
+      ["module_root", "Debug", "bindings"],
+      ["module_root", "out", "Release", "bindings"],
+      ["module_root", "Release", "bindings"],
+      ["module_root", "build", "default", "bindings"],
+      ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+      ["module_root", "addon-build", "release", "install-root", "bindings"],
+      ["module_root", "addon-build", "debug", "install-root", "bindings"],
+      ["module_root", "addon-build", "default", "install-root", "bindings"],
+      ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+    ]
+  };
+  function bindings(opts) {
+    if (typeof opts == "string") {
+      opts = { bindings: opts };
+    } else if (!opts) {
+      opts = {};
+    }
+    Object.keys(defaults).map(function(i3) {
+      if (!(i3 in opts))
+        opts[i3] = defaults[i3];
+    });
+    if (!opts.module_root) {
+      opts.module_root = exports.getRoot(exports.getFileName());
+    }
+    if (path.extname(opts.bindings) != ".node") {
+      opts.bindings += ".node";
+    }
+    var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+    var tries = [], i2 = 0, l = opts.try.length, n, b, err;
+    for (;i2 < l; i2++) {
+      n = join5.apply(null, opts.try[i2].map(function(p) {
+        return opts[p] || p;
+      }));
+      tries.push(n);
+      try {
+        b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+        if (!opts.path) {
+          b.path = n;
+        }
+        return b;
+      } catch (e2) {
+        if (e2.code !== "MODULE_NOT_FOUND" && e2.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e2.message)) {
+          throw e2;
+        }
+      }
+    }
+    err = new Error(`Could not locate the bindings file. Tried:
+` + tries.map(function(a) {
+      return opts.arrow + a;
+    }).join(`
+`));
+    err.tries = tries;
+    throw err;
+  }
+  module.exports = exports = bindings;
+  exports.getFileName = function getFileName(calling_file) {
+    var { prepareStackTrace: origPST, stackTraceLimit: origSTL } = Error, dummy = {}, fileName;
+    Error.stackTraceLimit = 10;
+    Error.prepareStackTrace = function(e2, st) {
+      for (var i2 = 0, l = st.length;i2 < l; i2++) {
+        fileName = st[i2].getFileName();
+        if (fileName !== __filename) {
+          if (calling_file) {
+            if (fileName !== calling_file) {
+              return;
+            }
+          } else {
+            return;
+          }
+        }
+      }
+    };
+    Error.captureStackTrace(dummy);
+    dummy.stack;
+    Error.prepareStackTrace = origPST;
+    Error.stackTraceLimit = origSTL;
+    var fileSchema = "file://";
+    if (fileName.indexOf(fileSchema) === 0) {
+      fileName = fileURLToPath(fileName);
+    }
+    return fileName;
+  };
+  exports.getRoot = function getRoot(file2) {
+    var dir = dirname2(file2), prev;
+    while (true) {
+      if (dir === ".") {
+        dir = process.cwd();
+      }
+      if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
+        return dir;
+      }
+      if (prev === dir) {
+        throw new Error('Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? ');
+      }
+      prev = dir;
+      dir = join5(dir, "..");
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS((exports) => {
+  var { cppdb } = require_util3();
+  exports.prepare = function prepare(sql) {
+    return this[cppdb].prepare(sql, this, false);
+  };
+  exports.exec = function exec(sql) {
+    this[cppdb].exec(sql);
+    return this;
+  };
+  exports.close = function close() {
+    this[cppdb].close();
+    return this;
+  };
+  exports.loadExtension = function loadExtension(...args) {
+    this[cppdb].loadExtension(...args);
+    return this;
+  };
+  exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+    this[cppdb].defaultSafeIntegers(...args);
+    return this;
+  };
+  exports.unsafeMode = function unsafeMode(...args) {
+    this[cppdb].unsafeMode(...args);
+    return this;
+  };
+  exports.getters = {
+    name: {
+      get: function name() {
+        return this[cppdb].name;
+      },
+      enumerable: true
+    },
+    open: {
+      get: function open() {
+        return this[cppdb].open;
+      },
+      enumerable: true
+    },
+    inTransaction: {
+      get: function inTransaction() {
+        return this[cppdb].inTransaction;
+      },
+      enumerable: true
+    },
+    readonly: {
+      get: function readonly() {
+        return this[cppdb].readonly;
+      },
+      enumerable: true
+    },
+    memory: {
+      get: function memory() {
+        return this[cppdb].memory;
+      },
+      enumerable: true
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  var controllers = new WeakMap;
+  module.exports = function transaction(fn) {
+    if (typeof fn !== "function")
+      throw new TypeError("Expected first argument to be a function");
+    const db2 = this[cppdb];
+    const controller = getController(db2, this);
+    const { apply: apply2 } = Function.prototype;
+    const properties = {
+      default: { value: wrapTransaction(apply2, fn, db2, controller.default) },
+      deferred: { value: wrapTransaction(apply2, fn, db2, controller.deferred) },
+      immediate: { value: wrapTransaction(apply2, fn, db2, controller.immediate) },
+      exclusive: { value: wrapTransaction(apply2, fn, db2, controller.exclusive) },
+      database: { value: this, enumerable: true }
+    };
+    Object.defineProperties(properties.default.value, properties);
+    Object.defineProperties(properties.deferred.value, properties);
+    Object.defineProperties(properties.immediate.value, properties);
+    Object.defineProperties(properties.exclusive.value, properties);
+    return properties.default.value;
+  };
+  var getController = (db2, self2) => {
+    let controller = controllers.get(db2);
+    if (!controller) {
+      const shared = {
+        commit: db2.prepare("COMMIT", self2, false),
+        rollback: db2.prepare("ROLLBACK", self2, false),
+        savepoint: db2.prepare("SAVEPOINT `\t_bs3.\t`", self2, false),
+        release: db2.prepare("RELEASE `\t_bs3.\t`", self2, false),
+        rollbackTo: db2.prepare("ROLLBACK TO `\t_bs3.\t`", self2, false)
+      };
+      controllers.set(db2, controller = {
+        default: Object.assign({ begin: db2.prepare("BEGIN", self2, false) }, shared),
+        deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self2, false) }, shared),
+        immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self2, false) }, shared),
+        exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self2, false) }, shared)
+      });
+    }
+    return controller;
+  };
+  var wrapTransaction = (apply2, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+    let before, after, undo;
+    if (db2.inTransaction) {
+      before = savepoint;
+      after = release;
+      undo = rollbackTo;
+    } else {
+      before = begin;
+      after = commit;
+      undo = rollback;
+    }
+    before.run();
+    try {
+      const result = apply2.call(fn, this, arguments);
+      if (result && typeof result.then === "function") {
+        throw new TypeError("Transaction function cannot return a promise");
+      }
+      after.run();
+      return result;
+    } catch (ex) {
+      if (db2.inTransaction) {
+        undo.run();
+        if (undo !== rollback)
+          after.run();
+      }
+      throw ex;
+    }
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function pragma(source, options) {
+    if (options == null)
+      options = {};
+    if (typeof source !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    const simple = getBooleanOption(options, "simple");
+    const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+    return simple ? stmt.pluck().get() : stmt.all();
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var { promisify: promisify2 } = __require("util");
+  var { cppdb } = require_util3();
+  var fsAccess = promisify2(fs4.access);
+  module.exports = async function backup(filename, options) {
+    if (options == null)
+      options = {};
+    if (typeof filename !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    filename = filename.trim();
+    const attachedName = "attached" in options ? options.attached : "main";
+    const handler13 = "progress" in options ? options.progress : null;
+    if (!filename)
+      throw new TypeError("Backup filename cannot be an empty string");
+    if (filename === ":memory:")
+      throw new TypeError('Invalid backup filename ":memory:"');
+    if (typeof attachedName !== "string")
+      throw new TypeError('Expected the "attached" option to be a string');
+    if (!attachedName)
+      throw new TypeError('The "attached" option cannot be an empty string');
+    if (handler13 != null && typeof handler13 !== "function")
+      throw new TypeError('Expected the "progress" option to be a function');
+    await fsAccess(path.dirname(filename)).catch(() => {
+      throw new TypeError("Cannot save backup because the directory does not exist");
+    });
+    const isNewFile = await fsAccess(filename).then(() => false, () => true);
+    return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler13 || null);
+  };
+  var runBackup = (backup, handler13) => {
+    let rate = 0;
+    let useDefault = true;
+    return new Promise((resolve4, reject) => {
+      setImmediate(function step() {
+        try {
+          const progress = backup.transfer(rate);
+          if (!progress.remainingPages) {
+            backup.close();
+            resolve4(progress);
+            return;
+          }
+          if (useDefault) {
+            useDefault = false;
+            rate = 100;
+          }
+          if (handler13) {
+            const ret = handler13(progress);
+            if (ret !== undefined) {
+              if (typeof ret === "number" && ret === ret)
+                rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+              else
+                throw new TypeError("Expected progress callback to return a number or undefined");
+            }
+          }
+          setImmediate(step);
+        } catch (err) {
+          backup.close();
+          reject(err);
+        }
+      });
+    });
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  module.exports = function serialize(options) {
+    if (options == null)
+      options = {};
+    if (typeof options !== "object")
+      throw new TypeError("Expected first argument to be an options object");
+    const attachedName = "attached" in options ? options.attached : "main";
+    if (typeof attachedName !== "string")
+      throw new TypeError('Expected the "attached" option to be a string');
+    if (!attachedName)
+      throw new TypeError('The "attached" option cannot be an empty string');
+    return this[cppdb].serialize(attachedName);
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function defineFunction(name17, options, fn) {
+    if (options == null)
+      options = {};
+    if (typeof options === "function") {
+      fn = options;
+      options = {};
+    }
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof fn !== "function")
+      throw new TypeError("Expected last argument to be a function");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    if (!name17)
+      throw new TypeError("User-defined function name cannot be an empty string");
+    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+    const deterministic = getBooleanOption(options, "deterministic");
+    const directOnly = getBooleanOption(options, "directOnly");
+    const varargs = getBooleanOption(options, "varargs");
+    let argCount = -1;
+    if (!varargs) {
+      argCount = fn.length;
+      if (!Number.isInteger(argCount) || argCount < 0)
+        throw new TypeError("Expected function.length to be a positive integer");
+      if (argCount > 100)
+        throw new RangeError("User-defined functions cannot have more than 100 arguments");
+    }
+    this[cppdb].function(fn, name17, argCount, safeIntegers, deterministic, directOnly);
+    return this;
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS((exports, module) => {
+  var { getBooleanOption, cppdb } = require_util3();
+  module.exports = function defineAggregate(name17, options) {
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object" || options === null)
+      throw new TypeError("Expected second argument to be an options object");
+    if (!name17)
+      throw new TypeError("User-defined function name cannot be an empty string");
+    const start = "start" in options ? options.start : null;
+    const step = getFunctionOption(options, "step", true);
+    const inverse = getFunctionOption(options, "inverse", false);
+    const result = getFunctionOption(options, "result", false);
+    const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+    const deterministic = getBooleanOption(options, "deterministic");
+    const directOnly = getBooleanOption(options, "directOnly");
+    const varargs = getBooleanOption(options, "varargs");
+    let argCount = -1;
+    if (!varargs) {
+      argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+      if (argCount > 0)
+        argCount -= 1;
+      if (argCount > 100)
+        throw new RangeError("User-defined functions cannot have more than 100 arguments");
+    }
+    this[cppdb].aggregate(start, step, inverse, result, name17, argCount, safeIntegers, deterministic, directOnly);
+    return this;
+  };
+  var getFunctionOption = (options, key, required2) => {
+    const value = key in options ? options[key] : null;
+    if (typeof value === "function")
+      return value;
+    if (value != null)
+      throw new TypeError(`Expected the "${key}" option to be a function`);
+    if (required2)
+      throw new TypeError(`Missing required option "${key}"`);
+    return null;
+  };
+  var getLength = ({ length }) => {
+    if (Number.isInteger(length) && length >= 0)
+      return length;
+    throw new TypeError("Expected function.length to be a positive integer");
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS((exports, module) => {
+  var { cppdb } = require_util3();
+  module.exports = function defineTable(name17, factory) {
+    if (typeof name17 !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (!name17)
+      throw new TypeError("Virtual table module name cannot be an empty string");
+    let eponymous = false;
+    if (typeof factory === "object" && factory !== null) {
+      eponymous = true;
+      factory = defer(parseTableDefinition(factory, "used", name17));
+    } else {
+      if (typeof factory !== "function")
+        throw new TypeError("Expected second argument to be a function or a table definition object");
+      factory = wrapFactory(factory);
+    }
+    this[cppdb].table(factory, name17, eponymous);
+    return this;
+  };
+  function wrapFactory(factory) {
+    return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+      const thisObject = {
+        module: moduleName,
+        database: databaseName,
+        table: tableName
+      };
+      const def = apply2.call(factory, thisObject, args);
+      if (typeof def !== "object" || def === null) {
+        throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+      }
+      return parseTableDefinition(def, "returned", moduleName);
+    };
+  }
+  function parseTableDefinition(def, verb, moduleName) {
+    if (!hasOwnProperty10.call(def, "rows")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+    }
+    if (!hasOwnProperty10.call(def, "columns")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+    }
+    const rows = def.rows;
+    if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+    }
+    let columns = def.columns;
+    if (!Array.isArray(columns) || !(columns = [...columns]).every((x2) => typeof x2 === "string")) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+    }
+    if (columns.length !== new Set(columns).size) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+    }
+    if (!columns.length) {
+      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+    }
+    let parameters;
+    if (hasOwnProperty10.call(def, "parameters")) {
+      parameters = def.parameters;
+      if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x2) => typeof x2 === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+      }
+    } else {
+      parameters = inferParameters(rows);
+    }
+    if (parameters.length !== new Set(parameters).size) {
+      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+    }
+    if (parameters.length > 32) {
+      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+    }
+    for (const parameter of parameters) {
+      if (columns.includes(parameter)) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+      }
+    }
+    let safeIntegers = 2;
+    if (hasOwnProperty10.call(def, "safeIntegers")) {
+      const bool = def.safeIntegers;
+      if (typeof bool !== "boolean") {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+      }
+      safeIntegers = +bool;
+    }
+    let directOnly = false;
+    if (hasOwnProperty10.call(def, "directOnly")) {
+      directOnly = def.directOnly;
+      if (typeof directOnly !== "boolean") {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+      }
+    }
+    const columnDefinitions = [
+      ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+      ...columns.map(identifier)
+    ];
+    return [
+      `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+      wrapGenerator(rows, new Map(columns.map((x2, i2) => [x2, parameters.length + i2])), moduleName),
+      parameters,
+      safeIntegers,
+      directOnly
+    ];
+  }
+  function wrapGenerator(generator, columnMap, moduleName) {
+    return function* virtualTable(...args) {
+      const output = args.map((x2) => Buffer.isBuffer(x2) ? Buffer.from(x2) : x2);
+      for (let i2 = 0;i2 < columnMap.size; ++i2) {
+        output.push(null);
+      }
+      for (const row of generator(...args)) {
+        if (Array.isArray(row)) {
+          extractRowArray(row, output, columnMap.size, moduleName);
+          yield output;
+        } else if (typeof row === "object" && row !== null) {
+          extractRowObject(row, output, columnMap, moduleName);
+          yield output;
+        } else {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+        }
+      }
+    };
+  }
+  function extractRowArray(row, output, columnCount, moduleName) {
+    if (row.length !== columnCount) {
+      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+    }
+    const offset = output.length - columnCount;
+    for (let i2 = 0;i2 < columnCount; ++i2) {
+      output[i2 + offset] = row[i2];
+    }
+  }
+  function extractRowObject(row, output, columnMap, moduleName) {
+    let count = 0;
+    for (const key of Object.keys(row)) {
+      const index = columnMap.get(key);
+      if (index === undefined) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+      }
+      output[index] = row[key];
+      count += 1;
+    }
+    if (count !== columnMap.size) {
+      throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+    }
+  }
+  function inferParameters({ length }) {
+    if (!Number.isInteger(length) || length < 0) {
+      throw new TypeError("Expected function.length to be a positive integer");
+    }
+    const params = [];
+    for (let i2 = 0;i2 < length; ++i2) {
+      params.push(`$${i2 + 1}`);
+    }
+    return params;
+  }
+  var { hasOwnProperty: hasOwnProperty10 } = Object.prototype;
+  var { apply: apply2 } = Function.prototype;
+  var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {});
+  var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+  var defer = (x2) => () => x2;
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS((exports, module) => {
+  var DatabaseInspection = function Database() {};
+  module.exports = function inspect(depth, opts) {
+    return Object.assign(new DatabaseInspection, this);
+  };
+});
+
+// ../../node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS((exports, module) => {
+  var fs4 = __require("fs");
+  var path = __require("path");
+  var util3 = require_util3();
+  var SqliteError = require_sqlite_error();
+  var DEFAULT_ADDON;
+  function Database(filenameGiven, options) {
+    if (new.target == null) {
+      return new Database(filenameGiven, options);
+    }
+    let buffer;
+    if (Buffer.isBuffer(filenameGiven)) {
+      buffer = filenameGiven;
+      filenameGiven = ":memory:";
+    }
+    if (filenameGiven == null)
+      filenameGiven = "";
+    if (options == null)
+      options = {};
+    if (typeof filenameGiven !== "string")
+      throw new TypeError("Expected first argument to be a string");
+    if (typeof options !== "object")
+      throw new TypeError("Expected second argument to be an options object");
+    if ("readOnly" in options)
+      throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+    if ("memory" in options)
+      throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+    const filename = filenameGiven.trim();
+    const anonymous = filename === "" || filename === ":memory:";
+    const readonly2 = util3.getBooleanOption(options, "readonly");
+    const fileMustExist = util3.getBooleanOption(options, "fileMustExist");
+    const timeout = "timeout" in options ? options.timeout : 5000;
+    const verbose = "verbose" in options ? options.verbose : null;
+    const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+    if (readonly2 && anonymous && !buffer)
+      throw new TypeError("In-memory/temporary databases cannot be readonly");
+    if (!Number.isInteger(timeout) || timeout < 0)
+      throw new TypeError('Expected the "timeout" option to be a positive integer');
+    if (timeout > 2147483647)
+      throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+    if (verbose != null && typeof verbose !== "function")
+      throw new TypeError('Expected the "verbose" option to be a function');
+    if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object")
+      throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+    let addon;
+    if (nativeBinding == null) {
+      addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+    } else if (typeof nativeBinding === "string") {
+      const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      addon = requireFunc(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+    } else {
+      addon = nativeBinding;
+    }
+    if (!addon.isInitialized) {
+      addon.setErrorConstructor(SqliteError);
+      addon.isInitialized = true;
+    }
+    if (!anonymous && !filename.startsWith("file:") && !fs4.existsSync(path.dirname(filename))) {
+      throw new TypeError("Cannot open database because the directory does not exist");
+    }
+    Object.defineProperties(this, {
+      [util3.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
+      ...wrappers.getters
+    });
+  }
+  var wrappers = require_wrappers();
+  Database.prototype.prepare = wrappers.prepare;
+  Database.prototype.transaction = require_transaction();
+  Database.prototype.pragma = require_pragma();
+  Database.prototype.backup = require_backup();
+  Database.prototype.serialize = require_serialize();
+  Database.prototype.function = require_function();
+  Database.prototype.aggregate = require_aggregate();
+  Database.prototype.table = require_table();
+  Database.prototype.loadExtension = wrappers.loadExtension;
+  Database.prototype.exec = wrappers.exec;
+  Database.prototype.close = wrappers.close;
+  Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+  Database.prototype.unsafeMode = wrappers.unsafeMode;
+  Database.prototype[util3.inspect] = require_inspect();
+  module.exports = Database;
+});
+
+// ../../node_modules/better-sqlite3/lib/index.js
+var require_lib2 = __commonJS((exports, module) => {
+  module.exports = require_database();
+  module.exports.SqliteError = require_sqlite_error();
+});
+
+// ../cli-shared/src/sqlite-memory-store.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir2, rename as rename2 } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve4 } from "node:path";
+var import_better_sqlite3, SQLiteMemoryStore;
+var init_sqlite_memory_store = __esm(() => {
+  import_better_sqlite3 = __toESM(require_lib2(), 1);
+  SQLiteMemoryStore = class SQLiteMemoryStore {
+    db = null;
+    dbPromise = null;
+    config;
+    currentScope;
+    maxRetries = 3;
+    retryDelay = 100;
+    static SORT_COLUMNS = {
+      created: "created_at",
+      updated: "updated_at",
+      accessed: "last_accessed",
+      name: "name"
+    };
+    static ALLOWED_SORT_ORDERS = ["asc", "desc"];
+    static ALLOWED_PRIORITIES = ["low", "medium", "high", "critical"];
+    constructor(config3, scope) {
+      this.config = config3;
+      this.currentScope = scope;
+    }
+    async initializeDatabase() {
+      if (this.dbPromise) {
+        return this.dbPromise;
+      }
+      this.dbPromise = (async () => {
+        if (this.db) {
+          return this.db;
+        }
+        const dbPath = this.resolvePath(this.config.path || "~/.config/polka-codes/memory.sqlite");
+        try {
+          const dir = dirname2(dbPath);
+          if (!existsSync3(dir)) {
+            await mkdir2(dir, { recursive: true, mode: 448 });
+          }
+          if (!existsSync3(dbPath)) {
+            const { openSync, closeSync } = await import("node:fs");
+            const fd = openSync(dbPath, "w");
+            closeSync(fd);
+            await import("node:fs/promises").then((fs4) => fs4.chmod(dbPath, 384));
+          }
+          const db2 = new import_better_sqlite3.default(dbPath, {
+            verbose: process.env.SQLITE_DEBUG ? console.log : undefined
+          });
+          this.configurePragmas(db2);
+          this.checkIntegrity(db2);
+          this.initializeSchema(db2);
+          this.db = db2;
+          return db2;
+        } catch (error48) {
+          console.error("[SQLiteMemoryStore] Initialization failed:", error48);
+          if (existsSync3(dbPath)) {
+            const backupPath = `${dbPath}.corrupted.${Date.now()}`;
+            console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
+            try {
+              await rename2(dbPath, backupPath);
+            } catch (backupError) {
+              console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
+              this.dbPromise = null;
+              throw backupError;
+            }
+            this.dbPromise = null;
+            return this.initializeDatabase();
+          }
+          this.dbPromise = null;
+          throw error48;
+        }
+      })();
+      return this.dbPromise;
+    }
+    configurePragmas(db2) {
+      db2.pragma("journal_mode = WAL");
+      db2.pragma("synchronous = NORMAL");
+      db2.pragma("busy_timeout = 5000");
+      db2.pragma("foreign_keys = ON");
+      db2.pragma("temp_store = MEMORY");
+      db2.pragma("mmap_size = 30000000000");
+      db2.pragma("page_size = 4096");
+    }
+    checkIntegrity(db2) {
+      try {
+        const result = db2.pragma("integrity_check", { simple: true });
+        if (result !== "ok") {
+          throw new Error(`Database integrity check failed: ${result}`);
+        }
+      } catch (error48) {
+        console.error("[SQLiteMemoryStore] Integrity check failed:", error48);
+        throw new Error("Database is corrupted");
+      }
+    }
+    initializeSchema(db2) {
+      db2.exec(`
+      CREATE TABLE IF NOT EXISTS memory_entries (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL CHECK(length(name) > 0),
+        scope TEXT NOT NULL CHECK(scope IN ('global') OR scope LIKE 'project:%'),
+        content TEXT NOT NULL CHECK(length(content) > 0),
+        entry_type TEXT NOT NULL CHECK(length(entry_type) > 0),
+        status TEXT CHECK(status IS NULL OR length(status) > 0),
+        priority TEXT CHECK(priority IS NULL OR priority IN ('low', 'medium', 'high', 'critical')),
+        tags TEXT CHECK(tags IS NULL OR length(tags) > 0),
+        metadata TEXT CHECK(metadata IS NULL OR json_valid(metadata)),
+        created_at INTEGER NOT NULL CHECK(created_at > 0),
+        updated_at INTEGER NOT NULL CHECK(updated_at > 0),
+        last_accessed INTEGER NOT NULL CHECK(last_accessed > 0),
+        UNIQUE(name, scope)
+      )
+    `);
+      db2.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memory_entries_scope_type ON memory_entries(scope, entry_type);
+      CREATE INDEX IF NOT EXISTS idx_memory_entries_updated ON memory_entries(updated_at);
+    `);
+    }
+    async getDatabase() {
+      if (!this.db) {
+        this.db = await this.initializeDatabase();
+      }
+      return this.db;
+    }
+    resolvePath(path) {
+      if (path.startsWith("~")) {
+        const home = process.env.HOME || process.env.USERPROFILE || ".";
+        if (home === ".") {
+          throw new Error("Cannot resolve home directory");
+        }
+        const expanded = `${home}${path.slice(1)}`;
+        const resolved = resolve4(expanded);
+        const sep = process.platform === "win32" ? "\\" : "/";
+        if (resolved !== home && !resolved.startsWith(home + sep)) {
+          throw new Error(`Path escapes home directory: ${path}`);
+        }
+        return resolved;
+      }
+      return resolve4(path);
+    }
+    generateUUID() {
+      return randomUUID();
+    }
+    now() {
+      return Date.now();
+    }
+    sleep(ms) {
+      return new Promise((resolve5) => setTimeout(resolve5, ms));
+    }
+    isRetryableError(error48) {
+      if (error48 instanceof Error) {
+        const message = error48.message.toLowerCase();
+        return message.includes("database is locked") || message.includes("database is busy") || message.includes("sqlite_busy") || message.includes("sqlite_locked");
+      }
+      return false;
+    }
+    async transaction(callback, options = {}) {
+      const db2 = await this.getDatabase();
+      const retries = options.retries ?? this.maxRetries;
+      for (let attempt = 0;attempt < retries; attempt++) {
+        try {
+          db2.exec("BEGIN IMMEDIATE");
+          const result = await callback();
+          db2.exec("COMMIT");
+          return result;
+        } catch (error48) {
+          try {
+            db2.exec("ROLLBACK");
+          } catch (rollbackError) {
+            console.error("[SQLiteMemoryStore] Rollback failed:", rollbackError);
+          }
+          const isRetryable = this.isRetryableError(error48);
+          if (isRetryable && attempt < retries - 1) {
+            const delay2 = this.retryDelay * 2 ** attempt;
+            console.warn(`[SQLiteMemoryStore] Retryable error, retrying in ${delay2}ms...`);
+            await this.sleep(delay2);
+            continue;
+          }
+          throw error48;
+        }
+      }
+      throw new Error("Maximum retries exceeded");
+    }
+    async readMemory(topic) {
+      const db2 = await this.getDatabase();
+      const scope = this.currentScope;
+      return this.transaction(async () => {
+        const stmt = db2.prepare("SELECT content FROM memory_entries WHERE name = ? AND scope = ?");
+        const row = stmt.get(topic, scope);
+        if (row) {
+          const updateStmt = db2.prepare("UPDATE memory_entries SET last_accessed = ? WHERE name = ? AND scope = ?");
+          updateStmt.run(this.now(), topic, scope);
+        }
+        return row?.content;
+      });
+    }
+    async updateMemoryInternal(db2, operation, topic, content, metadata) {
+      const scope = this.currentScope;
+      const now2 = this.now();
+      if (operation === "remove") {
+        const stmt = db2.prepare("DELETE FROM memory_entries WHERE name = ? AND scope = ?");
+        stmt.run(topic, scope);
+        return;
+      }
+      const existingStmt = db2.prepare("SELECT content, entry_type, status, priority, tags FROM memory_entries WHERE name = ? AND scope = ?");
+      const existing = existingStmt.get(topic, scope);
+      let finalContent;
+      let entry_type;
+      let status;
+      let priority;
+      let tags;
+      if (existing) {
+        if (operation === "append") {
+          if (!content) {
+            throw new Error("Content is required for append operation.");
+          }
+          finalContent = `${existing.content}
+${content}`;
+        } else {
+          if (!content) {
+            throw new Error("Content is required for replace operation.");
+          }
+          finalContent = content;
+        }
+        entry_type = metadata?.entry_type || existing.entry_type;
+        status = metadata?.status || existing.status;
+        priority = metadata?.priority || existing.priority;
+        tags = metadata?.tags || existing.tags;
+      } else {
+        if (!content) {
+          throw new Error("Content is required for new memory entries.");
+        }
+        finalContent = content;
+        entry_type = metadata?.entry_type || "note";
+        status = metadata?.status;
+        priority = metadata?.priority;
+        tags = metadata?.tags;
+      }
+      const upsertStmt = db2.prepare(`
+      INSERT INTO memory_entries (id, name, scope, content, entry_type, status, priority, tags, created_at, updated_at, last_accessed)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(name, scope) DO UPDATE SET
+        content = excluded.content,
+        entry_type = excluded.entry_type,
+        status = excluded.status,
+        priority = excluded.priority,
+        tags = excluded.tags,
+        updated_at = excluded.updated_at,
+        last_accessed = excluded.last_accessed
+    `);
+      upsertStmt.run(this.generateUUID(), topic, scope, finalContent, entry_type, status || null, priority || null, tags || null, now2, now2, now2);
+    }
+    async updateMemory(operation, topic, content, metadata) {
+      return this.transaction(async () => {
+        const db2 = await this.getDatabase();
+        await this.updateMemoryInternal(db2, operation, topic, content, metadata);
+      });
+    }
+    async queryMemory(query = {}, options = {}) {
+      const db2 = await this.getDatabase();
+      const { sql, params } = this.buildQuery(query, options);
+      if (options.operation === "count") {
+        const countStmt = db2.prepare(`SELECT COUNT(*) as count FROM (${sql})`);
+        const result = countStmt.get(...params);
+        return result.count;
+      }
+      if (options.operation === "delete") {
+        const deleteStmt = db2.prepare(`DELETE FROM memory_entries WHERE id IN (SELECT id FROM (${sql}))`);
+        const info = deleteStmt.run(...params);
+        return info.changes;
+      }
+      const stmt = db2.prepare(sql);
+      return stmt.all(...params);
+    }
+    buildQuery(query, _options) {
+      const conditions = [];
+      const params = [];
+      let sql = "SELECT * FROM memory_entries WHERE 1=1";
+      const scope = query.scope === "auto" ? this.currentScope : query.scope;
+      if (scope === "global") {
+        conditions.push("scope = ?");
+        params.push("global");
+      } else if (scope === "project" || !scope && this.currentScope !== "global") {
+        conditions.push("scope = ?");
+        params.push(this.currentScope);
+      }
+      if (query.type) {
+        if (!query.type.trim()) {
+          throw new Error("Type cannot be empty");
+        }
+        conditions.push("entry_type = ?");
+        params.push(query.type.trim());
+      }
+      if (query.status) {
+        conditions.push("status = ?");
+        params.push(query.status);
+      }
+      if (query.priority) {
+        if (!SQLiteMemoryStore.ALLOWED_PRIORITIES.includes(query.priority)) {
+          throw new Error(`Invalid priority: ${query.priority}`);
+        }
+        conditions.push("priority = ?");
+        params.push(query.priority);
+      }
+      if (query.tags) {
+        const tags = Array.isArray(query.tags) ? query.tags : [query.tags];
+        for (const tag of tags) {
+          const trimmed = tag.trim();
+          if (!trimmed) {
+            throw new Error("Tags cannot be empty");
+          }
+          conditions.push("(tags = ? OR tags LIKE ? OR tags LIKE ? OR tags LIKE ?)");
+          params.push(trimmed, `${trimmed},%`, `%,${trimmed}`, `%,${trimmed},%`);
+        }
+      }
+      if (query.search) {
+        const searchTerm = query.search.trim();
+        const sanitized = searchTerm.replace(/[\\_%]/g, "\\$&");
+        conditions.push("(content LIKE ? OR name LIKE ?)");
+        params.push(`%${sanitized}%`, `%${sanitized}%`);
+      }
+      if (query.createdAfter) {
+        conditions.push("created_at >= ?");
+        params.push(query.createdAfter);
+      }
+      if (query.createdBefore) {
+        conditions.push("created_at <= ?");
+        params.push(query.createdBefore);
+      }
+      if (query.updatedAfter) {
+        conditions.push("updated_at >= ?");
+        params.push(query.updatedAfter);
+      }
+      if (query.updatedBefore) {
+        conditions.push("updated_at <= ?");
+        params.push(query.updatedBefore);
+      }
+      if (conditions.length > 0) {
+        sql += ` AND ${conditions.join(" AND ")}`;
+      }
+      if (query.sortBy) {
+        const column = SQLiteMemoryStore.SORT_COLUMNS[query.sortBy];
+        if (!column) {
+          throw new Error(`Invalid sortBy: ${query.sortBy}`);
+        }
+        const order = query.sortOrder || "desc";
+        if (!SQLiteMemoryStore.ALLOWED_SORT_ORDERS.includes(order)) {
+          throw new Error(`Invalid sortOrder: ${order}`);
+        }
+        sql += ` ORDER BY ${column} ${order.toUpperCase()}`;
+      }
+      if (query.limit) {
+        const limit = Number(query.limit);
+        if (Number.isNaN(limit) || limit < 1 || limit > 1e4) {
+          throw new Error("Limit must be between 1 and 10000");
+        }
+        sql += " LIMIT ?";
+        params.push(limit);
+        if (query.offset) {
+          const offset = Number(query.offset);
+          if (Number.isNaN(offset) || offset < 0) {
+            throw new Error("Offset must be >= 0");
+          }
+          sql += " OFFSET ?";
+          params.push(offset);
+        }
+      }
+      return { sql, params };
+    }
+    async batchUpdateMemory(operations) {
+      return this.transaction(async () => {
+        const db2 = await this.getDatabase();
+        for (const op of operations) {
+          await this.updateMemoryInternal(db2, op.operation, op.name, op.content, op.metadata);
+        }
+      });
+    }
+    close() {
+      if (this.db) {
+        this.db.close();
+        this.db = null;
+      }
+    }
+    async getStats() {
+      const db2 = await this.getDatabase();
+      const countStmt = db2.prepare("SELECT COUNT(*) as count FROM memory_entries");
+      const { count: totalEntries } = countStmt.get();
+      const typeStmt = db2.prepare("SELECT entry_type, COUNT(*) as count FROM memory_entries GROUP BY entry_type");
+      const typeRows = typeStmt.all();
+      const entriesByType = Object.fromEntries(typeRows.map((r2) => [r2.entry_type, r2.count]));
+      const dbPath = this.resolvePath(this.config.path || "~/.config/polka-codes/memory.sqlite");
+      let databaseSize = 0;
+      try {
+        const stats = await import("node:fs/promises").then((fs4) => fs4.stat(dbPath));
+        databaseSize = stats.size;
+      } catch {}
+      return {
+        totalEntries,
+        entriesByType,
+        databaseSize
+      };
+    }
+  };
+});
+
 // ../../node_modules/chalk/source/vendor/ansi-styles/index.js
 function assembleStyles2() {
   const codes = new Map;
@@ -73903,7 +75239,7 @@ var init_eventHandler = __esm(() => {
 // ../cli-shared/src/utils/readMultiline.ts
 import readline3 from "node:readline";
 function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     console.log(prompt);
     const rl = readline3.createInterface({
       input: process.stdin,
@@ -73915,7 +75251,7 @@ function readMultiline(prompt = "Enter text (Ctrl+D to finish):") {
       lines.push(line);
     });
     rl.on("close", () => {
-      resolve4(lines.join(`
+      resolve5(lines.join(`
 `));
     });
   });
@@ -73936,6 +75272,7 @@ var init_utils3 = __esm(() => {
 var init_src3 = __esm(() => {
   init_config2();
   init_provider();
+  init_sqlite_memory_store();
   init_utils3();
 });
 
@@ -73959,20 +75296,47 @@ You MUST follow these style constraints for the action line:
 - NO apologies, hedging, or promises about later work.
 `, MEMORY_USAGE_SECTION = `## Memory Usage
 
-You have access to a memory feature to store and retrieve information across tool calls.
+You have access to a persistent SQLite-based memory store to track information across sessions. This is particularly useful for managing todos, bugs, decisions, and notes.
+
+### Memory Entry Types
+
+Memory entries can be organized by type:
+- **todo**: Task items with status (open/done), priority, and tags
+- **bug**: Bug reports with priority and status
+- **decision**: Architectural decisions and rationale
+- **note**: General notes and documentation
+
+### Todo List Workflow
+
+When working on multi-step tasks, use the memory store to track progress:
 
-### Topic Organization
+**Creating a todo item:**
+Use topic names that clearly describe the task. The content should include the full description.
 
-Memory is organized using topics, which are like named containers for different types of information:
-- **Default topic** (\`:default:\`): Used when no topic is specified. Good for general context.
-- **Named topics**: Create meaningful topic names to organize different types of information
+**Updating todo status:**
+- Mark todos as done when completed
+- Update descriptions as requirements evolve
+- Add tags for organization (e.g., "bug,urgent", "feature,auth")
+
+**Querying todos:**
+- Filter by type: "todo" to see all tasks
+- Filter by status: "open" for pending work
+- Filter by priority: "high" or "critical" for urgent items
+- Search: Find specific todos by keyword
 
 ### Best Practices
 
-- Store decisions and context that inform subsequent steps
-- Use named topics to organize different types of information
-- Use the default topic for simple, single-context scenarios
-- Memory persists across all tool calls within the current workflow
+- **Use descriptive topic names**: "fix-login-bug" is better than "bug-1"
+- **Set appropriate priorities**: Use "critical", "high", "medium", or "low"
+- **Add relevant tags**: Group related items with tags like "auth", "ui", "backend"
+- **Update status regularly**: Mark items as done when completed
+- **Store context**: Include important decisions in memory for future reference
+- **Memory persists**: All stored information is available across sessions in the current project
+
+### Memory Scopes
+
+- **Project scope**: When working in a project directory (with .polkacodes.yml), memory is isolated to that project
+- **Global scope**: When working outside a project, memory is shared globally
 `, AGENTS_INSTRUCTION = `## AGENTS.md Instructions
 
 If you are working in a subdirectory, check if there is an AGENTS.md file in that directory or parent directories for specific instructions. These files contain project-specific guidelines and conventions that you must follow.`;
@@ -89771,6 +91135,29 @@ ${defaultContext}`;
         }
       }
     }
+    if (plan2) {
+      try {
+        const taskSummary = task.split(`
+`)[0].substring(0, 100);
+        const topic = `plan:${taskSummary.replace(/[^a-zA-Z0-9_-]+/g, "-").toLowerCase()}`;
+        const keywords = task.toLowerCase().match(/(?:implement|create|add|fix|refactor|update|improve|optimize|test|document)(?:\s+(\w+))?/g);
+        const _tags = keywords ? keywords.map((k) => {
+          const parts = k.split(" ");
+          if (parts.length > 1) {
+            return parts.join("-");
+          }
+          return k;
+        }).join(",") : undefined;
+        await tools3.updateMemory({
+          operation: "replace",
+          topic,
+          content: plan2
+        });
+        context.logger.info(`Plan saved to memory as: ${topic}`);
+      } catch (error48) {
+        context.logger.warn("Failed to save plan to memory:", error48);
+      }
+    }
     return { plan: plan2 || undefined, files: outputFiles, messages: result.messages };
   }
   context.logger.warn("Failed to generate plan.", result);
@@ -93074,15 +94461,15 @@ function parseUnionDef2(def, refs) {
     return asAnyOf2(def, refs);
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x2) => (x2._def.typeName in primitiveMappings2) && (!x2._def.checks || !x2._def.checks.length))) {
-    const types6 = options.reduce((types7, x2) => {
+    const types7 = options.reduce((types8, x2) => {
       const type = primitiveMappings2[x2._def.typeName];
-      return type && !types7.includes(type) ? [...types7, type] : types7;
+      return type && !types8.includes(type) ? [...types8, type] : types8;
     }, []);
     return {
-      type: types6.length > 1 ? types6 : types6[0]
+      type: types7.length > 1 ? types7 : types7[0]
     };
   } else if (options.every((x2) => x2._def.typeName === "ZodLiteral" && !x2.description)) {
-    const types6 = options.reduce((acc, x2) => {
+    const types7 = options.reduce((acc, x2) => {
       const type = typeof x2._def.value;
       switch (type) {
         case "string":
@@ -93101,8 +94488,8 @@ function parseUnionDef2(def, refs) {
           return acc;
       }
     }, []);
-    if (types6.length === options.length) {
-      const uniqueTypes = types6.filter((x2, i2, a) => a.indexOf(x2) === i2);
+    if (types7.length === options.length) {
+      const uniqueTypes = types7.filter((x2, i2, a) => a.indexOf(x2) === i2);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x2) => {
@@ -94192,7 +95579,7 @@ class Protocol {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+        await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error48) {
@@ -94204,7 +95591,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const earlyReject = (error48) => {
         reject(error48);
       };
@@ -94282,7 +95669,7 @@ class Protocol {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve5(parseResult.data);
+            resolve6(parseResult.data);
           }
         } catch (error48) {
           reject(error48);
@@ -94473,12 +95860,12 @@ class Protocol {
         interval = task.pollInterval;
       }
     } catch {}
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (signal.aborted) {
         reject(new McpError2(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve5, interval);
+      const timeoutId = setTimeout(resolve6, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError2(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -95588,7 +96975,7 @@ var require_codegen = __commonJS((exports) => {
 });
 
 // ../../node_modules/ajv/dist/compile/util.js
-var require_util3 = __commonJS((exports) => {
+var require_util4 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = undefined;
   var codegen_1 = require_codegen();
@@ -95781,7 +97168,7 @@ var require_errors2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var names_1 = require_names();
   exports.keywordError = {
     message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
@@ -95998,44 +97385,44 @@ var require_dataType = __commonJS((exports) => {
   var applicability_1 = require_applicability();
   var errors_1 = require_errors2();
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var DataType;
   (function(DataType2) {
     DataType2[DataType2["Correct"] = 0] = "Correct";
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema) {
-    const types6 = getJSONTypes(schema.type);
-    const hasNull = types6.includes("null");
+    const types7 = getJSONTypes(schema.type);
+    const hasNull = types7.includes("null");
     if (hasNull) {
       if (schema.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types6.length && schema.nullable !== undefined) {
+      if (!types7.length && schema.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema.nullable === true)
-        types6.push("null");
+        types7.push("null");
     }
-    return types6;
+    return types7;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types6 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types6.every(rules_1.isJSONType))
-      return types6;
-    throw new Error("type must be JSONType or JSONType[]: " + types6.join(","));
+    const types7 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types7.every(rules_1.isJSONType))
+      return types7;
+    throw new Error("type must be JSONType or JSONType[]: " + types7.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types6) {
+  function coerceAndCheckDataType(it, types7) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types6, opts.coerceTypes);
-    const checkTypes = types6.length > 0 && !(coerceTo.length === 0 && types6.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types6[0]));
+    const coerceTo = coerceToTypes(types7, opts.coerceTypes);
+    const checkTypes = types7.length > 0 && !(coerceTo.length === 0 && types7.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types7[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types6, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types7, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types6, coerceTo);
+          coerceData(it, types7, coerceTo);
         else
           reportTypeError(it);
       });
@@ -96044,15 +97431,15 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types6, coerceTypes) {
-    return coerceTypes ? types6.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : [];
+  function coerceToTypes(types7, coerceTypes) {
+    return coerceTypes ? types7.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : [];
   }
-  function coerceData(it, types6, coerceTo) {
+  function coerceData(it, types7, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types6, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types7, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t2 of coerceTo) {
@@ -96128,19 +97515,19 @@ var require_dataType = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types6 = (0, util_1.toHash)(dataTypes);
-    if (types6.array && types6.object) {
+    const types7 = (0, util_1.toHash)(dataTypes);
+    if (types7.array && types7.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types6.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types6.null;
-      delete types6.array;
-      delete types6.object;
+      cond = types7.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types7.null;
+      delete types7.array;
+      delete types7.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types6.number)
-      delete types6.integer;
-    for (const t2 in types6)
+    if (types7.number)
+      delete types7.integer;
+    for (const t2 in types7)
       cond = (0, codegen_1.and)(cond, checkDataType(t2, data, strictNums, correct));
     return cond;
   }
@@ -96176,7 +97563,7 @@ var require_defaults = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.assignDefaults = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   function assignDefaults(it, ty) {
     const { properties, items } = it.schema;
     if (ty === "object" && properties) {
@@ -96210,9 +97597,9 @@ var require_code2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var names_1 = require_names();
-  var util_2 = require_util3();
+  var util_2 = require_util4();
   function checkReportMissingProp(cxt, prop) {
     const { gen, data, it } = cxt;
     gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
@@ -96454,7 +97841,7 @@ var require_subschema = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
     if (keyword !== undefined && schema !== undefined) {
       throw new Error('both "keyword" and "schema" passed, only one allowed');
@@ -96658,7 +98045,7 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
 var require_resolve = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = undefined;
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var equal = require_fast_deep_equal();
   var traverse = require_json_schema_traverse();
   var SIMPLE_INLINED = new Set([
@@ -96821,7 +98208,7 @@ var require_validate = __commonJS((exports) => {
   var codegen_1 = require_codegen();
   var names_1 = require_names();
   var resolve_1 = require_resolve();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var errors_1 = require_errors2();
   function validateFunctionCode(it) {
     if (isSchemaObj(it)) {
@@ -96928,9 +98315,9 @@ var require_validate = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types6 = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types6);
-    schemaKeywords(it, types6, !checkedTypes, errsCount);
+    const types7 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types7);
+    schemaKeywords(it, types7, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema, errSchemaPath, opts, self: self2 } = it;
@@ -96980,7 +98367,7 @@ var require_validate = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types6, typeErrors, errsCount) {
+  function schemaKeywords(it, types7, typeErrors, errsCount) {
     const { gen, schema, data, allErrors, opts, self: self2 } = it;
     const { RULES } = self2;
     if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
@@ -96988,7 +98375,7 @@ var require_validate = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types6);
+      checkStrictTypes(it, types7);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -97000,7 +98387,7 @@ var require_validate = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types6.length === 1 && types6[0] === group.type && typeErrors) {
+        if (types7.length === 1 && types7[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -97024,27 +98411,27 @@ var require_validate = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types6) {
+  function checkStrictTypes(it, types7) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types6);
+    checkContextTypes(it, types7);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types6);
+      checkMultipleTypes(it, types7);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types6) {
-    if (!types6.length)
+  function checkContextTypes(it, types7) {
+    if (!types7.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types6;
+      it.dataTypes = types7;
       return;
     }
-    types6.forEach((t2) => {
+    types7.forEach((t2) => {
       if (!includesType(it.dataTypes, t2)) {
         strictTypesError(it, `type "${t2}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types6);
+    narrowSchemaTypes(it, types7);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -97349,7 +98736,7 @@ var require_compile = __commonJS((exports) => {
   var validation_error_1 = require_validation_error();
   var names_1 = require_names();
   var resolve_1 = require_resolve();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var validate_1 = require_validate();
 
   class SchemaEnv {
@@ -97463,7 +98850,7 @@ var require_compile = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve5.call(this, root2, ref);
+    let _sch = resolve6.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a16 = root2.localRefs) === null || _a16 === undefined ? undefined : _a16[ref];
       const { schemaId } = this.opts;
@@ -97490,7 +98877,7 @@ var require_compile = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve5(root2, ref) {
+  function resolve6(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -98020,7 +99407,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return uri;
   }
-  function resolve5(baseURI, relativeURI, options) {
+  function resolve6(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -98248,7 +99635,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize: normalize5,
-    resolve: resolve5,
+    resolve: resolve6,
     resolveComponent,
     equal,
     serialize,
@@ -98301,7 +99688,7 @@ var require_core = __commonJS((exports) => {
   var codegen_2 = require_codegen();
   var resolve_1 = require_resolve();
   var dataType_1 = require_dataType();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var $dataRefSchema = require_data();
   var uri_1 = require_uri();
   var defaultRegExp = (str, flags) => new RegExp(str, flags);
@@ -98881,7 +100268,7 @@ var require_ref = __commonJS((exports) => {
   var codegen_1 = require_codegen();
   var names_1 = require_names();
   var compile_1 = require_compile();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var def = {
     keyword: "$ref",
     schemaType: "string",
@@ -99090,7 +100477,7 @@ var require_ucs2length = __commonJS((exports) => {
 var require_limitLength = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var ucs2length_1 = require_ucs2length();
   var error48 = {
     message({ keyword, schemaCode }) {
@@ -99171,7 +100558,7 @@ var require_required = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
     params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
@@ -99284,7 +100671,7 @@ var require_uniqueItems = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var dataType_1 = require_dataType();
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var equal_1 = require_equal();
   var error48 = {
     message: ({ params: { i: i2, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i2} are identical)`,
@@ -99347,7 +100734,7 @@ var require_uniqueItems = __commonJS((exports) => {
 var require_const = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var equal_1 = require_equal();
   var error48 = {
     message: "must be equal to constant",
@@ -99373,7 +100760,7 @@ var require_const = __commonJS((exports) => {
 var require_enum = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var equal_1 = require_equal();
   var error48 = {
     message: "must be equal to one of the allowed values",
@@ -99450,7 +100837,7 @@ var require_additionalItems = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateAdditionalItems = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
     params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
@@ -99500,7 +100887,7 @@ var require_items = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateTuple = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var code_1 = require_code2();
   var def = {
     keyword: "items",
@@ -99567,7 +100954,7 @@ var require_prefixItems = __commonJS((exports) => {
 var require_items2020 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var code_1 = require_code2();
   var additionalItems_1 = require_additionalItems();
   var error48 = {
@@ -99599,7 +100986,7 @@ var require_items2020 = __commonJS((exports) => {
 var require_contains = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: ({ params: { min, max } }) => max === undefined ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
     params: ({ params: { min, max } }) => max === undefined ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
@@ -99691,7 +101078,7 @@ var require_dependencies = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = undefined;
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var code_1 = require_code2();
   exports.error = {
     message: ({ params: { property, depsCount, deps } }) => {
@@ -99775,7 +101162,7 @@ var require_dependencies = __commonJS((exports) => {
 var require_propertyNames = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: "property name must be valid",
     params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
@@ -99817,7 +101204,7 @@ var require_additionalProperties = __commonJS((exports) => {
   var code_1 = require_code2();
   var codegen_1 = require_codegen();
   var names_1 = require_names();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: "must NOT have additional properties",
     params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
@@ -99919,7 +101306,7 @@ var require_properties = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var validate_1 = require_validate();
   var code_1 = require_code2();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var additionalProperties_1 = require_additionalProperties();
   var def = {
     keyword: "properties",
@@ -99974,8 +101361,8 @@ var require_patternProperties = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
-  var util_2 = require_util3();
+  var util_1 = require_util4();
+  var util_2 = require_util4();
   var def = {
     keyword: "patternProperties",
     type: "object",
@@ -100043,7 +101430,7 @@ var require_patternProperties = __commonJS((exports) => {
 // ../../node_modules/ajv/dist/vocabularies/applicator/not.js
 var require_not = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var def = {
     keyword: "not",
     schemaType: ["object", "boolean"],
@@ -100086,7 +101473,7 @@ var require_anyOf = __commonJS((exports) => {
 var require_oneOf = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: "must match exactly one schema in oneOf",
     params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
@@ -100140,7 +101527,7 @@ var require_oneOf = __commonJS((exports) => {
 // ../../node_modules/ajv/dist/vocabularies/applicator/allOf.js
 var require_allOf = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var def = {
     keyword: "allOf",
     schemaType: "array",
@@ -100165,7 +101552,7 @@ var require_allOf = __commonJS((exports) => {
 var require_if = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
     params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
@@ -100230,7 +101617,7 @@ var require_if = __commonJS((exports) => {
 // ../../node_modules/ajv/dist/vocabularies/applicator/thenElse.js
 var require_thenElse = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var def = {
     keyword: ["then", "else"],
     schemaType: ["object", "boolean"],
@@ -100437,7 +101824,7 @@ var require_discriminator = __commonJS((exports) => {
   var types_1 = require_types2();
   var compile_1 = require_compile();
   var ref_error_1 = require_ref_error();
-  var util_1 = require_util3();
+  var util_1 = require_util4();
   var error48 = {
     message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
     params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
@@ -101943,7 +103330,7 @@ var require_codegen2 = __commonJS((exports) => {
 });
 
 // ../../node_modules/ajv-formats/node_modules/ajv/dist/compile/util.js
-var require_util4 = __commonJS((exports) => {
+var require_util5 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.checkStrictMode = exports.getErrorPath = exports.Type = exports.useFunc = exports.setEvaluated = exports.evaluatedPropsToName = exports.mergeEvaluated = exports.eachItem = exports.unescapeJsonPointer = exports.escapeJsonPointer = exports.escapeFragment = exports.unescapeFragment = exports.schemaRefOrVal = exports.schemaHasRulesButRef = exports.schemaHasRules = exports.checkUnknownRules = exports.alwaysValidSchema = exports.toHash = undefined;
   var codegen_1 = require_codegen2();
@@ -102136,7 +103523,7 @@ var require_errors3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.extendErrors = exports.resetErrorsCount = exports.reportExtraError = exports.reportError = exports.keyword$DataError = exports.keywordError = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var names_1 = require_names2();
   exports.keywordError = {
     message: ({ keyword }) => (0, codegen_1.str)`must pass "${keyword}" keyword validation`
@@ -102353,44 +103740,44 @@ var require_dataType2 = __commonJS((exports) => {
   var applicability_1 = require_applicability2();
   var errors_1 = require_errors3();
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var DataType;
   (function(DataType2) {
     DataType2[DataType2["Correct"] = 0] = "Correct";
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema) {
-    const types6 = getJSONTypes(schema.type);
-    const hasNull = types6.includes("null");
+    const types7 = getJSONTypes(schema.type);
+    const hasNull = types7.includes("null");
     if (hasNull) {
       if (schema.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types6.length && schema.nullable !== undefined) {
+      if (!types7.length && schema.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema.nullable === true)
-        types6.push("null");
+        types7.push("null");
     }
-    return types6;
+    return types7;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types6 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types6.every(rules_1.isJSONType))
-      return types6;
-    throw new Error("type must be JSONType or JSONType[]: " + types6.join(","));
+    const types7 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types7.every(rules_1.isJSONType))
+      return types7;
+    throw new Error("type must be JSONType or JSONType[]: " + types7.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types6) {
+  function coerceAndCheckDataType(it, types7) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types6, opts.coerceTypes);
-    const checkTypes = types6.length > 0 && !(coerceTo.length === 0 && types6.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types6[0]));
+    const coerceTo = coerceToTypes(types7, opts.coerceTypes);
+    const checkTypes = types7.length > 0 && !(coerceTo.length === 0 && types7.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types7[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types6, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types7, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types6, coerceTo);
+          coerceData(it, types7, coerceTo);
         else
           reportTypeError(it);
       });
@@ -102399,15 +103786,15 @@ var require_dataType2 = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types6, coerceTypes) {
-    return coerceTypes ? types6.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : [];
+  function coerceToTypes(types7, coerceTypes) {
+    return coerceTypes ? types7.filter((t2) => COERCIBLE.has(t2) || coerceTypes === "array" && t2 === "array") : [];
   }
-  function coerceData(it, types6, coerceTo) {
+  function coerceData(it, types7, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types6, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types7, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t2 of coerceTo) {
@@ -102483,19 +103870,19 @@ var require_dataType2 = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types6 = (0, util_1.toHash)(dataTypes);
-    if (types6.array && types6.object) {
+    const types7 = (0, util_1.toHash)(dataTypes);
+    if (types7.array && types7.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types6.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types6.null;
-      delete types6.array;
-      delete types6.object;
+      cond = types7.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types7.null;
+      delete types7.array;
+      delete types7.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types6.number)
-      delete types6.integer;
-    for (const t2 in types6)
+    if (types7.number)
+      delete types7.integer;
+    for (const t2 in types7)
       cond = (0, codegen_1.and)(cond, checkDataType(t2, data, strictNums, correct));
     return cond;
   }
@@ -102531,7 +103918,7 @@ var require_defaults2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.assignDefaults = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   function assignDefaults(it, ty) {
     const { properties, items } = it.schema;
     if (ty === "object" && properties) {
@@ -102565,9 +103952,9 @@ var require_code4 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateUnion = exports.validateArray = exports.usePattern = exports.callValidateCode = exports.schemaProperties = exports.allSchemaProperties = exports.noPropertyInData = exports.propertyInData = exports.isOwnProperty = exports.hasPropFunc = exports.reportMissingProp = exports.checkMissingProp = exports.checkReportMissingProp = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var names_1 = require_names2();
-  var util_2 = require_util4();
+  var util_2 = require_util5();
   function checkReportMissingProp(cxt, prop) {
     const { gen, data, it } = cxt;
     gen.if(noPropertyInData(gen, data, prop, it.opts.ownProperties), () => {
@@ -102809,7 +104196,7 @@ var require_subschema2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
     if (keyword !== undefined && schema !== undefined) {
       throw new Error('both "keyword" and "schema" passed, only one allowed');
@@ -102888,7 +104275,7 @@ var require_subschema2 = __commonJS((exports) => {
 var require_resolve2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.getSchemaRefs = exports.resolveUrl = exports.normalizeId = exports._getFullPath = exports.getFullPath = exports.inlineRef = undefined;
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var equal = require_fast_deep_equal();
   var traverse = require_json_schema_traverse();
   var SIMPLE_INLINED = new Set([
@@ -103051,7 +104438,7 @@ var require_validate2 = __commonJS((exports) => {
   var codegen_1 = require_codegen2();
   var names_1 = require_names2();
   var resolve_1 = require_resolve2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var errors_1 = require_errors3();
   function validateFunctionCode(it) {
     if (isSchemaObj(it)) {
@@ -103158,9 +104545,9 @@ var require_validate2 = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types6 = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types6);
-    schemaKeywords(it, types6, !checkedTypes, errsCount);
+    const types7 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types7);
+    schemaKeywords(it, types7, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema, errSchemaPath, opts, self: self2 } = it;
@@ -103210,7 +104597,7 @@ var require_validate2 = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types6, typeErrors, errsCount) {
+  function schemaKeywords(it, types7, typeErrors, errsCount) {
     const { gen, schema, data, allErrors, opts, self: self2 } = it;
     const { RULES } = self2;
     if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
@@ -103218,7 +104605,7 @@ var require_validate2 = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types6);
+      checkStrictTypes(it, types7);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -103230,7 +104617,7 @@ var require_validate2 = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types6.length === 1 && types6[0] === group.type && typeErrors) {
+        if (types7.length === 1 && types7[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -103254,27 +104641,27 @@ var require_validate2 = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types6) {
+  function checkStrictTypes(it, types7) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types6);
+    checkContextTypes(it, types7);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types6);
+      checkMultipleTypes(it, types7);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types6) {
-    if (!types6.length)
+  function checkContextTypes(it, types7) {
+    if (!types7.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types6;
+      it.dataTypes = types7;
       return;
     }
-    types6.forEach((t2) => {
+    types7.forEach((t2) => {
       if (!includesType(it.dataTypes, t2)) {
         strictTypesError(it, `type "${t2}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types6);
+    narrowSchemaTypes(it, types7);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -103579,7 +104966,7 @@ var require_compile2 = __commonJS((exports) => {
   var validation_error_1 = require_validation_error2();
   var names_1 = require_names2();
   var resolve_1 = require_resolve2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var validate_1 = require_validate2();
 
   class SchemaEnv {
@@ -103693,7 +105080,7 @@ var require_compile2 = __commonJS((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve5.call(this, root2, ref);
+    let _sch = resolve6.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a16 = root2.localRefs) === null || _a16 === undefined ? undefined : _a16[ref];
       const { schemaId } = this.opts;
@@ -103720,7 +105107,7 @@ var require_compile2 = __commonJS((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve5(root2, ref) {
+  function resolve6(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -104536,7 +105923,7 @@ var require_uri_all = __commonJS((exports, module) => {
       target.fragment = relative3.fragment;
       return target;
     }
-    function resolve5(baseURI, relativeURI, options) {
+    function resolve6(baseURI, relativeURI, options) {
       var schemelessOptions = assign({ scheme: "null" }, options);
       return serialize(resolveComponents(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
     }
@@ -104804,7 +106191,7 @@ var require_uri_all = __commonJS((exports, module) => {
     exports2.removeDotSegments = removeDotSegments;
     exports2.serialize = serialize;
     exports2.resolveComponents = resolveComponents;
-    exports2.resolve = resolve5;
+    exports2.resolve = resolve6;
     exports2.normalize = normalize5;
     exports2.equal = equal;
     exports2.escapeComponent = escapeComponent;
@@ -104855,7 +106242,7 @@ var require_core3 = __commonJS((exports) => {
   var codegen_2 = require_codegen2();
   var resolve_1 = require_resolve2();
   var dataType_1 = require_dataType2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var $dataRefSchema = require_data2();
   var uri_1 = require_uri2();
   var defaultRegExp = (str, flags) => new RegExp(str, flags);
@@ -105435,7 +106822,7 @@ var require_ref2 = __commonJS((exports) => {
   var codegen_1 = require_codegen2();
   var names_1 = require_names2();
   var compile_1 = require_compile2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var def = {
     keyword: "$ref",
     schemaType: "string",
@@ -105644,7 +107031,7 @@ var require_ucs2length2 = __commonJS((exports) => {
 var require_limitLength2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var ucs2length_1 = require_ucs2length2();
   var error48 = {
     message({ keyword, schemaCode }) {
@@ -105725,7 +107112,7 @@ var require_required2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code4();
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: ({ params: { missingProperty } }) => (0, codegen_1.str)`must have required property '${missingProperty}'`,
     params: ({ params: { missingProperty } }) => (0, codegen_1._)`{missingProperty: ${missingProperty}}`
@@ -105838,7 +107225,7 @@ var require_uniqueItems2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var dataType_1 = require_dataType2();
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var equal_1 = require_equal2();
   var error48 = {
     message: ({ params: { i: i2, j } }) => (0, codegen_1.str)`must NOT have duplicate items (items ## ${j} and ${i2} are identical)`,
@@ -105901,7 +107288,7 @@ var require_uniqueItems2 = __commonJS((exports) => {
 var require_const2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var equal_1 = require_equal2();
   var error48 = {
     message: "must be equal to constant",
@@ -105927,7 +107314,7 @@ var require_const2 = __commonJS((exports) => {
 var require_enum2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var equal_1 = require_equal2();
   var error48 = {
     message: "must be equal to one of the allowed values",
@@ -106004,7 +107391,7 @@ var require_additionalItems2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateAdditionalItems = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
     params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
@@ -106054,7 +107441,7 @@ var require_items2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateTuple = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var code_1 = require_code4();
   var def = {
     keyword: "items",
@@ -106121,7 +107508,7 @@ var require_prefixItems2 = __commonJS((exports) => {
 var require_items20202 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var code_1 = require_code4();
   var additionalItems_1 = require_additionalItems2();
   var error48 = {
@@ -106153,7 +107540,7 @@ var require_items20202 = __commonJS((exports) => {
 var require_contains2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: ({ params: { min, max } }) => max === undefined ? (0, codegen_1.str)`must contain at least ${min} valid item(s)` : (0, codegen_1.str)`must contain at least ${min} and no more than ${max} valid item(s)`,
     params: ({ params: { min, max } }) => max === undefined ? (0, codegen_1._)`{minContains: ${min}}` : (0, codegen_1._)`{minContains: ${min}, maxContains: ${max}}`
@@ -106245,7 +107632,7 @@ var require_dependencies2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateSchemaDeps = exports.validatePropertyDeps = exports.error = undefined;
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var code_1 = require_code4();
   exports.error = {
     message: ({ params: { property, depsCount, deps } }) => {
@@ -106329,7 +107716,7 @@ var require_dependencies2 = __commonJS((exports) => {
 var require_propertyNames2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: "property name must be valid",
     params: ({ params }) => (0, codegen_1._)`{propertyName: ${params.propertyName}}`
@@ -106371,7 +107758,7 @@ var require_additionalProperties2 = __commonJS((exports) => {
   var code_1 = require_code4();
   var codegen_1 = require_codegen2();
   var names_1 = require_names2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: "must NOT have additional properties",
     params: ({ params }) => (0, codegen_1._)`{additionalProperty: ${params.additionalProperty}}`
@@ -106473,7 +107860,7 @@ var require_properties2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var validate_1 = require_validate2();
   var code_1 = require_code4();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var additionalProperties_1 = require_additionalProperties2();
   var def = {
     keyword: "properties",
@@ -106528,8 +107915,8 @@ var require_patternProperties2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code4();
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
-  var util_2 = require_util4();
+  var util_1 = require_util5();
+  var util_2 = require_util5();
   var def = {
     keyword: "patternProperties",
     type: "object",
@@ -106597,7 +107984,7 @@ var require_patternProperties2 = __commonJS((exports) => {
 // ../../node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/not.js
 var require_not2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var def = {
     keyword: "not",
     schemaType: ["object", "boolean"],
@@ -106640,7 +108027,7 @@ var require_anyOf2 = __commonJS((exports) => {
 var require_oneOf2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: "must match exactly one schema in oneOf",
     params: ({ params }) => (0, codegen_1._)`{passingSchemas: ${params.passing}}`
@@ -106694,7 +108081,7 @@ var require_oneOf2 = __commonJS((exports) => {
 // ../../node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/allOf.js
 var require_allOf2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var def = {
     keyword: "allOf",
     schemaType: "array",
@@ -106719,7 +108106,7 @@ var require_allOf2 = __commonJS((exports) => {
 var require_if2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: ({ params }) => (0, codegen_1.str)`must match "${params.ifClause}" schema`,
     params: ({ params }) => (0, codegen_1._)`{failingKeyword: ${params.ifClause}}`
@@ -106784,7 +108171,7 @@ var require_if2 = __commonJS((exports) => {
 // ../../node_modules/ajv-formats/node_modules/ajv/dist/vocabularies/applicator/thenElse.js
 var require_thenElse2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var def = {
     keyword: ["then", "else"],
     schemaType: ["object", "boolean"],
@@ -106990,7 +108377,7 @@ var require_discriminator2 = __commonJS((exports) => {
   var codegen_1 = require_codegen2();
   var types_1 = require_types3();
   var compile_1 = require_compile2();
-  var util_1 = require_util4();
+  var util_1 = require_util5();
   var error48 = {
     message: ({ params: { discrError, tagName } }) => discrError === types_1.DiscrError.Tag ? `tag "${tagName}" must be string` : `value of tag "${tagName}" must be in oneOf`,
     params: ({ params: { discrError, tag, tagName } }) => (0, codegen_1._)`{error: ${discrError}, tag: ${tagName}, tagValue: ${tag}}`
@@ -108121,12 +109508,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve5, reject) {
+      return new Promise(function(resolve6, reject) {
         isexe(path11, options || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve5(is);
+            resolve6(is);
           }
         });
       });
@@ -108188,27 +109575,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve5, reject) => {
+    const step = (i2) => new Promise((resolve6, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve5(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve6(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path11.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve5(subStep(p, i2, 0));
+      resolve6(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve5, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve6, reject) => {
       if (ii === pathExt.length)
-        return resolve5(step(i2 + 1));
+        return resolve6(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve5(p + ext);
+            return resolve6(p + ext);
         }
-        return resolve5(subStep(p, i2, ii + 1));
+        return resolve6(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -108552,7 +109939,7 @@ class StdioClientTransport {
     if (this._process) {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
@@ -108568,7 +109955,7 @@ class StdioClientTransport {
         this.onerror?.(error48);
       });
       this._process.on("spawn", () => {
-        resolve5();
+        resolve6();
       });
       this._process.on("close", (_code) => {
         this._process = undefined;
@@ -108615,20 +110002,20 @@ class StdioClientTransport {
     if (this._process) {
       const processToClose = this._process;
       this._process = undefined;
-      const closePromise = new Promise((resolve5) => {
+      const closePromise = new Promise((resolve6) => {
         processToClose.once("close", () => {
-          resolve5();
+          resolve6();
         });
       });
       try {
         processToClose.stdin?.end();
       } catch {}
-      await Promise.race([closePromise, new Promise((resolve5) => setTimeout(resolve5, 2000).unref())]);
+      await Promise.race([closePromise, new Promise((resolve6) => setTimeout(resolve6, 2000).unref())]);
       if (processToClose.exitCode === null) {
         try {
           processToClose.kill("SIGTERM");
         } catch {}
-        await Promise.race([closePromise, new Promise((resolve5) => setTimeout(resolve5, 2000).unref())]);
+        await Promise.race([closePromise, new Promise((resolve6) => setTimeout(resolve6, 2000).unref())]);
       }
       if (processToClose.exitCode === null) {
         try {
@@ -108639,15 +110026,15 @@ class StdioClientTransport {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       if (!this._process?.stdin) {
         throw new Error("Not connected");
       }
       const json2 = serializeMessage(message);
       if (this._process.stdin.write(json2)) {
-        resolve5();
+        resolve6();
       } else {
-        this._process.stdin.once("drain", resolve5);
+        this._process.stdin.once("drain", resolve6);
       }
     });
   }
@@ -108827,12 +110214,12 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.88";
+var version = "0.9.89";
 
 // src/commands/agent.ts
 init_src();
 import { exec as exec3 } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import * as fs12 from "node:fs/promises";
 import * as path10 from "node:path";
 import { promisify as promisify3 } from "node:util";
@@ -111222,7 +112609,7 @@ function createContinuousImprovementLoop(context, stateManager, _sessionId) {
         context.logger.info("[Continuous] Wait interrupted");
         return;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, 1000));
+      await new Promise((resolve5) => setTimeout(resolve5, 1000));
     }
   }
   return {
@@ -111573,10 +112960,10 @@ ${"═".repeat(60)}`);
       input: process.stdin,
       output: process.stdout
     });
-    const answer = await new Promise((resolve4) => {
+    const answer = await new Promise((resolve5) => {
       rl.question("Approve this task? (yes/no): ", (response) => {
         rl.close();
-        resolve4(response);
+        resolve5(response);
       });
     });
     if (!answer) {
@@ -111655,10 +113042,10 @@ ${"═".repeat(60)}`);
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       rl.question(query, (answer) => {
         rl.close();
-        resolve4(answer.trim());
+        resolve5(answer.trim());
       });
     });
   }
@@ -112993,7 +114380,7 @@ async function runAgent(goal, options, _command) {
   const config4 = await loadConfig(configOptions, options.config);
   const workingDir = process.cwd();
   const stateDir = path10.join(workingDir, ".polka", "agent-state");
-  const sessionId = `agent-${Date.now()}-${randomUUID()}`;
+  const sessionId = `agent-${Date.now()}-${randomUUID2()}`;
   const asyncExec = promisify3(exec3);
   const tools3 = {
     executeCommand: async (input) => {
@@ -113100,7 +114487,7 @@ ${errorStdout}` : ""}`);
 var agentCommand = new Command("agent").description("Run autonomous agent (experimental)").argument("[goal]", "Goal to achieve", "").option("--continuous", "Run in continuous improvement mode").option("--preset <name>", "Configuration preset", "balanced").option("--config <path>", "Configuration file path").option("--approval-level <level>", "Approval level (none|destructive|commits|all)", "destructive").action(runAgent);
 
 // src/commands/code.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 init_mime_types();
 
 // src/runWorkflow.ts
@@ -113476,8 +114863,6 @@ init_dist7();
 init_errors5();
 init_errors6();
 import { spawn as spawn4, spawnSync as spawnSync2 } from "node:child_process";
-import fs13, { mkdir as mkdir7 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
 
 // src/skillIntegration.ts
 init_src();
@@ -113627,7 +115012,7 @@ async function confirm(input, context) {
   if (context.yes) {
     return true;
   }
-  await new Promise((resolve5) => setTimeout(resolve5, 50));
+  await new Promise((resolve6) => setTimeout(resolve6, 50));
   process.stderr.write("\x07");
   return await dist_default4({ message: input.message });
 }
@@ -113635,7 +115020,7 @@ async function input(input2, context) {
   if (context.yes) {
     return input2.default ?? "";
   }
-  await new Promise((resolve5) => setTimeout(resolve5, 50));
+  await new Promise((resolve6) => setTimeout(resolve6, 50));
   process.stderr.write("\x07");
   const result = await getUserInput(input2.message, {
     default: input2.default
@@ -113649,33 +115034,12 @@ async function select(input2, context) {
   if (context.yes) {
     return input2.choices[0].value;
   }
-  await new Promise((resolve5) => setTimeout(resolve5, 50));
+  await new Promise((resolve6) => setTimeout(resolve6, 50));
   process.stderr.write("\x07");
   return await dist_default7({ message: input2.message, choices: input2.choices });
 }
-async function writeToFile(input2) {
-  await mkdir7(dirname5(input2.path), { recursive: true });
-  await fs13.writeFile(input2.path, input2.content);
-  return {
-    success: true,
-    message: {
-      type: "text",
-      value: `Successfully wrote to ${input2.path}`
-    }
-  };
-}
-async function readFile11(input2) {
-  try {
-    return await fs13.readFile(input2.path, "utf8");
-  } catch (error48) {
-    if (error48 && typeof error48 === "object" && "code" in error48 && (error48.code === "ENOENT" || error48.code === "EISDIR")) {
-      return null;
-    }
-    throw error48;
-  }
-}
 async function executeCommand(input2) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = input2.shell === true ? spawn4(input2.args && input2.args.length > 0 ? `${input2.command} ${input2.args.map(quoteForShell).join(" ")}` : input2.command, {
       shell: true,
       stdio: "pipe"
@@ -113691,7 +115055,7 @@ async function executeCommand(input2) {
     let exitCode = null;
     const checkAndResolve = () => {
       if (stdoutEnded && stderrEnded && closeEventFired) {
-        resolve5({ exitCode: exitCode ?? -1, stdout, stderr });
+        resolve6({ exitCode: exitCode ?? -1, stdout, stderr });
       }
     };
     if (child.stdout) {
@@ -113824,7 +115188,7 @@ async function generateText2(input2, context) {
           lastError = providerError;
           const backoff2 = computeRateLimitBackoffSeconds(i2);
           console.debug(`Waiting ${backoff2}s before retry...`);
-          await new Promise((resolve5) => setTimeout(resolve5, backoff2 * 1000));
+          await new Promise((resolve6) => setTimeout(resolve6, backoff2 * 1000));
           continue;
         }
         throw providerError;
@@ -114008,8 +115372,6 @@ var localToolHandlers = {
   confirm,
   input,
   select,
-  writeToFile,
-  readFile: readFile11,
   executeCommand,
   generateText: generateText2,
   invokeTool,
@@ -114025,6 +115387,7 @@ var localToolHandlers = {
   listSkills: listSkills3,
   readSkillFile: readSkillFile3
 };
+var localToolNames = Object.keys(localToolHandlers);
 async function toolCall(toolCall2, context) {
   const handler20 = localToolHandlers[toolCall2.tool];
   if (handler20) {
@@ -114137,6 +115500,9 @@ async function runWorkflow(workflow2, workflowInput, options) {
       if (typeof prop !== "string" || prop === "then" || prop === "toJSON") {
         return;
       }
+      if (!toolHandlers.has(prop) && !localToolNames.includes(prop)) {
+        return;
+      }
       return async (input2) => {
         logger.debug(`Running tool: ${prop}`);
         return await toolCall({ tool: prop, input: input2 }, {
@@ -114601,7 +115967,7 @@ var readStdin = async (timeoutMs = COMMAND_CONSTANTS.DEFAULT_STDIN_TIMEOUT_MS) =
   if (process.stdin.isTTY) {
     return "";
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let input2 = "";
     const cleanup = () => {
       if (timeoutId)
@@ -114610,14 +115976,14 @@ var readStdin = async (timeoutMs = COMMAND_CONSTANTS.DEFAULT_STDIN_TIMEOUT_MS) =
     };
     const timeoutId = setTimeout(() => {
       cleanup();
-      resolve5(input2);
+      resolve6(input2);
     }, timeoutMs);
     process.stdin.on("data", (chunk) => {
       input2 += chunk.toString();
     });
     process.stdin.on("end", () => {
       cleanup();
-      resolve5(input2);
+      resolve6(input2);
     });
     process.stdin.on("error", (err) => {
       cleanup();
@@ -114638,7 +116004,7 @@ async function runCode(task2, _options, command) {
       try {
         const mimeType = $lookup(file2);
         if (mimeType) {
-          const buffer = await readFile12(file2);
+          const buffer = await readFile11(file2);
           if (mimeType.startsWith("image/")) {
             fileContents.push({
               type: "image",
@@ -114707,7 +116073,7 @@ var fixCommand = new Command("fix").description("Fix issues by running a command
 // src/commands/init.ts
 init_dist18();
 init_src3();
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
 import { join as join14 } from "node:path";
 init_lodash();
 init_dist();
@@ -114862,54 +116228,56 @@ var initInteractiveWorkflow = async (input2, context) => {
   const { configPath, scriptName, scriptInstructions, generateScript = false, skipConfirmation = false } = input2;
   let generatedConfig = {};
   let generatedScriptPath;
-  const analyzeResult = await step("analyze-project", async () => {
-    logger.info("Analyzing project structure and configuration...");
-    return await agentWorkflow({
-      systemPrompt: INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT,
-      userMessage: [
-        {
-          role: "user",
-          content: "Please provide a valid polkacodes YAML configuration for the project."
-        }
-      ],
-      tools: [readFile_default, listFiles_default, searchFiles_default],
-      outputSchema: exports_external.object({ yaml: exports_external.string() })
-    }, { logger, tools: tools3, step });
-  });
-  if (analyzeResult.type === "Exit" && analyzeResult.object) {
-    const yamlConfig = analyzeResult.object.yaml;
-    generatedConfig = yamlConfig ? $parse(yamlConfig) : {};
-  }
-  await step("save-config", async () => {
-    const existingConfig = loadConfigAtPath(configPath) ?? {};
-    const finalConfig = {
-      ...existingConfig,
-      ...generatedConfig
-    };
-    await tools3.writeToFile({ path: configPath, content: $stringify(finalConfig) });
-    logger.info(`✅ Configuration saved to ${configPath}`);
-    if (generatedConfig.scripts) {
-      logger.info(`
+  if (!generateScript) {
+    const analyzeResult = await step("analyze-project", async () => {
+      logger.info("Analyzing project structure and configuration...");
+      return await agentWorkflow({
+        systemPrompt: INIT_WORKFLOW_ANALYZE_SYSTEM_PROMPT,
+        userMessage: [
+          {
+            role: "user",
+            content: "Please provide a valid polkacodes YAML configuration for the project."
+          }
+        ],
+        tools: [readFile_default, listFiles_default, searchFiles_default],
+        outputSchema: exports_external.object({ yaml: exports_external.string() })
+      }, { logger, tools: tools3, step });
+    });
+    if (analyzeResult.type === "Exit" && analyzeResult.object) {
+      const yamlConfig = analyzeResult.object.yaml;
+      generatedConfig = yamlConfig ? $parse(yamlConfig) : {};
+    }
+    await step("save-config", async () => {
+      const existingConfig = loadConfigAtPath(configPath) ?? {};
+      const finalConfig = {
+        ...existingConfig,
+        ...generatedConfig
+      };
+      await tools3.writeToFile({ path: configPath, content: $stringify(finalConfig) });
+      logger.info(`✅ Configuration saved to ${configPath}`);
+      if (generatedConfig.scripts) {
+        logger.info(`
 \uD83D\uDCDD Generated scripts:`);
-      Object.entries(generatedConfig.scripts).forEach(([name18, scriptConfig]) => {
-        if (typeof scriptConfig === "string") {
-          logger.info(`  - ${name18}: ${scriptConfig}`);
-        } else if (typeof scriptConfig === "object" && scriptConfig !== null) {
-          logger.info(`  - ${name18}: ${scriptConfig.description || JSON.stringify(scriptConfig)}`);
-        }
-      });
-    }
-    if (generatedConfig.rules) {
-      const rules = Array.isArray(generatedConfig.rules) ? generatedConfig.rules : [generatedConfig.rules];
-      logger.info(`
+        Object.entries(generatedConfig.scripts).forEach(([name18, scriptConfig]) => {
+          if (typeof scriptConfig === "string") {
+            logger.info(`  - ${name18}: ${scriptConfig}`);
+          } else if (typeof scriptConfig === "object" && scriptConfig !== null) {
+            logger.info(`  - ${name18}: ${scriptConfig.description || JSON.stringify(scriptConfig)}`);
+          }
+        });
+      }
+      if (generatedConfig.rules) {
+        const rules = Array.isArray(generatedConfig.rules) ? generatedConfig.rules : [generatedConfig.rules];
+        logger.info(`
 \uD83D\uDCCB Identified project rules:`);
-      rules.forEach((rule) => {
-        if (typeof rule === "string") {
-          logger.info(`  - ${rule}`);
-        }
-      });
-    }
-  });
+        rules.forEach((rule) => {
+          if (typeof rule === "string") {
+            logger.info(`  - ${rule}`);
+          }
+        });
+      }
+    });
+  }
   if (generateScript && scriptName && scriptInstructions) {
     const scriptResult = await step("generate-script", async () => {
       logger.info(`
@@ -114985,7 +116353,7 @@ async function createSkill(name18, logger, interactive) {
     throw new Error(`Skill name '${name18}' conflicts with a built-in command. ` + `Please choose a different name (e.g., '${name18}-skill' or 'my-${name18}')`);
   }
   const skillDir = join14(".claude", "skills", name18);
-  if (existsSync3(skillDir)) {
+  if (existsSync4(skillDir)) {
     if (interactive) {
       const proceed = await dist_default4({
         message: `Skill '${name18}' already exists. Overwrite?`,
@@ -115074,7 +116442,7 @@ async function createScript(name18, logger, interactive, isGlobal = false) {
   const scriptDir = ".polka-scripts";
   const scriptPathConfig = `${scriptDir}/${name18}.ts`;
   const scriptPathActual = join14(scriptDir, `${name18}.ts`);
-  if (existsSync3(scriptPathActual)) {
+  if (existsSync4(scriptPathActual)) {
     if (interactive) {
       const proceed = await dist_default4({
         message: `Script '${scriptPathActual}' already exists. Overwrite?`,
@@ -115088,7 +116456,7 @@ async function createScript(name18, logger, interactive, isGlobal = false) {
       throw new Error(`Script already exists: ${scriptPathActual}`);
     }
   }
-  if (!existsSync3(scriptDir)) {
+  if (!existsSync4(scriptDir)) {
     mkdirSync(scriptDir, { recursive: true });
     logger.info(`Created directory: ${scriptDir}`);
   }
@@ -115115,7 +116483,7 @@ if (import.meta.main) {
   writeFileSync(scriptPathActual, template);
   logger.info(`Created script: ${scriptPathActual}`);
   const configPath = isGlobal ? getGlobalConfigPath() : localConfigFileName;
-  if (existsSync3(configPath)) {
+  if (existsSync4(configPath)) {
     try {
       const config4 = readConfig(configPath);
       if (!config4.scripts) {
@@ -115238,7 +116606,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
         }
         const scriptDir = ".polka-scripts";
         const scriptPath = join14(scriptDir, `${name18}.ts`);
-        if (existsSync3(scriptPath)) {
+        if (existsSync4(scriptPath)) {
           if (interactive) {
             const proceed = await dist_default4({
               message: `Script '${scriptPath}' already exists. Overwrite?`,
@@ -115292,7 +116660,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
   const globalConfigPath = getGlobalConfigPath();
   let isGlobal = options.global ?? false;
   let configPath = isGlobal ? globalConfigPath : localConfigFileName;
-  const exists = existsSync3(configPath);
+  const exists = existsSync4(configPath);
   if (exists) {
     if (interactive) {
       const proceed = await dist_default4({
@@ -115354,7 +116722,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
       }
       case "env": {
         let envFileContent = "";
-        const envExists = existsSync3(".env");
+        const envExists = existsSync4(".env");
         if (envExists) {
           envFileContent = readFileSync2(".env", "utf-8");
           if (!envFileContent.endsWith(`
@@ -116045,7 +117413,7 @@ class McpServer {
     let task2 = createTaskResult.task;
     const pollInterval = task2.pollInterval ?? 5000;
     while (task2.status !== "completed" && task2.status !== "failed" && task2.status !== "cancelled") {
-      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
+      await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError2(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -116627,12 +117995,12 @@ class StdioServerTransport {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve5();
+        resolve6();
       } else {
-        this._stdout.once("drain", resolve5);
+        this._stdout.once("drain", resolve6);
       }
     });
   }
@@ -117049,6 +118417,322 @@ var mcpServerCommand = new Command("mcp-server").description("Start polka-codes
   process.on("SIGTERM", shutdown);
 });
 
+// src/commands/memory.ts
+init_src3();
+init_src();
+import { existsSync as existsSync5 } from "node:fs";
+import { mkdir as mkdir8, readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
+import { dirname as dirname7, join as join15, resolve as resolve7, sep as sep2 } from "node:path";
+async function getMemoryStore() {
+  const globalConfigPath = getGlobalConfigPath();
+  const config4 = await loadConfigAtPath(globalConfigPath);
+  const memoryConfig = config4?.memory || { enabled: true, type: "sqlite", path: "~/.config/polka-codes/memory.sqlite" };
+  if (!memoryConfig.enabled || memoryConfig.type === "memory") {
+    console.error("Memory store is not enabled. Enable it in config with memory.enabled: true");
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const scope = detectProjectScope(cwd);
+  const sqliteStore = new SQLiteMemoryStore(memoryConfig, scope);
+  return new MemoryManager(sqliteStore, cwd);
+}
+function detectProjectScope(cwd) {
+  const projectPath = findProjectRoot(cwd);
+  if (!projectPath) {
+    return "global";
+  }
+  const normalizedPath = normalizePath(projectPath);
+  return `project:${normalizedPath}`;
+  function findProjectRoot(dir) {
+    let currentDir = resolve7(dir);
+    while (currentDir !== "/") {
+      const configPath = join15(currentDir, ".polkacodes.yml");
+      if (existsSync5(configPath)) {
+        return currentDir;
+      }
+      const parentDir = dirname7(currentDir);
+      if (parentDir === currentDir)
+        break;
+      currentDir = parentDir;
+      if (currentDir.split(sep2).length < 3)
+        break;
+    }
+    return null;
+  }
+  function normalizePath(path12) {
+    const normalized = resolve7(path12).replace(/\/$/, "");
+    if (normalized.includes("..")) {
+      throw new Error(`Path contains parent directory references: ${path12}`);
+    }
+    return normalized;
+  }
+}
+async function memoryList(options) {
+  const store = await getMemoryStore();
+  try {
+    const query = {
+      scope: "auto"
+    };
+    if (options.type)
+      query.type = options.type;
+    if (options.status)
+      query.status = options.status;
+    if (options.priority)
+      query.priority = options.priority;
+    if (options.tags)
+      query.tags = options.tags.split(",");
+    if (options.search)
+      query.search = options.search;
+    if (options.limit)
+      query.limit = options.limit;
+    if (options.offset)
+      query.offset = options.offset;
+    if (options.sortBy)
+      query.sortBy = options.sortBy;
+    if (options.sortOrder)
+      query.sortOrder = options.sortOrder;
+    const entries = await store.queryMemory(query, { operation: "select" });
+    if (options.format === "json") {
+      console.log(JSON.stringify(entries, null, 2));
+    } else {
+      if (!Array.isArray(entries) || entries.length === 0) {
+        console.log("No entries found.");
+        return;
+      }
+      console.log(`
+Memory Entries:`);
+      console.log("─".repeat(80));
+      for (const entry of entries) {
+        console.log(`
+Name: ${entry.name}`);
+        console.log(`Type: ${entry.entry_type}`);
+        console.log(`Status: ${entry.status || "N/A"}`);
+        console.log(`Priority: ${entry.priority || "N/A"}`);
+        console.log(`Tags: ${entry.tags || "N/A"}`);
+        console.log(`Updated: ${new Date(entry.updated_at).toLocaleString()}`);
+        console.log(`Content:
+${entry.content}`);
+        console.log("─".repeat(80));
+      }
+      console.log(`
+Total: ${entries.length} entries`);
+    }
+  } finally {
+    store.close();
+  }
+}
+async function memoryRead(name18, options) {
+  const store = await getMemoryStore();
+  try {
+    const content = await store.readMemory(name18);
+    if (!content) {
+      console.error(`Memory entry "${name18}" not found.`);
+      process.exit(1);
+    }
+    if (options.format === "json") {
+      console.log(JSON.stringify({ name: name18, content }, null, 2));
+    } else {
+      console.log(content);
+    }
+  } finally {
+    store.close();
+  }
+}
+async function memoryDelete(name18, options) {
+  if (!options.force) {
+    console.log(`Are you sure you want to delete memory entry "${name18}"?`);
+    console.log("This action cannot be undone.");
+    console.log("Use --force to skip this confirmation.");
+    process.exit(1);
+  }
+  const store = await getMemoryStore();
+  try {
+    await store.updateMemory("remove", name18, undefined);
+    console.log(`Memory entry "${name18}" deleted.`);
+  } finally {
+    store.close();
+  }
+}
+async function memoryRename(oldName, newName) {
+  const store = await getMemoryStore();
+  try {
+    const oldEntries = await store.queryMemory({ search: oldName }, { operation: "select" });
+    if (!Array.isArray(oldEntries) || oldEntries.length === 0) {
+      console.error(`Memory entry "${oldName}" not found.`);
+      process.exit(1);
+    }
+    const oldEntry = oldEntries[0];
+    const newEntries = await store.queryMemory({ search: newName }, { operation: "select" });
+    if (Array.isArray(newEntries) && newEntries.length > 0) {
+      console.error(`Memory entry "${newName}" already exists.`);
+      process.exit(1);
+    }
+    await store.batchUpdateMemory([
+      {
+        operation: "replace",
+        name: newName,
+        content: oldEntry.content,
+        metadata: {
+          entry_type: oldEntry.entry_type,
+          status: oldEntry.status,
+          priority: oldEntry.priority,
+          tags: oldEntry.tags
+        }
+      },
+      { operation: "remove", name: oldName }
+    ]);
+    console.log(`Memory entry renamed from "${oldName}" to "${newName}".`);
+  } finally {
+    store.close();
+  }
+}
+async function memoryExport(options) {
+  const store = await getMemoryStore();
+  try {
+    const query = {};
+    if (options.type)
+      query.type = options.type;
+    if (options.scope === "global") {
+      query.scope = "global";
+    } else if (options.scope === "project") {
+      query.scope = "project";
+    } else {
+      query.scope = "auto";
+    }
+    const entries = await store.queryMemory(query, { operation: "select" });
+    if (!Array.isArray(entries)) {
+      console.error("Failed to export: query did not return entries");
+      return;
+    }
+    const outputPath = options.output ? resolve7(process.cwd(), options.output) : resolve7(process.cwd(), `memory-export-${Date.now()}.json`);
+    await mkdir8(dirname7(outputPath), { recursive: true });
+    await writeFile7(outputPath, JSON.stringify(entries, null, 2));
+    console.log(`Exported ${entries.length} entries to ${outputPath}`);
+  } finally {
+    store.close();
+  }
+}
+async function memoryImport(inputFile, options) {
+  const store = await getMemoryStore();
+  try {
+    const inputPath = resolve7(process.cwd(), inputFile);
+    const data = await readFile12(inputPath, "utf-8");
+    let entries;
+    try {
+      entries = JSON.parse(data);
+    } catch (error48) {
+      console.error(`Failed to parse JSON from ${inputPath}:`, error48);
+      process.exit(1);
+    }
+    if (!Array.isArray(entries)) {
+      console.error("Invalid import file format. Expected an array of memory entries.");
+      process.exit(1);
+    }
+    let imported = 0;
+    let skipped = 0;
+    for (const entry of entries) {
+      let entryName;
+      try {
+        if (typeof entry !== "object" || entry === null) {
+          console.error("Skipping invalid entry: not an object");
+          skipped++;
+          continue;
+        }
+        const entryObj = entry;
+        if (!entryObj.name || typeof entryObj.name !== "string") {
+          console.error("Skipping invalid entry: missing or invalid name");
+          skipped++;
+          continue;
+        }
+        entryName = entryObj.name;
+        if (!entryObj.content || typeof entryObj.content !== "string") {
+          console.error(`Skipping entry "${entryName}": missing or invalid content`);
+          skipped++;
+          continue;
+        }
+        const validPriorities = ["low", "medium", "high", "critical"];
+        let priority = entryObj.priority;
+        if (priority && !validPriorities.includes(priority)) {
+          console.warn(`Entry "${entryName}" has invalid priority "${priority}", defaulting to null`);
+          priority = undefined;
+        }
+        const existing = await store.readMemory(entryName);
+        if (existing && !options.merge) {
+          skipped++;
+          continue;
+        }
+        const entryType = entryObj.entry_type;
+        const validatedEntryType = typeof entryType === "string" ? entryType : "note";
+        const status = entryObj.status;
+        const validatedStatus = typeof status === "string" ? status : undefined;
+        const tags = entryObj.tags;
+        const validatedTags = typeof tags === "string" ? tags : undefined;
+        await store.updateMemory("replace", entryName, entryObj.content, {
+          entry_type: validatedEntryType,
+          status: validatedStatus,
+          priority,
+          tags: validatedTags
+        });
+        imported++;
+      } catch (error48) {
+        console.error(`Failed to import entry "${entryName || "unknown"}":`, error48);
+        skipped++;
+      }
+    }
+    console.log(`Imported ${imported} entries, skipped ${skipped} entries.`);
+  } finally {
+    store.close();
+  }
+}
+async function memoryStatus() {
+  const store = await getMemoryStore();
+  try {
+    const stats = await store.getStats();
+    const globalConfigPath = getGlobalConfigPath();
+    const config4 = await loadConfigAtPath(globalConfigPath);
+    const memoryConfig = config4?.memory || { path: "~/.config/polka-codes/memory.sqlite" };
+    const dbPath = resolveHomePath(memoryConfig.path || "~/.config/polka-codes/memory.sqlite");
+    console.log(`
+Memory Store Status:`);
+    console.log("─".repeat(80));
+    console.log(`Database: ${dbPath}`);
+    console.log(`Total entries: ${stats.totalEntries}`);
+    console.log(`Database size: ${(stats.databaseSize / 1024).toFixed(2)} KB`);
+    console.log(`
+Entries by type:`);
+    for (const [type, count] of Object.entries(stats.entriesByType)) {
+      console.log(`  ${type}: ${count}`);
+    }
+    console.log("─".repeat(80));
+  } finally {
+    store.close();
+  }
+}
+function registerMemoryCommands(program2) {
+  const memoryCmd = program2.command("memory").description("Memory management commands");
+  memoryCmd.command("list").description("List memory entries").option("--type <type>", "Filter by type").option("--status <status>", "Filter by status").option("--priority <priority>", "Filter by priority").option("--tags <tags>", "Filter by tags (comma-separated)").option("--search <term>", "Search in content and name").option("--limit <number>", "Limit results", parseInt).option("--offset <number>", "Offset results", parseInt).option("--sort-by <field>", "Sort by field (created, updated, accessed, name)").option("--sort-order <order>", "Sort order (asc, desc)", "desc").option("--format <format>", "Output format (json, table)", "table").action(async (options) => {
+    await memoryList(options);
+  });
+  memoryCmd.command("read <name>").description("Read a specific memory entry").option("--format <format>", "Output format (json, text)", "text").action(async (name18, options) => {
+    await memoryRead(name18, options);
+  });
+  memoryCmd.command("delete <name>").description("Delete a memory entry").option("--force", "Skip confirmation").action(async (name18, options) => {
+    await memoryDelete(name18, options);
+  });
+  memoryCmd.command("rename <oldName> <newName>").description("Rename a memory entry").action(async (oldName, newName) => {
+    await memoryRename(oldName, newName);
+  });
+  memoryCmd.command("export").description("Export memory to JSON").option("--output <file>", "Output file path").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope (global, project)").action(async (options) => {
+    await memoryExport(options);
+  });
+  memoryCmd.command("import <file>").description("Import memory from JSON").option("--merge", "Merge with existing data (skip conflicts)").action(async (file2, options) => {
+    await memoryImport(file2, options);
+  });
+  memoryCmd.command("status").description("Show memory statistics").action(async () => {
+    await memoryStatus();
+  });
+}
+
 // src/commands/meta.ts
 init_src3();
 import { execSync as execSync2 } from "node:child_process";
@@ -117057,8 +118741,8 @@ import { execSync as execSync2 } from "node:child_process";
 import { spawnSync as spawnSync3 } from "node:child_process";
 
 // src/script/runner.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { relative as relative3, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { relative as relative3, resolve as resolve8 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 class ScriptValidationError extends Error {
@@ -117085,13 +118769,13 @@ class ScriptExecutionError extends Error {
   }
 }
 function validateScriptPath(scriptPath, projectRoot2 = process.cwd()) {
-  const normalizedRoot = resolve6(projectRoot2);
-  const normalizedScript = resolve6(projectRoot2, scriptPath);
+  const normalizedRoot = resolve8(projectRoot2);
+  const normalizedScript = resolve8(projectRoot2, scriptPath);
   const relativePath = relative3(normalizedRoot, normalizedScript);
   if (relativePath.startsWith("..")) {
     throw new ScriptValidationError(`Script path '${scriptPath}' is outside project directory`);
   }
-  if (!existsSync4(normalizedScript)) {
+  if (!existsSync6(normalizedScript)) {
     throw new ScriptValidationError(`Script file not found: ${scriptPath}`);
   }
   const validExtensions = [".ts", ".js", ".mjs", ".cjs"];
@@ -117106,9 +118790,9 @@ function validateScriptPermissions(script, logger) {
   }
   if ("script" in script && script.permissions) {
     logger?.warn("Script permissions are currently advisory only. Scripts run with full process permissions.");
-    const { fs: fs14, network, subprocess } = script.permissions;
-    if (fs14 && !["read", "write", "none"].includes(fs14)) {
-      throw new ScriptValidationError(`Invalid fs permission: ${fs14}. Must be 'read', 'write', or 'none'`);
+    const { fs: fs13, network, subprocess } = script.permissions;
+    if (fs13 && !["read", "write", "none"].includes(fs13)) {
+      throw new ScriptValidationError(`Invalid fs permission: ${fs13}. Must be 'read', 'write', or 'none'`);
     }
     if (typeof network !== "boolean" && network !== undefined) {
       throw new ScriptValidationError(`Invalid network permission: must be true or false`);
@@ -117129,7 +118813,7 @@ class ScriptRunner {
     try {
       const returnValue = await this.withTimeout(timeout, async () => {
         const projectRoot2 = context.projectRoot || process.cwd();
-        const absolutePath = resolve6(projectRoot2, scriptPath);
+        const absolutePath = resolve8(projectRoot2, scriptPath);
         const cacheBustUrl = `${pathToFileURL(absolutePath).href}?t=${Date.now()}`;
         const scriptModule = await import(cacheBustUrl);
         if (typeof scriptModule.main !== "function") {
@@ -117418,7 +119102,7 @@ var prCommand = new Command("pr").description("Create a GitHub pull request").ar
 
 // src/commands/review.ts
 init_dist18();
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 init_workflow_utils();
 var reviewCommand = new Command("review").description("Review a GitHub pull request or local changes").argument("[files...]", "Specific files to review (use --context for review instructions)").option("--pr <pr>", "The pull request number to review", (value) => {
   const parsedValue = parseInt(value, 10);
@@ -117441,7 +119125,7 @@ var reviewCommand = new Command("review").description("Review a GitHub pull requ
   let changesAppliedInThisIteration = false;
   let context = contextOption;
   let filesToReview = files;
-  if (files.length === 1 && !existsSync5(files[0]) && files[0].includes(" ") && !context) {
+  if (files.length === 1 && !existsSync7(files[0]) && files[0].includes(" ") && !context) {
     if (!json2) {
       console.warn("Warning: The argument looks like context but was passed as a file. Treating it as context. Please use --context for review instructions in the future.");
     }
@@ -117480,7 +119164,7 @@ var reviewCommand = new Command("review").description("Review a GitHub pull requ
         if (yes) {
           shouldRunTask = true;
         } else if (process.stdin.isTTY && !json2) {
-          await new Promise((resolve7) => setTimeout(resolve7, 50));
+          await new Promise((resolve9) => setTimeout(resolve9, 50));
           try {
             const answer = await dist_default7({
               message: "Do you wish polka-codes to address the review results?",
@@ -117866,6 +119550,7 @@ program2.addCommand(runCommand);
 program2.addCommand(skillsCommand);
 program2.addCommand(mcpServerCommand);
 program2.addCommand(workflowCommand);
+registerMemoryCommands(program2);
 addSharedOptions(program2);
 if (__require.main == __require.module) {
   program2.parse();