duclaw-cli 1.9.3 → 1.9.4

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 path20 = 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 = path20.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] === "~" ? path20.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 = path20.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 path21 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path22, { encoding }));
+          const parsed = DotenvModule.parse(fs3.readFileSync(path21, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path22} ${e.message}`);
+            _debug(`Failed to load ${path21} ${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 = path20.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, path20, moduleArguments) {
+        parser.push("MODULE", "LOAD", path20);
         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, path20, json, ...jsons) {
         parser.push("JSON.ARRAPPEND");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (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, path20, json, options) {
         parser.push("JSON.ARRINDEX");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (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, path20, index, json, ...jsons) {
         parser.push("JSON.ARRINSERT");
         parser.pushKey(key);
-        parser.push(path21, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, 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, path20, start, stop) {
         parser.push("JSON.ARRTRIM");
         parser.pushKey(key);
-        parser.push(path21, start.toString(), stop.toString());
+        parser.push(path20, 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, path20, value) {
         parser.push("JSON.MERGE");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(value));
+        parser.push(path20, (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, path20) {
         parser.push("JSON.MGET");
         parser.pushKeys(keys);
-        parser.push(path21);
+        parser.push(path20);
       },
       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, path20, by) {
         parser.push("JSON.NUMINCRBY");
         parser.pushKey(key);
-        parser.push(path21, by.toString());
+        parser.push(path20, 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, path20, by) {
         parser.push("JSON.NUMMULTBY");
         parser.pushKey(key);
-        parser.push(path21, by.toString());
+        parser.push(path20, 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, path20, json, options) {
         parser.push("JSON.SET");
         parser.pushKey(key);
-        parser.push(path21, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path20, (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, path20) {
         parser.push("JSON.TOGGLE");
         parser.pushKey(key);
-        parser.push(path21);
+        parser.push(path20);
       },
       transformReply: void 0
     };
@@ -30242,7 +30242,7 @@ function printHelp() {
 `);
 }
 function printVersion() {
-  console.log(`duclaw-cli v${true ? "1.9.3" : "unknown"}`);
+  console.log(`duclaw-cli v${true ? "1.9.4" : "unknown"}`);
 }
 function getDuclawTemplate() {
   return {
@@ -31627,7 +31627,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 = (path20) => statMethod(path20, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -31652,8 +31652,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: path20, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path20));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -31693,20 +31693,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path21, depth) {
+  async _exploreDir(path20, depth) {
     let files;
     try {
-      files = await (0, import_promises3.readdir)(path21, this._rdOptions);
+      files = await (0, import_promises3.readdir)(path20, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path21 };
+    return { files, depth, path: path20 };
   }
-  async _formatEntry(dirent, path21) {
+  async _formatEntry(dirent, path20) {
     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)(path20, 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) {
@@ -32106,16 +32106,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(path20, 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(path20);
+    emitRaw(rawEvent, evPath, { watchedPath: path20 });
+    if (evPath && path20 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path20, evPath), KEY_LISTENERS, sp.join(path20, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path21, {
+    return (0, import_node_fs.watch)(path20, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -32131,12 +32131,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path21, fullPath, options, handlers) => {
+var setFsWatchListener = (path20, 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(path20, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -32147,7 +32147,7 @@ var setFsWatchListener = (path21, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path21,
+      path20,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -32162,7 +32162,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)(path20, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -32193,7 +32193,7 @@ var setFsWatchListener = (path21, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path21, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path20, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -32215,7 +32215,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(path20, curr));
         }
       })
     };
@@ -32245,13 +32245,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path21, listener) {
+  _watchWithNodeFs(path20, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path21);
-    const basename4 = sp.basename(path21);
+    const directory = sp.dirname(path20);
+    const basename4 = sp.basename(path20);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path21);
+    const absolutePath = sp.resolve(path20);
     const options = {
       persistent: opts.persistent
     };
@@ -32261,12 +32261,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(path20, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path21, absolutePath, options, {
+      closer = setFsWatchListener(path20, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -32288,7 +32288,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path21, newStats) => {
+    const listener = async (path20, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -32302,11 +32302,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(path20);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path21, closer2);
+              this.fsw._addPathCloser(path20, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -32338,7 +32338,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, path20, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -32348,7 +32348,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises4.realpath)(path21);
+        linkPath = await (0, import_promises4.realpath)(path20);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -32358,12 +32358,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, path20, 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, path20, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -32393,9 +32393,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path21 = sp.join(directory, item);
+      let path20 = 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, path20, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -32404,8 +32404,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);
+        path20 = sp.join(dir, sp.relative(dir, path20));
+        this._addToNodeFs(path20, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve11, reject) => {
@@ -32474,13 +32474,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(path20, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path21) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path20) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path21);
+    const wh = this.fsw._getWatchHelpers(path20);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -32496,8 +32496,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(path20);
+        const targetPath = follow ? await (0, import_promises4.realpath)(path20) : path20;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -32507,29 +32507,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)(path20) : path20;
         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, path20, 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(path20), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path21, closer);
+        this.fsw._addPathCloser(path20, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path21;
+        return path20;
       }
     }
   }
@@ -32572,24 +32572,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path21) {
-  if (typeof path21 !== "string")
+function normalizePath(path20) {
+  if (typeof path20 !== "string")
     throw new Error("string expected");
-  path21 = sp2.normalize(path21);
-  path21 = path21.replace(/\\/g, "/");
+  path20 = sp2.normalize(path20);
+  path20 = path20.replace(/\\/g, "/");
   let prepend = false;
-  if (path21.startsWith("//"))
+  if (path20.startsWith("//"))
     prepend = true;
-  path21 = path21.replace(DOUBLE_SLASH_RE, "/");
+  path20 = path20.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path21 = "/" + path21;
-  return path21;
+    path20 = "/" + path20;
+  return path20;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path21 = normalizePath(testString);
+  const path20 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path21, stats)) {
+    if (pattern(path20, stats)) {
       return true;
     }
   }
@@ -32627,19 +32627,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 = (path20) => toUnix(sp2.normalize(toUnix(path20)));
+var normalizeIgnored = (cwd = "") => (path20) => {
+  if (typeof path20 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path20) ? path20 : sp2.join(cwd, path20));
   } else {
-    return path21;
+    return path20;
   }
 };
-var getAbsolutePath = (path21, cwd) => {
-  if (sp2.isAbsolute(path21)) {
-    return path21;
+var getAbsolutePath = (path20, cwd) => {
+  if (sp2.isAbsolute(path20)) {
+    return path20;
   }
-  return sp2.join(cwd, path21);
+  return sp2.join(cwd, path20);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -32704,10 +32704,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path21, follow, fsw) {
+  constructor(path20, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path21;
-    this.path = path21 = path21.replace(REPLACER_RE, "");
+    const watchPath = path20;
+    this.path = path20 = path20.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -32847,20 +32847,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((path20) => {
+        const absPath = getAbsolutePath(path20, cwd);
         return absPath;
       });
     }
-    paths.forEach((path21) => {
-      this._removeIgnoredPath(path21);
+    paths.forEach((path20) => {
+      this._removeIgnoredPath(path20);
     });
     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 (path20) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path20, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -32882,17 +32882,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((path20) => {
+      if (!sp2.isAbsolute(path20) && !this._closers.has(path20)) {
         if (cwd)
-          path21 = sp2.join(cwd, path21);
-        path21 = sp2.resolve(path21);
+          path20 = sp2.join(cwd, path20);
+        path20 = sp2.resolve(path20);
       }
-      this._closePath(path21);
-      this._addIgnoredPath(path21);
-      if (this._watched.has(path21)) {
+      this._closePath(path20);
+      this._addIgnoredPath(path20);
+      if (this._watched.has(path20)) {
         this._addIgnoredPath({
-          path: path21,
+          path: path20,
           recursive: true
         });
       }
@@ -32956,38 +32956,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, path20, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path21 = sp2.normalize(path21);
+      path20 = sp2.normalize(path20);
     if (opts.cwd)
-      path21 = sp2.relative(opts.cwd, path21);
-    const args = [path21];
+      path20 = sp2.relative(opts.cwd, path20);
+    const args = [path20];
     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(path20))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path21, [event, ...args]);
+        this._pendingUnlinks.set(path20, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path22) => {
+          this._pendingUnlinks.forEach((entry, path21) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path22);
+            this._pendingUnlinks.delete(path21);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path21)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path20)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path21);
+        this._pendingUnlinks.delete(path20);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -33005,16 +33005,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path21, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path20, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path21, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path20, 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, path20) : path20;
       let stats2;
       try {
         stats2 = await (0, import_promises5.stat)(fullPath);
@@ -33045,23 +33045,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, path20, 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(path20);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path21);
+      const item = action.get(path20);
       const count = item ? item.count : 0;
-      action.delete(path21);
+      action.delete(path20);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -33069,7 +33069,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(path20, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -33083,44 +33083,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(path20, 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 = path20;
+    if (this.options.cwd && !sp2.isAbsolute(path20)) {
+      fullPath = sp2.join(this.options.cwd, path20);
     }
     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(path20)) {
           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(path20).lastChange = now2;
         }
-        const pw = writes.get(path21);
+        const pw = writes.get(path20);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path21);
+          writes.delete(path20);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path21)) {
-      writes.set(path21, {
+    if (!writes.has(path20)) {
+      writes.set(path20, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path21);
+          writes.delete(path20);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -33131,8 +33131,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(path20, stats) {
+    if (this.options.atomic && DOT_RE.test(path20))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -33142,17 +33142,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(path20, stats);
   }
-  _isntIgnored(path21, stat11) {
-    return !this._isIgnored(path21, stat11);
+  _isntIgnored(path20, stat11) {
+    return !this._isIgnored(path20, 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(path20) {
+    return new WatchHelper(path20, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -33184,63 +33184,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 path20 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path20);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path20) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path20, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path21);
+    const wp = this._getWatchedDir(path20);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path21, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path20, 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 = path20;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path21);
+      relPath = sp2.relative(this.options.cwd, path20);
     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(path20);
     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(path20))
+      this._emit(eventName, path20);
+    this._closePath(path20);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path21) {
-    this._closeFile(path21);
-    const dir = sp2.dirname(path21);
-    this._getWatchedDir(dir).remove(sp2.basename(path21));
+  _closePath(path20) {
+    this._closeFile(path20);
+    const dir = sp2.dirname(path20);
+    this._getWatchedDir(dir).remove(sp2.basename(path20));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path21) {
-    const closers = this._closers.get(path21);
+  _closeFile(path20) {
+    const closers = this._closers.get(path20);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path21);
+    this._closers.delete(path20);
   }
-  _addPathCloser(path21, closer) {
+  _addPathCloser(path20, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path21);
+    let list = this._closers.get(path20);
     if (!list) {
       list = [];
-      this._closers.set(path21, list);
+      this._closers.set(path20, list);
     }
     list.push(closer);
   }
@@ -34704,12 +34704,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 path20(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path22 = statics.reduce((previousValue, currentValue, index) => {
+  const path21 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -34726,7 +34726,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path21(sta
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path22.split(/[?#]/, 1)[0];
+  const pathOnly = path21.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match2;
   while ((match2 = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -34747,10 +34747,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}
+${path21}
 ${underline}`);
   }
-  return path22;
+  return path21;
 };
 var path5 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -37861,9 +37861,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error, message, headers) {
     return APIError.generate(status, error, message, headers);
   }
-  buildURL(path21, query, defaultBaseURL) {
+  buildURL(path20, 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(path20) ? new URL(path20) : new URL(baseURL + (baseURL.endsWith("/") && path20.startsWith("/") ? path20.slice(1) : path20));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -37894,24 +37894,24 @@ var BaseAnthropic = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path21, opts) {
-    return this.methodRequest("get", path21, opts);
+  get(path20, opts) {
+    return this.methodRequest("get", path20, opts);
   }
-  post(path21, opts) {
-    return this.methodRequest("post", path21, opts);
+  post(path20, opts) {
+    return this.methodRequest("post", path20, opts);
   }
-  patch(path21, opts) {
-    return this.methodRequest("patch", path21, opts);
+  patch(path20, opts) {
+    return this.methodRequest("patch", path20, opts);
   }
-  put(path21, opts) {
-    return this.methodRequest("put", path21, opts);
+  put(path20, opts) {
+    return this.methodRequest("put", path20, opts);
   }
-  delete(path21, opts) {
-    return this.methodRequest("delete", path21, opts);
+  delete(path20, opts) {
+    return this.methodRequest("delete", path20, opts);
   }
-  methodRequest(method, path21, opts) {
+  methodRequest(method, path20, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path21, ...opts2 };
+      return { method, path: path20, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -38015,8 +38015,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(path20, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path20, ...opts2 })) : { method: "get", path: path20, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -38104,8 +38104,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: path20, query, defaultBaseURL } = options;
+    const url = this.buildURL(path20, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -38927,6 +38927,19 @@ async function reportRuntimeActivity(input) {
   }
 }
 
+// src/tools/UserRecoverableToolError.ts
+var UserRecoverableToolError = class extends Error {
+  userMessage;
+  code;
+  constructor(code, userMessage2, detail) {
+    super(detail ? `${code}: ${detail}` : code);
+    this.name = "UserRecoverableToolError";
+    this.code = code;
+    this.userMessage = userMessage2;
+  }
+};
+var isUserRecoverableToolError = (error) => error instanceof UserRecoverableToolError || typeof error === "object" && error !== null && error.name === "UserRecoverableToolError" && typeof error.userMessage === "string";
+
 // src/tools/ToolExecutor.ts
 var createToolExecutor = (registry2) => {
   return {
@@ -38979,6 +38992,9 @@ var createToolExecutor = (registry2) => {
             error: err.message
           }
         });
+        if (isUserRecoverableToolError(error)) {
+          throw error;
+        }
         return `\u5DE5\u5177\u6267\u884C\u5931\u8D25 [${name}], reason: ${err.message}`;
       }
     },
@@ -40210,16 +40226,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path21, added, removed, oldPosInc, options) {
-    const last = path21.lastComponent;
+  addToPath(path20, added, removed, oldPosInc, options) {
+    const last = path20.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path21.oldPos + oldPosInc,
+        oldPos: path20.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path21.oldPos + oldPosInc,
+        oldPos: path20.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -41354,7 +41370,6 @@ var cronUpdate = {
 
 // src/tools/tools/ImageUnderstand.ts
 var import_fs9 = __toESM(require("fs"));
-var import_path15 = __toESM(require("path"));
 
 // src/types/builders.ts
 var text = (text2) => ({
@@ -41532,21 +41547,19 @@ var guessMediaTypeFromHeader = (contentType) => {
   if (contentType.includes("image/webp")) return "image/webp";
   return null;
 };
-var guessMediaTypeFromExt = (filePath) => {
-  const ext = import_path15.default.extname(filePath).toLowerCase();
-  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
-  if (ext === ".png") return "image/png";
-  if (ext === ".gif") return "image/gif";
-  if (ext === ".webp") return "image/webp";
-  return null;
-};
 var controlPlaneBaseUrl = () => {
   return process.env.DUCLAW_CONTROL_PLANE_BASE_URL?.replace(/\/$/, "");
 };
+var USER_IMAGE_REUPLOAD_MESSAGE = `\u8FD9\u5F20\u56FE\u7247\u6682\u65F6\u65E0\u6CD5\u6309\u56FE\u7247\u683C\u5F0F\u89E3\u6790\u3002\u8BF7\u91CD\u65B0\u53D1\u9001 JPG/PNG/WebP \u56FE\u7247\uFF0C\u6216\u8005\u5728\u624B\u673A\u4E0A\u622A\u56FE\u540E\u518D\u53D1\u4E00\u6B21\u3002`;
+var normalizeRuntimeAttachmentUrl = (input) => {
+  return input.replace("/api/mobile/attachments/", "/internal/runtime/mobile/attachments/");
+};
 var resolveRemoteUrl = (input) => {
-  if (/^https?:\/\//i.test(input)) return input;
+  if (/^https?:\/\//i.test(input)) return normalizeRuntimeAttachmentUrl(input);
   const baseUrl = controlPlaneBaseUrl();
-  if (baseUrl && input.startsWith("/internal/")) return `${baseUrl}${input}`;
+  if (baseUrl && (input.startsWith("/internal/") || input.startsWith("/api/mobile/attachments/"))) {
+    return `${baseUrl}${normalizeRuntimeAttachmentUrl(input)}`;
+  }
   return void 0;
 };
 var shouldAttachRuntimeAuth = (url) => {
@@ -41558,6 +41571,20 @@ var shouldAttachRuntimeAuth = (url) => {
     return false;
   }
 };
+var unsupportedImageFormatError = (detail) => new UserRecoverableToolError("unsupported_image_format", USER_IMAGE_REUPLOAD_MESSAGE, detail);
+var imageBlockFromBuffer = (buffer, contentType, sourceHint) => {
+  const base64Data = buffer.toString("base64");
+  const mediaType = guessMediaTypeFromData(base64Data) ?? guessMediaTypeFromHeader(contentType);
+  if (!mediaType) {
+    throw unsupportedImageFormatError(`${sourceHint} content-type=${contentType || "unknown"}`);
+  }
+  console.log(`[ImageUnderstand] \u63A8\u65AD\u5A92\u4F53\u7C7B\u578B: ${mediaType} (content-type: ${contentType || "unknown"})`);
+  return imageBase64(base64Data, mediaType);
+};
+var isUnsupportedProviderImageError = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return /unsupported image format|application\/octet-stream|invalid image/i.test(message);
+};
 var resolveImageBlock = async (input) => {
   const remoteUrl = resolveRemoteUrl(input);
   if (remoteUrl) {
@@ -41571,21 +41598,23 @@ var resolveImageBlock = async (input) => {
     if (!res.ok) throw new Error(`[ImageUnderstand] \u56FE\u7247\u4E0B\u8F7D\u5931\u8D25: ${res.status} ${res.statusText}`);
     const contentType = res.headers.get("content-type") || "";
     const buffer = Buffer.from(await res.arrayBuffer());
-    const base64Data = buffer.toString("base64");
-    const mediaType2 = guessMediaTypeFromData(base64Data) ?? guessMediaTypeFromHeader(contentType) ?? "image/png";
-    console.log(`[ImageUnderstand] \u63A8\u65AD\u5A92\u4F53\u7C7B\u578B: ${mediaType2} (content-type: ${contentType})`);
-    return imageBase64(base64Data, mediaType2);
+    return imageBlockFromBuffer(buffer, contentType, remoteUrl);
   }
   if (input.startsWith("/") || input.startsWith(".") || /^[A-Za-z]:[\\/]/.test(input)) {
     if (!import_fs9.default.existsSync(input)) throw new Error(`[ImageUnderstand] \u672C\u5730\u6587\u4EF6\u4E0D\u5B58\u5728: ${input}`);
     console.log(`[ImageUnderstand] \u8BFB\u53D6\u672C\u5730\u6587\u4EF6: ${input}`);
     const buffer = import_fs9.default.readFileSync(input);
-    const base64Data = buffer.toString("base64");
-    const mediaType2 = guessMediaTypeFromExt(input) ?? guessMediaTypeFromData(base64Data) ?? "image/png";
+    const mediaType2 = guessMediaTypeFromData(buffer.toString("base64"));
+    if (!mediaType2) {
+      throw unsupportedImageFormatError(input);
+    }
     console.log(`[ImageUnderstand] \u63A8\u65AD\u5A92\u4F53\u7C7B\u578B: ${mediaType2}`);
-    return imageBase64(base64Data, mediaType2);
+    return imageBase64(buffer.toString("base64"), mediaType2);
+  }
+  const mediaType = guessMediaTypeFromData(input);
+  if (!mediaType) {
+    throw unsupportedImageFormatError("base64 data magic bytes not recognized");
   }
-  const mediaType = guessMediaTypeFromData(input) ?? "image/png";
   return imageBase64(input, mediaType);
 };
 var imageUnderstand = {
@@ -41632,7 +41661,12 @@ var imageUnderstand = {
     const response = await llmClient.chat(
       [imageMessage],
       system
-    );
+    ).catch((error) => {
+      if (isUnsupportedProviderImageError(error)) {
+        throw unsupportedImageFormatError(error instanceof Error ? error.message : String(error));
+      }
+      throw error;
+    });
     const resultText = extractText(response.content);
     await reportImageUnderstandUsage({
       baseUrl: process.env.DUCLAW_CONTROL_PLANE_BASE_URL,
@@ -41655,18 +41689,18 @@ var imageUnderstand = {
 // src/skill/SkillRegistry.ts
 var import_fs11 = require("fs");
 var import_os3 = require("os");
-var import_path17 = __toESM(require("path"));
+var import_path16 = __toESM(require("path"));
 
 // src/runtime/paths.ts
 var import_fs10 = require("fs");
-var import_path16 = __toESM(require("path"));
+var import_path15 = __toESM(require("path"));
 var findProjectRoot = (filename = "duclaw.json", startDir = process.cwd()) => {
   let currentDir = startDir;
   while (true) {
-    if ((0, import_fs10.existsSync)((0, import_path16.join)(currentDir, filename))) {
+    if ((0, import_fs10.existsSync)((0, import_path15.join)(currentDir, filename))) {
       return currentDir;
     }
-    const parentDir = (0, import_path16.dirname)(currentDir);
+    const parentDir = (0, import_path15.dirname)(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -41675,12 +41709,12 @@ var findProjectRoot = (filename = "duclaw.json", startDir = process.cwd()) => {
 };
 var resolveCoreRoot = () => {
   const candidates = [
-    import_path16.default.resolve(__dirname_m, ".."),
-    import_path16.default.resolve(__dirname_m, "..", ".."),
+    import_path15.default.resolve(__dirname_m, ".."),
+    import_path15.default.resolve(__dirname_m, "..", ".."),
     process.cwd()
   ];
   for (const candidate of candidates) {
-    if ((0, import_fs10.existsSync)(import_path16.default.join(candidate, "web", "dist", "index.html"))) {
+    if ((0, import_fs10.existsSync)(import_path15.default.join(candidate, "web", "dist", "index.html"))) {
       return candidate;
     }
   }
@@ -41689,11 +41723,11 @@ var resolveCoreRoot = () => {
 var resolveWebDistRoot = () => {
   const coreRoot = resolveCoreRoot();
   const candidates = [
-    import_path16.default.join(coreRoot, "dist", "web"),
-    import_path16.default.join(coreRoot, "web", "dist")
+    import_path15.default.join(coreRoot, "dist", "web"),
+    import_path15.default.join(coreRoot, "web", "dist")
   ];
   for (const candidate of candidates) {
-    if ((0, import_fs10.existsSync)(import_path16.default.join(candidate, "index.html"))) {
+    if ((0, import_fs10.existsSync)(import_path15.default.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -41703,14 +41737,14 @@ var resolveWebDistRoot = () => {
 // src/skill/SkillRegistry.ts
 var getProjectSkillsPath = () => {
   const projectRoot = findProjectRoot();
-  return projectRoot ? (0, import_path17.join)(projectRoot, "skills") : null;
+  return projectRoot ? (0, import_path16.join)(projectRoot, "skills") : null;
 };
 var getSkillPaths = () => {
   const paths = [];
   const seenPaths = /* @__PURE__ */ new Set();
   const pushPath = (candidate) => {
     if (!(0, import_fs11.existsSync)(candidate) || !(0, import_fs11.statSync)(candidate).isDirectory()) return;
-    const normalized = import_path17.default.resolve(candidate);
+    const normalized = import_path16.default.resolve(candidate);
     if (seenPaths.has(normalized)) return;
     seenPaths.add(normalized);
     paths.push(normalized);
@@ -41719,12 +41753,12 @@ var getSkillPaths = () => {
   if (projectSkillsPath) {
     pushPath(projectSkillsPath);
   }
-  pushPath((0, import_path17.join)((0, import_os3.homedir)(), ".duclaw", "skills"));
-  pushPath((0, import_path17.join)((0, import_os3.homedir)(), ".agents", "skills"));
+  pushPath((0, import_path16.join)((0, import_os3.homedir)(), ".duclaw", "skills"));
+  pushPath((0, import_path16.join)((0, import_os3.homedir)(), ".agents", "skills"));
   return paths;
 };
 var getDirectories = (dirPath) => {
-  return (0, import_fs11.readdirSync)(dirPath).filter((name) => (0, import_fs11.statSync)((0, import_path17.join)(dirPath, name)).isDirectory());
+  return (0, import_fs11.readdirSync)(dirPath).filter((name) => (0, import_fs11.statSync)((0, import_path16.join)(dirPath, name)).isDirectory());
 };
 var parseSkill = (mdPath, skillDir) => {
   if (!(0, import_fs11.existsSync)(mdPath)) return null;
@@ -41744,14 +41778,14 @@ var parseSkill = (mdPath, skillDir) => {
     }
   }
   if (!name) {
-    name = import_path17.default.basename(import_path17.default.dirname(mdPath));
+    name = import_path16.default.basename(import_path16.default.dirname(mdPath));
   }
   if (!description && body) {
     description = body.split("\n")[0].replace(/^#+\s*/, "").trim();
   }
   const projectSkillsPath = getProjectSkillsPath();
-  const normalizedSkillDir = import_path17.default.resolve(skillDir);
-  const deletable = projectSkillsPath ? normalizedSkillDir === import_path17.default.resolve(projectSkillsPath, import_path17.default.basename(normalizedSkillDir)) && normalizedSkillDir.startsWith(import_path17.default.resolve(projectSkillsPath) + import_path17.default.sep) : false;
+  const normalizedSkillDir = import_path16.default.resolve(skillDir);
+  const deletable = projectSkillsPath ? normalizedSkillDir === import_path16.default.resolve(projectSkillsPath, import_path16.default.basename(normalizedSkillDir)) && normalizedSkillDir.startsWith(import_path16.default.resolve(projectSkillsPath) + import_path16.default.sep) : false;
   return {
     name,
     description,
@@ -41773,8 +41807,8 @@ var loadSkill = () => {
   for (const skillPath of skillPaths) {
     const dirs = getDirectories(skillPath);
     for (const skillName of dirs) {
-      const eachSkillPath = (0, import_path17.join)(skillPath, skillName);
-      const eachSkillMdPath = (0, import_path17.join)(eachSkillPath, "SKILL.md");
+      const eachSkillPath = (0, import_path16.join)(skillPath, skillName);
+      const eachSkillMdPath = (0, import_path16.join)(eachSkillPath, "SKILL.md");
       const skill = parseSkill(eachSkillMdPath, eachSkillPath);
       if (skill && !seen.has(skill.name)) {
         seen.add(skill.name);
@@ -42402,29 +42436,29 @@ var listMailboxEvents = (params) => {
 
 // src/department/DepartmentMember.ts
 var import_fs13 = require("fs");
-var import_path19 = __toESM(require("path"));
+var import_path18 = __toESM(require("path"));
 
 // src/department/Department.ts
-var import_path18 = __toESM(require("path"));
+var import_path17 = __toESM(require("path"));
 var import_fs12 = require("fs");
 var legacyMigrationChecked = false;
 var getDepartmentBaseDir = () => {
-  return import_path18.default.join(getDuclawHomeDir(), "department");
+  return import_path17.default.join(getDuclawHomeDir(), "department");
 };
 var getLegacyTeamBaseDir = () => {
-  return import_path18.default.join(getDuclawHomeDir(), "team");
+  return import_path17.default.join(getDuclawHomeDir(), "team");
 };
 var getDepartmentWorkSpaceDir = (departmentName) => {
-  return import_path18.default.join(getDepartmentBaseDir(), "workspace", departmentName);
+  return import_path17.default.join(getDepartmentBaseDir(), "workspace", departmentName);
 };
 var getLegacyTeamWorkSpaceDir = (teamName) => {
-  return import_path18.default.join(getLegacyTeamBaseDir(), "workspace", teamName);
+  return import_path17.default.join(getLegacyTeamBaseDir(), "workspace", teamName);
 };
 var getDepartmentJsonPath = (departmentName) => {
-  return import_path18.default.join(getDepartmentWorkSpaceDir(departmentName), "department.json");
+  return import_path17.default.join(getDepartmentWorkSpaceDir(departmentName), "department.json");
 };
 var getLegacyTeamJsonPath = (teamName) => {
-  return import_path18.default.join(getLegacyTeamWorkSpaceDir(teamName), "team.json");
+  return import_path17.default.join(getLegacyTeamWorkSpaceDir(teamName), "team.json");
 };
 var mapLegacyRole = (role) => {
   return role === "team_manager" ? "department_head" : "executor";
@@ -42453,7 +42487,7 @@ var mapLegacyDepartment = (legacy) => {
 var migrateLegacyTeamsToDepartments = () => {
   if (legacyMigrationChecked) return;
   legacyMigrationChecked = true;
-  const legacyWorkspaceDir = import_path18.default.join(getLegacyTeamBaseDir(), "workspace");
+  const legacyWorkspaceDir = import_path17.default.join(getLegacyTeamBaseDir(), "workspace");
   if (!(0, import_fs12.existsSync)(legacyWorkspaceDir)) return;
   for (const legacyName of (0, import_fs12.readdirSync)(legacyWorkspaceDir)) {
     const legacyJsonPath = getLegacyTeamJsonPath(legacyName);
@@ -42486,7 +42520,7 @@ var getDepartment = (name) => {
 };
 var listDepartments = () => {
   migrateLegacyTeamsToDepartments();
-  const workspaceDir = import_path18.default.join(getDepartmentBaseDir(), "workspace");
+  const workspaceDir = import_path17.default.join(getDepartmentBaseDir(), "workspace");
   if (!(0, import_fs12.existsSync)(workspaceDir)) return [];
   const departments = [];
   for (const departmentName of (0, import_fs12.readdirSync)(workspaceDir)) {
@@ -42531,7 +42565,7 @@ var createDepartmentMember = (departmentMemberDefinition) => {
   const { name, departmentId, workspaceId } = departmentMemberDefinition;
   const department = getDepartmentById(departmentId);
   if (!department) throw new Error(`[createDepartmentMember] \u627E\u4E0D\u5230\u5BF9\u5E94\u7684 department: ${departmentId}`);
-  const memberPath = import_path19.default.join(getDepartmentWorkSpaceDir(department.name), name);
+  const memberPath = import_path18.default.join(getDepartmentWorkSpaceDir(department.name), name);
   (0, import_fs13.mkdirSync)(memberPath, { recursive: true });
   const workspace = {
     id: getWorkspaceId(department.name, departmentMemberDefinition.name),
@@ -46723,6 +46757,7 @@ ${memoryInjection}` : "") + dreamInjection;
         if (toolUses.length > 0) {
           await addMessage(storage, userId, assistantMessageFromResponse(response), beijingTime, job?.title);
           if (toolExecutor) {
+            const userRecoverableMessages = [];
             const toolResultPromises = toolUses.map(async (useBlock) => {
               if (signal.aborted) {
                 return toolResult(useBlock.id, `\u5DE5\u5177\u6267\u884C\u88AB\u4E2D\u65AD`);
@@ -46779,6 +46814,10 @@ ${memoryInjection}` : "") + dreamInjection;
                 return toolResult(useBlock.id, result);
               } catch (error) {
                 const err = error;
+                if (isUserRecoverableToolError(error)) {
+                  userRecoverableMessages.push(error.userMessage);
+                  return toolResult(useBlock.id, `${useBlock.name}\u5DE5\u5177\u9700\u8981\u7528\u6237\u8865\u5145\u8F93\u5165,reason: ${err.message}`);
+                }
                 return toolResult(useBlock.id, `${useBlock.name}\u5DE5\u5177\u6267\u884C\u9519\u8BEF,reason: ${err.message}`);
               }
             });
@@ -46786,6 +46825,30 @@ ${memoryInjection}` : "") + dreamInjection;
             if (toolResults.length > 0) {
               await addMessage(storage, userId, { role: "user", content: toolResults }, beijingTime, job?.title);
             }
+            const userRecoverableMessage = userRecoverableMessages[0]?.trim();
+            if (userRecoverableMessage) {
+              let recoverableMessageSent = false;
+              if (config2.channelPlugin && !internalOnly) {
+                if (claimOutboundSend(request.userId, userRecoverableMessage)) {
+                  await config2.channelPlugin.outbound.sendText({
+                    cfg: {},
+                    to: request.userId,
+                    text: userRecoverableMessage,
+                    accountId: request.requestId,
+                    metadata: request.metadata
+                  });
+                  recoverableMessageSent = true;
+                } else {
+                  console.log(`[outbound-dedup] \u8DF3\u8FC7\u5BF9\u7528\u6237 ${request.userId} \u7684\u8FD1\u91CD\u590D\u53EF\u6062\u590D\u9519\u8BEF\u63D0\u793A`);
+                }
+              }
+              await addMessage(storage, userId, assistantMessage(text(userRecoverableMessage)), beijingTime, job?.title);
+              markAgentEventsHandled([...injectedEventIds]);
+              return {
+                content: userRecoverableMessage,
+                alreadySent: recoverableMessageSent
+              };
+            }
           }
           continue;
         }
@@ -48335,26 +48398,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 = (path20) => {
+  const paths = path20.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path21 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path21);
+  const { groups, path: path20 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path20);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path21) => {
+var extractGroupsFromPath = (path20) => {
   const groups = [];
-  path21 = path21.replace(/\{[^}]+\}/g, (match2, index) => {
+  path20 = path20.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path21 };
+  return { groups, path: path20 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -48411,8 +48474,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 path20 = url.slice(start, end);
+      return tryDecodeURI(path20.includes("%25") ? path20.replace(/%25/g, "%2525") : path20);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -48429,11 +48492,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 = (path20) => {
+  if (path20.charCodeAt(path20.length - 1) !== 63 || !path20.includes(":")) {
     return null;
   }
-  const segments = path21.split("/");
+  const segments = path20.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -48574,9 +48637,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path21 = "/", matchResult = [[]]) {
+  constructor(request, path20 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path21;
+    this.path = path20;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -49313,8 +49376,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path21, ...handlers) => {
-      for (const p of [path21].flat()) {
+    this.on = (method, path20, ...handlers) => {
+      for (const p of [path20].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -49371,8 +49434,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path21, app) {
-    const subApp = this.basePath(path21);
+  route(path20, app) {
+    const subApp = this.basePath(path20);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -49398,9 +49461,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path21) {
+  basePath(path20) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path21);
+    subApp._basePath = mergePath(this._basePath, path20);
     return subApp;
   }
   /**
@@ -49474,7 +49537,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path21, applicationHandler, options) {
+  mount(path20, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -49501,7 +49564,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path21);
+      const mergedPath = mergePath(this._basePath, path20);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -49516,14 +49579,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path21, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path20, "*"), handler);
     return this;
   }
-  #addRoute(method, path21, handler) {
+  #addRoute(method, path20, 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]);
+    path20 = mergePath(this._basePath, path20);
+    const r = { basePath: this._basePath, path: path20, method, handler };
+    this.router.add(method, path20, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -49536,10 +49599,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 path20 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path20);
     const c = new Context(request, {
-      path: path21,
+      path: path20,
       matchResult,
       env,
       executionCtx,
@@ -49639,7 +49702,7 @@ 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, path20) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -49655,7 +49718,7 @@ function match(method, path21) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path21);
+  return match2(method, path20);
 }
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -49770,12 +49833,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path21, index, pathErrorCheckOnly) {
+  insert(path20, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path21 = path21.replace(/\{[^}]+\}/g, (m) => {
+      path20 = path20.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -49786,7 +49849,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path21.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path20.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -49825,9 +49888,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(path20) {
+  return wildcardRegExpCache[path20] ??= new RegExp(
+    path20 === "*" ? "" : `^${path20.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -49849,17 +49912,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, path20, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path21] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path20] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path21, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path20, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path21) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path20) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -49893,12 +49956,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path21) {
+function findMiddleware(middleware, path20) {
   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(path20)) {
       return [...middleware[k]];
     }
   }
@@ -49912,7 +49975,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, path20, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -49927,18 +49990,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path21 === "/*") {
-      path21 = "*";
+    if (path20 === "/*") {
+      path20 = "*";
     }
-    const paramCount = (path21.match(/\/:/g) || []).length;
-    if (/\*$/.test(path21)) {
-      const re = buildWildcardRegExp(path21);
+    const paramCount = (path20.match(/\/:/g) || []).length;
+    if (/\*$/.test(path20)) {
+      const re = buildWildcardRegExp(path20);
       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][path20] ||= findMiddleware(middleware[m], path20) || findMiddleware(middleware[METHOD_NAME_ALL], path20) || [];
         });
       } else {
-        middleware[method][path21] ||= findMiddleware(middleware[method], path21) || findMiddleware(middleware[METHOD_NAME_ALL], path21) || [];
+        middleware[method][path20] ||= findMiddleware(middleware[method], path20) || findMiddleware(middleware[METHOD_NAME_ALL], path20) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -49956,7 +50019,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path21) || [path21];
+    const paths = checkOptionalParameter(path20) || [path20];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -49983,13 +50046,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((path20) => [path20, r[method][path20]]) : [];
       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((path20) => [path20, r[METHOD_NAME_ALL][path20]])
         );
       }
     });
@@ -50009,13 +50072,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path21, handler) {
+  add(method, path20, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path21, handler]);
+    this.#routes.push([method, path20, handler]);
   }
-  match(method, path21) {
+  match(method, path20) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -50030,7 +50093,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, path20);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -50080,10 +50143,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path21, handler) {
+  insert(method, path20, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path21);
+    const parts = splitRoutingPath(path20);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -50132,12 +50195,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path21) {
+  search(method, path20) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path21);
+    const parts = splitPath(path20);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -50179,13 +50242,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path21[0] === "/" ? 1 : 0;
+              let offset = path20[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 = path20.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -50238,18 +50301,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path21, handler) {
-    const results = checkOptionalParameter(path21);
+  add(method, path20, handler) {
+    const results = checkOptionalParameter(path20);
     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, path20, handler);
   }
-  match(method, path21) {
-    return this.#node.search(method, path21);
+  match(method, path20) {
+    return this.#node.search(method, path20);
   }
 };
 
@@ -50914,7 +50977,7 @@ var baseMimes = _baseMimes;
 
 // node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.9/node_modules/@hono/node-server/dist/serve-static.mjs
 var import_fs15 = require("fs");
-var import_path20 = require("path");
+var import_path19 = require("path");
 var import_process = require("process");
 var import_stream2 = require("stream");
 var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
@@ -50951,10 +51014,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path21) => {
+var getStats = (path20) => {
   let stats;
   try {
-    stats = (0, import_fs15.statSync)(path21);
+    stats = (0, import_fs15.statSync)(path20);
   } catch {
   }
   return stats;
@@ -50997,21 +51060,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path21 = (0, import_path20.join)(
+    let path20 = (0, import_path19.join)(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path21);
+    let stats = getStats(path20);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path21 = (0, import_path20.join)(path21, indexFile);
-      stats = getStats(path21);
+      path20 = (0, import_path19.join)(path20, indexFile);
+      stats = getStats(path20);
     }
     if (!stats) {
-      await options.onNotFound?.(path21, c);
+      await options.onNotFound?.(path20, c);
       return next();
     }
-    const mimeType = getMimeType(path21);
+    const mimeType = getMimeType(path20);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -51021,12 +51084,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path21 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path20 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path21 = path21 + ENCODINGS[encoding];
+          path20 = path20 + ENCODINGS[encoding];
           break;
         }
       }
@@ -51040,7 +51103,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)(path20)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -51051,12 +51114,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)(path20, { 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?.(path20, c);
     return result;
   };
 };
@@ -51156,13 +51219,13 @@ var import_node_path17 = __toESM(require("node:path"));
 // src/git/worktree.ts
 var import_child_process2 = require("child_process");
 var import_util = require("util");
-var import_path21 = __toESM(require("path"));
+var import_path20 = __toESM(require("path"));
 var import_fs16 = require("fs");
 var execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
 var getProjectRoot = () => process.cwd();
 var getWorktreeBaseDir = () => getDuclawWorktreesDir();
 var getDisplayWorktreePath = (goalId, taskId) => `~/.duclaw/worktrees/${goalId}/${taskId}`;
-var getWorktreePath = (goalId, taskId) => import_path21.default.join(getWorktreeBaseDir(), goalId, taskId);
+var getWorktreePath = (goalId, taskId) => import_path20.default.join(getWorktreeBaseDir(), goalId, taskId);
 var getBranchName = (taskId) => `task/${taskId}`;
 async function git(args, cwd) {
   const { stdout } = await execFileAsync("git", args, {
@@ -51174,7 +51237,7 @@ async function git(args, cwd) {
 async function createWorktree(taskId, goalId, baseBranch = "main") {
   const wtPath = getWorktreePath(goalId, taskId);
   const branch = getBranchName(taskId);
-  const parentDir = import_path21.default.dirname(wtPath);
+  const parentDir = import_path20.default.dirname(wtPath);
   if (!(0, import_fs16.existsSync)(parentDir)) {
     (0, import_fs16.mkdirSync)(parentDir, { recursive: true });
   }
@@ -51280,8 +51343,8 @@ async function listWorktrees() {
     const fullBranch = branchLine.replace("branch refs/heads/", "");
     if (!fullBranch.startsWith("task/")) continue;
     const taskId = fullBranch.replace("task/", "");
-    const relPath = import_path21.default.relative(getProjectRoot(), wtPath);
-    const parts = relPath.split(import_path21.default.sep);
+    const relPath = import_path20.default.relative(getProjectRoot(), wtPath);
+    const parts = relPath.split(import_path20.default.sep);
     const worktreeIdx = parts.indexOf(".worktrees");
     const goalId = worktreeIdx >= 0 && parts.length > worktreeIdx + 1 ? parts[worktreeIdx + 1] : "";
     worktrees.push({
@@ -53110,7 +53173,7 @@ var systemRoutes = new Hono2();
 var startTime = Date.now();
 systemRoutes.get("/system/info", (c) => {
   return c.json({
-    version: true ? "1.9.3" : "unknown",
+    version: true ? "1.9.4" : "unknown",
     uptime: Math.floor((Date.now() - startTime) / 1e3),
     env: process.env.NODE_ENV || "development",
     nodeVersion: process.version