duclaw-cli 1.9.11 → 1.9.12

package/dist/bundle.js

@@ -115,7 +115,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
     var fs3 = require("fs");
-    var path21 = require("path");
+    var path22 = require("path");
     var os = require("os");
     var crypto2 = require("crypto");
     var packageJson = require_package();
@@ -261,7 +261,7 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path21.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path22.resolve(process.cwd(), ".env.vault");
       }
       if (fs3.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
@@ -269,7 +269,7 @@ var require_main = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path21.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path22.join(os.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
@@ -286,7 +286,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path21.resolve(process.cwd(), ".env");
+      const dotenvPath = path22.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       let processEnv = process.env;
       if (options && options.processEnv != null) {
@@ -314,13 +314,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path22 of optionPaths) {
+      for (const path23 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path22, { encoding }));
+          const parsed = DotenvModule.parse(fs3.readFileSync(path23, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path22} ${e.message}`);
+            _debug(`Failed to load ${path23} ${e.message}`);
           }
           lastError = e;
         }
@@ -333,7 +333,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative4 = path21.relative(process.cwd(), filePath);
+            const relative4 = path22.relative(process.cwd(), filePath);
             shortPaths.push(relative4);
           } catch (e) {
             if (debug) {
@@ -8237,8 +8237,8 @@ var require_MODULE_LOAD = __commonJS({
        * @param moduleArguments - Optional arguments to pass to the module
        * @see https://redis.io/commands/module-load/
        */
-      parseCommand(parser, path21, moduleArguments) {
-        parser.push("MODULE", "LOAD", path21);
+      parseCommand(parser, path22, moduleArguments) {
+        parser.push("MODULE", "LOAD", path22);
         if (moduleArguments) {
           parser.push(...moduleArguments);
         }
@@ -23539,10 +23539,10 @@ var require_ARRAPPEND = __commonJS({
        * @param json - The first value to append
        * @param jsons - Additional values to append
        */
-      parseCommand(parser, key, path21, json, ...jsons) {
+      parseCommand(parser, key, path22, json, ...jsons) {
         parser.push("JSON.ARRAPPEND");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path22, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         for (let i = 0; i < jsons.length; i++) {
           parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
         }
@@ -23572,10 +23572,10 @@ var require_ARRINDEX = __commonJS({
        * @param options.range.start - Starting index for the search
        * @param options.range.stop - Optional ending index for the search
        */
-      parseCommand(parser, key, path21, json, options) {
+      parseCommand(parser, key, path22, json, options) {
         parser.push("JSON.ARRINDEX");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path22, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         if (options?.range) {
           parser.push(options.range.start.toString());
           if (options.range.stop !== void 0) {
@@ -23607,10 +23607,10 @@ var require_ARRINSERT = __commonJS({
        * @param json - The first value to insert
        * @param jsons - Additional values to insert
        */
-      parseCommand(parser, key, path21, index, json, ...jsons) {
+      parseCommand(parser, key, path22, index, json, ...jsons) {
         parser.push("JSON.ARRINSERT");
         parser.pushKey(key);
-        parser.push(path21, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path22, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
         for (let i = 0; i < jsons.length; i++) {
           parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
         }
@@ -23700,10 +23700,10 @@ var require_ARRTRIM = __commonJS({
        * @param start - Starting index (inclusive)
        * @param stop - Ending index (inclusive)
        */
-      parseCommand(parser, key, path21, start, stop) {
+      parseCommand(parser, key, path22, start, stop) {
         parser.push("JSON.ARRTRIM");
         parser.pushKey(key);
-        parser.push(path21, start.toString(), stop.toString());
+        parser.push(path22, start.toString(), stop.toString());
       },
       transformReply: void 0
     };
@@ -23868,10 +23868,10 @@ var require_MERGE3 = __commonJS({
        * @param path - Path to merge into
        * @param value - JSON value to merge
        */
-      parseCommand(parser, key, path21, value) {
+      parseCommand(parser, key, path22, value) {
         parser.push("JSON.MERGE");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(value));
+        parser.push(path22, (0, generic_transformers_1.transformRedisJsonArgument)(value));
       },
       transformReply: void 0
     };
@@ -23894,10 +23894,10 @@ var require_MGET2 = __commonJS({
        * @param keys - Array of keys containing JSON documents
        * @param path - Path to retrieve from each document
        */
-      parseCommand(parser, keys, path21) {
+      parseCommand(parser, keys, path22) {
         parser.push("JSON.MGET");
         parser.pushKeys(keys);
-        parser.push(path21);
+        parser.push(path22);
       },
       transformReply(reply) {
         return reply.map((json) => (0, generic_transformers_1.transformRedisJsonNullReply)(json));
@@ -23952,10 +23952,10 @@ var require_NUMINCRBY = __commonJS({
        * @param path - Path to the numeric value
        * @param by - Amount to increment by
        */
-      parseCommand(parser, key, path21, by) {
+      parseCommand(parser, key, path22, by) {
         parser.push("JSON.NUMINCRBY");
         parser.pushKey(key);
-        parser.push(path21, by.toString());
+        parser.push(path22, by.toString());
       },
       transformReply: {
         2: (reply) => {
@@ -23987,10 +23987,10 @@ var require_NUMMULTBY = __commonJS({
        * @param path - Path to the numeric value
        * @param by - Amount to multiply by
        */
-      parseCommand(parser, key, path21, by) {
+      parseCommand(parser, key, path22, by) {
         parser.push("JSON.NUMMULTBY");
         parser.pushKey(key);
-        parser.push(path21, by.toString());
+        parser.push(path22, by.toString());
       },
       transformReply: NUMINCRBY_1.default.transformReply
     };
@@ -24074,10 +24074,10 @@ var require_SET2 = __commonJS({
        * @deprecated options.NX - Use options.condition instead
        * @deprecated options.XX - Use options.condition instead
        */
-      parseCommand(parser, key, path21, json, options) {
+      parseCommand(parser, key, path22, json, options) {
         parser.push("JSON.SET");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path22, (0, generic_transformers_1.transformRedisJsonArgument)(json));
         if (options?.condition) {
           parser.push(options?.condition);
         } else if (options?.NX) {
@@ -24165,10 +24165,10 @@ var require_TOGGLE = __commonJS({
        * @param key - The key containing the JSON document
        * @param path - Path to the boolean value
        */
-      parseCommand(parser, key, path21) {
+      parseCommand(parser, key, path22) {
         parser.push("JSON.TOGGLE");
         parser.pushKey(key);
-        parser.push(path21);
+        parser.push(path22);
       },
       transformReply: void 0
     };
@@ -30242,7 +30242,7 @@ function printHelp() {
 `);
 }
 function printVersion() {
-  console.log(`duclaw-cli v${true ? "1.9.11" : "unknown"}`);
+  console.log(`duclaw-cli v${true ? "1.9.12" : "unknown"}`);
 }
 function getDuclawTemplate() {
   return {
@@ -31633,7 +31633,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises3.lstat : import_promises3.stat;
     if (wantBigintFsStats) {
-      this._stat = (path21) => statMethod(path21, { bigint: true });
+      this._stat = (path22) => statMethod(path22, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -31658,8 +31658,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path21, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path21));
+          const { path: path22, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path22));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -31699,20 +31699,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path21, depth) {
+  async _exploreDir(path22, depth) {
     let files;
     try {
-      files = await (0, import_promises3.readdir)(path21, this._rdOptions);
+      files = await (0, import_promises3.readdir)(path22, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path21 };
+    return { files, depth, path: path22 };
   }
-  async _formatEntry(dirent, path21) {
+  async _formatEntry(dirent, path22) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path4.resolve)((0, import_node_path4.join)(path21, basename4));
+      const fullPath = (0, import_node_path4.resolve)((0, import_node_path4.join)(path22, basename4));
       entry = { path: (0, import_node_path4.relative)(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -32112,16 +32112,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path21, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path22, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path21);
-    emitRaw(rawEvent, evPath, { watchedPath: path21 });
-    if (evPath && path21 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path21, evPath), KEY_LISTENERS, sp.join(path21, evPath));
+    listener(path22);
+    emitRaw(rawEvent, evPath, { watchedPath: path22 });
+    if (evPath && path22 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path22, evPath), KEY_LISTENERS, sp.join(path22, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path21, {
+    return (0, import_node_fs.watch)(path22, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -32137,12 +32137,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path21, fullPath, options, handlers) => {
+var setFsWatchListener = (path22, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path21, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path22, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -32153,7 +32153,7 @@ var setFsWatchListener = (path21, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path21,
+      path22,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -32168,7 +32168,7 @@ var setFsWatchListener = (path21, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises4.open)(path21, "r");
+          const fd = await (0, import_promises4.open)(path22, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -32199,7 +32199,7 @@ var setFsWatchListener = (path21, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path21, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path22, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -32221,7 +32221,7 @@ var setFsWatchFileListener = (path21, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path21, curr));
+          foreach(cont.listeners, (listener2) => listener2(path22, curr));
         }
       })
     };
@@ -32251,13 +32251,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path21, listener) {
+  _watchWithNodeFs(path22, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path21);
-    const basename4 = sp.basename(path21);
+    const directory = sp.dirname(path22);
+    const basename4 = sp.basename(path22);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path21);
+    const absolutePath = sp.resolve(path22);
     const options = {
       persistent: opts.persistent
     };
@@ -32267,12 +32267,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path21, absolutePath, options, {
+      closer = setFsWatchFileListener(path22, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path21, absolutePath, options, {
+      closer = setFsWatchListener(path22, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -32294,7 +32294,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path21, newStats) => {
+    const listener = async (path22, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -32308,11 +32308,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path21);
+            this.fsw._closeFile(path22);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path21, closer2);
+              this.fsw._addPathCloser(path22, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -32344,7 +32344,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path21, item) {
+  async _handleSymlink(entry, directory, path22, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -32354,7 +32354,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises4.realpath)(path21);
+        linkPath = await (0, import_promises4.realpath)(path22);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -32364,12 +32364,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path21, entry.stats);
+          this.fsw._emit(EV.CHANGE, path22, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path21, entry.stats);
+        this.fsw._emit(EV.ADD, path22, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -32399,9 +32399,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path21 = sp.join(directory, item);
+      let path22 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path21, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path22, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -32410,8 +32410,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path21 = sp.join(dir, sp.relative(dir, path21));
-        this._addToNodeFs(path21, initialAdd, wh, depth + 1);
+        path22 = sp.join(dir, sp.relative(dir, path22));
+        this._addToNodeFs(path22, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve11, reject) => {
@@ -32480,13 +32480,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path21, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path22, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path21) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path22) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path21);
+    const wh = this.fsw._getWatchHelpers(path22);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -32502,8 +32502,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path21);
-        const targetPath = follow ? await (0, import_promises4.realpath)(path21) : path21;
+        const absPath = sp.resolve(path22);
+        const targetPath = follow ? await (0, import_promises4.realpath)(path22) : path22;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -32513,29 +32513,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises4.realpath)(path21) : path21;
+        const targetPath = follow ? await (0, import_promises4.realpath)(path22) : path22;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path21, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path22, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path21), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path22), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path21, closer);
+        this.fsw._addPathCloser(path22, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path21;
+        return path22;
       }
     }
   }
@@ -32578,24 +32578,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path21) {
-  if (typeof path21 !== "string")
+function normalizePath(path22) {
+  if (typeof path22 !== "string")
     throw new Error("string expected");
-  path21 = sp2.normalize(path21);
-  path21 = path21.replace(/\\/g, "/");
+  path22 = sp2.normalize(path22);
+  path22 = path22.replace(/\\/g, "/");
   let prepend = false;
-  if (path21.startsWith("//"))
+  if (path22.startsWith("//"))
     prepend = true;
-  path21 = path21.replace(DOUBLE_SLASH_RE, "/");
+  path22 = path22.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path21 = "/" + path21;
-  return path21;
+    path22 = "/" + path22;
+  return path22;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path21 = normalizePath(testString);
+  const path22 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path21, stats)) {
+    if (pattern(path22, stats)) {
       return true;
     }
   }
@@ -32633,19 +32633,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path21) => toUnix(sp2.normalize(toUnix(path21)));
-var normalizeIgnored = (cwd = "") => (path21) => {
-  if (typeof path21 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path21) ? path21 : sp2.join(cwd, path21));
+var normalizePathToUnix = (path22) => toUnix(sp2.normalize(toUnix(path22)));
+var normalizeIgnored = (cwd = "") => (path22) => {
+  if (typeof path22 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path22) ? path22 : sp2.join(cwd, path22));
   } else {
-    return path21;
+    return path22;
   }
 };
-var getAbsolutePath = (path21, cwd) => {
-  if (sp2.isAbsolute(path21)) {
-    return path21;
+var getAbsolutePath = (path22, cwd) => {
+  if (sp2.isAbsolute(path22)) {
+    return path22;
   }
-  return sp2.join(cwd, path21);
+  return sp2.join(cwd, path22);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -32710,10 +32710,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path21, follow, fsw) {
+  constructor(path22, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path21;
-    this.path = path21 = path21.replace(REPLACER_RE, "");
+    const watchPath = path22;
+    this.path = path22 = path22.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -32853,20 +32853,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path21) => {
-        const absPath = getAbsolutePath(path21, cwd);
+      paths = paths.map((path22) => {
+        const absPath = getAbsolutePath(path22, cwd);
         return absPath;
       });
     }
-    paths.forEach((path21) => {
-      this._removeIgnoredPath(path21);
+    paths.forEach((path22) => {
+      this._removeIgnoredPath(path22);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path21) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path21, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path22) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path22, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -32888,17 +32888,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path21) => {
-      if (!sp2.isAbsolute(path21) && !this._closers.has(path21)) {
+    paths.forEach((path22) => {
+      if (!sp2.isAbsolute(path22) && !this._closers.has(path22)) {
         if (cwd)
-          path21 = sp2.join(cwd, path21);
-        path21 = sp2.resolve(path21);
+          path22 = sp2.join(cwd, path22);
+        path22 = sp2.resolve(path22);
       }
-      this._closePath(path21);
-      this._addIgnoredPath(path21);
-      if (this._watched.has(path21)) {
+      this._closePath(path22);
+      this._addIgnoredPath(path22);
+      if (this._watched.has(path22)) {
         this._addIgnoredPath({
-          path: path21,
+          path: path22,
           recursive: true
         });
       }
@@ -32962,38 +32962,38 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path21, stats) {
+  async _emit(event, path22, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path21 = sp2.normalize(path21);
+      path22 = sp2.normalize(path22);
     if (opts.cwd)
-      path21 = sp2.relative(opts.cwd, path21);
-    const args = [path21];
+      path22 = sp2.relative(opts.cwd, path22);
+    const args = [path22];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path21))) {
+    if (awf && (pw = this._pendingWrites.get(path22))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path21, [event, ...args]);
+        this._pendingUnlinks.set(path22, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path22) => {
+          this._pendingUnlinks.forEach((entry, path23) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path22);
+            this._pendingUnlinks.delete(path23);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path21)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path22)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path21);
+        this._pendingUnlinks.delete(path22);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -33011,16 +33011,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path21, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path22, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path21, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path22, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path21) : path21;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path22) : path22;
       let stats2;
       try {
         stats2 = await (0, import_promises5.stat)(fullPath);
@@ -33051,23 +33051,23 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path21, timeout) {
+  _throttle(actionType, path22, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path21);
+    const actionPath = action.get(path22);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path21);
+      const item = action.get(path22);
       const count = item ? item.count : 0;
-      action.delete(path21);
+      action.delete(path22);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -33075,7 +33075,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path21, thr);
+    action.set(path22, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -33089,44 +33089,44 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path21, threshold, event, awfEmit) {
+  _awaitWriteFinish(path22, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path21;
-    if (this.options.cwd && !sp2.isAbsolute(path21)) {
-      fullPath = sp2.join(this.options.cwd, path21);
+    let fullPath = path22;
+    if (this.options.cwd && !sp2.isAbsolute(path22)) {
+      fullPath = sp2.join(this.options.cwd, path22);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path21)) {
+        if (err || !writes.has(path22)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path21).lastChange = now2;
+          writes.get(path22).lastChange = now2;
         }
-        const pw = writes.get(path21);
+        const pw = writes.get(path22);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path21);
+          writes.delete(path22);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path21)) {
-      writes.set(path21, {
+    if (!writes.has(path22)) {
+      writes.set(path22, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path21);
+          writes.delete(path22);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -33137,8 +33137,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path21, stats) {
-    if (this.options.atomic && DOT_RE.test(path21))
+  _isIgnored(path22, stats) {
+    if (this.options.atomic && DOT_RE.test(path22))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -33148,17 +33148,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path21, stats);
+    return this._userIgnored(path22, stats);
   }
-  _isntIgnored(path21, stat11) {
-    return !this._isIgnored(path21, stat11);
+  _isntIgnored(path22, stat11) {
+    return !this._isIgnored(path22, stat11);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path21) {
-    return new WatchHelper(path21, this.options.followSymlinks, this);
+  _getWatchHelpers(path22) {
+    return new WatchHelper(path22, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -33190,63 +33190,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path21 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path21);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path21) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path21, 100))
+    const path22 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path22);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path22) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path22, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path21);
+    const wp = this._getWatchedDir(path22);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path21, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path22, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path21;
+    let relPath = path22;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path21);
+      relPath = sp2.relative(this.options.cwd, path22);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path21);
+    this._watched.delete(path22);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path21))
-      this._emit(eventName, path21);
-    this._closePath(path21);
+    if (wasTracked && !this._isIgnored(path22))
+      this._emit(eventName, path22);
+    this._closePath(path22);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path21) {
-    this._closeFile(path21);
-    const dir = sp2.dirname(path21);
-    this._getWatchedDir(dir).remove(sp2.basename(path21));
+  _closePath(path22) {
+    this._closeFile(path22);
+    const dir = sp2.dirname(path22);
+    this._getWatchedDir(dir).remove(sp2.basename(path22));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path21) {
-    const closers = this._closers.get(path21);
+  _closeFile(path22) {
+    const closers = this._closers.get(path22);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path21);
+    this._closers.delete(path22);
   }
-  _addPathCloser(path21, closer) {
+  _addPathCloser(path22, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path21);
+    let list = this._closers.get(path22);
     if (!list) {
       list = [];
-      this._closers.set(path21, list);
+      this._closers.set(path22, list);
     }
     list.push(closer);
   }
@@ -34710,12 +34710,12 @@ function encodeURIPath(str) {
   return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
 var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-var createPathTagFunction = (pathEncoder = encodeURIPath) => function path21(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path22(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path22 = statics.reduce((previousValue, currentValue, index) => {
+  const path23 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -34732,7 +34732,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path21(sta
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path22.split(/[?#]/, 1)[0];
+  const pathOnly = path23.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match2;
   while ((match2 = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -34753,10 +34753,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path21(sta
     }, "");
     throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path22}
+${path23}
 ${underline}`);
   }
-  return path22;
+  return path23;
 };
 var path5 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -37867,9 +37867,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error, message, headers) {
     return APIError.generate(status, error, message, headers);
   }
-  buildURL(path21, query, defaultBaseURL) {
+  buildURL(path22, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path21) ? new URL(path21) : new URL(baseURL + (baseURL.endsWith("/") && path21.startsWith("/") ? path21.slice(1) : path21));
+    const url = isAbsoluteURL(path22) ? new URL(path22) : new URL(baseURL + (baseURL.endsWith("/") && path22.startsWith("/") ? path22.slice(1) : path22));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -37900,24 +37900,24 @@ var BaseAnthropic = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path21, opts) {
-    return this.methodRequest("get", path21, opts);
+  get(path22, opts) {
+    return this.methodRequest("get", path22, opts);
   }
-  post(path21, opts) {
-    return this.methodRequest("post", path21, opts);
+  post(path22, opts) {
+    return this.methodRequest("post", path22, opts);
   }
-  patch(path21, opts) {
-    return this.methodRequest("patch", path21, opts);
+  patch(path22, opts) {
+    return this.methodRequest("patch", path22, opts);
   }
-  put(path21, opts) {
-    return this.methodRequest("put", path21, opts);
+  put(path22, opts) {
+    return this.methodRequest("put", path22, opts);
   }
-  delete(path21, opts) {
-    return this.methodRequest("delete", path21, opts);
+  delete(path22, opts) {
+    return this.methodRequest("delete", path22, opts);
   }
-  methodRequest(method, path21, opts) {
+  methodRequest(method, path22, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path21, ...opts2 };
+      return { method, path: path22, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -38021,8 +38021,8 @@ var BaseAnthropic = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime: startTime2 };
   }
-  getAPIList(path21, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path21, ...opts2 })) : { method: "get", path: path21, ...opts });
+  getAPIList(path22, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path22, ...opts2 })) : { method: "get", path: path22, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -38110,8 +38110,8 @@ var BaseAnthropic = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path21, query, defaultBaseURL } = options;
-    const url = this.buildURL(path21, query, defaultBaseURL);
+    const { method, path: path22, query, defaultBaseURL } = options;
+    const url = this.buildURL(path22, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -40321,16 +40321,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path21, added, removed, oldPosInc, options) {
-    const last = path21.lastComponent;
+  addToPath(path22, added, removed, oldPosInc, options) {
+    const last = path22.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path21.oldPos + oldPosInc,
+        oldPos: path22.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path21.oldPos + oldPosInc,
+        oldPos: path22.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -41781,6 +41781,196 @@ var imageUnderstand = {
   }
 };
 
+// src/tools/tools/ImageGenerate.ts
+var import_promises12 = require("node:fs/promises");
+var import_node_path12 = __toESM(require("node:path"));
+var DEFAULT_BASE_URL = "https://direct.shanyiapi.com";
+var DEFAULT_MODEL = "gpt-image-2";
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([403, 429, 500, 502, 503, 504, 524]);
+var MAX_RETRIES = 3;
+var RETRY_BACKOFF_BASE_MS = 5e3;
+var DESCRIPTION15 = `
+Generate images with the platform-configured Shanyi/NewAPI image provider.
+
+Use this when the user asks to create, draw, render, or generate a new image. The tool uses the runtime's SHANYI_API_KEY from the platform environment; never ask the user for this key.
+
+The tool saves generated images to local files and returns filePath/fileName values. After a successful generation, call send_file with the returned filePath and fileName to deliver the image to the user.
+`;
+function sanitizeName(value, fallback = "image") {
+  const cleaned = value.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-._]+|[-._]+$/g, "");
+  return cleaned.slice(0, 80) || fallback;
+}
+function extensionFromContentType(contentType) {
+  const normalized = (contentType || "").toLowerCase();
+  if (normalized.includes("image/jpeg") || normalized.includes("image/jpg")) return ".jpg";
+  if (normalized.includes("image/png")) return ".png";
+  if (normalized.includes("image/webp")) return ".webp";
+  if (normalized.includes("image/gif")) return ".gif";
+  return ".png";
+}
+function extensionFromUrl(url) {
+  try {
+    const ext = import_node_path12.default.extname(new URL(url).pathname).toLowerCase();
+    if ([".png", ".jpg", ".jpeg", ".webp", ".gif"].includes(ext)) return ext;
+  } catch {
+    return "";
+  }
+  return "";
+}
+async function sleep2(ms) {
+  await new Promise((resolve11) => setTimeout(resolve11, ms));
+}
+async function requestImageGeneration(url, apiKey, payload, timeoutMs) {
+  let lastError;
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    const response = await fetch(url, {
+      method: "POST",
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    }).catch((error) => {
+      throw new Error(`image_generation_network_error:${error instanceof Error ? error.message : String(error)}`);
+    });
+    const requestId = response.headers.get("x-oneapi-request-id") ?? void 0;
+    const raw2 = await response.text();
+    if (!response.ok) {
+      lastError = new Error(`image_generation_http_${response.status}: request_id=${requestId ?? "unknown"} body=${raw2.slice(0, 1e3)}`);
+      if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < MAX_RETRIES) {
+        await sleep2(RETRY_BACKOFF_BASE_MS * attempt);
+        continue;
+      }
+      throw lastError;
+    }
+    try {
+      return {
+        data: JSON.parse(raw2),
+        requestId
+      };
+    } catch {
+      throw new Error(`image_generation_invalid_json: request_id=${requestId ?? "unknown"}`);
+    }
+  }
+  throw lastError ?? new Error("image_generation_failed");
+}
+async function downloadImage(url, timeoutMs) {
+  const response = await fetch(url, {
+    method: "GET",
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`image_download_failed:${response.status}`);
+  }
+  const contentType = response.headers.get("content-type");
+  const extension = extensionFromUrl(url) || extensionFromContentType(contentType);
+  return {
+    buffer: Buffer.from(await response.arrayBuffer()),
+    extension
+  };
+}
+function decodeBase64Image(data) {
+  const match2 = data.match(/^data:(image\/[^;]+);base64,(.+)$/);
+  if (match2) {
+    return {
+      buffer: Buffer.from(match2[2], "base64"),
+      extension: extensionFromContentType(match2[1])
+    };
+  }
+  return {
+    buffer: Buffer.from(data, "base64"),
+    extension: ".png"
+  };
+}
+var imageGenerate = {
+  name: "image_generate",
+  description: DESCRIPTION15,
+  input_schema: {
+    type: "object",
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Image prompt. Preserve important user constraints and avoid adding unrelated subjects."
+      },
+      size: {
+        type: "string",
+        description: "Pixel size or aspect ratio. Common values: 1024x1024, 1:1, 16:9, 9:16.",
+        default: "1024x1024"
+      },
+      resolution: {
+        type: "string",
+        description: "Optional resolution tier for ratio-style sizes, such as 1k, 2k, or 4k."
+      },
+      model: {
+        type: "string",
+        description: "Image model. Defaults to SHANYI_IMAGE_MODEL or gpt-image-2.",
+        default: DEFAULT_MODEL
+      },
+      n: {
+        type: "number",
+        description: "Number of image variants to generate. Defaults to 1.",
+        default: 1
+      },
+      filenameStem: {
+        type: "string",
+        description: "Optional filename stem for saved images."
+      }
+    },
+    required: ["prompt"]
+  },
+  async execute(input, userRequest) {
+    const apiKey = process.env.SHANYI_API_KEY;
+    if (!apiKey) {
+      return "\u56FE\u7247\u751F\u6210\u670D\u52A1\u672A\u914D\u7F6E\uFF1A\u7F3A\u5C11 SHANYI_API_KEY\u3002\u8BF7\u5728 control-plane \u73AF\u5883\u53D8\u91CF\u4E2D\u914D\u7F6E\u540E\u91CD\u542F/\u91CD\u65B0\u6CE8\u5165 runtime\u3002";
+    }
+    const prompt = String(input.prompt ?? "").trim();
+    if (!prompt) return "\u9519\u8BEF\uFF1Aprompt \u4E0D\u80FD\u4E3A\u7A7A";
+    const baseUrl = (process.env.SHANYI_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    const model = String(input.model || process.env.SHANYI_IMAGE_MODEL || DEFAULT_MODEL);
+    const size = String(input.size || "1024x1024");
+    const n = Number.isFinite(Number(input.n)) ? Math.max(1, Math.min(4, Number(input.n))) : 1;
+    const timeoutMs = 18e4;
+    const payload = { model, prompt, n, size };
+    if (input.resolution) payload.resolution = String(input.resolution);
+    const started = Date.now();
+    const generated = await requestImageGeneration(`${baseUrl}/v1/images/generations`, apiKey, payload, timeoutMs);
+    const items = generated.data.data ?? [];
+    if (items.length === 0) {
+      return JSON.stringify({
+        ok: false,
+        error: "image_generation_empty_response",
+        requestId: generated.requestId
+      }, null, 2);
+    }
+    const outDir = import_node_path12.default.join(getEffectiveCwd(userRequest), "imagegen");
+    await (0, import_promises12.mkdir)(outDir, { recursive: true });
+    const stem = sanitizeName(String(input.filenameStem || prompt));
+    const savedFiles = [];
+    for (let index = 0; index < items.length; index++) {
+      const item = items[index];
+      const image = item.url ? await downloadImage(item.url, timeoutMs) : item.b64_json ? decodeBase64Image(item.b64_json) : null;
+      if (!image) continue;
+      const fileName = `${stem}-${index + 1}${image.extension}`;
+      const filePath = import_node_path12.default.join(outDir, fileName);
+      await (0, import_promises12.writeFile)(filePath, image.buffer);
+      savedFiles.push({ filePath, fileName });
+    }
+    return JSON.stringify({
+      ok: savedFiles.length > 0,
+      savedFiles,
+      filePath: savedFiles[0]?.filePath,
+      fileName: savedFiles[0]?.fileName,
+      model,
+      size,
+      resolution: payload.resolution,
+      requestId: generated.requestId,
+      elapsedSeconds: Number(((Date.now() - started) / 1e3).toFixed(3)),
+      nextStep: "Call send_file with filePath and fileName to deliver the generated image."
+    }, null, 2);
+  }
+};
+
 // src/skill/SkillRegistry.ts
 var import_fs11 = require("fs");
 var import_os3 = require("os");
@@ -41957,7 +42147,7 @@ var getSkillDetail = (skillName) => {
 };
 
 // src/tools/tools/Skill.ts
-var DESCRIPTION15 = `
+var DESCRIPTION16 = `
 Execute a skill within the main conversation
 
 <skills_instructions>
@@ -41984,7 +42174,7 @@ ${getSkillMeta()}
 `;
 var skillTool = {
   name: `skill`,
-  description: DESCRIPTION15,
+  description: DESCRIPTION16,
   input_schema: {
     type: `object`,
     properties: {
@@ -42050,12 +42240,12 @@ var goalCreate = {
 };
 
 // src/tools/tools/tasks/GoalGet.ts
-var DESCRIPTION16 = `
+var DESCRIPTION17 = `
     \u83B7\u53D6\u4EFB\u52A1\u7CFB\u7EDF\u4E2D\u6307\u5B9A\u7684Goal
 `;
 var goalGet = {
   name: `goal_get`,
-  description: DESCRIPTION16,
+  description: DESCRIPTION17,
   input_schema: {
     type: `object`,
     properties: {
@@ -42086,12 +42276,12 @@ var goalGet = {
 };
 
 // src/tools/tools/tasks/GoalList.ts
-var DESCRIPTION17 = `
+var DESCRIPTION18 = `
     \u5728\u4EFB\u52A1\u7CFB\u7EDF\u4E2D\u5217\u51FA\u6240\u6709\u76EE\u6807
 `;
 var goalList = {
   name: `goal_list`,
-  description: DESCRIPTION17,
+  description: DESCRIPTION18,
   input_schema: {
     type: `object`,
     properties: {}
@@ -42106,7 +42296,7 @@ var goalList = {
 };
 
 // src/tools/tools/tasks/GoalUpdate.ts
-var DESCRIPTION18 = `
+var DESCRIPTION19 = `
 \u66F4\u65B0\u4EFB\u52A1\u7CFB\u7EDF\u4E2D\u6307\u5B9A\u7684Goal
 
 \u5DE5\u5177\u4F7F\u7528\u89C4\u5219:
@@ -42115,7 +42305,7 @@ var DESCRIPTION18 = `
 `;
 var goalUpdate = {
   name: `goal_update`,
-  description: DESCRIPTION18,
+  description: DESCRIPTION19,
   input_schema: {
     type: `object`,
     properties: {
@@ -42172,7 +42362,7 @@ var goalUpdate = {
 };
 
 // src/tools/tools/tasks/GoalDelete.ts
-var DESCRIPTION19 = `
+var DESCRIPTION20 = `
 \u5220\u9664\u4EFB\u52A1\u7CFB\u7EDF\u4E2D\u6307\u5B9A\u7684Goal\u53CA\u5176\u5BF9\u5E94\u7684JSON\u6587\u4EF6
 
 \u5DE5\u5177\u4F7F\u7528\u89C4\u5219:
@@ -42181,7 +42371,7 @@ var DESCRIPTION19 = `
 `;
 var goalDelete = {
   name: `goal_delete`,
-  description: DESCRIPTION19,
+  description: DESCRIPTION20,
   input_schema: {
     type: `object`,
     properties: {
@@ -43212,7 +43402,7 @@ var updateMailboxMessageStatus = (messageId, nextStatus, options) => {
 };
 
 // src/tools/tools/department/DepartmentCreate.ts
-var DESCRIPTION20 = `
+var DESCRIPTION21 = `
 \u521B\u5EFA\u90E8\u95E8\u3002Department \u662F\u516C\u53F8\u7EC4\u7EC7\u4E2D\u7684\u957F\u671F\u804C\u8D23\u5355\u5143\uFF0C\u4E0D\u662F\u4E00\u6B21\u6027\u9879\u76EE\u5C0F\u961F\u3002
 
 \u5DE5\u5177\u8C03\u7528\u89C4\u5219\uFF1A
@@ -43222,7 +43412,7 @@ var DESCRIPTION20 = `
 `;
 var departmentCreate = {
   name: `department_create`,
-  description: DESCRIPTION20,
+  description: DESCRIPTION21,
   input_schema: {
     type: `object`,
     properties: {
@@ -43303,7 +43493,7 @@ var getActiveMailboxContext = (actorMailboxId, messageId) => {
   ).get(messageId, actorMailboxId, actorMailboxId);
   return row ?? null;
 };
-var DESCRIPTION21 = `
+var DESCRIPTION22 = `
 \u5411\u90E8\u95E8\u6210\u5458\u53D1\u9001\u6D88\u606F\u6216\u6307\u4EE4\uFF0C\u662F\u516C\u53F8\u5185\u90E8\u5F02\u6B65\u534F\u4F5C\u901A\u4FE1\u6E20\u9053\u3002
 
 \u9ED8\u8BA4\u7EC4\u7EC7\u6CBB\u7406\uFF1A
@@ -43319,7 +43509,7 @@ var DESCRIPTION21 = `
 `;
 var departmentCommunicate = {
   name: `department_communicate`,
-  description: DESCRIPTION21,
+  description: DESCRIPTION22,
   input_schema: {
     type: `object`,
     properties: {
@@ -43428,7 +43618,7 @@ var departmentCommunicate = {
 };
 
 // src/tools/tools/department/DepartmentDelete.ts
-var DESCRIPTION22 = `
+var DESCRIPTION23 = `
 \u5220\u9664\u90E8\u95E8\u3002
 
 \u5DE5\u5177\u8C03\u7528\u89C4\u5219\uFF1A
@@ -43438,7 +43628,7 @@ var DESCRIPTION22 = `
 `;
 var departmentDelete = {
   name: `department_delete`,
-  description: DESCRIPTION22,
+  description: DESCRIPTION23,
   input_schema: {
     type: `object`,
     properties: {
@@ -43478,7 +43668,7 @@ var departmentDelete = {
 };
 
 // src/tools/tools/department/DepartmentList.ts
-var DESCRIPTION23 = `
+var DESCRIPTION24 = `
 \u5217\u51FA\u6240\u6709\u90E8\u95E8\u3002\u8BE5\u5DE5\u5177\u9762\u5411 CEO\uFF0C\u53EA\u8FD4\u56DE\u90E8\u95E8\u4E0E Department Head \u4FE1\u606F\uFF0C\u4E0D\u66B4\u9732 Executor \u660E\u7EC6\u3002
 
 \u5DE5\u5177\u8C03\u7528\u89C4\u5219\uFF1A
@@ -43487,7 +43677,7 @@ var DESCRIPTION23 = `
 `;
 var departmentList = {
   name: `department_list`,
-  description: DESCRIPTION23,
+  description: DESCRIPTION24,
   input_schema: {
     type: `object`,
     properties: {},
@@ -43522,7 +43712,7 @@ var departmentList = {
 
 // src/tools/tools/department/DepartmentMemberCreate.ts
 var import_node_crypto9 = require("node:crypto");
-var DESCRIPTION24 = `
+var DESCRIPTION25 = `
 \u521B\u5EFA\u90E8\u95E8\u6210\u5458\u3002
 
 \u7BA1\u7406\u6743\u9650\uFF1A
@@ -43532,7 +43722,7 @@ var DESCRIPTION24 = `
 `;
 var departmentMemberCreate = {
   name: `department_member_create`,
-  description: DESCRIPTION24,
+  description: DESCRIPTION25,
   input_schema: {
     type: `object`,
     properties: {
@@ -43605,7 +43795,7 @@ var departmentMemberCreate = {
 };
 
 // src/tools/tools/department/DepartmentMemberDelete.ts
-var DESCRIPTION25 = `
+var DESCRIPTION26 = `
 \u5220\u9664\u90E8\u95E8\u6210\u5458\u3002
 
 \u5DE5\u5177\u8C03\u7528\u89C4\u5219\uFF1A
@@ -43615,7 +43805,7 @@ var DESCRIPTION25 = `
 `;
 var departmentMemberDelete = {
   name: `department_member_delete`,
-  description: DESCRIPTION25,
+  description: DESCRIPTION26,
   input_schema: {
     type: `object`,
     properties: {
@@ -43660,7 +43850,7 @@ var departmentMemberDelete = {
 };
 
 // src/tools/tools/department/DepartmentMemberList.ts
-var DESCRIPTION26 = `
+var DESCRIPTION27 = `
 \u67E5\u770B\u5F53\u524D Department Head \u6240\u5C5E\u90E8\u95E8\u7684\u6210\u5458\u76EE\u5F55\u3002
 
 \u4F7F\u7528\u8FB9\u754C\uFF1A
@@ -43670,7 +43860,7 @@ var DESCRIPTION26 = `
 `;
 var departmentMemberList = {
   name: `department_member_list`,
-  description: DESCRIPTION26,
+  description: DESCRIPTION27,
   input_schema: {
     type: `object`,
     properties: {},
@@ -43705,14 +43895,14 @@ var departmentMemberList = {
 };
 
 // src/tools/tools/department/CheckDepartmentReplies.ts
-var DESCRIPTION27 = `
+var DESCRIPTION28 = `
 \u67E5\u770B Department Head \u6216\u90E8\u95E8\u6210\u5458\u53D1\u7ED9 CEO \u7684\u5DE5\u4F5C\u56DE\u590D\u3002
 
 \u5F53 CEO \u5411 Department Head \u6D3E\u53D1\u4EFB\u52A1\u540E\uFF0C\u5BF9\u65B9\u5B8C\u6210\u5DE5\u4F5C\u4F1A\u901A\u8FC7 mailbox \u56DE\u4FE1\u3002\u4F7F\u7528\u6B64\u5DE5\u5177\u53EF\u4EE5\u67E5\u770B\u672A\u8BFB\u7684\u90E8\u95E8\u56DE\u4FE1\u5185\u5BB9\uFF0C\u4E86\u89E3\u5DE5\u4F5C\u8FDB\u5C55\u548C\u6210\u679C\u3002
 `;
 var checkDepartmentReplies = {
   name: `check_department_replies`,
-  description: DESCRIPTION27,
+  description: DESCRIPTION28,
   input_schema: {
     type: `object`,
     properties: {
@@ -43778,12 +43968,12 @@ ${replies}`;
 
 // src/department/learning.ts
 var import_node_fs4 = require("node:fs");
-var import_node_path13 = __toESM(require("node:path"));
+var import_node_path14 = __toESM(require("node:path"));
 var import_node_crypto10 = require("node:crypto");
 
 // src/skill/SkillValidator.ts
 var import_node_fs3 = require("node:fs");
-var import_node_path12 = __toESM(require("node:path"));
+var import_node_path13 = __toESM(require("node:path"));
 var SKILL_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 var REQUIRED_SECTIONS = [
   /(^|\n)##\s+(when to use|何时使用|trigger|triggers)\b/i,
@@ -43809,9 +43999,9 @@ var assertSafeSkillTarget = (rootDir, skillName) => {
   if (!isValidSkillName(skillName)) {
     throw new Error(`Invalid skill name "${skillName}". Use lowercase letters, digits, and single hyphens only.`);
   }
-  const root = import_node_path12.default.resolve(rootDir);
-  const target = import_node_path12.default.resolve(root, skillName);
-  if (target !== import_node_path12.default.join(root, skillName) || !target.startsWith(root + import_node_path12.default.sep)) {
+  const root = import_node_path13.default.resolve(rootDir);
+  const target = import_node_path13.default.resolve(root, skillName);
+  if (target !== import_node_path13.default.join(root, skillName) || !target.startsWith(root + import_node_path13.default.sep)) {
     throw new Error(`Invalid skill install target for "${skillName}".`);
   }
   return target;
@@ -43884,12 +44074,12 @@ var validateSkillDocument = (input) => {
     }
   }
   if (input.baseDir) {
-    const normalizedBase = import_node_path12.default.resolve(input.baseDir);
+    const normalizedBase = import_node_path13.default.resolve(input.baseDir);
     for (const match2 of parsed.body.matchAll(/\]\(([^)]+)\)/g)) {
       const href = match2[1].trim();
       if (!href || /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith(`#`)) continue;
-      const target = import_node_path12.default.resolve(normalizedBase, href.split(`#`)[0]);
-      if (!target.startsWith(normalizedBase + import_node_path12.default.sep) && target !== normalizedBase) {
+      const target = import_node_path13.default.resolve(normalizedBase, href.split(`#`)[0]);
+      if (!target.startsWith(normalizedBase + import_node_path13.default.sep) && target !== normalizedBase) {
         addError(errors, `unsafe_reference`, `Relative link "${href}" escapes the skill directory.`);
       } else if (!(0, import_node_fs3.existsSync)(target)) {
         addError(errors, `missing_reference`, `Relative link "${href}" does not exist in the skill directory.`);
@@ -43908,7 +44098,7 @@ var mergeIssues = (target, source) => {
   target.warnings.push(...source.warnings);
 };
 var validateScriptsDirectory = (skillDir, warnings) => {
-  const scriptsDir = import_node_path12.default.join(skillDir, `scripts`);
+  const scriptsDir = import_node_path13.default.join(skillDir, `scripts`);
   if (!(0, import_node_fs3.existsSync)(scriptsDir)) return;
   const entries = (0, import_node_fs3.readdirSync)(scriptsDir, { withFileTypes: true }).filter((entry) => entry.isFile());
   if (entries.length === 0) {
@@ -43918,8 +44108,8 @@ var validateScriptsDirectory = (skillDir, warnings) => {
 var validateSkillDirectory = (skillDir, options = {}) => {
   const errors = [];
   const warnings = [];
-  const normalizedSkillDir = import_node_path12.default.resolve(skillDir);
-  const skillMdPath = import_node_path12.default.join(normalizedSkillDir, `SKILL.md`);
+  const normalizedSkillDir = import_node_path13.default.resolve(skillDir);
+  const skillMdPath = import_node_path13.default.join(normalizedSkillDir, `SKILL.md`);
   if (!(0, import_node_fs3.existsSync)(normalizedSkillDir) || !(0, import_node_fs3.statSync)(normalizedSkillDir).isDirectory()) {
     addError(errors, `missing_skill_dir`, `Skill directory does not exist: ${normalizedSkillDir}`);
     return { ok: false, errors, warnings, skillDir: normalizedSkillDir, skillMdPath };
@@ -43930,7 +44120,7 @@ var validateSkillDirectory = (skillDir, options = {}) => {
   }
   const raw2 = (0, import_node_fs3.readFileSync)(skillMdPath, `utf-8`);
   const documentResult = validateSkillDocument({
-    skillName: options.expectedName ?? import_node_path12.default.basename(normalizedSkillDir),
+    skillName: options.expectedName ?? import_node_path13.default.basename(normalizedSkillDir),
     skillMd: raw2,
     baseDir: normalizedSkillDir
   });
@@ -43988,20 +44178,20 @@ var readJsonArray = (filePath) => {
   return JSON.parse((0, import_node_fs4.readFileSync)(filePath, "utf-8"));
 };
 var writeJsonArray = (filePath, records) => {
-  ensureDir(import_node_path13.default.dirname(filePath));
+  ensureDir(import_node_path14.default.dirname(filePath));
   (0, import_node_fs4.writeFileSync)(filePath, JSON.stringify(records, null, "	"), "utf-8");
 };
 var departmentMemoryPath = (departmentName) => {
-  return import_node_path13.default.join(getDepartmentWorkSpaceDir(departmentName), "department-memory.json");
+  return import_node_path14.default.join(getDepartmentWorkSpaceDir(departmentName), "department-memory.json");
 };
 var departmentSkillPath = (departmentName) => {
-  return import_node_path13.default.join(getDepartmentWorkSpaceDir(departmentName), "department-skills.json");
+  return import_node_path14.default.join(getDepartmentWorkSpaceDir(departmentName), "department-skills.json");
 };
 var departmentSkillDir = (departmentName, skillName) => {
-  return assertSafeSkillTarget(import_node_path13.default.join(getDepartmentWorkSpaceDir(departmentName), "skills"), skillName);
+  return assertSafeSkillTarget(import_node_path14.default.join(getDepartmentWorkSpaceDir(departmentName), "skills"), skillName);
 };
 var proposalsPath = () => {
-  return import_node_path13.default.join(getDepartmentBaseDir(), "department-proposals.json");
+  return import_node_path14.default.join(getDepartmentBaseDir(), "department-proposals.json");
 };
 var getDepartmentNameForHead = (request) => {
   const mailboxId = request?.departmentAgentId;
@@ -44099,7 +44289,7 @@ var keepDepartmentSkill = (departmentName, id) => {
 ${formatSkillValidationIssues(validation)}`);
   }
   ensureDir(skillDir);
-  (0, import_node_fs4.writeFileSync)(import_node_path13.default.join(skillDir, "SKILL.md"), records[idx].skillMd, "utf-8");
+  (0, import_node_fs4.writeFileSync)(import_node_path14.default.join(skillDir, "SKILL.md"), records[idx].skillMd, "utf-8");
   const smokeTest = smokeTestSkillDirectory(skillDir, { expectedName: records[idx].skillName });
   if (!smokeTest.ok) {
     throw new Error(`[departmentSkill] Skill smoke test \u5931\u8D25\uFF1A
@@ -44361,7 +44551,7 @@ var getCeoNudgeCooldownMs = () => {
   const configured = Number(process.env.CEO_MAILBOX_NUDGE_COOLDOWN_MS ?? DEFAULT_CEO_NUDGE_COOLDOWN_MS);
   return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CEO_NUDGE_COOLDOWN_MS;
 };
-var DESCRIPTION28 = `
+var DESCRIPTION29 = `
 \u5728\u5F53\u524D mailbox \u7EBF\u7A0B\u4E2D\u8FFD\u52A0\u4E00\u6761\u8865\u5145\u6D88\u606F\uFF0C\u4F46\u4E0D\u7ED3\u675F\u539F\u6D88\u606F\u7684\u5904\u7406\u3002
 
 \u5B83\u5728\u7EC4\u7EC7\u91CC\u7684\u542B\u4E49\u66F4\u63A5\u8FD1\u201C\u540C\u4E00\u4EF6\u4E8B\u7684\u7EE7\u7EED\u6C9F\u901A\u201D\uFF1A\u8BA9\u5BF9\u65B9\u77E5\u9053\u4F60\u5DF2\u7ECF\u5B89\u6392\u3001\u6B63\u5728\u7B49\u8C01\u3001\u50AC\u4E86\u8C01\u3001\u76EE\u524D\u770B\u5230\u4E86\u54EA\u4E9B\u90E8\u5206\u7ED3\u679C\uFF0C\u6216\u9700\u8981\u5BF9\u65B9\u8865\u5145\u4EC0\u4E48\u3002
@@ -44390,7 +44580,7 @@ var looksLikeCeoNudge = (content, kind) => {
 };
 var mailboxFollowup = {
   name: `mailbox_followup`,
-  description: DESCRIPTION28,
+  description: DESCRIPTION29,
   input_schema: {
     type: `object`,
     properties: {
@@ -44480,7 +44670,7 @@ var mailboxFollowup = {
 var import_node_child_process = require("node:child_process");
 var import_node_crypto11 = require("node:crypto");
 var import_node_fs5 = require("node:fs");
-var DESCRIPTION29 = `\u5728\u7CFB\u7EDF shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002
+var DESCRIPTION30 = `\u5728\u7CFB\u7EDF shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002
 
 \u7528\u9014\uFF1A
 - \u8FD0\u884C shell \u547D\u4EE4\uFF08\u5982 ls\u3001mkdir\u3001npm\u3001git\u3001rg \u7B49\uFF09
@@ -44684,7 +44874,7 @@ function waitForClose(session, waitMs) {
 }
 var bashTool = {
   name: `bash`,
-  description: DESCRIPTION29,
+  description: DESCRIPTION30,
   input_schema: {
     type: `object`,
     properties: {
@@ -44821,7 +45011,7 @@ var bashTool = {
 };
 
 // src/tools/tools/SendFile.ts
-var DESCRIPTION30 = `
+var DESCRIPTION31 = `
 \u53D1\u9001\u6587\u4EF6\u7ED9\u7528\u6237\u3002\u652F\u6301\u4E24\u79CD\u65B9\u5F0F\uFF1A
 1. \u672C\u5730\u6587\u4EF6\u8DEF\u5F84\uFF08filePath\uFF09\uFF1A\u9002\u7528\u4E8E\u4F60\u901A\u8FC7 Write \u5DE5\u5177\u751F\u6210\u7684\u6587\u4EF6
 2. \u8FDC\u7A0B URL\uFF08url\uFF09\uFF1A\u9002\u7528\u4E8E\u4ECE\u7F51\u7EDC\u83B7\u53D6\u7684\u6587\u4EF6
@@ -44846,7 +45036,7 @@ var inferFileType = (fileName) => {
 };
 var sendFile = {
   name: `send_file`,
-  description: DESCRIPTION30,
+  description: DESCRIPTION31,
   input_schema: {
     type: `object`,
     properties: {
@@ -45076,6 +45266,7 @@ var createDefaultTools = (bg, hookPlugins = []) => {
   registerTool(registry2, webSearchTool);
   registerTool(registry2, webFetchTool);
   registerTool(registry2, imageUnderstand);
+  registerTool(registry2, imageGenerate);
   registerTool(registry2, skillTool);
   registerTool(registry2, goalCreate);
   registerTool(registry2, goalGet);
@@ -45179,7 +45370,7 @@ var searchRecallIndex = async (storage, userId, query, date, limit = 8) => {
 };
 
 // src/tools/tools/RecallChatHistory.ts
-var DESCRIPTION31 = `\u641C\u7D22\u7528\u6237\u7684\u5386\u53F2\u804A\u5929\u8BB0\u5F55\u3001compact \u6458\u8981\u3001dream \u957F\u671F\u8BB0\u5FC6\u548C\u663E\u5F0F\u957F\u671F memory\u3002\u5F53\u7528\u6237\u63D0\u5230\u8FC7\u53BB\u7684\u5BF9\u8BDD\u3001\u4E4B\u524D\u7684\u8BF7\u6C42\u3001\u4E0A\u6B21\u4EFB\u52A1\u3001\u6216\u4F60\u9700\u8981\u56DE\u5FC6\u65E9\u671F\u4EA4\u4E92\u5185\u5BB9\u65F6\u4F7F\u7528\u3002
+var DESCRIPTION32 = `\u641C\u7D22\u7528\u6237\u7684\u5386\u53F2\u804A\u5929\u8BB0\u5F55\u3001compact \u6458\u8981\u3001dream \u957F\u671F\u8BB0\u5FC6\u548C\u663E\u5F0F\u957F\u671F memory\u3002\u5F53\u7528\u6237\u63D0\u5230\u8FC7\u53BB\u7684\u5BF9\u8BDD\u3001\u4E4B\u524D\u7684\u8BF7\u6C42\u3001\u4E0A\u6B21\u4EFB\u52A1\u3001\u6216\u4F60\u9700\u8981\u56DE\u5FC6\u65E9\u671F\u4EA4\u4E92\u5185\u5BB9\u65F6\u4F7F\u7528\u3002
 
 \u4F7F\u7528\u6307\u5357\uFF1A
 - query \u5FC5\u987B\u5177\u4F53\uFF0C\u5305\u542B\u5173\u952E\u8BCD\uFF08\u5982\u6587\u4EF6\u540D\u3001\u529F\u80FD\u540D\u3001\u4E3B\u9898\u8BCD\uFF09
@@ -45234,7 +45425,7 @@ var formatRecallResult = (result, indexResult) => {
 };
 var recallChatHistory = (messageStorage, topicStorage, recallIndexStorage) => ({
   name: "recall_chat_history",
-  description: DESCRIPTION31,
+  description: DESCRIPTION32,
   input_schema: {
     type: "object",
     properties: {
@@ -45543,7 +45734,7 @@ var readDreamHistoryLimit = () => {
 // src/skillForge/SkillForgeEngine.ts
 var import_node_fs6 = require("node:fs");
 var import_node_os2 = require("node:os");
-var import_node_path14 = require("node:path");
+var import_node_path15 = require("node:path");
 var import_node_crypto12 = require("node:crypto");
 var SkillForgeEngine = class {
   proposalStorage;
@@ -45552,8 +45743,8 @@ var SkillForgeEngine = class {
   constructor(deps) {
     this.proposalStorage = deps.proposalStorage;
     const opt = deps.options ?? {};
-    this.draftRoot = opt.draftRoot ?? (0, import_node_path14.join)((0, import_node_os2.homedir)(), ".duclaw", "skill-proposals");
-    this.skillsInstallDir = opt.skillsInstallDir ?? (0, import_node_path14.join)((0, import_node_os2.homedir)(), ".agents", "skills");
+    this.draftRoot = opt.draftRoot ?? (0, import_node_path15.join)((0, import_node_os2.homedir)(), ".duclaw", "skill-proposals");
+    this.skillsInstallDir = opt.skillsInstallDir ?? (0, import_node_path15.join)((0, import_node_os2.homedir)(), ".agents", "skills");
   }
   // ---------- 公开方法 ----------
   /**
@@ -45579,9 +45770,9 @@ ${formatSkillValidationIssues(validation)}`);
       return null;
     }
     const id = (0, import_node_crypto12.randomBytes)(4).toString("hex");
-    const draftDir = (0, import_node_path14.join)(this.draftRoot, userId, id);
+    const draftDir = (0, import_node_path15.join)(this.draftRoot, userId, id);
     (0, import_node_fs6.mkdirSync)(draftDir, { recursive: true });
-    (0, import_node_fs6.writeFileSync)((0, import_node_path14.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
+    (0, import_node_fs6.writeFileSync)((0, import_node_path15.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
     const directoryValidation = validateSkillDirectory(draftDir, { expectedName: skillName });
     if (!directoryValidation.ok) {
       try {
@@ -45680,7 +45871,7 @@ ${formatSkillValidationIssues(smokeTest)}`);
 };
 
 // src/tools/tools/skillforge/SkillForgePropose.ts
-var DESCRIPTION32 = `\u63D0\u4EA4\u4E00\u4E2A"\u6280\u80FD\u8349\u7A3F"\u5230 pending \u5217\u8868\uFF08\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u540E\u843D\u5730\u5230 ~/.agents/skills/\uFF09\u3002
+var DESCRIPTION33 = `\u63D0\u4EA4\u4E00\u4E2A"\u6280\u80FD\u8349\u7A3F"\u5230 pending \u5217\u8868\uFF08\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u540E\u843D\u5730\u5230 ~/.agents/skills/\uFF09\u3002
 
 \u4F55\u65F6\u8C03\u7528\uFF1A
 \u4F60\u521A\u6210\u529F\u5B8C\u6210\u4E86\u4E00\u4E2A\u590D\u6742\u4EFB\u52A1\uFF08\u901A\u5E38\u5305\u542B 5 \u6B21\u4EE5\u4E0A\u5DE5\u5177\u8C03\u7528\uFF09\uFF0C\u5E76\u4E14\u4F60\u5224\u65AD\u8FD9\u4E2A\u64CD\u4F5C\u6D41\u7A0B\uFF1A
@@ -45716,7 +45907,7 @@ description: <\u4E0E\u53C2\u6570 description \u4E00\u81F4>
 `;
 var skillForgePropose = (engine) => ({
   name: `skill_forge_propose`,
-  description: DESCRIPTION32,
+  description: DESCRIPTION33,
   input_schema: {
     type: `object`,
     properties: {
@@ -45758,7 +45949,7 @@ var skillForgePropose = (engine) => ({
 });
 
 // src/tools/tools/skillforge/SkillForgeKeep.ts
-var DESCRIPTION33 = `\u4FDD\u7559\u4E00\u4E2A\u7531 agent \u81EA\u52A8\u521B\u5EFA\u7684\u6280\u80FD\u8349\u7A3F\uFF08\u628A\u8349\u7A3F\u4ECE\u6682\u5B58\u76EE\u5F55\u62F7\u8D1D\u5230 ~/.agents/skills/\uFF0C\u4E0B\u6B21\u7C7B\u4F3C\u4EFB\u52A1\u4F1A\u81EA\u52A8\u590D\u7528\uFF09\u3002
+var DESCRIPTION34 = `\u4FDD\u7559\u4E00\u4E2A\u7531 agent \u81EA\u52A8\u521B\u5EFA\u7684\u6280\u80FD\u8349\u7A3F\uFF08\u628A\u8349\u7A3F\u4ECE\u6682\u5B58\u76EE\u5F55\u62F7\u8D1D\u5230 ~/.agents/skills/\uFF0C\u4E0B\u6B21\u7C7B\u4F3C\u4EFB\u52A1\u4F1A\u81EA\u52A8\u590D\u7528\uFF09\u3002
 \u4EC5\u5F53\u7528\u6237\u5BF9\u4E00\u4E2A pending \u7684\u6280\u80FD\u8349\u7A3F\u660E\u786E\u8868\u8FBE"\u4FDD\u7559/\u53EF\u4EE5/\u540C\u610F/\u597D\u7684"\u4E4B\u7C7B\u80AF\u5B9A\u610F\u56FE\u65F6\uFF0C\u624D\u8C03\u7528\u672C\u5DE5\u5177\u3002
 \u53C2\u6570 proposalId \u53EF\u9009\uFF1A
   - \u5F53\u524D\u53EA\u6709 1 \u4E2A pending \u8349\u7A3F\u65F6\u53EF\u4E0D\u586B\uFF0C\u5DE5\u5177\u4F1A\u81EA\u52A8\u9009\u4E2D\u90A3\u4E00\u6761\uFF1B
@@ -45779,7 +45970,7 @@ var pickProposal = (pending, hint) => {
 };
 var skillForgeKeep = (engine) => ({
   name: `skill_forge_keep`,
-  description: DESCRIPTION33,
+  description: DESCRIPTION34,
   input_schema: {
     type: `object`,
     properties: {
@@ -45811,7 +46002,7 @@ var skillForgeKeep = (engine) => ({
 });
 
 // src/tools/tools/skillforge/SkillForgeDrop.ts
-var DESCRIPTION34 = `\u4E22\u5F03\u4E00\u4E2A pending \u7684\u6280\u80FD\u8349\u7A3F\uFF08\u5220\u9664\u6682\u5B58\u76EE\u5F55\u91CC\u7684 SKILL.md\uFF0C\u4ECE pending \u5217\u8868\u79FB\u9664\uFF09\u3002
+var DESCRIPTION35 = `\u4E22\u5F03\u4E00\u4E2A pending \u7684\u6280\u80FD\u8349\u7A3F\uFF08\u5220\u9664\u6682\u5B58\u76EE\u5F55\u91CC\u7684 SKILL.md\uFF0C\u4ECE pending \u5217\u8868\u79FB\u9664\uFF09\u3002
 \u4EC5\u5F53\u7528\u6237\u5BF9\u6280\u80FD\u8349\u7A3F\u660E\u786E\u8868\u8FBE"\u4E0D\u7528/\u4E0D\u8981/\u7B97\u4E86/\u4E0D\u4FDD\u7559"\u7B49\u5426\u5B9A\u610F\u56FE\u65F6\u8C03\u7528\u3002
 \u53C2\u6570 proposalId \u53EF\u9009\uFF1A
   - \u5F53\u524D\u53EA\u6709 1 \u4E2A pending \u8349\u7A3F\u65F6\u53EF\u4E0D\u586B\uFF0C\u5DE5\u5177\u4F1A\u81EA\u52A8\u9009\u4E2D\u90A3\u4E00\u6761\uFF1B
@@ -45832,7 +46023,7 @@ var pickProposal2 = (pending, hint) => {
 };
 var skillForgeDrop = (engine) => ({
   name: `skill_forge_drop`,
-  description: DESCRIPTION34,
+  description: DESCRIPTION35,
   input_schema: {
     type: `object`,
     properties: {
@@ -45978,7 +46169,7 @@ ${memory.content}`),
 };
 
 // src/tools/tools/memory/MemoryCreate.ts
-var DESCRIPTION35 = `\u628A\u4E00\u6761\u503C\u5F97\u957F\u671F\u8BB0\u4F4F\u7684\u4E8B\u5B9E / \u504F\u597D / \u7EA6\u675F\u5199\u5165\u957F\u671F\u8BB0\u5FC6\uFF0C\u4E4B\u540E\u6BCF\u8F6E\u5BF9\u8BDD\u90FD\u4F1A\u81EA\u52A8\u6CE8\u5165\u7ED9\u4F60\u53C2\u8003\u3002
+var DESCRIPTION36 = `\u628A\u4E00\u6761\u503C\u5F97\u957F\u671F\u8BB0\u4F4F\u7684\u4E8B\u5B9E / \u504F\u597D / \u7EA6\u675F\u5199\u5165\u957F\u671F\u8BB0\u5FC6\uFF0C\u4E4B\u540E\u6BCF\u8F6E\u5BF9\u8BDD\u90FD\u4F1A\u81EA\u52A8\u6CE8\u5165\u7ED9\u4F60\u53C2\u8003\u3002
 
 \u4F55\u65F6\u8C03\u7528\uFF1A
   1. \u7528\u6237\u660E\u786E\u8BF4"\u8BB0\u4F4F / \u4EE5\u540E\u90FD / \u522B\u518D / \u4ECE\u73B0\u5728\u8D77"\u7B49\u6307\u793A\u6027\u63AA\u8F9E
@@ -45998,7 +46189,7 @@ var DESCRIPTION35 = `\u628A\u4E00\u6761\u503C\u5F97\u957F\u671F\u8BB0\u4F4F\u768
 `;
 var memoryCreate = (engine) => ({
   name: `memory_create`,
-  description: DESCRIPTION35,
+  description: DESCRIPTION36,
   input_schema: {
     type: `object`,
     properties: {
@@ -46030,7 +46221,7 @@ var memoryCreate = (engine) => ({
 });
 
 // src/tools/tools/memory/MemoryUpdate.ts
-var DESCRIPTION36 = `\u66F4\u65B0\u4E00\u6761\u5DF2\u5B58\u5728\u7684\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
+var DESCRIPTION37 = `\u66F4\u65B0\u4E00\u6761\u5DF2\u5B58\u5728\u7684\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
 
 \u4F55\u65F6\u8C03\u7528\uFF1A
   1. <memory-context> \u91CC\u5DF2\u6709\u7684\u8BB0\u5FC6\u4FE1\u606F\u8FC7\u65F6\u3001\u6709\u504F\u5DEE\u3001\u9700\u8981\u8865\u5145\u7EC6\u8282
@@ -46044,7 +46235,7 @@ var DESCRIPTION36 = `\u66F4\u65B0\u4E00\u6761\u5DF2\u5B58\u5728\u7684\u957F\u671
 `;
 var memoryUpdate = (engine) => ({
   name: `memory_update`,
-  description: DESCRIPTION36,
+  description: DESCRIPTION37,
   input_schema: {
     type: `object`,
     properties: {
@@ -46081,7 +46272,7 @@ var memoryUpdate = (engine) => ({
 });
 
 // src/tools/tools/memory/MemoryDelete.ts
-var DESCRIPTION37 = `\u5220\u9664\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
+var DESCRIPTION38 = `\u5220\u9664\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
 
 \u4F55\u65F6\u8C03\u7528\uFF1A
   1. \u7528\u6237\u660E\u786E\u8981\u6C42"\u5FD8\u6389 / \u522B\u518D\u8BB0 / \u5220\u6389\u5173\u4E8E X \u7684\u8BB0\u5FC6"
@@ -46094,7 +46285,7 @@ var DESCRIPTION37 = `\u5220\u9664\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\uFF08\u630
 `;
 var memoryDelete = (engine) => ({
   name: `memory_delete`,
-  description: DESCRIPTION37,
+  description: DESCRIPTION38,
   input_schema: {
     type: `object`,
     properties: {
@@ -46666,6 +46857,7 @@ ${RUNTIME_PROCESS_SAFETY_PROMPT}
   - \u4EFB\u52A1\u7406\u89E3\u6709\u6B67\u4E49\u65F6\uFF0C\u5148\u786E\u8BA4\u7528\u6237\u7684\u771F\u5B9E\u610F\u56FE
   - \u64CD\u4F5C\u7ED3\u679C\u4F1A\u5F71\u54CD\u5176\u4ED6\u4EBA\u6216\u5916\u90E8\u7CFB\u7EDF\u65F6
 - \u98DE\u4E66/Lark \u6388\u6743\u94FE\u63A5\u5FC5\u987B\u4E3B\u52A8\u8F6C\u53D1\uFF1A\u5F53\u5DE5\u5177\u8F93\u51FA\u3001\u90E8\u95E8\u6210\u5458\u56DE\u590D\u6216\u9519\u8BEF\u4FE1\u606F\u4E2D\u51FA\u73B0\u9700\u8981\u7528\u6237\u5728\u6D4F\u89C8\u5668\u5B8C\u6210\u7684\u98DE\u4E66/Lark \u6388\u6743\u3001\u5E94\u7528\u914D\u7F6E\u3001scope \u5F00\u901A\u3001console_url\u3001authorize_url\u3001auth login URL \u7B49\u94FE\u63A5\u65F6\uFF0C\u5FC5\u987B\u901A\u8FC7 send_message \u628A\u5B8C\u6574 URL \u76F4\u63A5\u53D1\u7ED9\u7528\u6237\uFF0C\u5E76\u660E\u786E\u8BF4\u660E\u9700\u8981\u7528\u6237\u6253\u5F00\u8BE5\u94FE\u63A5\u5B8C\u6210\u6388\u6743\u3002\u4E0D\u8981\u53EA\u8BF4\u201C\u8BF7\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u6388\u6743\u94FE\u63A5\u201D\u800C\u4E0D\u63D0\u4F9B\u94FE\u63A5\u3002
+- \u98DE\u4E66/Lark \u4E2A\u4EBA\u8D44\u4EA7\u64CD\u4F5C\u5FC5\u987B\u4FDD\u6301\u8EAB\u4EFD\u4E00\u81F4\uFF1A\u641C\u7D22\u3001\u8BFB\u53D6\u3001\u521B\u5EFA\u3001\u7F16\u8F91\u3001\u4E0A\u4F20\u3001\u5220\u9664\u3001\u79FB\u52A8\u4E91\u6587\u6863/\u8868\u683C/\u4E91\u7A7A\u95F4\u6587\u4EF6/\u5999\u8BB0/\u65E5\u5386/\u4EFB\u52A1\u7B49\u7528\u6237\u4E2A\u4EBA\u8D44\u4EA7\u65F6\uFF0C\u9ED8\u8BA4\u4F7F\u7528\u5F53\u524D\u804A\u5929\u7528\u6237\u7684 user \u8EAB\u4EFD\uFF0C\u4E0D\u8981\u9759\u9ED8\u4F7F\u7528 bot \u8EAB\u4EFD\u3002\u6267\u884C\u524D\u786E\u8BA4\u5C06\u4F7F\u7528 user \u8FD8\u662F bot\uFF1B\u5982\u679C\u7F3A user scope\uFF0C\u5148\u53D1\u8D77 user \u6388\u6743\u5E76\u8F6C\u53D1\u5B8C\u6574\u6388\u6743\u94FE\u63A5\u3002\u53EA\u6709\u7528\u6237\u660E\u786E\u8981\u6C42\u3001\u8D44\u6E90\u672C\u6765\u5C5E\u4E8E bot\u3001\u6216 API \u53EA\u80FD\u7531 bot \u6267\u884C\u65F6\u624D\u7528 bot\uFF1B\u5982\u679C bot \u521B\u5EFA\u4E86\u7528\u6237\u671F\u671B\u957F\u671F\u4F7F\u7528\u7684\u8D44\u4EA7\uFF0C\u5FC5\u987B\u5C1D\u8BD5\u7ED9\u5F53\u524D user \u6388\u4E88\u53EF\u7BA1\u7406\u6743\u9650\uFF0C\u5E76\u5411\u7528\u6237\u8BF4\u660E owner \u4E0E\u6388\u6743\u7ED3\u679C\u3002
 - \u4E0D\u8981\u64C5\u81EA\u505A\u91CD\u5927\u51B3\u5B9A\uFF0C\u5B81\u53EF\u591A\u95EE\u4E00\u53E5\u4E5F\u4E0D\u8981\u9ED8\u9ED8\u6267\u884C\u53EF\u80FD\u51FA\u9519\u7684\u64CD\u4F5C\u3002
 </Communication>
 
@@ -47662,7 +47854,7 @@ var saveResultToFile = (job, cronResp) => {
 };
 
 // src/tools/tools/department/ListMailbox.ts
-var DESCRIPTION38 = `
+var DESCRIPTION39 = `
 \u67E5\u770B\u4F60\u7684\u90AE\u7BB1\u4E2D\u6240\u6709\u5F85\u5904\u7406\u90AE\u4EF6\u7684\u6458\u8981\u5217\u8868\u3002
 
 \u8FD4\u56DE\u6BCF\u5C01\u90AE\u4EF6\u7684\uFF1Aid\u3001\u53D1\u9001\u8005\u3001\u53D1\u9001\u65F6\u95F4\u3001\u72B6\u6001\u3001\u5185\u5BB9\u6458\u8981\uFF08\u524D100\u5B57\uFF09\u3002
@@ -47678,7 +47870,7 @@ var DESCRIPTION38 = `
 `;
 var listMailbox = {
   name: `list_mailbox`,
-  description: DESCRIPTION38,
+  description: DESCRIPTION39,
   input_schema: {
     type: `object`,
     properties: {},
@@ -47735,7 +47927,7 @@ ${list}`;
 };
 
 // src/tools/tools/department/GetMailbox.ts
-var DESCRIPTION39 = `
+var DESCRIPTION40 = `
 \u83B7\u53D6\u6307\u5B9A\u90AE\u4EF6\u7684\u5B8C\u6574\u5185\u5BB9\u3002
 
 \u5728 list_mailbox \u67E5\u770B\u90AE\u4EF6\u5217\u8868\u540E\uFF0C\u4F7F\u7528\u6B64\u5DE5\u5177\u83B7\u53D6\u4F60\u60F3\u8981\u5904\u7406\u7684\u90AE\u4EF6\u7684\u5B8C\u6574\u5185\u5BB9\u3002
@@ -47778,7 +47970,7 @@ var buildUpstreamContext = (msg) => {
 };
 var getMailbox = {
   name: `get_mailbox`,
-  description: DESCRIPTION39,
+  description: DESCRIPTION40,
   input_schema: {
     type: `object`,
     properties: {
@@ -47855,7 +48047,7 @@ ${msg.content}`;
 };
 
 // src/tools/tools/department/DiscardMailbox.ts
-var DESCRIPTION40 = `
+var DESCRIPTION41 = `
 \u4E22\u5F03\u4E00\u5C01\u65E0\u9700\u5904\u7406\u7684 mailbox \u90AE\u4EF6\uFF0C\u5E76\u5C06\u5B83\u4ECE\u5F85\u5904\u7406\u5217\u8868\u4E2D\u79FB\u9664\u3002
 
 \u9002\u7528\u573A\u666F\uFF1A
@@ -47873,7 +48065,7 @@ var DESCRIPTION40 = `
 `;
 var discardMailbox = {
   name: `discard_mailbox`,
-  description: DESCRIPTION40,
+  description: DESCRIPTION41,
   input_schema: {
     type: `object`,
     properties: {
@@ -47955,7 +48147,7 @@ var discardMailbox = {
 };
 
 // src/tools/tools/department/ReplyMailbox.ts
-var DESCRIPTION41 = `
+var DESCRIPTION42 = `
 \u6B63\u5F0F\u56DE\u590D\u4E00\u5C01\u90AE\u4EF6\u3002\u5BF9\u5F53\u524D\u6D88\u606F\u5F62\u6210\u53EF\u4EE5\u4EA4\u4ED8\u7ED9\u5BF9\u65B9\u7684\u6700\u7EC8\u7ED3\u8BBA\u540E\uFF0C\u4F7F\u7528\u6B64\u5DE5\u5177\u5C06\u7ED3\u679C\u53D1\u56DE\u7ED9\u90AE\u4EF6\u53D1\u9001\u8005\uFF0C\u5E76\u7ED3\u675F\u8FD9\u5C01\u6D88\u606F\u7684\u5904\u7406\u3002
 
 \u5B83\u5728\u7EC4\u7EC7\u91CC\u7684\u542B\u4E49\u66F4\u63A5\u8FD1\u201C\u6211\u5DF2\u7ECF\u628A\u8FD9\u4EF6\u4E8B\u9A8C\u6536\u6E05\u695A\uFF0C\u53EF\u4EE5\u7ED9\u4F60\u4E00\u4E2A\u7ED3\u8BBA\u201D\uFF0C\u800C\u4E0D\u662F\u666E\u901A\u804A\u5929\u56DE\u590D\u3002
@@ -48019,7 +48211,7 @@ var buildUpstreamReminder = (myMailboxId, repliedToMailboxId, threadId, workItem
 };
 var replyMailbox = {
   name: `reply_mailbox`,
-  description: DESCRIPTION41,
+  description: DESCRIPTION42,
   input_schema: {
     type: `object`,
     properties: {
@@ -48854,26 +49046,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path21) => {
-  const paths = path21.split("/");
+var splitPath = (path22) => {
+  const paths = path22.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path21 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path21);
+  const { groups, path: path22 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path22);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path21) => {
+var extractGroupsFromPath = (path22) => {
   const groups = [];
-  path21 = path21.replace(/\{[^}]+\}/g, (match2, index) => {
+  path22 = path22.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path21 };
+  return { groups, path: path22 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -48930,8 +49122,8 @@ var getPath = (request) => {
       const queryIndex = url.indexOf("?", i);
       const hashIndex = url.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path21 = url.slice(start, end);
-      return tryDecodeURI(path21.includes("%25") ? path21.replace(/%25/g, "%2525") : path21);
+      const path22 = url.slice(start, end);
+      return tryDecodeURI(path22.includes("%25") ? path22.replace(/%25/g, "%2525") : path22);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -48948,11 +49140,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path21) => {
-  if (path21.charCodeAt(path21.length - 1) !== 63 || !path21.includes(":")) {
+var checkOptionalParameter = (path22) => {
+  if (path22.charCodeAt(path22.length - 1) !== 63 || !path22.includes(":")) {
     return null;
   }
-  const segments = path21.split("/");
+  const segments = path22.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -49093,9 +49285,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path21 = "/", matchResult = [[]]) {
+  constructor(request, path22 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path21;
+    this.path = path22;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -49832,8 +50024,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path21, ...handlers) => {
-      for (const p of [path21].flat()) {
+    this.on = (method, path22, ...handlers) => {
+      for (const p of [path22].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -49890,8 +50082,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path21, app) {
-    const subApp = this.basePath(path21);
+  route(path22, app) {
+    const subApp = this.basePath(path22);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -49917,9 +50109,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path21) {
+  basePath(path22) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path21);
+    subApp._basePath = mergePath(this._basePath, path22);
     return subApp;
   }
   /**
@@ -49993,7 +50185,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path21, applicationHandler, options) {
+  mount(path22, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -50020,7 +50212,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path21);
+      const mergedPath = mergePath(this._basePath, path22);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -50035,14 +50227,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path21, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path22, "*"), handler);
     return this;
   }
-  #addRoute(method, path21, handler) {
+  #addRoute(method, path22, handler) {
     method = method.toUpperCase();
-    path21 = mergePath(this._basePath, path21);
-    const r = { basePath: this._basePath, path: path21, method, handler };
-    this.router.add(method, path21, [handler, r]);
+    path22 = mergePath(this._basePath, path22);
+    const r = { basePath: this._basePath, path: path22, method, handler };
+    this.router.add(method, path22, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -50055,10 +50247,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path21 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path21);
+    const path22 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path22);
     const c = new Context(request, {
-      path: path21,
+      path: path22,
       matchResult,
       env,
       executionCtx,
@@ -50158,15 +50350,15 @@ var Hono = class _Hono {
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path21) {
+function match(method, path22) {
   const matchers = this.buildAllMatchers();
-  const match2 = ((method2, path22) => {
+  const match2 = ((method2, path23) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-    const staticMatch = matcher[2][path22];
+    const staticMatch = matcher[2][path23];
     if (staticMatch) {
       return staticMatch;
     }
-    const match3 = path22.match(matcher[0]);
+    const match3 = path23.match(matcher[0]);
     if (!match3) {
       return [[], emptyParam];
     }
@@ -50174,7 +50366,7 @@ function match(method, path21) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path21);
+  return match2(method, path22);
 }
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -50289,12 +50481,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path21, index, pathErrorCheckOnly) {
+  insert(path22, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path21 = path21.replace(/\{[^}]+\}/g, (m) => {
+      path22 = path22.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -50305,7 +50497,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path21.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path22.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -50344,9 +50536,9 @@ var Trie = class {
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path21) {
-  return wildcardRegExpCache[path21] ??= new RegExp(
-    path21 === "*" ? "" : `^${path21.replace(
+function buildWildcardRegExp(path22) {
+  return wildcardRegExpCache[path22] ??= new RegExp(
+    path22 === "*" ? "" : `^${path22.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -50368,17 +50560,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path21, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path22, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path21] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path22] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path21, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path22, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path21) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path22) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -50412,12 +50604,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path21) {
+function findMiddleware(middleware, path22) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path21)) {
+    if (buildWildcardRegExp(k).test(path22)) {
       return [...middleware[k]];
     }
   }
@@ -50431,7 +50623,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path21, handler) {
+  add(method, path22, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -50446,18 +50638,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path21 === "/*") {
-      path21 = "*";
+    if (path22 === "/*") {
+      path22 = "*";
     }
-    const paramCount = (path21.match(/\/:/g) || []).length;
-    if (/\*$/.test(path21)) {
-      const re = buildWildcardRegExp(path21);
+    const paramCount = (path22.match(/\/:/g) || []).length;
+    if (/\*$/.test(path22)) {
+      const re = buildWildcardRegExp(path22);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path21] ||= findMiddleware(middleware[m], path21) || findMiddleware(middleware[METHOD_NAME_ALL], path21) || [];
+          middleware[m][path22] ||= findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || [];
         });
       } else {
-        middleware[method][path21] ||= findMiddleware(middleware[method], path21) || findMiddleware(middleware[METHOD_NAME_ALL], path21) || [];
+        middleware[method][path22] ||= findMiddleware(middleware[method], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -50475,15 +50667,15 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path21) || [path21];
+    const paths = checkOptionalParameter(path22) || [path22];
     for (let i = 0, len = paths.length; i < len; i++) {
-      const path22 = paths[i];
+      const path23 = paths[i];
       Object.keys(routes).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path22] ||= [
-            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
+          routes[m][path23] ||= [
+            ...findMiddleware(middleware[m], path23) || findMiddleware(middleware[METHOD_NAME_ALL], path23) || []
           ];
-          routes[m][path22].push([handler, paramCount - len + i + 1]);
+          routes[m][path23].push([handler, paramCount - len + i + 1]);
         }
       });
     }
@@ -50502,13 +50694,13 @@ var RegExpRouter = class {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
     [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path21) => [path21, r[method][path21]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path22) => [path22, r[method][path22]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path21) => [path21, r[METHOD_NAME_ALL][path21]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path22) => [path22, r[METHOD_NAME_ALL][path22]])
         );
       }
     });
@@ -50528,13 +50720,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path21, handler) {
+  add(method, path22, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path21, handler]);
+    this.#routes.push([method, path22, handler]);
   }
-  match(method, path21) {
+  match(method, path22) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -50549,7 +50741,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path21);
+        res = router.match(method, path22);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -50599,10 +50791,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path21, handler) {
+  insert(method, path22, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path21);
+    const parts = splitRoutingPath(path22);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -50651,12 +50843,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path21) {
+  search(method, path22) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path21);
+    const parts = splitPath(path22);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -50698,13 +50890,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path21[0] === "/" ? 1 : 0;
+              let offset = path22[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path21.substring(partOffsets[i]);
+            const restPathString = path22.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -50757,18 +50949,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path21, handler) {
-    const results = checkOptionalParameter(path21);
+  add(method, path22, handler) {
+    const results = checkOptionalParameter(path22);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path21, handler);
+    this.#node.insert(method, path22, handler);
   }
-  match(method, path21) {
-    return this.#node.search(method, path21);
+  match(method, path22) {
+    return this.#node.search(method, path22);
   }
 };
 
@@ -51470,10 +51662,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path21) => {
+var getStats = (path22) => {
   let stats;
   try {
-    stats = (0, import_fs15.statSync)(path21);
+    stats = (0, import_fs15.statSync)(path22);
   } catch {
   }
   return stats;
@@ -51516,21 +51708,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path21 = (0, import_path19.join)(
+    let path22 = (0, import_path19.join)(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path21);
+    let stats = getStats(path22);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path21 = (0, import_path19.join)(path21, indexFile);
-      stats = getStats(path21);
+      path22 = (0, import_path19.join)(path22, indexFile);
+      stats = getStats(path22);
     }
     if (!stats) {
-      await options.onNotFound?.(path21, c);
+      await options.onNotFound?.(path22, c);
       return next();
     }
-    const mimeType = getMimeType(path21);
+    const mimeType = getMimeType(path22);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -51540,12 +51732,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path21 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path22 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path21 = path21 + ENCODINGS[encoding];
+          path22 = path22 + ENCODINGS[encoding];
           break;
         }
       }
@@ -51559,7 +51751,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody((0, import_fs15.createReadStream)(path21)), 200);
+      result = c.body(createStreamBody((0, import_fs15.createReadStream)(path22)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -51570,12 +51762,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = (0, import_fs15.createReadStream)(path21, { start, end });
+      const stream = (0, import_fs15.createReadStream)(path22, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
       result = c.body(createStreamBody(stream), 206);
     }
-    await options.onFound?.(path21, c);
+    await options.onFound?.(path22, c);
     return result;
   };
 };
@@ -51669,8 +51861,8 @@ var cors = (options) => {
 };
 
 // src/server/index.ts
-var import_promises13 = require("node:fs/promises");
-var import_node_path18 = __toESM(require("node:path"));
+var import_promises14 = require("node:fs/promises");
+var import_node_path19 = __toESM(require("node:path"));
 
 // src/git/worktree.ts
 var import_child_process2 = require("child_process");
@@ -53016,7 +53208,7 @@ mailboxRoutes.get("/mailbox/summary", (c) => {
 // src/server/routes/memory.ts
 var import_redis4 = __toESM(require_dist2());
 var import_node_fs8 = require("node:fs");
-var import_node_path15 = __toESM(require("node:path"));
+var import_node_path16 = __toESM(require("node:path"));
 var memoryEngineSingleton = null;
 var dreamStorageSingleton = null;
 var dreamHistoryStorageSingleton = null;
@@ -53121,7 +53313,7 @@ var readJsonFilesFromDir = (dir) => {
   for (const file of (0, import_node_fs8.readdirSync)(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      result.push(JSON.parse((0, import_node_fs8.readFileSync)(import_node_path15.default.join(dir, file), "utf-8")));
+      result.push(JSON.parse((0, import_node_fs8.readFileSync)(import_node_path16.default.join(dir, file), "utf-8")));
     } catch (err) {
       console.warn(`[memoryRoutes] \u8DF3\u8FC7\u65E0\u6CD5\u89E3\u6790\u7684\u672C\u5730\u4E0A\u4E0B\u6587\u6587\u4EF6 ${file}: ${err.message}`);
     }
@@ -53129,11 +53321,11 @@ var readJsonFilesFromDir = (dir) => {
   return result;
 };
 var extractFileBackedStorageKeysForTest = (dataDir) => {
-  const kvRoot = import_node_path15.default.join(dataDir, "kv");
+  const kvRoot = import_node_path16.default.join(dataDir, "kv");
   if (!(0, import_node_fs8.existsSync)(kvRoot)) return [];
   const keys = [];
   for (const prefixDir of (0, import_node_fs8.readdirSync)(kvRoot)) {
-    const absolutePrefixDir = import_node_path15.default.join(kvRoot, prefixDir);
+    const absolutePrefixDir = import_node_path16.default.join(kvRoot, prefixDir);
     if (!(0, import_node_fs8.existsSync)(absolutePrefixDir)) continue;
     for (const file of (0, import_node_fs8.readdirSync)(absolutePrefixDir)) {
       if (!file.endsWith(".json")) continue;
@@ -53153,12 +53345,12 @@ var collectLocalConversationUserIds = () => {
 };
 var extractLocalConversationUserIdsForTest = (homeDir) => {
   const userIds = /* @__PURE__ */ new Set();
-  for (const context of readJsonFilesFromDir(import_node_path15.default.join(homeDir, "goal-context"))) {
+  for (const context of readJsonFilesFromDir(import_node_path16.default.join(homeDir, "goal-context"))) {
     addPlausibleUserId(userIds, context.threadId);
     addPlausibleUserId(userIds, context.originUserId);
     if (context.goalId) addPlausibleUserId(userIds, `kanban:goal:${context.goalId}`);
   }
-  for (const goal of readJsonFilesFromDir(import_node_path15.default.join(homeDir, "tasks"))) {
+  for (const goal of readJsonFilesFromDir(import_node_path16.default.join(homeDir, "tasks"))) {
     if (goal.id) addPlausibleUserId(userIds, `kanban:goal:${goal.id}`);
   }
   return userIds;
@@ -53575,7 +53767,7 @@ ${item.dreamContent}` : item.dreamContent).join("\n\n");
 });
 
 // src/server/routes/tools.ts
-var import_node_path16 = __toESM(require("node:path"));
+var import_node_path17 = __toESM(require("node:path"));
 var toolRoutes = new Hono2();
 var listActiveDepartmentSkills = () => {
   return listDepartments().flatMap(
@@ -53586,7 +53778,7 @@ var listActiveDepartmentSkills = () => {
       scope: "department",
       departmentName: department.name,
       detail: () => {
-        const skillDir = import_node_path16.default.join(getDepartmentWorkSpaceDir(department.name), "skills", skill.skillName);
+        const skillDir = import_node_path17.default.join(getDepartmentWorkSpaceDir(department.name), "skills", skill.skillName);
         return `Base directory for this skill: ${skillDir}
 
 ${skill.skillMd}`;
@@ -53675,7 +53867,7 @@ var systemRoutes = new Hono2();
 var startTime = Date.now();
 systemRoutes.get("/system/info", (c) => {
   return c.json({
-    version: true ? "1.9.11" : "unknown",
+    version: true ? "1.9.12" : "unknown",
     uptime: Math.floor((Date.now() - startTime) / 1e3),
     env: process.env.NODE_ENV || "development",
     nodeVersion: process.version
@@ -53684,8 +53876,8 @@ systemRoutes.get("/system/info", (c) => {
 
 // src/server/routes/mobile.ts
 var import_node_crypto16 = require("node:crypto");
-var import_promises12 = require("node:fs/promises");
-var import_node_path17 = __toESM(require("node:path"));
+var import_promises13 = require("node:fs/promises");
+var import_node_path18 = __toESM(require("node:path"));
 var mobileRoutes = new Hono2();
 var resolveMobileUserId = (body, headerUserId) => {
   return body.userId?.trim() || headerUserId?.trim() || "ios:local-user";
@@ -53727,12 +53919,12 @@ ${goal.tasks.map((task) => `- [${task.status}] ${task.subject}`).join("\n")}` :
   return lines.join("\n");
 };
 var sanitizeFileName = (fileName) => {
-  const cleaned = import_node_path17.default.basename(fileName).replace(/[^\w.\-()\u4e00-\u9fa5 ]+/g, "_").trim();
+  const cleaned = import_node_path18.default.basename(fileName).replace(/[^\w.\-()\u4e00-\u9fa5 ]+/g, "_").trim();
   return cleaned || `attachment-${Date.now()}`;
 };
 var inferAttachmentType2 = (mimeType = "", fileName = "") => {
   if (mimeType.startsWith("image/")) return "image";
-  const ext = import_node_path17.default.extname(fileName).toLowerCase();
+  const ext = import_node_path18.default.extname(fileName).toLowerCase();
   if ([".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(ext)) return "image";
   return "file";
 };
@@ -53789,10 +53981,10 @@ mobileRoutes.post("/mobile/attachments", async (c) => {
   const type = inferAttachmentType2(mimeType, fileName);
   const attachmentId = (0, import_node_crypto16.randomUUID)();
   const buffer = Buffer.from(dataBase64, "base64");
-  const dir = import_node_path17.default.join(getDuclawWorkspaceDir(), mobileUserId, "mobile", type === "image" ? "images" : "files");
-  await (0, import_promises12.mkdir)(dir, { recursive: true });
-  const localPath = import_node_path17.default.join(dir, `${attachmentId}-${fileName}`);
-  await (0, import_promises12.writeFile)(localPath, buffer);
+  const dir = import_node_path18.default.join(getDuclawWorkspaceDir(), mobileUserId, "mobile", type === "image" ? "images" : "files");
+  await (0, import_promises13.mkdir)(dir, { recursive: true });
+  const localPath = import_node_path18.default.join(dir, `${attachmentId}-${fileName}`);
+  await (0, import_promises13.writeFile)(localPath, buffer);
   const attachment = saveMobileAttachment({
     id: attachmentId,
     type,
@@ -54010,7 +54202,7 @@ function createServer() {
   app.route("/api", mobileRoutes);
   app.use("/*", serveStatic({ root: webDistRoot }));
   app.get("/*", async (c) => {
-    const indexHtml = await (0, import_promises13.readFile)(import_node_path18.default.join(webDistRoot, "index.html"), "utf8");
+    const indexHtml = await (0, import_promises14.readFile)(import_node_path19.default.join(webDistRoot, "index.html"), "utf8");
     const tenantId = c.req.header("x-tenant-id");
     const assetBase = tenantId ? `/t/${tenantId}` : "";
     const html = indexHtml.replaceAll('"./', `"${assetBase}/`);
@@ -54038,9 +54230,9 @@ function shouldStartCoreChannelGateways(env = process.env) {
 
 // src/runtime/saasAssets.ts
 var import_node_fs9 = require("node:fs");
-var import_promises14 = require("node:fs/promises");
+var import_promises15 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path19 = __toESM(require("node:path"));
+var import_node_path20 = __toESM(require("node:path"));
 var MAX_CONTEXT_ASSETS = Number(process.env.DUCLAW_SAAS_ASSET_CONTEXT_LIMIT ?? 1e3);
 var MAX_SKILL_ASSETS = Number(process.env.DUCLAW_SAAS_ASSET_SKILL_LIMIT ?? 200);
 async function restoreSaasRuntimeAssets(reason) {
@@ -54071,8 +54263,8 @@ async function restoreContextAsset(context, overwrite) {
   const target = contextPathForSourceKey(context.sourceKey);
   if (!target) return false;
   if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
-  await (0, import_promises14.mkdir)(import_node_path19.default.dirname(target), { recursive: true });
-  await (0, import_promises14.writeFile)(target, JSON.stringify(context.payload), "utf8");
+  await (0, import_promises15.mkdir)(import_node_path20.default.dirname(target), { recursive: true });
+  await (0, import_promises15.writeFile)(target, JSON.stringify(context.payload), "utf8");
   return true;
 }
 async function restoreSkillAsset(skill, overwrite) {
@@ -54080,8 +54272,8 @@ async function restoreSkillAsset(skill, overwrite) {
   const target = safeSkillTargetPath(skill.sourcePath, skill.skillName);
   if (!target) return false;
   if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
-  await (0, import_promises14.mkdir)(import_node_path19.default.dirname(target), { recursive: true });
-  await (0, import_promises14.writeFile)(target, skill.skillMd, "utf8");
+  await (0, import_promises15.mkdir)(import_node_path20.default.dirname(target), { recursive: true });
+  await (0, import_promises15.writeFile)(target, skill.skillMd, "utf8");
   return true;
 }
 function runtimeAssetClient() {
@@ -54113,30 +54305,30 @@ function runtimeAssetClient() {
 function contextPathForSourceKey(sourceKey) {
   if (sourceKey.startsWith("agent:")) {
     const logicalKey = sourceKey.slice("agent:".length);
-    return import_node_path19.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
+    return import_node_path20.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
   }
   if (sourceKey.startsWith("goal-context:")) {
-    return import_node_path19.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
+    return import_node_path20.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
   }
   if (sourceKey.startsWith("tasks:")) {
-    return import_node_path19.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
+    return import_node_path20.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
   }
   return null;
 }
 function safeSkillTargetPath(sourcePath, skillName) {
-  const allowedRoots = skillRoots().map((root) => import_node_path19.default.resolve(root));
-  const normalized = import_node_path19.default.resolve(sourcePath);
-  if (allowedRoots.some((root) => normalized === import_node_path19.default.join(root, import_node_path19.default.basename(import_node_path19.default.dirname(normalized)), "SKILL.md"))) {
+  const allowedRoots = skillRoots().map((root) => import_node_path20.default.resolve(root));
+  const normalized = import_node_path20.default.resolve(sourcePath);
+  if (allowedRoots.some((root) => normalized === import_node_path20.default.join(root, import_node_path20.default.basename(import_node_path20.default.dirname(normalized)), "SKILL.md"))) {
     return normalized;
   }
   const safeName = skillName.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "imported-skill";
-  return import_node_path19.default.join("/home/user/app/skills", safeName, "SKILL.md");
+  return import_node_path20.default.join("/home/user/app/skills", safeName, "SKILL.md");
 }
 function skillRoots() {
   return [
     "/home/user/app/skills",
-    import_node_path19.default.join(getDuclawHomeDir(), "skills"),
-    import_node_path19.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
+    import_node_path20.default.join(getDuclawHomeDir(), "skills"),
+    import_node_path20.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
   ];
 }