npm - duclaw-cli - Versions diffs - 1.8.15 → 1.8.17 - Mend

duclaw-cli 1.8.15 → 1.8.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/bundle.js CHANGED Viewed

@@ -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 path18 = require("path");
+    var path19 = 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 = path18.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path19.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] === "~" ? path18.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path19.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 = path18.resolve(process.cwd(), ".env");
+      const dotenvPath = path19.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 path19 of optionPaths) {
+      for (const path20 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path19, { encoding }));
+          const parsed = DotenvModule.parse(fs3.readFileSync(path20, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path19} ${e.message}`);
+            _debug(`Failed to load ${path20} ${e.message}`);
           }
           lastError = e;
         }
@@ -333,7 +333,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative4 = path18.relative(process.cwd(), filePath);
+            const relative4 = path19.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, path18, moduleArguments) {
-        parser.push("MODULE", "LOAD", path18);
+      parseCommand(parser, path19, moduleArguments) {
+        parser.push("MODULE", "LOAD", path19);
         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, path18, json, ...jsons) {
+      parseCommand(parser, key, path19, json, ...jsons) {
         parser.push("JSON.ARRAPPEND");
         parser.pushKey(key);
-        parser.push(path18, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path19, (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, path18, json, options) {
+      parseCommand(parser, key, path19, json, options) {
         parser.push("JSON.ARRINDEX");
         parser.pushKey(key);
-        parser.push(path18, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path19, (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, path18, index, json, ...jsons) {
+      parseCommand(parser, key, path19, index, json, ...jsons) {
         parser.push("JSON.ARRINSERT");
         parser.pushKey(key);
-        parser.push(path18, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path19, 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, path18, start, stop) {
+      parseCommand(parser, key, path19, start, stop) {
         parser.push("JSON.ARRTRIM");
         parser.pushKey(key);
-        parser.push(path18, start.toString(), stop.toString());
+        parser.push(path19, 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, path18, value) {
+      parseCommand(parser, key, path19, value) {
         parser.push("JSON.MERGE");
         parser.pushKey(key);
-        parser.push(path18, (0, generic_transformers_1.transformRedisJsonArgument)(value));
+        parser.push(path19, (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, path18) {
+      parseCommand(parser, keys, path19) {
         parser.push("JSON.MGET");
         parser.pushKeys(keys);
-        parser.push(path18);
+        parser.push(path19);
       },
       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, path18, by) {
+      parseCommand(parser, key, path19, by) {
         parser.push("JSON.NUMINCRBY");
         parser.pushKey(key);
-        parser.push(path18, by.toString());
+        parser.push(path19, 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, path18, by) {
+      parseCommand(parser, key, path19, by) {
         parser.push("JSON.NUMMULTBY");
         parser.pushKey(key);
-        parser.push(path18, by.toString());
+        parser.push(path19, 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, path18, json, options) {
+      parseCommand(parser, key, path19, json, options) {
         parser.push("JSON.SET");
         parser.pushKey(key);
-        parser.push(path18, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path19, (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, path18) {
+      parseCommand(parser, key, path19) {
         parser.push("JSON.TOGGLE");
         parser.pushKey(key);
-        parser.push(path18);
+        parser.push(path19);
       },
       transformReply: void 0
     };
@@ -30242,7 +30242,7 @@ function printHelp() {
 `);
 }
 function printVersion() {
-  console.log(`duclaw-cli v${true ? "1.8.15" : "unknown"}`);
+  console.log(`duclaw-cli v${true ? "1.8.17" : "unknown"}`);
 }
 function getDuclawTemplate() {
   return {
@@ -30983,7 +30983,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises2.lstat : import_promises2.stat;
     if (wantBigintFsStats) {
-      this._stat = (path18) => statMethod(path18, { bigint: true });
+      this._stat = (path19) => statMethod(path19, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -31008,8 +31008,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: path18, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
+          const { path: path19, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path19));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -31049,20 +31049,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path18, depth) {
+  async _exploreDir(path19, depth) {
     let files;
     try {
-      files = await (0, import_promises2.readdir)(path18, this._rdOptions);
+      files = await (0, import_promises2.readdir)(path19, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path18 };
+    return { files, depth, path: path19 };
   }
-  async _formatEntry(dirent, path18) {
+  async _formatEntry(dirent, path19) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path2.resolve)((0, import_node_path2.join)(path18, basename4));
+      const fullPath = (0, import_node_path2.resolve)((0, import_node_path2.join)(path19, basename4));
       entry = { path: (0, import_node_path2.relative)(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -31462,16 +31462,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path19, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path18);
-    emitRaw(rawEvent, evPath, { watchedPath: path18 });
-    if (evPath && path18 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path18, evPath), KEY_LISTENERS, sp.join(path18, evPath));
+    listener(path19);
+    emitRaw(rawEvent, evPath, { watchedPath: path19 });
+    if (evPath && path19 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path19, evPath), KEY_LISTENERS, sp.join(path19, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path18, {
+    return (0, import_node_fs.watch)(path19, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -31487,12 +31487,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path18, fullPath, options, handlers) => {
+var setFsWatchListener = (path19, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path19, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -31503,7 +31503,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path18,
+      path19,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -31518,7 +31518,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises3.open)(path18, "r");
+          const fd = await (0, import_promises3.open)(path19, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -31549,7 +31549,7 @@ var setFsWatchListener = (path18, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path19, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -31571,7 +31571,7 @@ var setFsWatchFileListener = (path18, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path18, curr));
+          foreach(cont.listeners, (listener2) => listener2(path19, curr));
         }
       })
     };
@@ -31601,13 +31601,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path18, listener) {
+  _watchWithNodeFs(path19, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path18);
-    const basename4 = sp.basename(path18);
+    const directory = sp.dirname(path19);
+    const basename4 = sp.basename(path19);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path18);
+    const absolutePath = sp.resolve(path19);
     const options = {
       persistent: opts.persistent
     };
@@ -31617,12 +31617,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path18, absolutePath, options, {
+      closer = setFsWatchFileListener(path19, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path18, absolutePath, options, {
+      closer = setFsWatchListener(path19, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -31644,7 +31644,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path18, newStats) => {
+    const listener = async (path19, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -31658,11 +31658,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path18);
+            this.fsw._closeFile(path19);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path18, closer2);
+              this.fsw._addPathCloser(path19, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -31694,7 +31694,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, path18, item) {
+  async _handleSymlink(entry, directory, path19, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -31704,7 +31704,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises3.realpath)(path18);
+        linkPath = await (0, import_promises3.realpath)(path19);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -31714,12 +31714,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, path18, entry.stats);
+          this.fsw._emit(EV.CHANGE, path19, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path18, entry.stats);
+        this.fsw._emit(EV.ADD, path19, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -31749,9 +31749,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path18 = sp.join(directory, item);
+      let path19 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path19, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -31760,8 +31760,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path18 = sp.join(dir, sp.relative(dir, path18));
-        this._addToNodeFs(path18, initialAdd, wh, depth + 1);
+        path19 = sp.join(dir, sp.relative(dir, path19));
+        this._addToNodeFs(path19, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve11, reject) => {
@@ -31830,13 +31830,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path19, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path18) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path19) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path18);
+    const wh = this.fsw._getWatchHelpers(path19);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -31852,8 +31852,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path18);
-        const targetPath = follow ? await (0, import_promises3.realpath)(path18) : path18;
+        const absPath = sp.resolve(path19);
+        const targetPath = follow ? await (0, import_promises3.realpath)(path19) : path19;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -31863,29 +31863,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises3.realpath)(path18) : path18;
+        const targetPath = follow ? await (0, import_promises3.realpath)(path19) : path19;
         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, path18, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path19, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path18), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path19), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path18, closer);
+        this.fsw._addPathCloser(path19, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path18;
+        return path19;
       }
     }
   }
@@ -31928,24 +31928,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path18) {
-  if (typeof path18 !== "string")
+function normalizePath(path19) {
+  if (typeof path19 !== "string")
     throw new Error("string expected");
-  path18 = sp2.normalize(path18);
-  path18 = path18.replace(/\\/g, "/");
+  path19 = sp2.normalize(path19);
+  path19 = path19.replace(/\\/g, "/");
   let prepend = false;
-  if (path18.startsWith("//"))
+  if (path19.startsWith("//"))
     prepend = true;
-  path18 = path18.replace(DOUBLE_SLASH_RE, "/");
+  path19 = path19.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path18 = "/" + path18;
-  return path18;
+    path19 = "/" + path19;
+  return path19;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path18 = normalizePath(testString);
+  const path19 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path18, stats)) {
+    if (pattern(path19, stats)) {
       return true;
     }
   }
@@ -31983,19 +31983,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path18) => toUnix(sp2.normalize(toUnix(path18)));
-var normalizeIgnored = (cwd = "") => (path18) => {
-  if (typeof path18 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path18) ? path18 : sp2.join(cwd, path18));
+var normalizePathToUnix = (path19) => toUnix(sp2.normalize(toUnix(path19)));
+var normalizeIgnored = (cwd = "") => (path19) => {
+  if (typeof path19 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path19) ? path19 : sp2.join(cwd, path19));
   } else {
-    return path18;
+    return path19;
   }
 };
-var getAbsolutePath = (path18, cwd) => {
-  if (sp2.isAbsolute(path18)) {
-    return path18;
+var getAbsolutePath = (path19, cwd) => {
+  if (sp2.isAbsolute(path19)) {
+    return path19;
   }
-  return sp2.join(cwd, path18);
+  return sp2.join(cwd, path19);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -32060,10 +32060,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path18, follow, fsw) {
+  constructor(path19, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path18;
-    this.path = path18 = path18.replace(REPLACER_RE, "");
+    const watchPath = path19;
+    this.path = path19 = path19.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -32203,20 +32203,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path18) => {
-        const absPath = getAbsolutePath(path18, cwd);
+      paths = paths.map((path19) => {
+        const absPath = getAbsolutePath(path19, cwd);
         return absPath;
       });
     }
-    paths.forEach((path18) => {
-      this._removeIgnoredPath(path18);
+    paths.forEach((path19) => {
+      this._removeIgnoredPath(path19);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path18) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path19) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path19, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -32238,17 +32238,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path18) => {
-      if (!sp2.isAbsolute(path18) && !this._closers.has(path18)) {
+    paths.forEach((path19) => {
+      if (!sp2.isAbsolute(path19) && !this._closers.has(path19)) {
         if (cwd)
-          path18 = sp2.join(cwd, path18);
-        path18 = sp2.resolve(path18);
+          path19 = sp2.join(cwd, path19);
+        path19 = sp2.resolve(path19);
       }
-      this._closePath(path18);
-      this._addIgnoredPath(path18);
-      if (this._watched.has(path18)) {
+      this._closePath(path19);
+      this._addIgnoredPath(path19);
+      if (this._watched.has(path19)) {
         this._addIgnoredPath({
-          path: path18,
+          path: path19,
           recursive: true
         });
       }
@@ -32312,38 +32312,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, path18, stats) {
+  async _emit(event, path19, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path18 = sp2.normalize(path18);
+      path19 = sp2.normalize(path19);
     if (opts.cwd)
-      path18 = sp2.relative(opts.cwd, path18);
-    const args = [path18];
+      path19 = sp2.relative(opts.cwd, path19);
+    const args = [path19];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path18))) {
+    if (awf && (pw = this._pendingWrites.get(path19))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path18, [event, ...args]);
+        this._pendingUnlinks.set(path19, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path19) => {
+          this._pendingUnlinks.forEach((entry, path20) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path19);
+            this._pendingUnlinks.delete(path20);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path19)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path18);
+        this._pendingUnlinks.delete(path19);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -32361,16 +32361,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path19, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path19, 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, path18) : path18;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path19) : path19;
       let stats2;
       try {
         stats2 = await (0, import_promises4.stat)(fullPath);
@@ -32401,23 +32401,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, path18, timeout) {
+  _throttle(actionType, path19, 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(path18);
+    const actionPath = action.get(path19);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path18);
+      const item = action.get(path19);
       const count = item ? item.count : 0;
-      action.delete(path18);
+      action.delete(path19);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -32425,7 +32425,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path18, thr);
+    action.set(path19, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -32439,44 +32439,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(path18, threshold, event, awfEmit) {
+  _awaitWriteFinish(path19, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path18;
-    if (this.options.cwd && !sp2.isAbsolute(path18)) {
-      fullPath = sp2.join(this.options.cwd, path18);
+    let fullPath = path19;
+    if (this.options.cwd && !sp2.isAbsolute(path19)) {
+      fullPath = sp2.join(this.options.cwd, path19);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path18)) {
+        if (err || !writes.has(path19)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path18).lastChange = now2;
+          writes.get(path19).lastChange = now2;
         }
-        const pw = writes.get(path18);
+        const pw = writes.get(path19);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path18);
+          writes.delete(path19);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path18)) {
-      writes.set(path18, {
+    if (!writes.has(path19)) {
+      writes.set(path19, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path18);
+          writes.delete(path19);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -32487,8 +32487,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path18, stats) {
-    if (this.options.atomic && DOT_RE.test(path18))
+  _isIgnored(path19, stats) {
+    if (this.options.atomic && DOT_RE.test(path19))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -32498,17 +32498,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(path18, stats);
+    return this._userIgnored(path19, stats);
   }
-  _isntIgnored(path18, stat10) {
-    return !this._isIgnored(path18, stat10);
+  _isntIgnored(path19, stat10) {
+    return !this._isIgnored(path19, stat10);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path18) {
-    return new WatchHelper(path18, this.options.followSymlinks, this);
+  _getWatchHelpers(path19) {
+    return new WatchHelper(path19, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -32540,63 +32540,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path18 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path18);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path18, 100))
+    const path19 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path19);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path19) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path19, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path18);
+    const wp = this._getWatchedDir(path19);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path18, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path19, 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 = path18;
+    let relPath = path19;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path18);
+      relPath = sp2.relative(this.options.cwd, path19);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path18);
+    this._watched.delete(path19);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path18))
-      this._emit(eventName, path18);
-    this._closePath(path18);
+    if (wasTracked && !this._isIgnored(path19))
+      this._emit(eventName, path19);
+    this._closePath(path19);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path18) {
-    this._closeFile(path18);
-    const dir = sp2.dirname(path18);
-    this._getWatchedDir(dir).remove(sp2.basename(path18));
+  _closePath(path19) {
+    this._closeFile(path19);
+    const dir = sp2.dirname(path19);
+    this._getWatchedDir(dir).remove(sp2.basename(path19));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path18) {
-    const closers = this._closers.get(path18);
+  _closeFile(path19) {
+    const closers = this._closers.get(path19);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path18);
+    this._closers.delete(path19);
   }
-  _addPathCloser(path18, closer) {
+  _addPathCloser(path19, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path18);
+    let list = this._closers.get(path19);
     if (!list) {
       list = [];
-      this._closers.set(path18, list);
+      this._closers.set(path19, list);
     }
     list.push(closer);
   }
@@ -32630,7 +32630,7 @@ var import_node_cron = __toESM(require_node_cron());
 // src/agent/createAgent.ts
 var import_node_crypto11 = require("node:crypto");
-var import_node_fs6 = require("node:fs");
+var import_node_fs7 = require("node:fs");
 // src/background/BackgroundManager.ts
 var import_child_process = require("child_process");
@@ -34060,12 +34060,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 path18(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path19(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path19 = statics.reduce((previousValue, currentValue, index) => {
+  const path20 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -34082,7 +34082,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path18(sta
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path19.split(/[?#]/, 1)[0];
+  const pathOnly = path20.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match2;
   while ((match2 = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -34103,10 +34103,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path18(sta
     }, "");
     throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path19}
+${path20}
 ${underline}`);
   }
-  return path19;
+  return path20;
 };
 var path4 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
@@ -37217,9 +37217,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error, message, headers) {
     return APIError.generate(status, error, message, headers);
   }
-  buildURL(path18, query, defaultBaseURL) {
+  buildURL(path19, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path18) ? new URL(path18) : new URL(baseURL + (baseURL.endsWith("/") && path18.startsWith("/") ? path18.slice(1) : path18));
+    const url = isAbsoluteURL(path19) ? new URL(path19) : new URL(baseURL + (baseURL.endsWith("/") && path19.startsWith("/") ? path19.slice(1) : path19));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -37250,24 +37250,24 @@ var BaseAnthropic = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path18, opts) {
-    return this.methodRequest("get", path18, opts);
+  get(path19, opts) {
+    return this.methodRequest("get", path19, opts);
   }
-  post(path18, opts) {
-    return this.methodRequest("post", path18, opts);
+  post(path19, opts) {
+    return this.methodRequest("post", path19, opts);
   }
-  patch(path18, opts) {
-    return this.methodRequest("patch", path18, opts);
+  patch(path19, opts) {
+    return this.methodRequest("patch", path19, opts);
   }
-  put(path18, opts) {
-    return this.methodRequest("put", path18, opts);
+  put(path19, opts) {
+    return this.methodRequest("put", path19, opts);
   }
-  delete(path18, opts) {
-    return this.methodRequest("delete", path18, opts);
+  delete(path19, opts) {
+    return this.methodRequest("delete", path19, opts);
   }
-  methodRequest(method, path18, opts) {
+  methodRequest(method, path19, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path18, ...opts2 };
+      return { method, path: path19, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -37371,8 +37371,8 @@ var BaseAnthropic = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime: startTime2 };
   }
-  getAPIList(path18, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path18, ...opts2 })) : { method: "get", path: path18, ...opts });
+  getAPIList(path19, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path19, ...opts2 })) : { method: "get", path: path19, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -37460,8 +37460,8 @@ var BaseAnthropic = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path18, query, defaultBaseURL } = options;
-    const url = this.buildURL(path18, query, defaultBaseURL);
+    const { method, path: path19, query, defaultBaseURL } = options;
+    const url = this.buildURL(path19, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -38248,6 +38248,38 @@ var clearMessages = async (storage, userId, date, cronTitle) => {
   await storage.del(key);
 };
+// src/runtime/activity.ts
+async function reportRuntimeActivity(input) {
+  const baseUrl = process.env.DUCLAW_CONTROL_PLANE_BASE_URL?.replace(/\/$/, "");
+  const token = process.env.DUCLAW_CONTROL_PLANE_METERING_TOKEN;
+  const tenantId = process.env.DUCLAW_TENANT_ID;
+  if (!baseUrl || !token || !tenantId) return;
+  try {
+    const response = await fetch(`${baseUrl}/internal/runtime/activity`, {
+      method: "POST",
+      signal: AbortSignal.timeout(2500),
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        tenantId,
+        kind: input.kind,
+        status: input.status,
+        toolName: input.toolName,
+        toolCallId: input.toolCallId ?? null,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: input.metadata ?? {}
+      })
+    });
+    if (!response.ok) {
+      console.warn(`[runtime-activity] \u4E0A\u62A5\u5931\u8D25: tool=${input.toolName} status=${input.status} http=${response.status}`);
+    }
+  } catch (err) {
+    console.warn(`[runtime-activity] \u4E0A\u62A5\u5F02\u5E38: tool=${input.toolName} status=${input.status} error=${err.message}`);
+  }
+}
 // src/tools/ToolExecutor.ts
 var createToolExecutor = (registry2) => {
   return {
@@ -38260,10 +38292,46 @@ var createToolExecutor = (registry2) => {
           throw new Error(`[ToolExecutor] \u5DE5\u5177 ${name} \u7F3A\u5C11\u5FC5\u586B\u53C2\u6570: ${key}`);
         }
       }
+      const toolCallId = typeof userRequest?.metadata?.toolCallId === "string" ? userRequest.metadata.toolCallId : null;
+      await reportRuntimeActivity({
+        kind: "tool_use",
+        toolName: name,
+        status: "started",
+        toolCallId,
+        metadata: {
+          platform: userRequest?.platform,
+          requestId: userRequest?.requestId,
+          departmentAgentId: userRequest?.departmentAgentId
+        }
+      });
       try {
-        return await tool.execute(input ?? {}, userRequest);
+        const result = await tool.execute(input ?? {}, userRequest);
+        await reportRuntimeActivity({
+          kind: "tool_use",
+          toolName: name,
+          status: "completed",
+          toolCallId,
+          metadata: {
+            platform: userRequest?.platform,
+            requestId: userRequest?.requestId,
+            departmentAgentId: userRequest?.departmentAgentId
+          }
+        });
+        return result;
       } catch (error) {
         const err = error;
+        await reportRuntimeActivity({
+          kind: "tool_use",
+          toolName: name,
+          status: "failed",
+          toolCallId,
+          metadata: {
+            platform: userRequest?.platform,
+            requestId: userRequest?.requestId,
+            departmentAgentId: userRequest?.departmentAgentId,
+            error: err.message
+          }
+        });
         return `\u5DE5\u5177\u6267\u884C\u5931\u8D25 [${name}], reason: ${err.message}`;
       }
     },
@@ -39495,16 +39563,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path18, added, removed, oldPosInc, options) {
-    const last = path18.lastComponent;
+  addToPath(path19, added, removed, oldPosInc, options) {
+    const last = path19.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path18.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path18.oldPos + oldPosInc,
+        oldPos: path19.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -42433,29 +42501,231 @@ ${replies}`;
 };
 // src/department/learning.ts
+var import_node_fs4 = require("node:fs");
+var import_node_path12 = __toESM(require("node:path"));
+var import_node_crypto6 = require("node:crypto");
+// src/skill/SkillValidator.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path11 = __toESM(require("node:path"));
-var import_node_crypto6 = require("node:crypto");
-var ensureDir = (dir) => (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+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,
+  /(^|\n)##\s+(steps|workflow|procedure|执行步骤|工作流)\b/i
+];
+var stripYamlQuotes = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.startsWith(`"`) && trimmed.endsWith(`"`) || trimmed.startsWith(`'`) && trimmed.endsWith(`'`)) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+};
+var addError = (errors, code, message) => {
+  errors.push({ code, message });
+};
+var addWarning = (warnings, code, message) => {
+  warnings.push({ code, message });
+};
+var isValidSkillName = (name) => {
+  return SKILL_NAME_PATTERN.test(name) && !name.includes(`--`);
+};
+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_path11.default.resolve(rootDir);
+  const target = import_node_path11.default.resolve(root, skillName);
+  if (target !== import_node_path11.default.join(root, skillName) || !target.startsWith(root + import_node_path11.default.sep)) {
+    throw new Error(`Invalid skill install target for "${skillName}".`);
+  }
+  return target;
+};
+var parseSkillDocument = (skillMd) => {
+  const fmMatch = skillMd.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!fmMatch) return null;
+  const frontmatter = {};
+  for (const rawLine of fmMatch[1].split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith(`#`)) continue;
+    const match2 = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match2) {
+      frontmatter[`__invalid__${Object.keys(frontmatter).length}`] = line;
+      continue;
+    }
+    frontmatter[match2[1]] = stripYamlQuotes(match2[2]);
+  }
+  return {
+    name: frontmatter.name ?? ``,
+    description: frontmatter.description ?? ``,
+    body: skillMd.slice(fmMatch[0].length).trim(),
+    frontmatter
+  };
+};
+var validateSkillDocument = (input) => {
+  const errors = [];
+  const warnings = [];
+  const skillMd = input.skillMd;
+  if (!skillMd || !skillMd.trim()) {
+    addError(errors, `empty_skill_md`, `SKILL.md content is required.`);
+    return { ok: false, errors, warnings };
+  }
+  const parsed = parseSkillDocument(skillMd);
+  if (!parsed) {
+    addError(errors, `missing_frontmatter`, `SKILL.md must start with YAML frontmatter delimited by "---".`);
+    return { ok: false, errors, warnings };
+  }
+  const invalidFrontmatterLines = Object.keys(parsed.frontmatter).filter((key) => key.startsWith(`__invalid__`));
+  if (invalidFrontmatterLines.length > 0) {
+    addError(errors, `invalid_frontmatter`, `Frontmatter must contain simple "key: value" lines.`);
+  }
+  if (!parsed.name) {
+    addError(errors, `missing_name`, `Frontmatter field "name" is required.`);
+  } else if (!isValidSkillName(parsed.name)) {
+    addError(errors, `invalid_name`, `Skill name "${parsed.name}" must be kebab-case, under 64 characters, and path-safe.`);
+  }
+  if (!parsed.description) {
+    addError(errors, `missing_description`, `Frontmatter field "description" is required.`);
+  } else if (parsed.description.length > 500) {
+    addWarning(warnings, `long_description`, `Skill description is long; keep trigger metadata concise.`);
+  }
+  if (input.skillName && parsed.name && input.skillName !== parsed.name) {
+    addError(errors, `name_mismatch`, `Input skillName "${input.skillName}" must match frontmatter name "${parsed.name}".`);
+  }
+  if (input.description && parsed.description && input.description !== parsed.description) {
+    addError(errors, `description_mismatch`, `Input description must match frontmatter description.`);
+  }
+  if (!parsed.body) {
+    addError(errors, `empty_body`, `SKILL.md body is required.`);
+  } else {
+    if (!/(^|\n)#\s+\S/.test(parsed.body)) {
+      addWarning(warnings, `missing_title`, `Skill body should start with a Markdown H1 title.`);
+    }
+    for (const sectionPattern of REQUIRED_SECTIONS) {
+      if (!sectionPattern.test(parsed.body)) {
+        addWarning(warnings, `missing_recommended_section`, `Skill body should include when-to-use and execution workflow sections.`);
+        break;
+      }
+    }
+  }
+  if (input.baseDir) {
+    const normalizedBase = import_node_path11.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_path11.default.resolve(normalizedBase, href.split(`#`)[0]);
+      if (!target.startsWith(normalizedBase + import_node_path11.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.`);
+      }
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    skill: parsed,
+    errors,
+    warnings
+  };
+};
+var mergeIssues = (target, source) => {
+  target.errors.push(...source.errors);
+  target.warnings.push(...source.warnings);
+};
+var validateScriptsDirectory = (skillDir, warnings) => {
+  const scriptsDir = import_node_path11.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) {
+    addWarning(warnings, `empty_scripts_dir`, `scripts/ exists but contains no files.`);
+  }
+};
+var validateSkillDirectory = (skillDir, options = {}) => {
+  const errors = [];
+  const warnings = [];
+  const normalizedSkillDir = import_node_path11.default.resolve(skillDir);
+  const skillMdPath = import_node_path11.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 };
+  }
+  if (!(0, import_node_fs3.existsSync)(skillMdPath) || !(0, import_node_fs3.statSync)(skillMdPath).isFile()) {
+    addError(errors, `missing_skill_md`, `Skill directory must contain SKILL.md.`);
+    return { ok: false, errors, warnings, skillDir: normalizedSkillDir, skillMdPath };
+  }
+  const raw2 = (0, import_node_fs3.readFileSync)(skillMdPath, `utf-8`);
+  const documentResult = validateSkillDocument({
+    skillName: options.expectedName ?? import_node_path11.default.basename(normalizedSkillDir),
+    skillMd: raw2,
+    baseDir: normalizedSkillDir
+  });
+  mergeIssues({ errors, warnings }, documentResult);
+  validateScriptsDirectory(normalizedSkillDir, warnings);
+  return {
+    ok: errors.length === 0,
+    skill: documentResult.skill,
+    errors,
+    warnings,
+    skillDir: normalizedSkillDir,
+    skillMdPath
+  };
+};
+var smokeTestSkillDirectory = (skillDir, options = {}) => {
+  const directoryResult = validateSkillDirectory(skillDir, options);
+  const errors = [...directoryResult.errors];
+  const warnings = [...directoryResult.warnings];
+  let detail;
+  if (directoryResult.ok && directoryResult.skill) {
+    detail = `Base directory for this skill: ${directoryResult.skillDir}
+${directoryResult.skill.body}`;
+    if (!detail.includes(directoryResult.skillDir)) {
+      addError(errors, `smoke_missing_base_dir`, `Skill detail does not include its base directory.`);
+    }
+    if (!detail.includes(directoryResult.skill.body)) {
+      addError(errors, `smoke_missing_body`, `Skill detail does not include the SKILL.md body.`);
+    }
+    if (detail.length < 80) {
+      addWarning(warnings, `smoke_short_detail`, `Skill detail is unusually short.`);
+    }
+  }
+  return {
+    ...directoryResult,
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    detail
+  };
+};
+var formatSkillValidationIssues = (result) => {
+  const lines = [
+    ...result.errors.map((issue) => `- [${issue.code}] ${issue.message}`),
+    ...result.warnings.map((issue) => `- [warning:${issue.code}] ${issue.message}`)
+  ];
+  return lines.join(`
+`);
+};
+// src/department/learning.ts
+var ensureDir = (dir) => (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
 var readJsonArray = (filePath) => {
-  if (!(0, import_node_fs3.existsSync)(filePath)) return [];
-  return JSON.parse((0, import_node_fs3.readFileSync)(filePath, "utf-8"));
+  if (!(0, import_node_fs4.existsSync)(filePath)) return [];
+  return JSON.parse((0, import_node_fs4.readFileSync)(filePath, "utf-8"));
 };
 var writeJsonArray = (filePath, records) => {
-  ensureDir(import_node_path11.default.dirname(filePath));
-  (0, import_node_fs3.writeFileSync)(filePath, JSON.stringify(records, null, "	"), "utf-8");
+  ensureDir(import_node_path12.default.dirname(filePath));
+  (0, import_node_fs4.writeFileSync)(filePath, JSON.stringify(records, null, "	"), "utf-8");
 };
 var departmentMemoryPath = (departmentName) => {
-  return import_node_path11.default.join(getDepartmentWorkSpaceDir(departmentName), "department-memory.json");
+  return import_node_path12.default.join(getDepartmentWorkSpaceDir(departmentName), "department-memory.json");
 };
 var departmentSkillPath = (departmentName) => {
-  return import_node_path11.default.join(getDepartmentWorkSpaceDir(departmentName), "department-skills.json");
+  return import_node_path12.default.join(getDepartmentWorkSpaceDir(departmentName), "department-skills.json");
 };
 var departmentSkillDir = (departmentName, skillName) => {
-  return import_node_path11.default.join(getDepartmentWorkSpaceDir(departmentName), "skills", skillName);
+  return assertSafeSkillTarget(import_node_path12.default.join(getDepartmentWorkSpaceDir(departmentName), "skills"), skillName);
 };
 var proposalsPath = () => {
-  return import_node_path11.default.join(getDepartmentBaseDir(), "department-proposals.json");
+  return import_node_path12.default.join(getDepartmentBaseDir(), "department-proposals.json");
 };
 var getDepartmentNameForHead = (request) => {
   const mailboxId = request?.departmentAgentId;
@@ -42507,6 +42777,15 @@ var listDepartmentSkills = (departmentName) => {
   return readJsonArray(departmentSkillPath(departmentName)).sort((a, b) => b.updatedAt - a.updatedAt);
 };
 var proposeDepartmentSkill = (departmentName, input) => {
+  const validation = validateSkillDocument({
+    skillName: input.skillName,
+    description: input.description,
+    skillMd: input.skillMd
+  });
+  if (!validation.ok) {
+    throw new Error(`[departmentSkill] Skill \u8349\u7A3F\u6821\u9A8C\u5931\u8D25\uFF1A
+${formatSkillValidationIssues(validation)}`);
+  }
   const records = listDepartmentSkills(departmentName);
   if (records.some((record) => record.skillName === input.skillName && record.status !== "dropped")) {
     return null;
@@ -42533,8 +42812,23 @@ var keepDepartmentSkill = (departmentName, id) => {
   if (idx < 0) return null;
   records[idx] = { ...records[idx], status: "active", updatedAt: Date.now() };
   const skillDir = departmentSkillDir(departmentName, records[idx].skillName);
+  const validation = validateSkillDocument({
+    skillName: records[idx].skillName,
+    description: records[idx].description,
+    skillMd: records[idx].skillMd,
+    baseDir: skillDir
+  });
+  if (!validation.ok) {
+    throw new Error(`[departmentSkill] Skill \u8349\u7A3F\u6821\u9A8C\u5931\u8D25\uFF0C\u62D2\u7EDD\u4FDD\u7559\uFF1A
+${formatSkillValidationIssues(validation)}`);
+  }
   ensureDir(skillDir);
-  (0, import_node_fs3.writeFileSync)(import_node_path11.default.join(skillDir, "SKILL.md"), records[idx].skillMd, "utf-8");
+  (0, import_node_fs4.writeFileSync)(import_node_path12.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
+${formatSkillValidationIssues(smokeTest)}`);
+  }
   writeJsonArray(departmentSkillPath(departmentName), records);
   return records[idx];
 };
@@ -42695,14 +42989,18 @@ var departmentSkillPropose = {
   async execute(input, userRequest) {
     const departmentName = requireDepartmentHead(userRequest);
     if (!departmentName) return `[departmentSkillPropose] \u53EA\u6709 Department Head \u53EF\u4EE5\u63D0\u4EA4\u90E8\u95E8 Skill \u8349\u7A3F`;
-    const skill = proposeDepartmentSkill(departmentName, {
-      skillName: input.skillName,
-      description: input.description,
-      skillMd: input.skillMd,
-      createdByMailboxId: userRequest?.departmentAgentId
-    });
-    if (!skill) return `[departmentSkillPropose] \u540C\u540D\u90E8\u95E8 Skill \u5DF2\u5B58\u5728\u6216\u5F85\u786E\u8BA4: ${input.skillName}`;
-    return `[departmentSkillPropose] \u5DF2\u63D0\u4EA4\u90E8\u95E8 Skill \u8349\u7A3F: ${JSON.stringify(skill)}`;
+    try {
+      const skill = proposeDepartmentSkill(departmentName, {
+        skillName: input.skillName,
+        description: input.description,
+        skillMd: input.skillMd,
+        createdByMailboxId: userRequest?.departmentAgentId
+      });
+      if (!skill) return `[departmentSkillPropose] \u540C\u540D\u90E8\u95E8 Skill \u5DF2\u5B58\u5728\u6216\u5F85\u786E\u8BA4: ${input.skillName}`;
+      return `[departmentSkillPropose] \u5DF2\u63D0\u4EA4\u90E8\u95E8 Skill \u8349\u7A3F: ${JSON.stringify(skill)}`;
+    } catch (err) {
+      return `[departmentSkillPropose] ${err.message}`;
+    }
   }
 };
 var departmentSkillKeep = {
@@ -42718,9 +43016,13 @@ var departmentSkillKeep = {
   async execute(input, userRequest) {
     const departmentName = requireDepartmentHead(userRequest);
     if (!departmentName) return `[departmentSkillKeep] \u53EA\u6709 Department Head \u53EF\u4EE5\u4FDD\u7559\u90E8\u95E8 Skill`;
-    const skill = keepDepartmentSkill(departmentName, input.id);
-    if (!skill) return `[departmentSkillKeep] \u672A\u627E\u5230\u90E8\u95E8 Skill: ${input.id}`;
-    return `[departmentSkillKeep] \u5DF2\u4FDD\u7559\u90E8\u95E8 Skill: ${JSON.stringify(skill)}`;
+    try {
+      const skill = keepDepartmentSkill(departmentName, input.id);
+      if (!skill) return `[departmentSkillKeep] \u672A\u627E\u5230\u90E8\u95E8 Skill: ${input.id}`;
+      return `[departmentSkillKeep] \u5DF2\u4FDD\u7559\u90E8\u95E8 Skill: ${JSON.stringify(skill)}`;
+    } catch (err) {
+      return `[departmentSkillKeep] ${err.message}`;
+    }
   }
 };
 var departmentSkillDrop = {
@@ -42874,7 +43176,7 @@ var mailboxFollowup = {
 // src/tools/tools/Bash.ts
 var import_node_child_process = require("node:child_process");
 var import_node_crypto7 = require("node:crypto");
-var import_node_fs4 = require("node:fs");
+var import_node_fs5 = require("node:fs");
 var DESCRIPTION29 = `\u5728\u7CFB\u7EDF shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002
 \u7528\u9014\uFF1A
@@ -42910,7 +43212,7 @@ var sessions = /* @__PURE__ */ new Map();
 function findExecutableShell2() {
   for (const shell of SHELL_CANDIDATES2) {
     try {
-      (0, import_node_fs4.accessSync)(shell, import_node_fs4.constants.X_OK);
+      (0, import_node_fs5.accessSync)(shell, import_node_fs5.constants.X_OK);
       return shell;
     } catch {
     }
@@ -42919,11 +43221,11 @@ function findExecutableShell2() {
 }
 function validateCwd(cwd) {
   try {
-    const stat10 = (0, import_node_fs4.statSync)(cwd);
+    const stat10 = (0, import_node_fs5.statSync)(cwd);
     if (!stat10.isDirectory()) {
       return `[bash] \u9519\u8BEF: cwd \u4E0D\u662F\u76EE\u5F55: ${cwd}`;
     }
-    (0, import_node_fs4.accessSync)(cwd, import_node_fs4.constants.R_OK | import_node_fs4.constants.X_OK);
+    (0, import_node_fs5.accessSync)(cwd, import_node_fs5.constants.R_OK | import_node_fs5.constants.X_OK);
     return null;
   } catch (err) {
     const code = err.code;
@@ -43688,9 +43990,9 @@ var readDreamHistoryLimit = () => {
 };
 // src/skillForge/SkillForgeEngine.ts
-var import_node_fs5 = require("node:fs");
+var import_node_fs6 = require("node:fs");
 var import_node_os2 = require("node:os");
-var import_node_path12 = require("node:path");
+var import_node_path13 = require("node:path");
 var import_node_crypto8 = require("node:crypto");
 var SkillForgeEngine = class {
   proposalStorage;
@@ -43699,8 +44001,8 @@ var SkillForgeEngine = class {
   constructor(deps) {
     this.proposalStorage = deps.proposalStorage;
     const opt = deps.options ?? {};
-    this.draftRoot = opt.draftRoot ?? (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".duclaw", "skill-proposals");
-    this.skillsInstallDir = opt.skillsInstallDir ?? (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".agents", "skills");
+    this.draftRoot = opt.draftRoot ?? (0, import_node_path13.join)((0, import_node_os2.homedir)(), ".duclaw", "skill-proposals");
+    this.skillsInstallDir = opt.skillsInstallDir ?? (0, import_node_path13.join)((0, import_node_os2.homedir)(), ".agents", "skills");
   }
   // ---------- 公开方法 ----------
   /**
@@ -43712,6 +44014,11 @@ var SkillForgeEngine = class {
     if (!skillName || !description || !skillMd) {
       throw new Error(`[skillForge] propose \u53C2\u6570\u4E0D\u5B8C\u6574\uFF1AskillName/description/skillMd \u5747\u5FC5\u586B`);
     }
+    const validation = validateSkillDocument({ skillName, description, skillMd });
+    if (!validation.ok) {
+      throw new Error(`[skillForge] Skill \u8349\u7A3F\u6821\u9A8C\u5931\u8D25\uFF1A
+${formatSkillValidationIssues(validation)}`);
+    }
     const existingSkills = SkillRegistry_default();
     if (existingSkills.some((s) => s.name === skillName)) {
       return null;
@@ -43721,9 +44028,18 @@ var SkillForgeEngine = class {
       return null;
     }
     const id = (0, import_node_crypto8.randomBytes)(4).toString("hex");
-    const draftDir = (0, import_node_path12.join)(this.draftRoot, userId, id);
-    (0, import_node_fs5.mkdirSync)(draftDir, { recursive: true });
-    (0, import_node_fs5.writeFileSync)((0, import_node_path12.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
+    const draftDir = (0, import_node_path13.join)(this.draftRoot, userId, id);
+    (0, import_node_fs6.mkdirSync)(draftDir, { recursive: true });
+    (0, import_node_fs6.writeFileSync)((0, import_node_path13.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
+    const directoryValidation = validateSkillDirectory(draftDir, { expectedName: skillName });
+    if (!directoryValidation.ok) {
+      try {
+        (0, import_node_fs6.rmSync)(draftDir, { recursive: true, force: true });
+      } catch {
+      }
+      throw new Error(`[skillForge] Skill \u76EE\u5F55\u6821\u9A8C\u5931\u8D25\uFF1A
+${formatSkillValidationIssues(directoryValidation)}`);
+    }
     const proposal = {
       id,
       userId,
@@ -43741,17 +44057,38 @@ var SkillForgeEngine = class {
     const list = await this.proposalStorage.get(this.proposalKey(userId)) ?? [];
     const proposal = list.find((p) => p.id === proposalId);
     if (!proposal) return null;
-    const target = (0, import_node_path12.join)(this.skillsInstallDir, proposal.skillName);
-    if ((0, import_node_fs5.existsSync)(target)) {
+    const validation = validateSkillDocument({
+      skillName: proposal.skillName,
+      description: proposal.description,
+      skillMd: proposal.skillMd,
+      baseDir: proposal.draftDir
+    });
+    if (!validation.ok) {
+      throw new Error(`[skillForge] Skill \u8349\u7A3F\u6821\u9A8C\u5931\u8D25\uFF0C\u62D2\u7EDD\u843D\u5730\uFF1A
+${formatSkillValidationIssues(validation)}`);
+    }
+    const target = assertSafeSkillTarget(this.skillsInstallDir, proposal.skillName);
+    let installedTarget = target;
+    if ((0, import_node_fs6.existsSync)(target)) {
       const alt = target + "-" + proposalId;
-      (0, import_node_fs5.mkdirSync)(alt, { recursive: true });
-      (0, import_node_fs5.cpSync)(proposal.draftDir, alt, { recursive: true });
+      (0, import_node_fs6.mkdirSync)(alt, { recursive: true });
+      (0, import_node_fs6.cpSync)(proposal.draftDir, alt, { recursive: true });
+      installedTarget = alt;
     } else {
-      (0, import_node_fs5.mkdirSync)(target, { recursive: true });
-      (0, import_node_fs5.cpSync)(proposal.draftDir, target, { recursive: true });
+      (0, import_node_fs6.mkdirSync)(target, { recursive: true });
+      (0, import_node_fs6.cpSync)(proposal.draftDir, target, { recursive: true });
+    }
+    const smokeTest = smokeTestSkillDirectory(installedTarget, { expectedName: proposal.skillName });
+    if (!smokeTest.ok) {
+      try {
+        (0, import_node_fs6.rmSync)(installedTarget, { recursive: true, force: true });
+      } catch {
+      }
+      throw new Error(`[skillForge] Skill smoke test \u5931\u8D25\uFF0C\u5DF2\u56DE\u6EDA\u843D\u5730\u76EE\u5F55\uFF1A
+${formatSkillValidationIssues(smokeTest)}`);
     }
     try {
-      (0, import_node_fs5.rmSync)(proposal.draftDir, { recursive: true, force: true });
+      (0, import_node_fs6.rmSync)(proposal.draftDir, { recursive: true, force: true });
     } catch {
     }
     await this.removeProposal(userId, proposalId);
@@ -43763,7 +44100,7 @@ var SkillForgeEngine = class {
     const proposal = list.find((p) => p.id === proposalId);
     if (!proposal) return null;
     try {
-      (0, import_node_fs5.rmSync)(proposal.draftDir, { recursive: true, force: true });
+      (0, import_node_fs6.rmSync)(proposal.draftDir, { recursive: true, force: true });
     } catch {
     }
     await this.removeProposal(userId, proposalId);
@@ -43912,9 +44249,13 @@ var skillForgeKeep = (engine) => ({
       return `\u672A\u80FD\u5B9A\u4F4D\u5230\u5177\u4F53\u7684\u8349\u7A3F\uFF0C\u8BF7\u8BA9\u7528\u6237\u8865\u5145\u8349\u7A3F\u540D\u79F0\u6216 id\u3002\u5F53\u524D pending \u5217\u8868\uFF1A
 ` + pending.map((p) => `- ${p.id} ${p.skillName}`).join("\n");
     }
-    const approved = await engine.approve(userId, target.id);
-    if (!approved) return `\u4FDD\u7559\u5931\u8D25\uFF1A\u8349\u7A3F ${target.id} \u5DF2\u88AB\u5904\u7406\u6216\u4E0D\u5B58\u5728\u3002`;
-    return `\u2705 \u5DF2\u4FDD\u7559\u6280\u80FD\u300C${approved.skillName}\u300D\u5230 ~/.agents/skills/\uFF0C\u4E0B\u6B21\u7C7B\u4F3C\u4EFB\u52A1\u5C06\u81EA\u52A8\u590D\u7528\u3002`;
+    try {
+      const approved = await engine.approve(userId, target.id);
+      if (!approved) return `\u4FDD\u7559\u5931\u8D25\uFF1A\u8349\u7A3F ${target.id} \u5DF2\u88AB\u5904\u7406\u6216\u4E0D\u5B58\u5728\u3002`;
+      return `\u2705 \u5DF2\u4FDD\u7559\u6280\u80FD\u300C${approved.skillName}\u300D\u5230 ~/.agents/skills/\uFF0C\u4E0B\u6B21\u7C7B\u4F3C\u4EFB\u52A1\u5C06\u81EA\u52A8\u590D\u7528\u3002`;
+    } catch (err) {
+      return `\u4FDD\u7559\u5931\u8D25\uFF1A${err.message}`;
+    }
   }
 });
@@ -44803,7 +45144,7 @@ var llmRequestIdForTurn = (request, messages, system, tools) => {
 };
 var getDefaultAgentConfig = (tools, systemPrompt) => {
   loadEnv();
-  (0, import_node_fs6.mkdirSync)(DEFAULT_WORKSPACE_PATH, { recursive: true });
+  (0, import_node_fs7.mkdirSync)(DEFAULT_WORKSPACE_PATH, { recursive: true });
   let system = ``;
   if (!systemPrompt) {
     system = `
@@ -44892,6 +45233,7 @@ The user will primarily request you perform software engineering tasks. This inc
   - \u5B58\u5728\u591A\u79CD\u65B9\u6848\u4E14\u5404\u6709\u5229\u5F0A\u65F6\uFF0C\u5217\u51FA\u9009\u9879\u8BA9\u7528\u6237\u9009\u62E9
   - \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
 - \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>
@@ -46108,15 +46450,7 @@ var wakeDepartmentAgent = async (mailboxId, msgIds) => {
     };
     const result = await agent(request);
     console.log(`[mailbox] department agent ${mailboxId} \u5904\u7406\u5B8C\u6210, alreadySent=${result.alreadySent}`);
-    for (const id of msgIds) {
-      const changed = updateMailboxMessageStatus(id, "pending", {
-        fromStatus: "processing",
-        reason: "department_agent_retry"
-      });
-      if (changed) {
-        console.log(`[mailbox] \u6D88\u606F ${id} \u672A\u88AB agent \u5904\u7406\uFF0C\u5DF2\u91CD\u7F6E\u4E3A pending`);
-      }
-    }
+    finalizeDepartmentAgentUnrepliedMessages(mailboxId, msgIds, result);
   } catch (err) {
     console.error(`[mailbox] \u5524\u9192 department agent ${mailboxId} \u5931\u8D25:`, err);
     for (const id of msgIds) {
@@ -46127,6 +46461,63 @@ var wakeDepartmentAgent = async (mailboxId, msgIds) => {
     }
   }
 };
+var finalizeDepartmentAgentUnrepliedMessages = (mailboxId, msgIds, result) => {
+  const fallbackContent = result.content?.trim();
+  for (const id of msgIds) {
+    const row = db2.prepare(
+      `SELECT
+                id,
+                to_mailbox_id as toMailboxId,
+                from_mailbox_id as fromMailboxId,
+                status,
+                origin_user_id as originUserId,
+                origin_platform as originPlatform,
+                thread_id as threadId
+             FROM mailbox
+             WHERE id = ?`
+    ).get(id);
+    if (!row || row.status !== "processing") continue;
+    if (fallbackContent) {
+      const changed2 = updateMailboxMessageStatus(id, "done", {
+        fromStatus: "processing",
+        actorMailboxId: mailboxId,
+        counterpartMailboxId: row.fromMailboxId,
+        reason: "department_agent_fallback_reply"
+      });
+      if (changed2) {
+        sendMessage2(mailboxId, row.fromMailboxId, fallbackContent, {
+          originUserId: row.originUserId,
+          originPlatform: row.originPlatform,
+          threadId: row.threadId || row.id,
+          parentMessageId: row.id,
+          auditDetail: {
+            fallbackReason: "department_agent_returned_without_reply_mailbox"
+          }
+        });
+        console.warn(`[mailbox] department agent ${mailboxId} \u672A\u8C03\u7528 reply_mailbox\uFF0C\u5DF2\u5C06\u6700\u7EC8\u6587\u672C\u515C\u5E95\u8F6C\u4E3A\u90AE\u4EF6 ${id} \u7684\u56DE\u4FE1`);
+      }
+      continue;
+    }
+    const changed = updateMailboxMessageStatus(id, "failed", {
+      fromStatus: "processing",
+      actorMailboxId: mailboxId,
+      counterpartMailboxId: row.fromMailboxId,
+      reason: "department_agent_no_reply"
+    });
+    if (changed) {
+      sendMessage2(mailboxId, row.fromMailboxId, `[\u7CFB\u7EDF\u901A\u77E5] ${mailboxId} \u672C\u8F6E\u88AB\u5524\u9192\u540E\u6CA1\u6709\u4EA7\u51FA\u53EF\u8F6C\u4EA4\u7684\u56DE\u590D\uFF0C\u539F\u90AE\u4EF6\u5DF2\u6807\u8BB0\u4E3A failed\uFF0C\u907F\u514D\u7EE7\u7EED\u91CD\u590D\u6295\u9012\u3002`, {
+        originUserId: row.originUserId,
+        originPlatform: row.originPlatform,
+        threadId: row.threadId || row.id,
+        parentMessageId: row.id,
+        auditDetail: {
+          fallbackReason: "department_agent_returned_empty_without_reply_mailbox"
+        }
+      });
+      console.warn(`[mailbox] department agent ${mailboxId} \u6CA1\u6709\u56DE\u590D\u5185\u5BB9\uFF0C\u90AE\u4EF6 ${id} \u5DF2\u6807\u8BB0 failed`);
+    }
+  }
+};
 var polling = false;
 var pollMailbox = async () => {
   if (polling) return;
@@ -46210,7 +46601,6 @@ var createDepartmentAgentTools = () => {
   registerTool(registry2, departmentSkillKeep);
   registerTool(registry2, departmentSkillDrop);
   registerTool(registry2, departmentProposalCreate);
-  registerTool(registry2, sendMessage);
   return { registry: registry2, executor };
 };
 var getDepartmentAgentConfig = (tools, memberFocusOn, workspacePath, departmentName) => {
@@ -46445,26 +46835,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path18) => {
-  const paths = path18.split("/");
+var splitPath = (path19) => {
+  const paths = path19.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path18 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path18);
+  const { groups, path: path19 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path19);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path18) => {
+var extractGroupsFromPath = (path19) => {
   const groups = [];
-  path18 = path18.replace(/\{[^}]+\}/g, (match2, index) => {
+  path19 = path19.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path18 };
+  return { groups, path: path19 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -46521,8 +46911,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 path18 = url.slice(start, end);
-      return tryDecodeURI(path18.includes("%25") ? path18.replace(/%25/g, "%2525") : path18);
+      const path19 = url.slice(start, end);
+      return tryDecodeURI(path19.includes("%25") ? path19.replace(/%25/g, "%2525") : path19);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -46539,11 +46929,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path18) => {
-  if (path18.charCodeAt(path18.length - 1) !== 63 || !path18.includes(":")) {
+var checkOptionalParameter = (path19) => {
+  if (path19.charCodeAt(path19.length - 1) !== 63 || !path19.includes(":")) {
     return null;
   }
-  const segments = path18.split("/");
+  const segments = path19.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -46684,9 +47074,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path18 = "/", matchResult = [[]]) {
+  constructor(request, path19 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path18;
+    this.path = path19;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -47423,8 +47813,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path18, ...handlers) => {
-      for (const p of [path18].flat()) {
+    this.on = (method, path19, ...handlers) => {
+      for (const p of [path19].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -47481,8 +47871,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path18, app) {
-    const subApp = this.basePath(path18);
+  route(path19, app) {
+    const subApp = this.basePath(path19);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -47508,9 +47898,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path18) {
+  basePath(path19) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path18);
+    subApp._basePath = mergePath(this._basePath, path19);
     return subApp;
   }
   /**
@@ -47584,7 +47974,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path18, applicationHandler, options) {
+  mount(path19, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -47611,7 +48001,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path18);
+      const mergedPath = mergePath(this._basePath, path19);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -47626,14 +48016,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path18, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path19, "*"), handler);
     return this;
   }
-  #addRoute(method, path18, handler) {
+  #addRoute(method, path19, handler) {
     method = method.toUpperCase();
-    path18 = mergePath(this._basePath, path18);
-    const r = { basePath: this._basePath, path: path18, method, handler };
-    this.router.add(method, path18, [handler, r]);
+    path19 = mergePath(this._basePath, path19);
+    const r = { basePath: this._basePath, path: path19, method, handler };
+    this.router.add(method, path19, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -47646,10 +48036,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path18 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path18);
+    const path19 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path19);
     const c = new Context(request, {
-      path: path18,
+      path: path19,
       matchResult,
       env,
       executionCtx,
@@ -47749,7 +48139,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, path18) {
+function match(method, path19) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -47765,7 +48155,7 @@ function match(method, path18) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path18);
+  return match2(method, path19);
 }
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -47880,12 +48270,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path18, index, pathErrorCheckOnly) {
+  insert(path19, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path18 = path18.replace(/\{[^}]+\}/g, (m) => {
+      path19 = path19.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -47896,7 +48286,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path18.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path19.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -47935,9 +48325,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(path18) {
-  return wildcardRegExpCache[path18] ??= new RegExp(
-    path18 === "*" ? "" : `^${path18.replace(
+function buildWildcardRegExp(path19) {
+  return wildcardRegExpCache[path19] ??= new RegExp(
+    path19 === "*" ? "" : `^${path19.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -47959,17 +48349,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path18, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path19, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path18] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path19] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path18, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path19, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path18) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path19) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -48003,12 +48393,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path18) {
+function findMiddleware(middleware, path19) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path18)) {
+    if (buildWildcardRegExp(k).test(path19)) {
       return [...middleware[k]];
     }
   }
@@ -48022,7 +48412,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path18, handler) {
+  add(method, path19, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -48037,18 +48427,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path18 === "/*") {
-      path18 = "*";
+    if (path19 === "/*") {
+      path19 = "*";
     }
-    const paramCount = (path18.match(/\/:/g) || []).length;
-    if (/\*$/.test(path18)) {
-      const re = buildWildcardRegExp(path18);
+    const paramCount = (path19.match(/\/:/g) || []).length;
+    if (/\*$/.test(path19)) {
+      const re = buildWildcardRegExp(path19);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path18] ||= findMiddleware(middleware[m], path18) || findMiddleware(middleware[METHOD_NAME_ALL], path18) || [];
+          middleware[m][path19] ||= findMiddleware(middleware[m], path19) || findMiddleware(middleware[METHOD_NAME_ALL], path19) || [];
         });
       } else {
-        middleware[method][path18] ||= findMiddleware(middleware[method], path18) || findMiddleware(middleware[METHOD_NAME_ALL], path18) || [];
+        middleware[method][path19] ||= findMiddleware(middleware[method], path19) || findMiddleware(middleware[METHOD_NAME_ALL], path19) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -48066,7 +48456,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path18) || [path18];
+    const paths = checkOptionalParameter(path19) || [path19];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -48093,13 +48483,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((path18) => [path18, r[method][path18]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path19) => [path19, r[method][path19]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path18) => [path18, r[METHOD_NAME_ALL][path18]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path19) => [path19, r[METHOD_NAME_ALL][path19]])
         );
       }
     });
@@ -48119,13 +48509,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path18, handler) {
+  add(method, path19, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path18, handler]);
+    this.#routes.push([method, path19, handler]);
   }
-  match(method, path18) {
+  match(method, path19) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -48140,7 +48530,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path18);
+        res = router.match(method, path19);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -48190,10 +48580,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path18, handler) {
+  insert(method, path19, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path18);
+    const parts = splitRoutingPath(path19);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -48242,12 +48632,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path18) {
+  search(method, path19) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path18);
+    const parts = splitPath(path19);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -48289,13 +48679,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path18[0] === "/" ? 1 : 0;
+              let offset = path19[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path18.substring(partOffsets[i]);
+            const restPathString = path19.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -48348,18 +48738,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path18, handler) {
-    const results = checkOptionalParameter(path18);
+  add(method, path19, handler) {
+    const results = checkOptionalParameter(path19);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path18, handler);
+    this.#node.insert(method, path19, handler);
   }
-  match(method, path18) {
-    return this.#node.search(method, path18);
+  match(method, path19) {
+    return this.#node.search(method, path19);
   }
 };
@@ -49061,10 +49451,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path18) => {
+var getStats = (path19) => {
   let stats;
   try {
-    stats = (0, import_fs15.statSync)(path18);
+    stats = (0, import_fs15.statSync)(path19);
   } catch {
   }
   return stats;
@@ -49107,21 +49497,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path18 = (0, import_path20.join)(
+    let path19 = (0, import_path20.join)(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path18);
+    let stats = getStats(path19);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path18 = (0, import_path20.join)(path18, indexFile);
-      stats = getStats(path18);
+      path19 = (0, import_path20.join)(path19, indexFile);
+      stats = getStats(path19);
     }
     if (!stats) {
-      await options.onNotFound?.(path18, c);
+      await options.onNotFound?.(path19, c);
       return next();
     }
-    const mimeType = getMimeType(path18);
+    const mimeType = getMimeType(path19);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -49131,12 +49521,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path18 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path19 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path18 = path18 + ENCODINGS[encoding];
+          path19 = path19 + ENCODINGS[encoding];
           break;
         }
       }
@@ -49150,7 +49540,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)(path18)), 200);
+      result = c.body(createStreamBody((0, import_fs15.createReadStream)(path19)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -49161,12 +49551,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = (0, import_fs15.createReadStream)(path18, { start, end });
+      const stream = (0, import_fs15.createReadStream)(path19, { 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?.(path18, c);
+    await options.onFound?.(path19, c);
     return result;
   };
 };
@@ -49261,7 +49651,7 @@ var cors = (options) => {
 // src/server/index.ts
 var import_promises11 = require("node:fs/promises");
-var import_node_path14 = __toESM(require("node:path"));
+var import_node_path15 = __toESM(require("node:path"));
 // src/git/worktree.ts
 var import_child_process2 = require("child_process");
@@ -50492,8 +50882,8 @@ mailboxRoutes.get("/mailbox/summary", (c) => {
 // src/server/routes/memory.ts
 var import_redis4 = __toESM(require_dist2());
-var import_node_fs7 = require("node:fs");
-var import_node_path13 = __toESM(require("node:path"));
+var import_node_fs8 = require("node:fs");
+var import_node_path14 = __toESM(require("node:path"));
 var memoryEngineSingleton = null;
 var dreamStorageSingleton = null;
 var dreamHistoryStorageSingleton = null;
@@ -50593,12 +50983,12 @@ var addPlausibleUserId = (set, userId) => {
   if (normalized && isPlausibleUserId(normalized)) set.add(normalized);
 };
 var readJsonFilesFromDir = (dir) => {
-  if (!(0, import_node_fs7.existsSync)(dir)) return [];
+  if (!(0, import_node_fs8.existsSync)(dir)) return [];
   const result = [];
-  for (const file of (0, import_node_fs7.readdirSync)(dir)) {
+  for (const file of (0, import_node_fs8.readdirSync)(dir)) {
     if (!file.endsWith(".json")) continue;
     try {
-      result.push(JSON.parse((0, import_node_fs7.readFileSync)(import_node_path13.default.join(dir, file), "utf-8")));
+      result.push(JSON.parse((0, import_node_fs8.readFileSync)(import_node_path14.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}`);
     }
@@ -50606,13 +50996,13 @@ var readJsonFilesFromDir = (dir) => {
   return result;
 };
 var extractFileBackedStorageKeysForTest = (dataDir) => {
-  const kvRoot = import_node_path13.default.join(dataDir, "kv");
-  if (!(0, import_node_fs7.existsSync)(kvRoot)) return [];
+  const kvRoot = import_node_path14.default.join(dataDir, "kv");
+  if (!(0, import_node_fs8.existsSync)(kvRoot)) return [];
   const keys = [];
-  for (const prefixDir of (0, import_node_fs7.readdirSync)(kvRoot)) {
-    const absolutePrefixDir = import_node_path13.default.join(kvRoot, prefixDir);
-    if (!(0, import_node_fs7.existsSync)(absolutePrefixDir)) continue;
-    for (const file of (0, import_node_fs7.readdirSync)(absolutePrefixDir)) {
+  for (const prefixDir of (0, import_node_fs8.readdirSync)(kvRoot)) {
+    const absolutePrefixDir = import_node_path14.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;
       try {
         const logicalKey = Buffer.from(file.replace(/\.json$/, ""), "base64url").toString("utf8");
@@ -50630,12 +51020,12 @@ var collectLocalConversationUserIds = () => {
 };
 var extractLocalConversationUserIdsForTest = (homeDir) => {
   const userIds = /* @__PURE__ */ new Set();
-  for (const context of readJsonFilesFromDir(import_node_path13.default.join(homeDir, "goal-context"))) {
+  for (const context of readJsonFilesFromDir(import_node_path14.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_path13.default.join(homeDir, "tasks"))) {
+  for (const goal of readJsonFilesFromDir(import_node_path14.default.join(homeDir, "tasks"))) {
     if (goal.id) addPlausibleUserId(userIds, `kanban:goal:${goal.id}`);
   }
   return userIds;
@@ -51095,7 +51485,7 @@ var systemRoutes = new Hono2();
 var startTime = Date.now();
 systemRoutes.get("/system/info", (c) => {
   return c.json({
-    version: true ? "1.8.15" : "unknown",
+    version: true ? "1.8.17" : "unknown",
     uptime: Math.floor((Date.now() - startTime) / 1e3),
     env: process.env.NODE_ENV || "development",
     nodeVersion: process.version
@@ -51119,7 +51509,7 @@ function createServer() {
   app.route("/api", systemRoutes);
   app.use("/*", serveStatic({ root: webDistRoot }));
   app.get("/*", async (c) => {
-    const indexHtml = await (0, import_promises11.readFile)(import_node_path14.default.join(webDistRoot, "index.html"), "utf8");
+    const indexHtml = await (0, import_promises11.readFile)(import_node_path15.default.join(webDistRoot, "index.html"), "utf8");
     const tenantId = c.req.header("x-tenant-id");
     const assetBase = tenantId ? `/t/${tenantId}` : "";
     const html = indexHtml.replaceAll('"./', `"${assetBase}/`);
@@ -51146,10 +51536,10 @@ function shouldStartCoreChannelGateways(env = process.env) {
 }
 // src/runtime/saasAssets.ts
-var import_node_fs8 = require("node:fs");
+var import_node_fs9 = require("node:fs");
 var import_promises12 = require("node:fs/promises");
 var import_node_os3 = require("node:os");
-var import_node_path15 = __toESM(require("node:path"));
+var import_node_path16 = __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) {
@@ -51179,8 +51569,8 @@ async function restoreSaasRuntimeAssets(reason) {
 async function restoreContextAsset(context, overwrite) {
   const target = contextPathForSourceKey(context.sourceKey);
   if (!target) return false;
-  if (!overwrite && (0, import_node_fs8.existsSync)(target)) return false;
-  await (0, import_promises12.mkdir)(import_node_path15.default.dirname(target), { recursive: true });
+  if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
+  await (0, import_promises12.mkdir)(import_node_path16.default.dirname(target), { recursive: true });
   await (0, import_promises12.writeFile)(target, JSON.stringify(context.payload), "utf8");
   return true;
 }
@@ -51188,8 +51578,8 @@ async function restoreSkillAsset(skill, overwrite) {
   if (!skill.skillMd) return false;
   const target = safeSkillTargetPath(skill.sourcePath, skill.skillName);
   if (!target) return false;
-  if (!overwrite && (0, import_node_fs8.existsSync)(target)) return false;
-  await (0, import_promises12.mkdir)(import_node_path15.default.dirname(target), { recursive: true });
+  if (!overwrite && (0, import_node_fs9.existsSync)(target)) return false;
+  await (0, import_promises12.mkdir)(import_node_path16.default.dirname(target), { recursive: true });
   await (0, import_promises12.writeFile)(target, skill.skillMd, "utf8");
   return true;
 }
@@ -51222,30 +51612,30 @@ function runtimeAssetClient() {
 function contextPathForSourceKey(sourceKey) {
   if (sourceKey.startsWith("agent:")) {
     const logicalKey = sourceKey.slice("agent:".length);
-    return import_node_path15.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
+    return import_node_path16.default.join(getDuclawDataDir(), "kv", "agent", `${Buffer.from(logicalKey).toString("base64url")}.json`);
   }
   if (sourceKey.startsWith("goal-context:")) {
-    return import_node_path15.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
+    return import_node_path16.default.join(getDuclawHomeDir(), "goal-context", `${sourceKey.slice("goal-context:".length)}.json`);
   }
   if (sourceKey.startsWith("tasks:")) {
-    return import_node_path15.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
+    return import_node_path16.default.join(getDuclawHomeDir(), "tasks", `${sourceKey.slice("tasks:".length)}.json`);
   }
   return null;
 }
 function safeSkillTargetPath(sourcePath, skillName) {
-  const allowedRoots = skillRoots().map((root) => import_node_path15.default.resolve(root));
-  const normalized = import_node_path15.default.resolve(sourcePath);
-  if (allowedRoots.some((root) => normalized === import_node_path15.default.join(root, import_node_path15.default.basename(import_node_path15.default.dirname(normalized)), "SKILL.md"))) {
+  const allowedRoots = skillRoots().map((root) => import_node_path16.default.resolve(root));
+  const normalized = import_node_path16.default.resolve(sourcePath);
+  if (allowedRoots.some((root) => normalized === import_node_path16.default.join(root, import_node_path16.default.basename(import_node_path16.default.dirname(normalized)), "SKILL.md"))) {
     return normalized;
   }
   const safeName = skillName.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "imported-skill";
-  return import_node_path15.default.join("/home/user/app/skills", safeName, "SKILL.md");
+  return import_node_path16.default.join("/home/user/app/skills", safeName, "SKILL.md");
 }
 function skillRoots() {
   return [
     "/home/user/app/skills",
-    import_node_path15.default.join(getDuclawHomeDir(), "skills"),
-    import_node_path15.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
+    import_node_path16.default.join(getDuclawHomeDir(), "skills"),
+    import_node_path16.default.join((0, import_node_os3.homedir)(), ".agents", "skills")
   ];
 }