duclaw-cli 1.7.2 → 1.7.4

package/dist/bundle.js

@@ -115,7 +115,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/.pnpm/dotenv@17.3.1/node_modules/dotenv/lib/main.js"(exports2, module2) {
     var fs3 = require("fs");
-    var path9 = require("path");
+    var path10 = 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 = path9.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path10.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] === "~" ? path9.join(os.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path10.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 = path9.resolve(process.cwd(), ".env");
+      const dotenvPath = path10.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 path10 of optionPaths) {
+      for (const path11 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs3.readFileSync(path10, { encoding }));
+          const parsed = DotenvModule.parse(fs3.readFileSync(path11, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path10} ${e.message}`);
+            _debug(`Failed to load ${path11} ${e.message}`);
           }
           lastError = e;
         }
@@ -333,7 +333,7 @@ var require_main = __commonJS({
         const shortPaths = [];
         for (const filePath of optionPaths) {
           try {
-            const relative4 = path9.relative(process.cwd(), filePath);
+            const relative4 = path10.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, path9, moduleArguments) {
-        parser.push("MODULE", "LOAD", path9);
+      parseCommand(parser, path10, moduleArguments) {
+        parser.push("MODULE", "LOAD", path10);
         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, path9, json, ...jsons) {
+      parseCommand(parser, key, path10, json, ...jsons) {
         parser.push("JSON.ARRAPPEND");
         parser.pushKey(key);
-        parser.push(path9, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path10, (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, path9, json, options) {
+      parseCommand(parser, key, path10, json, options) {
         parser.push("JSON.ARRINDEX");
         parser.pushKey(key);
-        parser.push(path9, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path10, (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, path9, index, json, ...jsons) {
+      parseCommand(parser, key, path10, index, json, ...jsons) {
         parser.push("JSON.ARRINSERT");
         parser.pushKey(key);
-        parser.push(path9, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path10, 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, path9, start, stop) {
+      parseCommand(parser, key, path10, start, stop) {
         parser.push("JSON.ARRTRIM");
         parser.pushKey(key);
-        parser.push(path9, start.toString(), stop.toString());
+        parser.push(path10, 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, path9, value) {
+      parseCommand(parser, key, path10, value) {
         parser.push("JSON.MERGE");
         parser.pushKey(key);
-        parser.push(path9, (0, generic_transformers_1.transformRedisJsonArgument)(value));
+        parser.push(path10, (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, path9) {
+      parseCommand(parser, keys, path10) {
         parser.push("JSON.MGET");
         parser.pushKeys(keys);
-        parser.push(path9);
+        parser.push(path10);
       },
       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, path9, by) {
+      parseCommand(parser, key, path10, by) {
         parser.push("JSON.NUMINCRBY");
         parser.pushKey(key);
-        parser.push(path9, by.toString());
+        parser.push(path10, 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, path9, by) {
+      parseCommand(parser, key, path10, by) {
         parser.push("JSON.NUMMULTBY");
         parser.pushKey(key);
-        parser.push(path9, by.toString());
+        parser.push(path10, 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, path9, json, options) {
+      parseCommand(parser, key, path10, json, options) {
         parser.push("JSON.SET");
         parser.pushKey(key);
-        parser.push(path9, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        parser.push(path10, (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, path9) {
+      parseCommand(parser, key, path10) {
         parser.push("JSON.TOGGLE");
         parser.pushKey(key);
-        parser.push(path9);
+        parser.push(path10);
       },
       transformReply: void 0
     };
@@ -30242,7 +30242,7 @@ function printHelp() {
 `);
 }
 function printVersion() {
-  console.log(`duclaw-cli v${true ? "1.7.2" : "unknown"}`);
+  console.log(`duclaw-cli v${true ? "1.7.4" : "unknown"}`);
 }
 function getDuclawTemplate() {
   return {
@@ -30332,9 +30332,9 @@ var getChannel = (registry2, id) => {
 };
 
 // src/agent/createAgent.ts
-var import_node_path9 = require("node:path");
-var import_node_os3 = require("node:os");
-var import_node_fs4 = require("node:fs");
+var import_node_path10 = require("node:path");
+var import_node_os4 = require("node:os");
+var import_node_fs5 = require("node:fs");
 
 // src/background/BackgroundManager.ts
 var import_child_process = require("child_process");
@@ -31736,12 +31736,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 path9(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path10(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path10 = statics.reduce((previousValue, currentValue, index) => {
+  const path11 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -31758,7 +31758,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path9(stat
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path10.split(/[?#]/, 1)[0];
+  const pathOnly = path11.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match2;
   while ((match2 = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -31779,10 +31779,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path9(stat
     }, "");
     throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path10}
+${path11}
 ${underline}`);
   }
-  return path10;
+  return path11;
 };
 var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -34893,9 +34893,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error, message, headers) {
     return APIError.generate(status, error, message, headers);
   }
-  buildURL(path9, query, defaultBaseURL) {
+  buildURL(path10, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url = isAbsoluteURL(path9) ? new URL(path9) : new URL(baseURL + (baseURL.endsWith("/") && path9.startsWith("/") ? path9.slice(1) : path9));
+    const url = isAbsoluteURL(path10) ? new URL(path10) : new URL(baseURL + (baseURL.endsWith("/") && path10.startsWith("/") ? path10.slice(1) : path10));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -34926,24 +34926,24 @@ var BaseAnthropic = class {
    */
   async prepareRequest(request, { url, options }) {
   }
-  get(path9, opts) {
-    return this.methodRequest("get", path9, opts);
+  get(path10, opts) {
+    return this.methodRequest("get", path10, opts);
   }
-  post(path9, opts) {
-    return this.methodRequest("post", path9, opts);
+  post(path10, opts) {
+    return this.methodRequest("post", path10, opts);
   }
-  patch(path9, opts) {
-    return this.methodRequest("patch", path9, opts);
+  patch(path10, opts) {
+    return this.methodRequest("patch", path10, opts);
   }
-  put(path9, opts) {
-    return this.methodRequest("put", path9, opts);
+  put(path10, opts) {
+    return this.methodRequest("put", path10, opts);
   }
-  delete(path9, opts) {
-    return this.methodRequest("delete", path9, opts);
+  delete(path10, opts) {
+    return this.methodRequest("delete", path10, opts);
   }
-  methodRequest(method, path9, opts) {
+  methodRequest(method, path10, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path9, ...opts2 };
+      return { method, path: path10, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -35047,8 +35047,8 @@ var BaseAnthropic = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime: startTime2 };
   }
-  getAPIList(path9, Page2, opts) {
-    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path9, ...opts2 })) : { method: "get", path: path9, ...opts });
+  getAPIList(path10, Page2, opts) {
+    return this.requestAPIList(Page2, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path10, ...opts2 })) : { method: "get", path: path10, ...opts });
   }
   requestAPIList(Page2, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -35136,8 +35136,8 @@ var BaseAnthropic = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path9, query, defaultBaseURL } = options;
-    const url = this.buildURL(path9, query, defaultBaseURL);
+    const { method, path: path10, query, defaultBaseURL } = options;
+    const url = this.buildURL(path10, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -35312,6 +35312,9 @@ var toSDKMessage = (msg) => {
     };
   }
   const blocks = msg.content.map((block) => toSDKBlock(block)).filter((b) => b.type !== "text" || b.text);
+  if (blocks.length === 0) {
+    blocks.push({ type: "text", text: "(ok)" });
+  }
   return {
     role: `assistant`,
     content: blocks
@@ -35422,7 +35425,7 @@ var createRedisStorage = (options = {}) => {
 };
 
 // src/storage/utils.ts
-var getMessages = async (storage, userId, limit = 100, date, cronTitle) => {
+var getMessages = async (storage, userId, limit = 300, date, cronTitle) => {
   let key = `mem:${userId}`;
   if (date) {
     key = key + `:${date}`;
@@ -35453,6 +35456,7 @@ var sanitizeMessages = (messages) => {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
     if (!msg.content || msg.content.length === 0) continue;
+    if (msg.content.every((b) => b.type === "text" && !b.text?.trim())) continue;
     if (msg.role === "assistant") {
       const toolUses = msg.content.filter((b) => b.type === "tool_use");
       if (toolUses.length > 0) {
@@ -35504,6 +35508,19 @@ var addTopicIndex = async (storage, userId, date, messageIndex, snippet, cronTit
   });
   await storage.set(key, data);
 };
+var updateTopicSummary = async (storage, userId, date, summary, cronTitle) => {
+  const key = `topics:${userId}`;
+  const data = await storage.get(key);
+  if (!data || data.length === 0) return;
+  for (let i = data.length - 1; i >= 0; i--) {
+    const entry = data[i];
+    if (entry.d === date && (entry.c || void 0) === (cronTitle || void 0)) {
+      entry.s = summary.slice(0, 80);
+      await storage.set(key, data);
+      return;
+    }
+  }
+};
 var searchTopicIndex = async (topicStorage, userId, query, date, limit = 8) => {
   const key = `topics:${userId}`;
   const data = await topicStorage.get(key) || [];
@@ -35574,6 +35591,16 @@ var searchChatHistory = async (messageStorage, topicStorage, userId, query, date
   }
   return { matches: results, total, matchCount: matches.length };
 };
+var clearMessages = async (storage, userId, date, cronTitle) => {
+  let key = `mem:${userId}`;
+  if (date) {
+    key = key + `:${date}`;
+  }
+  if (cronTitle) {
+    key = key + `:${cronTitle}`;
+  }
+  await storage.del(key);
+};
 
 // src/tools/ToolExecutor.ts
 var createToolExecutor = (registry2) => {
@@ -35657,7 +35684,9 @@ var import_path11 = __toESM(require("path"));
 import_dayjs.default.extend(import_utc.default);
 import_dayjs.default.extend(import_timezone.default);
 var getGoalDir = () => {
-  return import_path11.default.join(process.cwd(), ".tasks");
+  const goalDir = import_path11.default.join(process.cwd(), ".tasks");
+  (0, import_fs4.mkdirSync)(goalDir, { recursive: true });
+  return goalDir;
 };
 var getGoalPath = (goalId) => {
   return import_path11.default.join(getGoalDir(), `${goalId}.json`);
@@ -36730,16 +36759,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
+  addToPath(path10, added, removed, oldPosInc, options) {
+    const last = path10.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path10.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -37984,7 +38013,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises6.lstat : import_promises6.stat;
     if (wantBigintFsStats) {
-      this._stat = (path9) => statMethod(path9, { bigint: true });
+      this._stat = (path10) => statMethod(path10, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -38009,8 +38038,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: path9, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
+          const { path: path10, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -38050,20 +38079,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path9, depth) {
+  async _exploreDir(path10, depth) {
     let files;
     try {
-      files = await (0, import_promises6.readdir)(path9, this._rdOptions);
+      files = await (0, import_promises6.readdir)(path10, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path9 };
+    return { files, depth, path: path10 };
   }
-  async _formatEntry(dirent, path9) {
+  async _formatEntry(dirent, path10) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path7.resolve)((0, import_node_path7.join)(path9, basename4));
+      const fullPath = (0, import_node_path7.resolve)((0, import_node_path7.join)(path10, basename4));
       entry = { path: (0, import_node_path7.relative)(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -38463,16 +38492,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path9);
-    emitRaw(rawEvent, evPath, { watchedPath: path9 });
-    if (evPath && path9 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path9, evPath), KEY_LISTENERS, sp.join(path9, evPath));
+    listener(path10);
+    emitRaw(rawEvent, evPath, { watchedPath: path10 });
+    if (evPath && path10 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path10, evPath), KEY_LISTENERS, sp.join(path10, evPath));
     }
   };
   try {
-    return (0, import_node_fs.watch)(path9, {
+    return (0, import_node_fs.watch)(path10, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -38488,12 +38517,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path9, fullPath, options, handlers) => {
+var setFsWatchListener = (path10, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -38504,7 +38533,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path9,
+      path10,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -38519,7 +38548,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises7.open)(path9, "r");
+          const fd = await (0, import_promises7.open)(path10, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -38550,7 +38579,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -38572,7 +38601,7 @@ var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path9, curr));
+          foreach(cont.listeners, (listener2) => listener2(path10, curr));
         }
       })
     };
@@ -38602,13 +38631,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path9, listener) {
+  _watchWithNodeFs(path10, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path9);
-    const basename4 = sp.basename(path9);
+    const directory = sp.dirname(path10);
+    const basename4 = sp.basename(path10);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path9);
+    const absolutePath = sp.resolve(path10);
     const options = {
       persistent: opts.persistent
     };
@@ -38618,12 +38647,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path9, absolutePath, options, {
+      closer = setFsWatchFileListener(path10, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path9, absolutePath, options, {
+      closer = setFsWatchListener(path10, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -38645,7 +38674,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path9, newStats) => {
+    const listener = async (path10, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -38659,11 +38688,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path9);
+            this.fsw._closeFile(path10);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path9, closer2);
+              this.fsw._addPathCloser(path10, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -38695,7 +38724,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, path9, item) {
+  async _handleSymlink(entry, directory, path10, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -38705,7 +38734,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises7.realpath)(path9);
+        linkPath = await (0, import_promises7.realpath)(path10);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -38715,12 +38744,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, path9, entry.stats);
+          this.fsw._emit(EV.CHANGE, path10, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path9, entry.stats);
+        this.fsw._emit(EV.ADD, path10, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -38750,9 +38779,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path9 = sp.join(directory, item);
+      let path10 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -38761,8 +38790,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path9 = sp.join(dir, sp.relative(dir, path9));
-        this._addToNodeFs(path9, initialAdd, wh, depth + 1);
+        path10 = sp.join(dir, sp.relative(dir, path10));
+        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve11, reject) => {
@@ -38831,13 +38860,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path9) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path9);
+    const wh = this.fsw._getWatchHelpers(path10);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -38853,8 +38882,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path9);
-        const targetPath = follow ? await (0, import_promises7.realpath)(path9) : path9;
+        const absPath = sp.resolve(path10);
+        const targetPath = follow ? await (0, import_promises7.realpath)(path10) : path10;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -38864,29 +38893,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises7.realpath)(path9) : path9;
+        const targetPath = follow ? await (0, import_promises7.realpath)(path10) : path10;
         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, path9, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path9), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path10), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path9, closer);
+        this.fsw._addPathCloser(path10, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path9;
+        return path10;
       }
     }
   }
@@ -38929,24 +38958,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path9) {
-  if (typeof path9 !== "string")
+function normalizePath(path10) {
+  if (typeof path10 !== "string")
     throw new Error("string expected");
-  path9 = sp2.normalize(path9);
-  path9 = path9.replace(/\\/g, "/");
+  path10 = sp2.normalize(path10);
+  path10 = path10.replace(/\\/g, "/");
   let prepend = false;
-  if (path9.startsWith("//"))
+  if (path10.startsWith("//"))
     prepend = true;
-  path9 = path9.replace(DOUBLE_SLASH_RE, "/");
+  path10 = path10.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path9 = "/" + path9;
-  return path9;
+    path10 = "/" + path10;
+  return path10;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path9 = normalizePath(testString);
+  const path10 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path9, stats)) {
+    if (pattern(path10, stats)) {
       return true;
     }
   }
@@ -38984,19 +39013,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path9) => toUnix(sp2.normalize(toUnix(path9)));
-var normalizeIgnored = (cwd = "") => (path9) => {
-  if (typeof path9 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path9) ? path9 : sp2.join(cwd, path9));
+var normalizePathToUnix = (path10) => toUnix(sp2.normalize(toUnix(path10)));
+var normalizeIgnored = (cwd = "") => (path10) => {
+  if (typeof path10 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path10) ? path10 : sp2.join(cwd, path10));
   } else {
-    return path9;
+    return path10;
   }
 };
-var getAbsolutePath = (path9, cwd) => {
-  if (sp2.isAbsolute(path9)) {
-    return path9;
+var getAbsolutePath = (path10, cwd) => {
+  if (sp2.isAbsolute(path10)) {
+    return path10;
   }
-  return sp2.join(cwd, path9);
+  return sp2.join(cwd, path10);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -39061,10 +39090,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path9, follow, fsw) {
+  constructor(path10, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path9;
-    this.path = path9 = path9.replace(REPLACER_RE, "");
+    const watchPath = path10;
+    this.path = path10 = path10.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -39204,20 +39233,20 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path9) => {
-        const absPath = getAbsolutePath(path9, cwd);
+      paths = paths.map((path10) => {
+        const absPath = getAbsolutePath(path10, cwd);
         return absPath;
       });
     }
-    paths.forEach((path9) => {
-      this._removeIgnoredPath(path9);
+    paths.forEach((path10) => {
+      this._removeIgnoredPath(path10);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path9) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path10) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -39239,17 +39268,17 @@ var FSWatcher = class extends import_node_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path9) => {
-      if (!sp2.isAbsolute(path9) && !this._closers.has(path9)) {
+    paths.forEach((path10) => {
+      if (!sp2.isAbsolute(path10) && !this._closers.has(path10)) {
         if (cwd)
-          path9 = sp2.join(cwd, path9);
-        path9 = sp2.resolve(path9);
+          path10 = sp2.join(cwd, path10);
+        path10 = sp2.resolve(path10);
       }
-      this._closePath(path9);
-      this._addIgnoredPath(path9);
-      if (this._watched.has(path9)) {
+      this._closePath(path10);
+      this._addIgnoredPath(path10);
+      if (this._watched.has(path10)) {
         this._addIgnoredPath({
-          path: path9,
+          path: path10,
           recursive: true
         });
       }
@@ -39313,38 +39342,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, path9, stats) {
+  async _emit(event, path10, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path9 = sp2.normalize(path9);
+      path10 = sp2.normalize(path10);
     if (opts.cwd)
-      path9 = sp2.relative(opts.cwd, path9);
-    const args = [path9];
+      path10 = sp2.relative(opts.cwd, path10);
+    const args = [path10];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path9))) {
+    if (awf && (pw = this._pendingWrites.get(path10))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path9, [event, ...args]);
+        this._pendingUnlinks.set(path10, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path10) => {
+          this._pendingUnlinks.forEach((entry, path11) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path10);
+            this._pendingUnlinks.delete(path11);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path9);
+        this._pendingUnlinks.delete(path10);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -39362,16 +39391,16 @@ var FSWatcher = class extends import_node_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 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, path9) : path9;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path10) : path10;
       let stats2;
       try {
         stats2 = await (0, import_promises8.stat)(fullPath);
@@ -39402,23 +39431,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, path9, timeout) {
+  _throttle(actionType, path10, 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(path9);
+    const actionPath = action.get(path10);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path9);
+      const item = action.get(path10);
       const count = item ? item.count : 0;
-      action.delete(path9);
+      action.delete(path10);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -39426,7 +39455,7 @@ var FSWatcher = class extends import_node_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path9, thr);
+    action.set(path10, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -39440,44 +39469,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(path9, threshold, event, awfEmit) {
+  _awaitWriteFinish(path10, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path9;
-    if (this.options.cwd && !sp2.isAbsolute(path9)) {
-      fullPath = sp2.join(this.options.cwd, path9);
+    let fullPath = path10;
+    if (this.options.cwd && !sp2.isAbsolute(path10)) {
+      fullPath = sp2.join(this.options.cwd, path10);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_node_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path9)) {
+        if (err || !writes.has(path10)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path9).lastChange = now2;
+          writes.get(path10).lastChange = now2;
         }
-        const pw = writes.get(path9);
+        const pw = writes.get(path10);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path9);
+          writes.delete(path10);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path9)) {
-      writes.set(path9, {
+    if (!writes.has(path10)) {
+      writes.set(path10, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path9);
+          writes.delete(path10);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -39488,8 +39517,8 @@ var FSWatcher = class extends import_node_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path9, stats) {
-    if (this.options.atomic && DOT_RE.test(path9))
+  _isIgnored(path10, stats) {
+    if (this.options.atomic && DOT_RE.test(path10))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -39499,17 +39528,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(path9, stats);
+    return this._userIgnored(path10, stats);
   }
-  _isntIgnored(path9, stat9) {
-    return !this._isIgnored(path9, stat9);
+  _isntIgnored(path10, stat9) {
+    return !this._isIgnored(path10, stat9);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path9) {
-    return new WatchHelper(path9, this.options.followSymlinks, this);
+  _getWatchHelpers(path10) {
+    return new WatchHelper(path10, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -39541,63 +39570,63 @@ var FSWatcher = class extends import_node_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path9 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path9);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path9, 100))
+    const path10 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path10);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path10, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path9);
+    const wp = this._getWatchedDir(path10);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path9, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path10, 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 = path9;
+    let relPath = path10;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path9);
+      relPath = sp2.relative(this.options.cwd, path10);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path9);
+    this._watched.delete(path10);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path9))
-      this._emit(eventName, path9);
-    this._closePath(path9);
+    if (wasTracked && !this._isIgnored(path10))
+      this._emit(eventName, path10);
+    this._closePath(path10);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path9) {
-    this._closeFile(path9);
-    const dir = sp2.dirname(path9);
-    this._getWatchedDir(dir).remove(sp2.basename(path9));
+  _closePath(path10) {
+    this._closeFile(path10);
+    const dir = sp2.dirname(path10);
+    this._getWatchedDir(dir).remove(sp2.basename(path10));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path9) {
-    const closers = this._closers.get(path9);
+  _closeFile(path10) {
+    const closers = this._closers.get(path10);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path9);
+    this._closers.delete(path10);
   }
-  _addPathCloser(path9, closer) {
+  _addPathCloser(path10, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path9);
+    let list = this._closers.get(path10);
     if (!list) {
       list = [];
-      this._closers.set(path9, list);
+      this._closers.set(path10, list);
     }
     list.push(closer);
   }
@@ -40119,44 +40148,79 @@ var imageUnderstand = {
 };
 
 // src/skill/SkillRegistry.ts
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_os3 = require("os");
+var import_path15 = __toESM(require("path"));
+
+// src/runtime/paths.ts
+var import_fs8 = require("fs");
 var import_path14 = __toESM(require("path"));
-var getSkillPaths = () => {
-  const paths = [];
-  let currentDir = __dirname_m;
-  let projectRoot = "";
-  while (currentDir !== "/") {
-    if ((0, import_fs8.existsSync)((0, import_path14.join)(currentDir, "duclaw.json"))) {
-      projectRoot = currentDir;
-      break;
+var findProjectRoot = (filename = "duclaw.json", startDir = process.cwd()) => {
+  let currentDir = startDir;
+  while (true) {
+    if ((0, import_fs8.existsSync)((0, import_path14.join)(currentDir, filename))) {
+      return currentDir;
     }
     const parentDir = (0, import_path14.dirname)(currentDir);
-    if (parentDir === currentDir) break;
+    if (parentDir === currentDir) {
+      return null;
+    }
     currentDir = parentDir;
   }
+};
+var resolveCoreRoot = () => {
+  const candidates = [
+    import_path14.default.resolve(__dirname_m, ".."),
+    import_path14.default.resolve(__dirname_m, "..", ".."),
+    process.cwd()
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_fs8.existsSync)(import_path14.default.join(candidate, "web", "dist", "index.html"))) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+};
+var resolveWebDistRoot = () => {
+  const coreRoot = resolveCoreRoot();
+  const candidates = [
+    import_path14.default.join(coreRoot, "dist", "web"),
+    import_path14.default.join(coreRoot, "web", "dist")
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_fs8.existsSync)(import_path14.default.join(candidate, "index.html"))) {
+      return candidate;
+    }
+  }
+  return candidates[0];
+};
+
+// src/skill/SkillRegistry.ts
+var getSkillPaths = () => {
+  const paths = [];
+  const projectRoot = findProjectRoot();
   if (projectRoot) {
-    const rootSkillsPath = (0, import_path14.join)(projectRoot, "skills");
-    if ((0, import_fs8.existsSync)(rootSkillsPath) && (0, import_fs8.statSync)(rootSkillsPath).isDirectory()) {
+    const rootSkillsPath = (0, import_path15.join)(projectRoot, "skills");
+    if ((0, import_fs9.existsSync)(rootSkillsPath) && (0, import_fs9.statSync)(rootSkillsPath).isDirectory()) {
       paths.push(rootSkillsPath);
     }
   }
-  const duclawSkillsPath = (0, import_path14.join)((0, import_os3.homedir)(), ".duclaw", "skills");
-  if ((0, import_fs8.existsSync)(duclawSkillsPath) && (0, import_fs8.statSync)(duclawSkillsPath).isDirectory()) {
+  const duclawSkillsPath = (0, import_path15.join)((0, import_os3.homedir)(), ".duclaw", "skills");
+  if ((0, import_fs9.existsSync)(duclawSkillsPath) && (0, import_fs9.statSync)(duclawSkillsPath).isDirectory()) {
     paths.push(duclawSkillsPath);
   }
-  const agentsSkillsPath = (0, import_path14.join)((0, import_os3.homedir)(), ".agents", "skills");
-  if ((0, import_fs8.existsSync)(agentsSkillsPath) && (0, import_fs8.statSync)(agentsSkillsPath).isDirectory()) {
+  const agentsSkillsPath = (0, import_path15.join)((0, import_os3.homedir)(), ".agents", "skills");
+  if ((0, import_fs9.existsSync)(agentsSkillsPath) && (0, import_fs9.statSync)(agentsSkillsPath).isDirectory()) {
     paths.push(agentsSkillsPath);
   }
   return paths;
 };
 var getDirectories = (dirPath) => {
-  return (0, import_fs8.readdirSync)(dirPath).filter((name) => (0, import_fs8.statSync)((0, import_path14.join)(dirPath, name)).isDirectory());
+  return (0, import_fs9.readdirSync)(dirPath).filter((name) => (0, import_fs9.statSync)((0, import_path15.join)(dirPath, name)).isDirectory());
 };
 var parseSkill = (mdPath, skillDir) => {
-  if (!(0, import_fs8.existsSync)(mdPath)) return null;
-  const raw2 = (0, import_fs8.readFileSync)(mdPath, "utf-8");
+  if (!(0, import_fs9.existsSync)(mdPath)) return null;
+  const raw2 = (0, import_fs9.readFileSync)(mdPath, "utf-8");
   let name = "";
   let description = "";
   let body = raw2;
@@ -40172,7 +40236,7 @@ var parseSkill = (mdPath, skillDir) => {
     }
   }
   if (!name) {
-    name = import_path14.default.basename(import_path14.default.dirname(mdPath));
+    name = import_path15.default.basename(import_path15.default.dirname(mdPath));
   }
   if (!description && body) {
     description = body.split("\n")[0].replace(/^#+\s*/, "").trim();
@@ -40197,8 +40261,8 @@ var loadSkill = () => {
   for (const skillPath of skillPaths) {
     const dirs = getDirectories(skillPath);
     for (const skillName of dirs) {
-      const eachSkillPath = (0, import_path14.join)(skillPath, skillName);
-      const eachSkillMdPath = (0, import_path14.join)(eachSkillPath, "SKILL.md");
+      const eachSkillPath = (0, import_path15.join)(skillPath, skillName);
+      const eachSkillMdPath = (0, import_path15.join)(eachSkillPath, "SKILL.md");
       const skill = parseSkill(eachSkillMdPath, eachSkillPath);
       if (skill && !seen.has(skill.name)) {
         seen.add(skill.name);
@@ -40550,14 +40614,15 @@ var create_mailbox_table = () => {
 };
 
 // src/team/TeamMember.ts
-var import_fs10 = require("fs");
-var import_path16 = __toESM(require("path"));
+var import_fs11 = require("fs");
+var import_path17 = __toESM(require("path"));
 
 // src/team/Team.ts
-var import_path15 = __toESM(require("path"));
-var import_fs9 = require("fs");
+var import_path16 = __toESM(require("path"));
+var import_os4 = require("os");
+var import_fs10 = require("fs");
 var getTeamBaseDir = () => {
-  return `~/.duclaw/team`;
+  return import_path16.default.join((0, import_os4.homedir)(), ".duclaw", "team");
 };
 var getTeamWorkSpaceDir = (teamName) => {
   return `${getTeamBaseDir()}/workspace/${teamName}`;
@@ -40568,22 +40633,22 @@ var getTeamJsonPath = (teamName) => {
 var createTeam = (teamDefinition) => {
   if (!teamDefinition) throw new Error(`[createTeam] teamDefinition\u4E0D\u80FD\u4E3A\u7A7A`);
   const { id, name, goalId, teamMembers } = teamDefinition;
-  const teamPath = import_path15.default.join(getTeamWorkSpaceDir(name));
-  (0, import_fs9.mkdirSync)(teamPath, { recursive: true });
-  (0, import_fs9.writeFileSync)(`${teamPath}/team.json`, JSON.stringify(teamDefinition, null, "	"), "utf-8");
+  const teamPath = import_path16.default.join(getTeamWorkSpaceDir(name));
+  (0, import_fs10.mkdirSync)(teamPath, { recursive: true });
+  (0, import_fs10.writeFileSync)(`${teamPath}/team.json`, JSON.stringify(teamDefinition, null, "	"), "utf-8");
   return teamDefinition;
 };
 var getTeam = (name) => {
   const teamJsonPath = getTeamJsonPath(name);
-  if (!(0, import_fs9.existsSync)(teamJsonPath)) return null;
-  const text2 = (0, import_fs9.readFileSync)(teamJsonPath, `utf-8`);
+  if (!(0, import_fs10.existsSync)(teamJsonPath)) return null;
+  const text2 = (0, import_fs10.readFileSync)(teamJsonPath, `utf-8`);
   const obj = JSON.parse(text2) || {};
   const team = obj;
   return team;
 };
 var listTeams = () => {
   const baseDir = getTeamBaseDir();
-  const teamnames = (0, import_fs9.readdirSync)(import_path15.default.join(baseDir, `workspace`));
+  const teamnames = (0, import_fs10.readdirSync)(import_path16.default.join(baseDir, `workspace`));
   const teams = [];
   for (const teamname of teamnames) {
     const team = getTeam(teamname);
@@ -40600,10 +40665,10 @@ var getTeamById = (id) => {
   return team;
 };
 var deleteTeam = (name) => {
-  if (!(0, import_fs9.existsSync)(getTeamJsonPath(name))) {
+  if (!(0, import_fs10.existsSync)(getTeamJsonPath(name))) {
     throw new Error(`[deleteTeam] \u4E0D\u5B58\u5728\u5BF9\u5E94\u7684\u56E2\u961F${name}\u7684team.json\u6587\u4EF6`);
   }
-  (0, import_fs9.rmSync)(getTeamJsonPath(name));
+  (0, import_fs10.rmSync)(getTeamJsonPath(name));
 };
 
 // src/team/workspace/workspace.ts
@@ -40631,8 +40696,8 @@ var createTeamMember = (teamMemberDefinition) => {
   const { id, name, teamId, mailBoxId, workspaceId } = teamMemberDefinition;
   const team = getTeamById(teamMemberDefinition.teamId);
   if (!team) throw new Error(`[createTeamMember] \u627E\u4E0D\u5230\u5BF9\u5E94\u7684team: ${teamId}`);
-  const memberPath = import_path16.default.join(getTeamWorkSpaceDir(team.name), name);
-  (0, import_fs10.mkdirSync)(memberPath, { recursive: true });
+  const memberPath = import_path17.default.join(getTeamWorkSpaceDir(team.name), name);
+  (0, import_fs11.mkdirSync)(memberPath, { recursive: true });
   const workspace = {
     id: getWorkspaceId(team.name, teamMemberDefinition.name),
     teamName: team.name,
@@ -40644,12 +40709,13 @@ var createTeamMember = (teamMemberDefinition) => {
     team.teamMembers = [];
   }
   team.teamMembers.push(teamMemberDefinition);
-  (0, import_fs10.writeFileSync)(getTeamJsonPath(team.name), JSON.stringify(team, null, "	"), "utf-8");
+  (0, import_fs11.writeFileSync)(getTeamJsonPath(team.name), JSON.stringify(team, null, "	"), "utf-8");
   return teamMemberDefinition;
 };
 var listTeamMember = (teamName) => {
   const teamJsonPath = getTeamJsonPath(teamName);
-  const text2 = (0, import_fs10.readFileSync)(teamJsonPath, `utf-8`);
+  if (!(0, import_fs11.existsSync)(teamJsonPath)) return [];
+  const text2 = (0, import_fs11.readFileSync)(teamJsonPath, `utf-8`);
   const team = JSON.parse(text2);
   if (!team) throw new Error(`[listTeamMember] \u627E\u4E0D\u5230\u5BF9\u5E94\u7684team: ${teamName}`);
   if (!team.teamMembers) return [];
@@ -40684,7 +40750,7 @@ var deleteTeamMemberById = (teamName, memberId) => {
   const workspaceId = team.teamMembers[memberIdx].workspaceId;
   let newTeamMember = team.teamMembers.filter((_, index) => index !== memberIdx);
   team.teamMembers = newTeamMember;
-  (0, import_fs10.writeFileSync)(getTeamJsonPath(teamName), JSON.stringify(team, null, `	`));
+  (0, import_fs11.writeFileSync)(getTeamJsonPath(teamName), JSON.stringify(team, null, `	`));
   deleteWorkspace(workspaceId);
 };
 
@@ -40871,8 +40937,8 @@ var DESCRIPTION22 = `
 
 \u5DE5\u5177\u8C03\u7528\u89C4\u5219\uFF1A
 - \u5F53\u7528\u6237\u8981\u6C42\u5220\u9664\u56E2\u961F\u65F6\u8C03\u7528\u6B64\u5DE5\u5177\u3002
-- \u5F53\u56E2\u961F\u5DF2\u7ECF\u4E0D\u518D\u9700\u8981\u4E3A\u5BF9\u5E94\u76EE\u6807\u800C\u5DE5\u4F5C\u65F6\u3002
-- \u5F53\u56E2\u961F\u5DF2\u7ECF\u6CA1\u6709\u5B58\u5728\u5FC5\u8981\u3002
+- \u5F53\u56E2\u961F\u5DF2\u7ECF\u4E0D\u518D\u9700\u8981\u4E3A\u5BF9\u5E94\u76EE\u6807\u800C\u5DE5\u4F5C\u65F6\uFF0C\u8BE2\u95EE\u7528\u6237\u662F\u5426\u89E3\u6563\u8BE5\u56E2\u961F\u3002
+- \u5F53\u56E2\u961F\u5DF2\u7ECF\u6CA1\u6709\u5B58\u5728\u5FC5\u8981\uFF0C\u8BE2\u95EE\u7528\u6237\u662F\u5426\u89E3\u6563\u8BE5\u56E2\u961F\u3002
 `;
 var teamDelete = {
   name: `team_delete`,
@@ -41319,11 +41385,688 @@ var drainInterrupts = (userId) => {
   return messages;
 };
 
+// src/dream/dreamPrompt.ts
+var DREAM_MAX_MESSAGE_CHARS = 1e4;
+var DREAM_SYSTEM_PROMPT = `\u4F60\u662F AI Agent \u7684"\u68A6\u5883\u81EA\u6211"\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u50CF\u4EBA\u7C7B\u5927\u8111\u5728\u7761\u7720\u4E2D\u4E00\u6837\uFF0C\u56DE\u987E\u6700\u8FD1\u7684\u5BF9\u8BDD\uFF0C\u63D0\u70BC\u91CD\u8981\u4FE1\u606F\uFF0C\u5F62\u6210\u4E00\u6BB5"\u68A6\u5883\u8BB0\u5FC6"\u3002
+
+\u4F60\u7684\u4EA7\u51FA\u4F1A\u88AB\u6CE8\u5165\u5230 Agent \u7684 systemPrompt \u4E2D\uFF0C\u4F5C\u4E3A"\u6211\u5BF9\u8FD9\u4E2A\u7528\u6237\u5DF2\u77E5\u7684\u4FE1\u606F"\u3002\u56E0\u6B64\uFF0C\u4F60\u5FC5\u987B\u7528\u7B2C\u4E00\u4EBA\u79F0\u6765\u5199\u2014\u2014\u8FD9\u4E9B\u5185\u5BB9\u770B\u8D77\u6765\u5E94\u8BE5\u662F Agent \u81EA\u5DF1\u7684\u8BB0\u5FC6\uFF0C\u800C\u4E0D\u662F\u4E00\u4EFD\u51B0\u51B7\u7684\u6570\u636E\u62A5\u544A\u3002
+
+\u6838\u5FC3\u539F\u5219\uFF1A
+1. \u7528\u7B2C\u4E00\u4EBA\u79F0\u3002\u5199"\u6211\u8BB0\u5F97..."\u800C\u4E0D\u662F"\u7528\u6237\u504F\u597D..."
+2. \u4FE1\u606F\u5BC6\u5EA6\u6BD4\u4FE1\u606F\u91CF\u66F4\u91CD\u8981\u3002\u63A7\u5236\u5728 500 \u5B57\u4EE5\u5185\u3002
+3. \u4FDD\u7559\u7528\u6237\u539F\u8BDD\u4E2D\u7684\u5173\u952E\u8868\u8FF0\uFF0C\u7528\u5F15\u53F7\u5305\u88F9\u3002\u4E0D\u8981\u8FC7\u5EA6\u6539\u5199\u3002
+4. \u4E25\u683C\u57FA\u4E8E\u8F93\u5165\u7684\u5BF9\u8BDD\u8BB0\u5F55\uFF0C\u4E0D\u7F16\u9020\u4EFB\u4F55\u4FE1\u606F\u3002
+5. \u65E7\u68A6\u5883\u4E2D\u7684\u4FE1\u606F\u5982\u679C\u4ECD\u7136\u6709\u6548\uFF0C\u4FDD\u7559\u5728\u65B0\u68A6\u5883\u4E2D\u3002\u5982\u679C\u5DF2\u8FC7\u65F6\uFF0C\u66FF\u6362\u6216\u5220\u9664\u3002\u65B0\u68A6\u5883\u662F\u5B8C\u5168\u91CD\u5199\u7684\uFF0C\u4E0D\u662F\u5728\u65E7\u68A6\u5883\u4E0A\u8FFD\u52A0\u3002
+6. \u5B81\u53EF\u5C11\u8BB0\uFF0C\u4E0D\u8981\u591A\u8BB0\u3002\u4E0D\u662F\u6240\u6709\u4FE1\u606F\u90FD\u503C\u5F97\u4FDD\u7559\u3002`;
+var buildDreamPrompt = (previousDream, messages) => {
+  const messageText = messages.map((msg) => {
+    const role = msg.role === "user" ? "\u7528\u6237" : "\u52A9\u624B";
+    const text2 = msg.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+    return `${role}: ${text2.slice(0, 200)}`;
+  }).join("\n");
+  const trimmedMessages = messageText.length > DREAM_MAX_MESSAGE_CHARS ? messageText.slice(-DREAM_MAX_MESSAGE_CHARS) : messageText;
+  const user = `== \u4E0A\u4E00\u6B21\u68A6\u5883 ==
+${previousDream || "\uFF08\u65E0\uFF0C\u8FD9\u662F\u7B2C\u4E00\u6B21\u505A\u68A6\uFF09"}
+
+\uFF08\u5982\u679C\u4E0A\u4E00\u6B21\u68A6\u5883\u4E2D\u7684\u4FE1\u606F\u4ECD\u7136\u51C6\u786E\uFF0C\u5728\u65B0\u68A6\u5883\u4E2D\u4FDD\u7559\u5B83\u4EEC\u3002\u5982\u679C\u67D0\u4E9B\u4FE1\u606F\u5DF2\u8FC7\u65F6\u2014\u2014\u6BD4\u5982\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3001\u60C5\u51B5\u5DF2\u53D8\u5316\u2014\u2014\u5728\u65B0\u68A6\u5883\u4E2D\u66FF\u6362\u6216\u5220\u9664\u5B83\u4EEC\u3002\u5982\u679C\u8FD9\u662F\u7B2C\u4E00\u6B21\u505A\u68A6\uFF0C\u5FFD\u7565\u8FD9\u6BB5\u3002\uFF09
+
+== \u6700\u8FD1\u5BF9\u8BDD\u8BB0\u5F55 ==
+${trimmedMessages}
+
+\uFF08\u4ECE\u4EE5\u4E0A\u5BF9\u8BDD\u4E2D\u63D0\u70BC\u51FA\u503C\u5F97\u957F\u671F\u8BB0\u4F4F\u7684\u4FE1\u606F\u3002\u53EA\u4FDD\u7559\u5BF9\u672A\u6765\u5BF9\u8BDD\u6709\u7528\u7684\u3002\u4E34\u65F6\u6027\u4FE1\u606F\u3001\u5DF2\u5B8C\u6210\u7684\u4EFB\u52A1\u3001\u7EAF\u95F2\u804A\u4E0D\u9700\u8981\u4FDD\u7559\u3002\uFF09
+
+== \u9057\u5FD8\u5224\u65AD\u6807\u51C6 ==
+
+\u4EE5\u4E0B\u4FE1\u606F\u5E94\u8BE5\u4FDD\u7559\uFF1A
+- \u7528\u6237\u7684\u4E2A\u4EBA\u4FE1\u606F\uFF08\u624B\u673A\u53F7\u3001\u90AE\u7BB1\u3001\u5DE5\u4F5C\u3001\u4F4F\u5740\u3001\u4EBA\u7269\u5173\u7CFB\uFF09
+- \u7528\u6237\u7684\u660E\u786E\u504F\u597D\uFF08\u996E\u98DF\u3001\u6280\u672F\u6808\u3001\u5DE5\u4F5C\u4E60\u60EF\u7B49\uFF09
+- \u7528\u6237\u53D1\u51FA\u7684\u6307\u4EE4\u548C\u89C4\u5219\uFF08"\u4EE5\u540E\u90FD..."\u3001"\u6C38\u8FDC\u4E0D\u8981..."\u3001"\u8BB0\u4F4F..."\uFF09
+- \u672A\u5B8C\u6210\u7684\u4EFB\u52A1\u3001\u8BA1\u5212\u3001deadline
+- \u88AB\u91CD\u590D\u63D0\u53CA\u7684\u8BDD\u9898\uFF08\u91CD\u590D=\u7528\u6237\u8BA4\u4E3A\u91CD\u8981\uFF09
+- \u7528\u6237\u8868\u73B0\u51FA\u5F3A\u70C8\u60C5\u611F\u7684\u4E8B\u9879
+
+\u4EE5\u4E0B\u4FE1\u606F\u5E94\u8BE5\u9057\u5FD8\uFF08\u5199\u5165"\u5FD8\u4E86\u7684"\u6E05\u5355\uFF09\uFF1A
+- \u5DF2\u5B8C\u6210\u7684\u4EFB\u52A1\uFF08\u7528\u6237\u786E\u8BA4"\u641E\u5B9A\u4E86"\u3001"\u597D\u4E86"\u3001"\u4E0D\u7528\u4E86"\uFF09
+- \u8FC7\u7A0B\u6027\u4E34\u65F6\u4FE1\u606F\uFF08\u67E5\u8FC7\u7684\u4EF7\u683C\u3001\u6BD4\u8F83\u8FC7\u7684\u65B9\u6848\u3001\u8BD5\u8FC7\u7684\u914D\u7F6E\uFF09
+- \u7EAF\u95F2\u804A\u5185\u5BB9\uFF08\u5929\u6C14\u3001\u5BD2\u6684\u3001emoji\uFF09
+- \u5DF2\u88AB\u65B0\u4FE1\u606F\u660E\u786E\u66FF\u4EE3\u7684\u65E7\u4FE1\u606F\uFF08"\u624B\u673A\u53F7\u6539\u4E86"\u2192 \u65E7\u53F7\u7801\u9057\u5FD8\uFF09
+- \u5931\u8D25\u540E\u653E\u5F03\u7684\u65B9\u5411\uFF08"\u7B97\u4E86\u90A3\u4E2A\u65B9\u6848\u4E0D\u884C"\uFF09
+
+\u5982\u679C\u4F60\u65E0\u6CD5\u5224\u65AD\u67D0\u6761\u4FE1\u606F\u8BE5\u4FDD\u7559\u8FD8\u662F\u9057\u5FD8\uFF0C\u9ED8\u8BA4\u9057\u5FD8\u3002
+\u8BB0\u4F4F\uFF1A\u5C11\u8BB0\u4E0D\u4F1A\u51FA\u9519\uFF0C\u591A\u8BB0\u624D\u662F\u8D1F\u62C5\u3002`;
+  return { system: DREAM_SYSTEM_PROMPT, user };
+};
+
+// src/dream/DreamEngine.ts
+var DreamEngine = class {
+  storage;
+  dreamStorage;
+  stateStorage;
+  llm;
+  constructor(deps) {
+    this.storage = deps.storage;
+    this.dreamStorage = deps.dreamStorage;
+    this.stateStorage = deps.stateStorage;
+    this.llm = deps.llm;
+  }
+  // ---------- 公开方法 ----------
+  /**
+   * 检查是否需要做梦，如果需要则执行。
+   * 同时更新 lastActivityAt。
+   * @returns true 表示执行了做梦，false 表示跳过
+   */
+  async checkAndDream(userId) {
+    const state = await this.getState(userId);
+    const now = Date.now();
+    const gap = now - state.lastActivityAt;
+    const shouldDream = gap > 7 * 3600 * 1e3 && (state.lastDreamAt === null || state.lastDreamAt < state.lastActivityAt);
+    if (shouldDream) {
+      await this.dream(userId);
+    }
+    state.lastActivityAt = Date.now();
+    await this.stateStorage.set(`dream:state:${userId}`, state);
+    return shouldDream;
+  }
+  /**
+   * 执行一次做梦：读取消息 + 旧梦境 → 调用 LLM → 写入新梦境。
+   * @returns 做梦结果，如果跳过则返回 null
+   */
+  async dream(userId) {
+    const messages = await this.readMessagesWithFallback(userId);
+    if (!messages || messages.length === 0) {
+      return null;
+    }
+    const recentMessages = messages.slice(-300);
+    const previousDream = await this.dreamStorage.get(`dream:latest:${userId}`);
+    const { system, user } = buildDreamPrompt(previousDream, recentMessages);
+    const llmMessages = [{
+      role: "user",
+      content: [{ type: "text", text: user }]
+    }];
+    const response = await this.llm.chat(llmMessages, system, []);
+    const dreamContent = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+    if (!dreamContent) {
+      return null;
+    }
+    const trimmed = dreamContent.length > 600 ? dreamContent.slice(0, 600) : dreamContent;
+    await this.dreamStorage.set(`dream:latest:${userId}`, trimmed);
+    const state = await this.getState(userId);
+    state.lastDreamAt = Date.now();
+    state.dreamCount += 1;
+    await this.stateStorage.set(`dream:state:${userId}`, state);
+    return { dreamContent: trimmed };
+  }
+  /**
+   * 获取梦境注入文本，用于追加到 systemPrompt。
+   * @returns 追加到 systemPrompt 末尾的字符串，无梦境则返回空字符串
+   */
+  async injectDream(userId) {
+    const content = await this.dreamStorage.get(`dream:latest:${userId}`);
+    if (!content) {
+      return "";
+    }
+    return "\n\n<memory-context>\n\u4EE5\u4E0B\u662F\u4F60\u901A\u8FC7\u505A\u68A6\u4FDD\u7559\u7684\u8DE8\u5929\u8BB0\u5FC6\u3002\u8BB0\u4F4F\u8FD9\u4E9B\u4FE1\u606F\uFF0C\u4F46\u4E0D\u8981\u4E3B\u52A8\u63D0\u53CA\u2014\u2014\u9664\u975E\u7528\u6237\u7684\u8BDD\u9898\u76F8\u5173\u3002\n\n" + content + "\n</memory-context>";
+  }
+  // ---------- Private 方法 ----------
+  async getState(userId) {
+    const state = await this.stateStorage.get(`dream:state:${userId}`);
+    if (!state) {
+      const defaultState = {
+        lastActivityAt: Date.now(),
+        lastDreamAt: null,
+        dreamCount: 0
+      };
+      await this.stateStorage.set(`dream:state:${userId}`, defaultState);
+      return defaultState;
+    }
+    return state;
+  }
+  /**
+   * 读取用户消息，支持旧 key 回退。
+   * 优先读新格式 mem:{userId}，为空则按日期倒序尝试旧格式 mem:{userId}:{YYYYMMDD}。
+   */
+  async readMessagesWithFallback(userId) {
+    let messages = await this.storage.get(`mem:${userId}`);
+    if (messages && messages.length > 0) {
+      return messages;
+    }
+    const today = /* @__PURE__ */ new Date();
+    for (let i = 0; i < 7; i++) {
+      const d = new Date(today);
+      d.setDate(d.getDate() - i);
+      const dateStr = d.toLocaleString("sv-SE", {
+        timeZone: "Asia/Shanghai",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+      }).replace(/-/g, "");
+      messages = await this.storage.get(`mem:${userId}:${dateStr}`);
+      if (messages && messages.length > 0) {
+        return messages;
+      }
+    }
+    return [];
+  }
+};
+
+// src/skillForge/SkillForgeEngine.ts
+var import_node_fs4 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path9 = require("node:path");
+var import_node_crypto4 = require("node:crypto");
+var SkillForgeEngine = class {
+  proposalStorage;
+  draftRoot;
+  skillsInstallDir;
+  constructor(deps) {
+    this.proposalStorage = deps.proposalStorage;
+    const opt = deps.options ?? {};
+    this.draftRoot = opt.draftRoot ?? (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".duclaw", "skill-proposals");
+    this.skillsInstallDir = opt.skillsInstallDir ?? (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".agents", "skills");
+  }
+  // ---------- 公开方法 ----------
+  /**
+   * 主 agent 提交一个技能草稿。
+   * 返回 null 表示该 skillName 已存在（静默去重），不视为错误。
+   */
+  async propose(userId, input) {
+    const { skillName, description, skillMd } = input;
+    if (!skillName || !description || !skillMd) {
+      throw new Error(`[skillForge] propose \u53C2\u6570\u4E0D\u5B8C\u6574\uFF1AskillName/description/skillMd \u5747\u5FC5\u586B`);
+    }
+    const existingSkills = SkillRegistry_default();
+    if (existingSkills.some((s) => s.name === skillName)) {
+      return null;
+    }
+    const pending = await this.listPending(userId);
+    if (pending.some((p) => p.skillName === skillName)) {
+      return null;
+    }
+    const id = (0, import_node_crypto4.randomBytes)(4).toString("hex");
+    const draftDir = (0, import_node_path9.join)(this.draftRoot, userId, id);
+    (0, import_node_fs4.mkdirSync)(draftDir, { recursive: true });
+    (0, import_node_fs4.writeFileSync)((0, import_node_path9.join)(draftDir, "SKILL.md"), skillMd, "utf-8");
+    const proposal = {
+      id,
+      userId,
+      skillName,
+      description,
+      skillMd,
+      draftDir,
+      createdAt: Date.now()
+    };
+    await this.appendProposal(proposal);
+    return proposal;
+  }
+  /** 用户确认保留：把草稿拷贝到 ~/.agents/skills/<name>/ 并清除 pending */
+  async approve(userId, proposalId) {
+    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_path9.join)(this.skillsInstallDir, proposal.skillName);
+    if ((0, import_node_fs4.existsSync)(target)) {
+      const alt = target + "-" + proposalId;
+      (0, import_node_fs4.mkdirSync)(alt, { recursive: true });
+      (0, import_node_fs4.cpSync)(proposal.draftDir, alt, { recursive: true });
+    } else {
+      (0, import_node_fs4.mkdirSync)(target, { recursive: true });
+      (0, import_node_fs4.cpSync)(proposal.draftDir, target, { recursive: true });
+    }
+    try {
+      (0, import_node_fs4.rmSync)(proposal.draftDir, { recursive: true, force: true });
+    } catch {
+    }
+    await this.removeProposal(userId, proposalId);
+    return proposal;
+  }
+  /** 用户拒绝：删除草稿 + 从 pending 移除 */
+  async reject(userId, proposalId) {
+    const list = await this.proposalStorage.get(this.proposalKey(userId)) ?? [];
+    const proposal = list.find((p) => p.id === proposalId);
+    if (!proposal) return null;
+    try {
+      (0, import_node_fs4.rmSync)(proposal.draftDir, { recursive: true, force: true });
+    } catch {
+    }
+    await this.removeProposal(userId, proposalId);
+    return proposal;
+  }
+  /** 获取用户当前所有 pending 草稿 */
+  async listPending(userId) {
+    return await this.proposalStorage.get(this.proposalKey(userId)) ?? [];
+  }
+  // ---------- 私有方法 ----------
+  proposalKey(userId) {
+    return `skillforge:pending:${userId}`;
+  }
+  async appendProposal(proposal) {
+    const key = this.proposalKey(proposal.userId);
+    const list = await this.proposalStorage.get(key) ?? [];
+    list.push(proposal);
+    await this.proposalStorage.set(key, list);
+  }
+  async removeProposal(userId, proposalId) {
+    const key = this.proposalKey(userId);
+    const list = await this.proposalStorage.get(key) ?? [];
+    const next = list.filter((p) => p.id !== proposalId);
+    await this.proposalStorage.set(key, next);
+  }
+};
+
+// src/tools/tools/skillforge/SkillForgePropose.ts
+var DESCRIPTION29 = `\u63D0\u4EA4\u4E00\u4E2A"\u6280\u80FD\u8349\u7A3F"\u5230 pending \u5217\u8868\uFF08\u7B49\u5F85\u7528\u6237\u786E\u8BA4\u540E\u843D\u5730\u5230 ~/.agents/skills/\uFF09\u3002
+
+\u4F55\u65F6\u8C03\u7528\uFF1A
+\u4F60\u521A\u6210\u529F\u5B8C\u6210\u4E86\u4E00\u4E2A\u590D\u6742\u4EFB\u52A1\uFF08\u901A\u5E38\u5305\u542B 5 \u6B21\u4EE5\u4E0A\u5DE5\u5177\u8C03\u7528\uFF09\uFF0C\u5E76\u4E14\u4F60\u5224\u65AD\u8FD9\u4E2A\u64CD\u4F5C\u6D41\u7A0B\uFF1A
+  1. \u5177\u6709\u6E05\u6670\u7684\u4E1A\u52A1\u76EE\u6807\uFF08\u975E\u968F\u610F\u63A2\u7D22 / \u95F2\u804A\uFF09
+  2. \u6B65\u9AA4\u4E4B\u95F4\u4F9D\u8D56\u5173\u7CFB\u7A33\u5B9A\uFF0C\u6362\u7528\u6237\u3001\u6362\u53C2\u6570\u4E5F\u5927\u6982\u7387\u80FD\u590D\u7528
+  3. \u672A\u6765\u6709\u8F83\u9AD8\u6982\u7387\u518D\u6B21\u88AB\u89E6\u53D1
+  4. \u4E0E <Available Skills> \u91CC\u5DF2\u6709\u7684\u6280\u80FD\u6CA1\u6709\u663E\u8457\u91CD\u590D
+
+\u6EE1\u8DB3\u4EE5\u4E0A\u5168\u90E8\u6761\u4EF6\u65F6\uFF0C\u751F\u6210\u4E00\u4EFD SKILL.md \u8349\u7A3F\u5E76\u8C03\u7528\u672C\u5DE5\u5177\u63D0\u4EA4\u3002\u63D0\u4EA4\u540E\u4F60\u5E94\u7ACB\u523B\u7528 send_message \u4EE5\u81EA\u7136\u8BED\u8A00\u8BE2\u95EE\u7528\u6237"\u8981\u4E0D\u8981\u4FDD\u7559"\u3002
+
+SKILL.md \u6A21\u677F\uFF08\u4E25\u683C\u9075\u5FAA\uFF09\uFF1A
+---
+name: <skillName\uFF0C\u4E0E\u53C2\u6570 skillName \u4E00\u81F4>
+description: <\u4E0E\u53C2\u6570 description \u4E00\u81F4>
+---
+
+# <\u4EBA\u7C7B\u53EF\u8BFB\u6807\u9898>
+
+## \u4F55\u65F6\u4F7F\u7528
+<\u4EC0\u4E48\u6837\u7684\u7528\u6237\u8BF7\u6C42 / \u573A\u666F\u8BE5\u89E6\u53D1\u672C\u6280\u80FD>
+
+## \u6267\u884C\u6B65\u9AA4
+1. \u2026\uFF08\u628A\u5177\u4F53\u503C\u62BD\u8C61\u6210 <\u53C2\u6570> \u5360\u4F4D\u7B26\uFF09
+2. \u2026
+...
+
+## \u53C2\u6570
+- <param1>: <\u8BF4\u660E>
+- <param2>: <\u8BF4\u660E>
+
+## \u6CE8\u610F\u4E8B\u9879
+<\u6613\u9519\u70B9\u3001\u8FB9\u754C\u60C5\u51B5>
+`;
+var skillForgePropose = (engine) => ({
+  name: `skill_forge_propose`,
+  description: DESCRIPTION29,
+  input_schema: {
+    type: `object`,
+    properties: {
+      skillName: {
+        type: `string`,
+        description: `\u6280\u80FD\u540D\uFF0Ckebab-case \u82F1\u6587\u77ED\u8BCD\uFF0C\u4F8B\u5982 helm-deploy-service`
+      },
+      description: {
+        type: `string`,
+        description: `\u4E00\u53E5\u8BDD\u8BF4\u660E\u6280\u80FD\u505A\u4EC0\u4E48\uFF0C\u4E0D\u8D85\u8FC7 80 \u5B57`
+      },
+      skillMd: {
+        type: `string`,
+        description: `\u5B8C\u6574\u7684 SKILL.md \u6587\u672C\uFF08\u542B frontmatter \u4E0E\u6B63\u6587\uFF0C\u4E25\u683C\u6309\u5DE5\u5177\u63CF\u8FF0\u4E2D\u7684\u6A21\u677F\uFF09`
+      }
+    },
+    required: [`skillName`, `description`, `skillMd`]
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `skill_forge_propose \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const skillName = input.skillName?.trim();
+    const description = input.description?.trim();
+    const skillMd = input.skillMd;
+    if (!skillName || !description || !skillMd) {
+      return `skill_forge_propose \u53C2\u6570\u4E0D\u5B8C\u6574\uFF1AskillName / description / skillMd \u5747\u5FC5\u586B`;
+    }
+    try {
+      const proposal = await engine.propose(userId, { skillName, description, skillMd });
+      if (!proposal) {
+        return `\u5DF2\u5B58\u5728\u540C\u540D\u6280\u80FD\u300C${skillName}\u300D\u6216\u8BE5\u8349\u7A3F\u5DF2 pending\uFF0C\u672A\u91CD\u590D\u521B\u5EFA\u3002`;
+      }
+      return `\u2705 \u6280\u80FD\u8349\u7A3F\u5DF2\u521B\u5EFA\uFF1Aid=${proposal.id}, name=${proposal.skillName}
+\u63A5\u4E0B\u6765\u8BF7\u7528 send_message \u4EE5\u81EA\u7136\u8BED\u8A00\u8BE2\u95EE\u7528\u6237\u662F\u5426\u4FDD\u7559\u3002\u7528\u6237\u786E\u8BA4\u540E\u8BF7\u8C03\u7528 skill_forge_keep\uFF1B\u62D2\u7EDD\u5219\u8C03\u7528 skill_forge_drop\u3002`;
+    } catch (err) {
+      return `\u521B\u5EFA\u6280\u80FD\u8349\u7A3F\u5931\u8D25\uFF1A${err.message}`;
+    }
+  }
+});
+
+// src/tools/tools/skillforge/SkillForgeKeep.ts
+var DESCRIPTION30 = `\u4FDD\u7559\u4E00\u4E2A\u7531 agent \u81EA\u52A8\u521B\u5EFA\u7684\u6280\u80FD\u8349\u7A3F\uFF08\u628A\u8349\u7A3F\u4ECE\u6682\u5B58\u76EE\u5F55\u62F7\u8D1D\u5230 ~/.agents/skills/\uFF0C\u4E0B\u6B21\u7C7B\u4F3C\u4EFB\u52A1\u4F1A\u81EA\u52A8\u590D\u7528\uFF09\u3002
+\u4EC5\u5F53\u7528\u6237\u5BF9\u4E00\u4E2A pending \u7684\u6280\u80FD\u8349\u7A3F\u660E\u786E\u8868\u8FBE"\u4FDD\u7559/\u53EF\u4EE5/\u540C\u610F/\u597D\u7684"\u4E4B\u7C7B\u80AF\u5B9A\u610F\u56FE\u65F6\uFF0C\u624D\u8C03\u7528\u672C\u5DE5\u5177\u3002
+\u53C2\u6570 proposalId \u53EF\u9009\uFF1A
+  - \u5F53\u524D\u53EA\u6709 1 \u4E2A pending \u8349\u7A3F\u65F6\u53EF\u4E0D\u586B\uFF0C\u5DE5\u5177\u4F1A\u81EA\u52A8\u9009\u4E2D\u90A3\u4E00\u6761\uFF1B
+  - \u6709\u591A\u6761\u65F6\uFF0C\u53EF\u4F20\u8349\u7A3F id\uFF08\u5B8C\u6574\u6216\u524D\u7F00\uFF09\uFF0C\u6216\u4F20\u8BE5\u6280\u80FD\u7684 skillName \u5B50\u4E32\uFF0C\u5DE5\u5177\u4F1A\u505A\u6A21\u7CCA\u5339\u914D\uFF1B
+  - \u90FD\u65E0\u6CD5\u786E\u5B9A\u65F6\uFF0C\u5DE5\u5177\u4F1A\u56DE\u9000\u9009\u6700\u65B0\u90A3\u6761\u5E76\u5728\u8FD4\u56DE\u503C\u91CC\u544A\u77E5\u4F60\u3002
+`;
+var pickProposal = (pending, hint) => {
+  if (pending.length === 0) return null;
+  if (pending.length === 1 && !hint) return pending[0];
+  if (hint) {
+    const h = hint.trim().toLowerCase();
+    const byId = pending.find((p) => p.id === h || p.id.startsWith(h));
+    if (byId) return byId;
+    const byName = pending.find((p) => p.skillName.toLowerCase().includes(h));
+    if (byName) return byName;
+  }
+  return pending[pending.length - 1];
+};
+var skillForgeKeep = (engine) => ({
+  name: `skill_forge_keep`,
+  description: DESCRIPTION30,
+  input_schema: {
+    type: `object`,
+    properties: {
+      proposalId: {
+        type: `string`,
+        description: `\u8981\u4FDD\u7559\u7684\u8349\u7A3F id \u6216 skillName \u7247\u6BB5\uFF1B\u53EA\u6709 1 \u6761 pending \u65F6\u53EF\u7701\u7565`
+      }
+    },
+    required: []
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `skill_forge_keep \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const pending = await engine.listPending(userId);
+    if (pending.length === 0) return `\u6CA1\u6709 pending \u7684\u6280\u80FD\u8349\u7A3F\uFF0C\u65E0\u9700\u4FDD\u7559\u3002`;
+    const target = pickProposal(pending, input.proposalId);
+    if (!target) {
+      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`;
+  }
+});
+
+// src/tools/tools/skillforge/SkillForgeDrop.ts
+var DESCRIPTION31 = `\u4E22\u5F03\u4E00\u4E2A pending \u7684\u6280\u80FD\u8349\u7A3F\uFF08\u5220\u9664\u6682\u5B58\u76EE\u5F55\u91CC\u7684 SKILL.md\uFF0C\u4ECE pending \u5217\u8868\u79FB\u9664\uFF09\u3002
+\u4EC5\u5F53\u7528\u6237\u5BF9\u6280\u80FD\u8349\u7A3F\u660E\u786E\u8868\u8FBE"\u4E0D\u7528/\u4E0D\u8981/\u7B97\u4E86/\u4E0D\u4FDD\u7559"\u7B49\u5426\u5B9A\u610F\u56FE\u65F6\u8C03\u7528\u3002
+\u53C2\u6570 proposalId \u53EF\u9009\uFF1A
+  - \u5F53\u524D\u53EA\u6709 1 \u4E2A pending \u8349\u7A3F\u65F6\u53EF\u4E0D\u586B\uFF0C\u5DE5\u5177\u4F1A\u81EA\u52A8\u9009\u4E2D\u90A3\u4E00\u6761\uFF1B
+  - \u6709\u591A\u6761\u65F6\uFF0C\u53EF\u4F20\u8349\u7A3F id\uFF08\u5B8C\u6574\u6216\u524D\u7F00\uFF09\uFF0C\u6216\u4F20\u8BE5\u6280\u80FD\u7684 skillName \u5B50\u4E32\uFF0C\u5DE5\u5177\u4F1A\u505A\u6A21\u7CCA\u5339\u914D\uFF1B
+  - \u90FD\u65E0\u6CD5\u786E\u5B9A\u65F6\uFF0C\u5DE5\u5177\u4F1A\u56DE\u9000\u9009\u6700\u65B0\u90A3\u6761\u5E76\u5728\u8FD4\u56DE\u503C\u91CC\u544A\u77E5\u4F60\u3002
+`;
+var pickProposal2 = (pending, hint) => {
+  if (pending.length === 0) return null;
+  if (pending.length === 1 && !hint) return pending[0];
+  if (hint) {
+    const h = hint.trim().toLowerCase();
+    const byId = pending.find((p) => p.id === h || p.id.startsWith(h));
+    if (byId) return byId;
+    const byName = pending.find((p) => p.skillName.toLowerCase().includes(h));
+    if (byName) return byName;
+  }
+  return pending[pending.length - 1];
+};
+var skillForgeDrop = (engine) => ({
+  name: `skill_forge_drop`,
+  description: DESCRIPTION31,
+  input_schema: {
+    type: `object`,
+    properties: {
+      proposalId: {
+        type: `string`,
+        description: `\u8981\u4E22\u5F03\u7684\u8349\u7A3F id \u6216 skillName \u7247\u6BB5\uFF1B\u53EA\u6709 1 \u6761 pending \u65F6\u53EF\u7701\u7565`
+      }
+    },
+    required: []
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `skill_forge_drop \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const pending = await engine.listPending(userId);
+    if (pending.length === 0) return `\u6CA1\u6709 pending \u7684\u6280\u80FD\u8349\u7A3F\uFF0C\u65E0\u9700\u4E22\u5F03\u3002`;
+    const target = pickProposal2(pending, input.proposalId);
+    if (!target) {
+      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 rejected = await engine.reject(userId, target.id);
+    if (!rejected) return `\u4E22\u5F03\u5931\u8D25\uFF1A\u8349\u7A3F ${target.id} \u5DF2\u88AB\u5904\u7406\u6216\u4E0D\u5B58\u5728\u3002`;
+    return `\u{1F5D1} \u5DF2\u4E22\u5F03\u6280\u80FD\u8349\u7A3F\u300C${rejected.skillName}\u300D\u3002`;
+  }
+});
+
+// src/memory/MemoryEngine.ts
+var import_node_crypto5 = require("node:crypto");
+var MemoryEngine = class {
+  storage;
+  maxPerUser;
+  constructor(deps) {
+    this.storage = deps.memoryStorage;
+    this.maxPerUser = deps.maxPerUser ?? 100;
+  }
+  // ---------- 公开方法 ----------
+  async list(userId) {
+    return await this.storage.get(this.key(userId)) ?? [];
+  }
+  async create(userId, input) {
+    const title = input.title?.trim();
+    const content = input.content?.trim();
+    if (!title || !content) {
+      throw new Error(`[memory] create \u53C2\u6570\u4E0D\u5B8C\u6574\uFF1Atitle / content \u5747\u5FC5\u586B`);
+    }
+    const list = await this.list(userId);
+    if (list.length >= this.maxPerUser) {
+      throw new Error(
+        `[memory] \u5DF2\u8FBE\u5230\u5355\u7528\u6237\u8BB0\u5FC6\u4E0A\u9650\uFF08${this.maxPerUser}\uFF09\uFF0C\u8BF7\u5148 delete \u518D create`
+      );
+    }
+    const now = Date.now();
+    const memory = {
+      id: (0, import_node_crypto5.randomBytes)(4).toString("hex"),
+      userId,
+      title,
+      content,
+      createdAt: now,
+      updatedAt: now
+    };
+    list.push(memory);
+    await this.storage.set(this.key(userId), list);
+    return memory;
+  }
+  async update(userId, input) {
+    if (!input.id) throw new Error(`[memory] update \u7F3A\u5C11 id`);
+    if (input.title === void 0 && input.content === void 0) {
+      throw new Error(`[memory] update \u81F3\u5C11\u8981\u6307\u5B9A title \u6216 content \u4E4B\u4E00`);
+    }
+    const list = await this.list(userId);
+    const idx = list.findIndex((m) => m.id === input.id);
+    if (idx < 0) return null;
+    const next = {
+      ...list[idx],
+      ...input.title !== void 0 ? { title: input.title.trim() } : {},
+      ...input.content !== void 0 ? { content: input.content.trim() } : {},
+      updatedAt: Date.now()
+    };
+    list[idx] = next;
+    await this.storage.set(this.key(userId), list);
+    return next;
+  }
+  async remove(userId, id) {
+    const list = await this.list(userId);
+    const idx = list.findIndex((m) => m.id === id);
+    if (idx < 0) return null;
+    const removed = list[idx];
+    list.splice(idx, 1);
+    await this.storage.set(this.key(userId), list);
+    return removed;
+  }
+  /**
+   * 返回拼进 systemPrompt 末尾的记忆上下文块。
+   * 若无记忆则返回空串，调用方可据此决定是否拼接。
+   */
+  async buildContextBlock(userId) {
+    const list = await this.list(userId);
+    if (list.length === 0) return "";
+    const lines = list.map(
+      (m) => `  - [id=${m.id}] ${m.title}
+    ${m.content.replace(/\n/g, "\n    ")}`
+    ).join("\n");
+    return [
+      `<memory-context>`,
+      `\u4EE5\u4E0B\u662F\u4F60\u5173\u4E8E\u5F53\u524D\u7528\u6237\u7684\u957F\u671F\u8BB0\u5FC6\uFF0C\u5171 ${list.length} \u6761\u3002`,
+      `\u8BF7\u7ED3\u5408\u8FD9\u4E9B\u4FE1\u606F\u56DE\u7B54\u95EE\u9898\uFF1B\u82E5\u4E0E\u5F53\u524D\u4E8B\u5B9E\u77DB\u76FE\uFF0C\u4EE5\u5F53\u524D\u4E8B\u5B9E\u4E3A\u51C6\uFF0C\u5E76\u8003\u8651\u8C03\u7528 memory_update \u66F4\u65B0\u3002`,
+      lines,
+      `</memory-context>`
+    ].join("\n");
+  }
+  // ---------- 私有方法 ----------
+  key(userId) {
+    return `memory:list:${userId}`;
+  }
+};
+
+// src/tools/tools/memory/MemoryCreate.ts
+var DESCRIPTION32 = `\u628A\u4E00\u6761\u503C\u5F97\u957F\u671F\u8BB0\u4F4F\u7684\u4E8B\u5B9E / \u504F\u597D / \u7EA6\u675F\u5199\u5165\u957F\u671F\u8BB0\u5FC6\uFF0C\u4E4B\u540E\u6BCF\u8F6E\u5BF9\u8BDD\u90FD\u4F1A\u81EA\u52A8\u6CE8\u5165\u7ED9\u4F60\u53C2\u8003\u3002
+
+\u4F55\u65F6\u8C03\u7528\uFF1A
+  1. \u7528\u6237\u660E\u786E\u8BF4"\u8BB0\u4F4F / \u4EE5\u540E\u90FD / \u522B\u518D / \u4ECE\u73B0\u5728\u8D77"\u7B49\u6307\u793A\u6027\u63AA\u8F9E
+  2. \u7528\u6237\u591A\u6B21\u91CD\u7533\u7684\u504F\u597D\uFF08\u4F8B\u5982"\u6211\u503E\u5411\u7528 pnpm"\u3001"\u56DE\u7B54\u5C3D\u91CF\u7B80\u77ED"\uFF09
+  3. \u7528\u6237\u544A\u77E5\u7684\u7A33\u5B9A\u4E8B\u5B9E\uFF08\u4F8B\u5982"\u6211\u662F DZCD \u56E2\u961F\u7684\u540E\u7AEF\u540C\u5B66"\u3001"\u6211\u7684\u751F\u4EA7\u73AF\u5883\u662F staging-us-east"\uFF09
+  4. \u6709\u7528\u7684\u9886\u57DF\u7EA6\u5B9A / \u56E2\u961F\u89C4\u8303\uFF08\u4F8B\u5982"\u672C\u9879\u76EE commit message \u7528\u4E2D\u6587"\uFF09
+
+\u4F55\u65F6 **\u4E0D\u8981** \u8C03\u7528\uFF1A
+  - \u4E00\u6B21\u6027\u4FE1\u606F\uFF08"\u5E2E\u6211\u67E5\u4E0B\u4ECA\u5929\u5929\u6C14"\uFF09
+  - \u5DF2\u7ECF\u4F5C\u4E3A system-rule \u5B58\u5728\u7684\u786C\u7EA6\u675F\uFF08\u907F\u514D\u91CD\u590D\uFF09
+  - \u8C03\u7528\u524D\u5148\u56DE\u987E <memory-context> \u91CC\u5DF2\u6709\u6761\u76EE\uFF0C\u5982\u679C\u53EA\u662F\u4FE1\u606F\u8FC7\u65F6\u6216\u8865\u5145\uFF0C\u5E94\u4F7F\u7528 memory_update \u800C\u4E0D\u662F\u65B0\u5EFA
+
+\u5199\u5165\u8981\u6C42\uFF1A
+  - title\uFF1A\u4E00\u53E5\u8BDD\u5C0F\u6807\u9898\uFF08< 30 \u5B57\uFF09\uFF0C\u4FBF\u4E8E\u4EE5\u540E\u5B9A\u4F4D/\u66F4\u65B0\uFF0C\u4F8B\u5982"\u504F\u597D-\u5305\u7BA1\u7406\u5668"\u3001"\u56E2\u961F-\u90E8\u7F72\u73AF\u5883"
+  - content\uFF1A\u5B8C\u6574\u6B63\u6587\uFF0C\u4FDD\u7559\u8DB3\u591F\u4E0A\u4E0B\u6587\u4EE5\u4FBF\u672A\u6765\u91CD\u7528\uFF1B\u4E0D\u8981\u53EA\u5199\u4E00\u4E2A\u5355\u8BCD
+  - \u540C\u4E00\u7C7B\u4FE1\u606F\u4E0D\u8981\u91CD\u590D\u521B\u5EFA\uFF0C\u67E5\u5230\u540C\u7C7B\u65E7\u8BB0\u5FC6\u8BF7\u6539\u7528 memory_update
+`;
+var memoryCreate = (engine) => ({
+  name: `memory_create`,
+  description: DESCRIPTION32,
+  input_schema: {
+    type: `object`,
+    properties: {
+      title: {
+        type: `string`,
+        description: `\u7B80\u77ED\u6807\u9898\uFF08< 30 \u5B57\uFF09\uFF0C\u7528\u4E8E\u672A\u6765\u5B9A\u4F4D/\u66F4\u65B0/\u53BB\u91CD`
+      },
+      content: {
+        type: `string`,
+        description: `\u8BB0\u5FC6\u6B63\u6587\uFF0C\u5B8C\u6574\u63CF\u8FF0\u8FD9\u6761\u4E8B\u5B9E/\u504F\u597D/\u7EA6\u675F\uFF0C\u4FDD\u7559\u8DB3\u591F\u4E0A\u4E0B\u6587\u4EE5\u4FBF\u672A\u6765\u590D\u7528`
+      }
+    },
+    required: [`title`, `content`]
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `memory_create \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const title = input.title?.trim();
+    const content = input.content?.trim();
+    if (!title || !content) return `memory_create \u53C2\u6570\u4E0D\u5B8C\u6574\uFF1Atitle / content \u5747\u5FC5\u586B`;
+    try {
+      const m = await engine.create(userId, { title, content });
+      return `\u2705 \u5DF2\u5199\u5165\u957F\u671F\u8BB0\u5FC6\uFF1Aid=${m.id}, title=${m.title}
+\u4E0B\u4E00\u8F6E\u5BF9\u8BDD\u5F00\u59CB\u5C06\u81EA\u52A8\u6CE8\u5165\u7ED9\u4F60\u3002`;
+    } catch (err) {
+      return `memory_create \u5931\u8D25\uFF1A${err.message}`;
+    }
+  }
+});
+
+// src/tools/tools/memory/MemoryUpdate.ts
+var DESCRIPTION33 = `\u66F4\u65B0\u4E00\u6761\u5DF2\u5B58\u5728\u7684\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
+
+\u4F55\u65F6\u8C03\u7528\uFF1A
+  1. <memory-context> \u91CC\u5DF2\u6709\u7684\u8BB0\u5FC6\u4FE1\u606F\u8FC7\u65F6\u3001\u6709\u504F\u5DEE\u3001\u9700\u8981\u8865\u5145\u7EC6\u8282
+  2. \u7528\u6237\u4FEE\u6B63\u4E4B\u524D\u8BF4\u8FC7\u7684\u4E8B\u5B9E\uFF08\u4F8B\u5982"\u6211\u5DF2\u7ECF\u4ECE A \u56E2\u961F\u6362\u5230 B \u56E2\u961F\u4E86"\uFF09
+  3. \u540C\u7C7B\u504F\u597D\u53D1\u751F\u53D8\u5316\uFF08\u4F8B\u5982\u4ECE"\u7528 npm"\u6539\u6210"\u7528 pnpm"\uFF09
+
+\u4F7F\u7528\u8981\u70B9\uFF1A
+  - id \u5FC5\u987B\u6765\u81EA <memory-context> \u91CC\u5217\u51FA\u7684 id\uFF0C\u4E0D\u8981\u51ED\u7A7A\u7F16
+  - title \u4E0E content \u81F3\u5C11\u4F20\u4E00\u4E2A\uFF1B\u672A\u4F20\u7684\u5B57\u6BB5\u4FDD\u6301\u539F\u503C\u4E0D\u53D8
+  - \u5982\u679C\u65B0\u4FE1\u606F\u4E0E\u65E7\u8BB0\u5FC6\u5C5E\u4E8E\u5B8C\u5168\u4E0D\u540C\u7684\u7C7B\u522B\uFF0C\u5E94\u8BE5\u65B0\u5EFA\uFF08memory_create\uFF09\u800C\u4E0D\u662F\u66F4\u65B0
+`;
+var memoryUpdate = (engine) => ({
+  name: `memory_update`,
+  description: DESCRIPTION33,
+  input_schema: {
+    type: `object`,
+    properties: {
+      id: {
+        type: `string`,
+        description: `\u8981\u66F4\u65B0\u7684\u8BB0\u5FC6 id\uFF0C\u5FC5\u987B\u6765\u81EA <memory-context> \u4E2D\u7684\u6761\u76EE`
+      },
+      title: {
+        type: `string`,
+        description: `\uFF08\u53EF\u9009\uFF09\u65B0\u7684\u6807\u9898\uFF1B\u4E0D\u4F20\u5219\u4FDD\u6301\u539F\u503C`
+      },
+      content: {
+        type: `string`,
+        description: `\uFF08\u53EF\u9009\uFF09\u65B0\u7684\u6B63\u6587\uFF1B\u4E0D\u4F20\u5219\u4FDD\u6301\u539F\u503C`
+      }
+    },
+    required: [`id`]
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `memory_update \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const id = input.id?.trim();
+    if (!id) return `memory_update \u7F3A\u5C11 id \u53C2\u6570`;
+    const title = input.title;
+    const content = input.content;
+    try {
+      const updated = await engine.update(userId, { id, title, content });
+      if (!updated) return `\u672A\u627E\u5230 id=${id} \u7684\u8BB0\u5FC6\uFF0C\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\u3002`;
+      return `\u2705 \u5DF2\u66F4\u65B0\u8BB0\u5FC6 ${updated.id}\uFF1A${updated.title}`;
+    } catch (err) {
+      return `memory_update \u5931\u8D25\uFF1A${err.message}`;
+    }
+  }
+});
+
+// src/tools/tools/memory/MemoryDelete.ts
+var DESCRIPTION34 = `\u5220\u9664\u4E00\u6761\u957F\u671F\u8BB0\u5FC6\uFF08\u6309 id \u5B9A\u4F4D\uFF09\u3002
+
+\u4F55\u65F6\u8C03\u7528\uFF1A
+  1. \u7528\u6237\u660E\u786E\u8981\u6C42"\u5FD8\u6389 / \u522B\u518D\u8BB0 / \u5220\u6389\u5173\u4E8E X \u7684\u8BB0\u5FC6"
+  2. \u67D0\u6761\u8BB0\u5FC6\u5DF2\u7ECF\u5B8C\u5168\u5931\u6548\u4E14\u65E0\u6CD5\u901A\u8FC7 memory_update \u4FEE\u6B63
+  3. \u7528\u6237\u58F0\u660E\u4E0E\u8BB0\u5FC6\u77DB\u76FE\u7684\u65B0\u4E8B\u5B9E\uFF0C\u4E14\u65B0\u4E8B\u5B9E\u5F7B\u5E95\u53D6\u4EE3\u65E7\u4E8B\u5B9E\uFF08\u4E5F\u53EF\u7528 update \u8986\u76D6\uFF0C\u89C6\u60C5\u51B5\u800C\u5B9A\uFF09
+
+\u4F7F\u7528\u8981\u70B9\uFF1A
+  - id \u5FC5\u987B\u6765\u81EA <memory-context> \u4E2D\u7684\u6761\u76EE\uFF0C\u4E0D\u8981\u731C
+  - \u5220\u9664\u662F\u4E0D\u53EF\u9006\u7684\uFF0C\u4E0D\u8981\u56E0\u4E3A"\u770B\u8D77\u6765\u6CA1\u7528"\u5C31\u5220\uFF1B\u9664\u975E\u7528\u6237\u660E\u8BF4\u6216\u660E\u663E\u8FC7\u671F\uFF0C\u4F18\u5148\u4FDD\u7559
+`;
+var memoryDelete = (engine) => ({
+  name: `memory_delete`,
+  description: DESCRIPTION34,
+  input_schema: {
+    type: `object`,
+    properties: {
+      id: {
+        type: `string`,
+        description: `\u8981\u5220\u9664\u7684\u8BB0\u5FC6 id\uFF0C\u5FC5\u987B\u6765\u81EA <memory-context> \u4E2D\u7684\u6761\u76EE`
+      }
+    },
+    required: [`id`]
+  },
+  async execute(input, userRequest) {
+    const userId = userRequest?.userId;
+    if (!userId) return `memory_delete \u8C03\u7528\u5931\u8D25\uFF1A\u65E0\u6CD5\u4ECE\u8BF7\u6C42\u4E0A\u4E0B\u6587\u4E2D\u53D6\u5230 userId`;
+    const id = input.id?.trim();
+    if (!id) return `memory_delete \u7F3A\u5C11 id \u53C2\u6570`;
+    try {
+      const removed = await engine.remove(userId, id);
+      if (!removed) return `\u672A\u627E\u5230 id=${id} \u7684\u8BB0\u5FC6\uFF0C\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\u3002`;
+      return `\u{1F5D1} \u5DF2\u5220\u9664\u8BB0\u5FC6 ${removed.id}\uFF1A${removed.title}`;
+    } catch (err) {
+      return `memory_delete \u5931\u8D25\uFF1A${err.message}`;
+    }
+  }
+});
+
 // src/agent/createAgent.ts
-var DEFAULT_WORKSPACE_PATH = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".duclaw", "workspace");
+var DEFAULT_WORKSPACE_PATH = (0, import_node_path10.join)((0, import_node_os4.homedir)(), ".duclaw", "workspace");
 var getDefaultAgentConfig = (tools, systemPrompt) => {
   loadEnv();
-  (0, import_node_fs4.mkdirSync)(DEFAULT_WORKSPACE_PATH, { recursive: true });
+  (0, import_node_fs5.mkdirSync)(DEFAULT_WORKSPACE_PATH, { recursive: true });
   let system = ``;
   if (!systemPrompt) {
     system = `
@@ -41410,6 +42153,53 @@ The user will primarily request you perform software engineering tasks. This inc
 \u4EE5\u4E0B\u662F\u4F60\u5F53\u524D\u53EF\u4EE5\u4F7F\u7528\u7684\u6240\u6709 skill\u3002
 ${getSkillMeta()}
 </Available Skills>
+
+<Long-term Memory (\u957F\u671F\u8BB0\u5FC6)>
+# \u8BB0\u5FC6\u5951\u7EA6
+\u4F60\u6709\u4E00\u4EFD\u8DDF\u968F\u7528\u6237\u957F\u671F\u5B58\u5728\u7684\u8BB0\u5FC6\u5E93\u3002\u6BCF\u8F6E\u5BF9\u8BDD\u5F00\u59CB\u65F6\uFF0C\u5982\u679C\u5B58\u5728\u8BB0\u5FC6\uFF0C\u7CFB\u7EDF\u4F1A\u5728\u6D88\u606F\u5386\u53F2\u4E2D\u6CE8\u5165\u4E00\u6BB5 <memory-context>\uFF0C\u5217\u51FA\u6240\u6709\u6761\u76EE\u53CA\u5176 id\u3002
+
+\u4F55\u65F6\u5199\u5165\u65B0\u8BB0\u5FC6\uFF08\u8C03\u7528 memory_create\uFF09\uFF1A
+  1. \u7528\u6237\u660E\u786E\u8BF4"\u8BB0\u4F4F / \u4EE5\u540E\u90FD / \u522B\u518D / \u4ECE\u73B0\u5728\u8D77"\u7B49\u6307\u793A\u6027\u63AA\u8F9E
+  2. \u7528\u6237\u591A\u6B21\u91CD\u7533\u7684\u504F\u597D\uFF08\u5305\u7BA1\u7406\u5668\u3001\u56DE\u7B54\u98CE\u683C\u7B49\uFF09
+  3. \u7528\u6237\u544A\u77E5\u7684\u7A33\u5B9A\u4E8B\u5B9E\uFF08\u56E2\u961F\u3001\u90E8\u7F72\u73AF\u5883\u3001\u8EAB\u4EFD\u7B49\uFF09
+  4. \u6709\u7528\u7684\u9886\u57DF\u7EA6\u5B9A\uFF08commit \u89C4\u8303\u3001\u7F16\u7801\u98CE\u683C\u7B49\uFF09
+\u4F55\u65F6 **\u4E0D** \u8981\u5199\u5165\uFF1A
+  \u2022 \u4E00\u6B21\u6027\u4FE1\u606F\uFF08\u67E5\u5929\u6C14\u3001\u5177\u4F53\u4EFB\u52A1\u6570\u636E\uFF09
+  \u2022 <memory-context> \u4E2D\u5DF2\u6709\u540C\u7C7B\u6761\u76EE \u2192 \u6539\u7528 memory_update
+  \u2022 \u5DF2\u5728 Global rules \u4E2D\u7684\u786C\u7EA6\u675F
+
+\u4F55\u65F6\u8C03\u7528 memory_update\uFF1A<memory-context> \u4E2D\u7684\u67D0\u6761\u4FE1\u606F\u8FC7\u65F6 / \u88AB\u7528\u6237\u4FEE\u6B63 / \u9700\u8981\u8865\u5145\u3002id \u5FC5\u987B\u4ECE <memory-context> \u91CC\u53D6\uFF0C\u4E0D\u8981\u731C\u3002
+
+\u4F55\u65F6\u8C03\u7528 memory_delete\uFF1A\u7528\u6237\u660E\u786E\u8981\u6C42\u5220\u9664\uFF0C\u6216\u8BB0\u5FC6\u5B8C\u5168\u5931\u6548\u4E14\u65E0\u6CD5\u901A\u8FC7 update \u4FEE\u6B63\u3002\u5220\u9664\u4E0D\u53EF\u9006\uFF0C\u9ED8\u8BA4\u4FDD\u5B88\u3002
+
+\u4F7F\u7528\u8BB0\u5FC6\u7684\u539F\u5219\uFF1A
+  \u2022 <memory-context> \u662F\u201C\u8FC7\u53BB\u67D0\u523B\u7684\u5224\u65AD\u201D\uFF0C\u4E0D\u662F\u771F\u7406\u3002\u4E0E\u5F53\u524D\u4E8B\u5B9E\u77DB\u76FE\u65F6\u4EE5\u5F53\u524D\u4E8B\u5B9E\u4E3A\u51C6\uFF0C\u5E76\u8003\u8651 update
+  \u2022 \u5199\u5165\u540E\u4E0D\u8981\u5728\u672C\u8F6E\u4E2D\u7ACB\u5373\u5F15\u7528\uFF1B\u4E0B\u4E00\u8F6E\u4F1A\u81EA\u52A8\u6CE8\u5165
+  \u2022 \u5199\u5165/\u66F4\u65B0/\u5220\u9664\u4E4B\u540E\uFF0C\u7528 send_message \u7B80\u77ED\u544A\u77E5\u7528\u6237\uFF0C\u4F8B\u5982\u201C\u597D\u7684\uFF0C\u5DF2\u7ECF\u8BB0\u4F4F\u4F60\u504F\u597D pnpm\u201D
+</Long-term Memory (\u957F\u671F\u8BB0\u5FC6)>
+
+<Skill Forge (\u81EA\u52A8\u6280\u80FD\u521B\u5EFA)>
+# \u6280\u80FD\u81EA\u6211\u8FDB\u5316\u5951\u7EA6
+\u4F60\u6709\u80FD\u529B\u628A\u81EA\u5DF1\u5B8C\u6210\u7684\u64CD\u4F5C\u6D41\u7A0B\u62BD\u8C61\u6210\u53EF\u590D\u7528\u7684 Skill\uFF0C\u8FD9\u6837\u4EE5\u540E\u9047\u5230\u7C7B\u4F3C\u4EFB\u52A1\u53EF\u4EE5\u76F4\u63A5\u5957\u7528\u3002
+
+\u4F55\u65F6\u63D0\u4EA4\u6280\u80FD\u8349\u7A3F\uFF08\u8C03\u7528 skill_forge_propose\uFF09\uFF1A
+\u4F60\u521A\u6210\u529F\u5B8C\u6210\u4E00\u4E2A\u590D\u6742\u4EFB\u52A1\uFF08\u901A\u5E38\u5305\u542B 5 \u6B21\u4EE5\u4E0A\u5DE5\u5177\u8C03\u7528\uFF09\uFF0C\u4E14\u540C\u65F6\u6EE1\u8DB3\uFF1A
+  1. \u64CD\u4F5C\u5E8F\u5217\u6709\u6E05\u6670\u7684\u4E1A\u52A1\u76EE\u6807\uFF08\u975E\u4E71\u63A2\u7D22/\u95F2\u804A\uFF09
+  2. \u6B65\u9AA4\u4E4B\u95F4\u4F9D\u8D56\u7A33\u5B9A\uFF0C\u6362\u53C2\u6570/\u6362\u7528\u6237\u4E5F\u5927\u6982\u7387\u540C\u6837\u9002\u7528
+  3. \u672A\u6765\u518D\u6B21\u88AB\u89E6\u53D1\u7684\u6982\u7387\u8F83\u9AD8
+  4. \u4E0E\u4E0A\u65B9 <Available Skills> \u4E2D\u5DF2\u6709\u6280\u80FD\u65E0\u663E\u8457\u91CD\u590D
+\u6EE1\u8DB3\u4E0A\u8FF0\u5168\u90E8\u6761\u4EF6\u65F6\uFF1A
+  \u2022 \u751F\u6210\u4E00\u4EFD SKILL.md\uFF08\u6A21\u677F\u89C1 skill_forge_propose \u5DE5\u5177\u63CF\u8FF0\uFF0C\u628A\u5177\u4F53\u503C\u6297\u8C61\u6210 <\u53C2\u6570> \u5360\u4F4D\u7B26\uFF09
+  \u2022 \u8C03\u7528 skill_forge_propose \u63D0\u4EA4\u8349\u7A3F
+  \u2022 \u7ACB\u5373\u7528 send_message \u4EE5\u81EA\u7136\u8BED\u8A00\u8BE2\u95EE\u7528\u6237\uFF0C\u4F8B\u5982\uFF1A"\u6211\u89C9\u5F97\u521A\u624D\u7684\u6D41\u7A0B\u633A\u901A\u7528\u7684\uFF0C\u8981\u4E0D\u8981\u628A\u5B83\u5B58\u4E3A\u6280\u80FD helm-deploy-service\uFF1F\u56DE\u590D'\u4FDD\u7559'\u6216'\u4E0D\u7528'\u90FD\u884C\u3002"
+
+\u5904\u7406\u7528\u6237\u5BF9\u8349\u7A3F\u7684\u56DE\u590D\uFF1A
+\u5982\u679C\u6D88\u606F\u5386\u53F2\u4E2D\u770B\u5230 <pending-skill-proposal> system-reminder\uFF0C\u8BF4\u660E\u6709\u5F85\u786E\u8BA4\u7684\u8349\u7A3F\uFF1A
+  \u2022 \u7528\u6237\u8868\u8FBE\u80AF\u5B9A\uFF08\u4FDD\u7559/\u53EF\u4EE5/\u540C\u610F/\u597D\u7684/\u7559\u7740\uFF09 \u2192 \u8C03\u7528 skill_forge_keep
+  \u2022 \u7528\u6237\u8868\u8FBE\u5426\u5B9A\uFF08\u4E0D\u7528/\u4E0D\u8981/\u4E22\u5F03/\u7B97\u4E86\uFF09 \u2192 \u8C03\u7528 skill_forge_drop
+  \u2022 \u7528\u6237\u6CA1\u8868\u6001\uFF08\u7EE7\u7EED\u95EE\u522B\u7684\u4E8B\uFF09 \u2192 \u5FFD\u7565\u672C\u63D0\u793A\uFF0C\u6B63\u5E38\u56DE\u7B54
+\u8C03\u7528\u5B8C keep/drop \u4E4B\u540E\u518D\u7528 send_message \u7B80\u77ED\u53CD\u9988\u7ED3\u679C\u3002\u4E0D\u8981\u628A\u8FD9\u4E09\u4E2A\u5DE5\u5177\u4F5C\u4E3A"\u7528\u6237\u547D\u4EE4"\u66B4\u9732\u3002
+</Skill Forge (\u81EA\u52A8\u6280\u80FD\u521B\u5EFA)>
 `;
   } else {
     system = systemPrompt;
@@ -41426,12 +42216,32 @@ ${getSkillMeta()}
   };
   const storage = createRedisStorage(redisConf);
   const topicStorage = createRedisStorage(redisConf);
+  const dreamStorage = createRedisStorage(redisConf);
+  const dreamStateStorage = createRedisStorage(redisConf);
+  const skillProposalStorage = createRedisStorage(redisConf);
+  const dreamEngine = new DreamEngine({
+    storage,
+    dreamStorage,
+    stateStorage: dreamStateStorage,
+    llm: llmClient
+  });
+  const skillForgeEngine = new SkillForgeEngine({
+    proposalStorage: skillProposalStorage
+  });
+  const memoryStorage = createRedisStorage(redisConf);
+  const memoryEngine = new MemoryEngine({ memoryStorage });
   const bg = createBackgroundManager();
   let finalTools = [];
   let finalExcutor;
   if (!tools) {
     const { registry: registry2, executor } = createDefaultTools(bg);
     registerTool(registry2, recallChatHistory(storage, topicStorage));
+    registerTool(registry2, skillForgePropose(skillForgeEngine));
+    registerTool(registry2, skillForgeKeep(skillForgeEngine));
+    registerTool(registry2, skillForgeDrop(skillForgeEngine));
+    registerTool(registry2, memoryCreate(memoryEngine));
+    registerTool(registry2, memoryUpdate(memoryEngine));
+    registerTool(registry2, memoryDelete(memoryEngine));
     finalTools = getAllTools(registry2);
     finalExcutor = executor;
   } else {
@@ -41457,12 +42267,15 @@ ${getSkillMeta()}
     backgroundManager: bg,
     maxIterations: 150,
     channelPlugin: feishuChannel,
-    workspacePath: DEFAULT_WORKSPACE_PATH
+    workspacePath: DEFAULT_WORKSPACE_PATH,
+    dreamEngine,
+    skillForgeEngine,
+    memoryEngine
   };
   return agentConfig;
 };
 var createAgent = (config2 = getDefaultAgentConfig()) => {
-  const { systemPrompt, llm, storage, topicStorage, toolExecutor, tools, backgroundManager, maxIterations = 50 } = config2;
+  const { systemPrompt, llm, storage, topicStorage, toolExecutor, tools, backgroundManager, maxIterations = 50, dreamEngine, skillForgeEngine, memoryEngine } = config2;
   const signals = /* @__PURE__ */ new Map();
   return async (request) => {
     if (config2.workspacePath && !request.defaultWorkDir) {
@@ -41482,6 +42295,13 @@ var createAgent = (config2 = getDefaultAgentConfig()) => {
     signals.set(userId, signal);
     markRunning(userId);
     try {
+      if (dreamEngine) {
+        try {
+          await dreamEngine.checkAndDream(userId);
+        } catch (err) {
+          console.warn(`[agent] checkAndDream \u5931\u8D25\uFF1A${err.message}`);
+        }
+      }
       const now = /* @__PURE__ */ new Date();
       const beijingTime = now.toLocaleString("sv-SE", {
         timeZone: "Asia/Shanghai",
@@ -41493,9 +42313,42 @@ var createAgent = (config2 = getDefaultAgentConfig()) => {
       if (topicStorage) {
         await addTopicIndex(topicStorage, userId, beijingTime, msgIndex, content, job?.title);
       }
+      if (memoryEngine) {
+        try {
+          const memoryBlock = await memoryEngine.buildContextBlock(userId);
+          if (memoryBlock) {
+            await addMessage(storage, userId, userMessage(text(memoryBlock)), beijingTime, job?.title);
+          }
+        } catch (err) {
+          console.warn(`[memory] \u6CE8\u5165\u8BB0\u5FC6\u4E0A\u4E0B\u6587\u5931\u8D25\uFF1A${err.message}`);
+        }
+      }
+      if (skillForgeEngine) {
+        try {
+          const pending = await skillForgeEngine.listPending(userId);
+          if (pending.length > 0) {
+            const lines = pending.map(
+              (p) => `  - id=${p.id} name=${p.skillName} :: ${p.description}`
+            ).join("\n");
+            await addMessage(storage, userId, userMessage(text(
+              `<pending-skill-proposal>
+\u5F53\u524D\u6709 ${pending.length} \u4E2A\u5F85\u7528\u6237\u786E\u8BA4\u7684\u6280\u80FD\u8349\u7A3F\uFF1A
+${lines}
+\u5982\u679C\u7528\u6237\u8FD9\u6761\u6D88\u606F\u662F\u5728\u56DE\u5E94"\u8981\u4E0D\u8981\u4FDD\u7559"\u8FD9\u4E2A\u95EE\u9898\uFF1A
+  \u2022 \u80AF\u5B9A\u610F\u56FE \u2192 \u8C03\u7528 skill_forge_keep\uFF08\u53EA\u6709 1 \u6761 pending \u65F6 proposalId \u53EF\u7701\u7565\uFF09
+  \u2022 \u5426\u5B9A\u610F\u56FE \u2192 \u8C03\u7528 skill_forge_drop
+  \u2022 \u672A\u8868\u6001 \u2192 \u5FFD\u7565\u672C\u63D0\u793A\uFF0C\u6B63\u5E38\u5904\u7406\u7528\u6237\u6D88\u606F
+</pending-skill-proposal>`
+            )), beijingTime, job?.title);
+          }
+        } catch (err) {
+          console.warn(`[skillForge] \u8BFB\u53D6 pending \u5217\u8868\u5931\u8D25\uFF1A${err.message}`);
+        }
+      }
       let iterations = 0;
       let hasSentMessage = false;
       let sentMessageContent = "";
+      let emptyRetries = 0;
       while (iterations < maxIterations) {
         if (signal.aborted) throw new Error(`[\u667A\u80FD\u4F53\u4E2D\u65AD] \u53D7\u5230\u4E2D\u65AD\u4FE1\u53F7\u5DF2\u4E2D\u65AD`);
         iterations++;
@@ -41531,12 +42384,31 @@ ${msg}</user-interrupt>`
             )), beijingTime, job?.title);
           }
         }
-        const messages = await getMessages(storage, userId, 100, beijingTime, job?.title);
+        const messages = await getMessages(storage, userId, 300, beijingTime, job?.title);
+        const dreamInjection = dreamEngine ? await dreamEngine.injectDream(userId) : "";
+        const effectiveSystemPrompt = systemPrompt + dreamInjection;
         const response = await llm.chat(
           messages,
-          systemPrompt,
+          effectiveSystemPrompt,
           tools
         );
+        if (response.stopReason === "model_context_window_exceeded") {
+          console.warn(`[agent] \u4E0A\u4E0B\u6587\u7A97\u53E3\u8D85\u9650\uFF0C\u89E6\u53D1\u5F3A\u5236\u505A\u68A6\u4EE5\u538B\u7F29\u8BB0\u5FC6`);
+          if (dreamEngine) {
+            try {
+              const result = await dreamEngine.dream(userId);
+              console.log(`[agent] \u5F3A\u5236\u505A\u68A6\u5B8C\u6210\uFF0C\u68A6\u5883\u957F\u5EA6=${result?.dreamContent.length ?? 0}`);
+            } catch (err) {
+              console.error(`[agent] \u5F3A\u5236\u505A\u68A6\u5931\u8D25\uFF1A${err.message}`);
+            }
+          }
+          await clearMessages(storage, userId, beijingTime, job?.title);
+          await addMessage(storage, userId, userMessage(text(
+            `<system-warning>\u4E0A\u4E0B\u6587\u6EA2\u51FA\uFF0C\u5DF2\u901A\u8FC7\u505A\u68A6\u538B\u7F29\u5386\u53F2\u5BF9\u8BDD\u3002\u91CD\u8981\u8BB0\u5FC6\u5DF2\u4FDD\u7559\u81F3\u68A6\u5883\uFF08systemPrompt \u4E2D\u7684 memory-context\uFF09\u3002\u8BF7\u76F4\u63A5\u56DE\u590D\u7528\u6237\u6700\u65B0\u7684\u6D88\u606F\u3002</system-warning>
+${content}`
+          )), beijingTime, job?.title);
+          continue;
+        }
         if (response.stopReason === "max_tokens") {
           const toolUsesTruncated = response.content.filter(isToolUseBlock);
           if (toolUsesTruncated.length > 0) {
@@ -41610,9 +42482,9 @@ ${msg}</user-interrupt>`
         const textBlocks = response.content.filter(
           (b) => b.type === "text"
         );
-        if (textBlocks.length > 0) {
-          const textContent = textBlocks.map((b) => b.text).join(`
-`);
+        const textContent = textBlocks.map((b) => b.text).join(`
+`).trim();
+        if (textContent) {
           await addMessage(storage, userId, assistantMessage(text(textContent)), beijingTime, job?.title);
           const lateInterrupts = drainInterrupts(userId);
           if (lateInterrupts.length > 0) {
@@ -41625,6 +42497,10 @@ ${msg}</user-interrupt>`
             }
             continue;
           }
+          if (topicStorage) {
+            const topicSummary = hasSentMessage ? sentMessageContent : textContent;
+            await updateTopicSummary(topicStorage, userId, beijingTime, topicSummary, job?.title);
+          }
           return {
             content: hasSentMessage ? sentMessageContent : textContent,
             alreadySent: hasSentMessage
@@ -41642,12 +42518,27 @@ ${msg}</user-interrupt>`
             }
             continue;
           }
+          if (topicStorage) {
+            await updateTopicSummary(topicStorage, userId, beijingTime, sentMessageContent, job?.title);
+          }
           return {
             content: sentMessageContent,
             alreadySent: true
           };
         }
-        throw new Error(`[createAgent] \u8FD0\u884C\u65F6\u5F02\u5E38\uFF0C\u667A\u80FD\u4F53\u6700\u540E\u7B54\u590D\u7ADF\u7136\u610F\u5916\u4E0D\u662F text \u7C7B\u578B`);
+        emptyRetries++;
+        console.warn(`[agent] LLM \u8FD4\u56DE\u7A7A\u5185\u5BB9\uFF08\u7B2C${emptyRetries}\u6B21\uFF09\uFF0CstopReason=${response.stopReason}, content=${JSON.stringify(response.content)}`);
+        if (emptyRetries >= 3) {
+          console.error(`[agent] LLM \u8FDE\u7EED ${emptyRetries} \u6B21\u8FD4\u56DE\u7A7A\u5185\u5BB9\uFF0C\u653E\u5F03\u91CD\u8BD5`);
+          const fallback = "\u62B1\u6B49\uFF0C\u6211\u6682\u65F6\u65E0\u6CD5\u56DE\u590D\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002";
+          await addMessage(storage, userId, assistantMessage(text(fallback)), beijingTime, job?.title);
+          return { content: fallback, alreadySent: false };
+        }
+        await addMessage(storage, userId, assistantMessage(text("(\u601D\u8003\u4E2D...)")), beijingTime, job?.title);
+        await addMessage(storage, userId, userMessage(text(
+          "<system-warning>\u4F60\u7684\u4E0A\u4E00\u6761\u56DE\u590D\u5185\u5BB9\u4E3A\u7A7A\u3002\u8BF7\u91CD\u65B0\u7EC4\u7EC7\u56DE\u590D\uFF0C\u4F7F\u7528 send_message \u5DE5\u5177\u5411\u7528\u6237\u53D1\u9001\u6D88\u606F\u3002</system-warning>"
+        )), beijingTime, job?.title);
+        continue;
       }
       throw new Error(`\u8FBE\u5230\u6700\u5927\u8FED\u4EE3\u6B21\u6570:${maxIterations}`);
     } finally {
@@ -41828,9 +42719,9 @@ var RedisMessageDeduplication = class {
 };
 
 // src/channels/feishu/MessageProcess.ts
-var import_node_path10 = require("node:path");
-var import_node_os4 = require("node:os");
-var import_node_fs5 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_node_os5 = require("node:os");
+var import_node_fs6 = require("node:fs");
 
 // src/oss/AliyunOSSClient.ts
 var import_ali_oss = __toESM(require("ali-oss"));
@@ -41867,10 +42758,10 @@ var createAliyunOssClient = () => {
 
 // src/channels/feishu/MessageProcess.ts
 var saveToLocal = (userId, subDir, fileName, buffer) => {
-  const dir = (0, import_node_path10.join)((0, import_node_os4.homedir)(), ".duclaw", "workspace", userId, subDir);
-  (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
-  const filePath = (0, import_node_path10.join)(dir, fileName);
-  (0, import_node_fs5.writeFileSync)(filePath, buffer);
+  const dir = (0, import_node_path11.join)((0, import_node_os5.homedir)(), ".duclaw", "workspace", userId, subDir);
+  (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+  const filePath = (0, import_node_path11.join)(dir, fileName);
+  (0, import_node_fs6.writeFileSync)(filePath, buffer);
   return filePath;
 };
 var tryUploadToOss = async (ossPath, buffer) => {
@@ -42120,7 +43011,7 @@ var createDefaultChannels = () => {
 };
 
 // src/tools/tools/team/ListMailbox.ts
-var DESCRIPTION29 = `
+var DESCRIPTION35 = `
 \u67E5\u770B\u4F60\u7684\u90AE\u7BB1\u4E2D\u6240\u6709\u5F85\u5904\u7406\u90AE\u4EF6\u7684\u6458\u8981\u5217\u8868\u3002
 
 \u8FD4\u56DE\u6BCF\u5C01\u90AE\u4EF6\u7684\uFF1Aid\u3001\u53D1\u9001\u8005\u3001\u53D1\u9001\u65F6\u95F4\u3001\u5185\u5BB9\u6458\u8981\uFF08\u524D100\u5B57\uFF09\u3002
@@ -42134,7 +43025,7 @@ var DESCRIPTION29 = `
 `;
 var listMailbox = {
   name: `list_mailbox`,
-  description: DESCRIPTION29,
+  description: DESCRIPTION35,
   input_schema: {
     type: `object`,
     properties: {},
@@ -42171,7 +43062,7 @@ ${list}`;
 };
 
 // src/tools/tools/team/GetMailbox.ts
-var DESCRIPTION30 = `
+var DESCRIPTION36 = `
 \u83B7\u53D6\u6307\u5B9A\u90AE\u4EF6\u7684\u5B8C\u6574\u5185\u5BB9\u3002
 
 \u5728 list_mailbox \u67E5\u770B\u90AE\u4EF6\u5217\u8868\u540E\uFF0C\u4F7F\u7528\u6B64\u5DE5\u5177\u83B7\u53D6\u4F60\u60F3\u8981\u5904\u7406\u7684\u90AE\u4EF6\u7684\u5B8C\u6574\u5185\u5BB9\u3002
@@ -42182,7 +43073,7 @@ var DESCRIPTION30 = `
 `;
 var getMailbox = {
   name: `get_mailbox`,
-  description: DESCRIPTION30,
+  description: DESCRIPTION36,
   input_schema: {
     type: `object`,
     properties: {
@@ -42223,7 +43114,7 @@ ${msg.content}`;
 };
 
 // src/tools/tools/team/ReplyMailbox.ts
-var DESCRIPTION31 = `
+var DESCRIPTION37 = `
 \u56DE\u590D\u4E00\u5C01\u90AE\u4EF6\u3002\u5B8C\u6210\u5DE5\u4F5C\u540E\uFF0C\u4F7F\u7528\u6B64\u5DE5\u5177\u5C06\u7ED3\u679C\u53D1\u56DE\u7ED9\u90AE\u4EF6\u7684\u53D1\u9001\u8005\u3002
 
 \u53C2\u6570\uFF1A
@@ -42236,7 +43127,7 @@ var DESCRIPTION31 = `
 `;
 var replyMailbox = {
   name: `reply_mailbox`,
-  description: DESCRIPTION31,
+  description: DESCRIPTION37,
   input_schema: {
     type: `object`,
     properties: {
@@ -42278,6 +43169,7 @@ var replyMailbox = {
 };
 
 // src/cron/mailbox.ts
+var import_crypto5 = require("crypto");
 var db2 = createSqliteDB();
 var selectStmt = db2.prepare(`select id, to_mailbox_id as toMailboxId, from_mailbox_id as fromMailboxId, content, send_time as sendTime, status
     from mailbox where status = ?`);
@@ -42343,6 +43235,25 @@ var wakeTeamAgent = async (mailboxId, msgIds) => {
     const member = getTeamMemberByName(teamName, memberName);
     if (!member) {
       console.warn(`[mailbox] \u76EE\u6807\u6210\u5458\u4E0D\u5B58\u5728\uFF08\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\uFF09: ${mailboxId}`);
+      const notifyContent = `[\u7CFB\u7EDF\u901A\u77E5] \u56E2\u961F\u6210\u5458 ${mailboxId} \u4E0D\u5B58\u5728\uFF08\u53EF\u80FD\u6240\u5C5E\u56E2\u961F\u5DF2\u89E3\u6563\u6216\u6210\u5458\u5DF2\u88AB\u5220\u9664\uFF09\uFF0C\u4EE5\u4E0B\u6D88\u606F\u65E0\u6CD5\u6295\u9012\u5DF2\u88AB\u53D6\u6D88\u3002\u8BF7\u6839\u636E\u60C5\u51B5\u51B3\u5B9A\u662F\u5426\u9700\u8981\u91CD\u65B0\u7EC4\u5EFA\u56E2\u961F\u6216\u8C03\u6574\u8BA1\u5212\u3002`;
+      const originStmt = db2.prepare(
+        `SELECT origin_user_id as originUserId, origin_platform as originPlatform 
+                 FROM mailbox WHERE id IN (${msgIds.map(() => "?").join(",")}) AND origin_user_id IS NOT NULL LIMIT 1`
+      );
+      const origin = originStmt.get(...msgIds);
+      const insertStmt = db2.prepare(
+        `INSERT INTO mailbox (id, to_mailbox_id, from_mailbox_id, content, send_time, status, origin_user_id, origin_platform) VALUES (?,?,?,?,?,?,?,?)`
+      );
+      insertStmt.run(
+        (0, import_crypto5.randomUUID)().slice(0, 8),
+        "manager",
+        mailboxId,
+        notifyContent,
+        (/* @__PURE__ */ new Date()).getTime(),
+        "pending",
+        origin?.originUserId || null,
+        origin?.originPlatform || null
+      );
       for (const id of msgIds) markMailboxStatus(id, "cancelled");
       return;
     }
@@ -42650,26 +43561,26 @@ var handleParsingNestedValues = (form, key, value) => {
 };
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/utils/url.js
-var splitPath = (path9) => {
-  const paths = path9.split("/");
+var splitPath = (path10) => {
+  const paths = path10.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path9 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path9);
+  const { groups, path: path10 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path10);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path9) => {
+var extractGroupsFromPath = (path10) => {
   const groups = [];
-  path9 = path9.replace(/\{[^}]+\}/g, (match2, index) => {
+  path10 = path10.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path9 };
+  return { groups, path: path10 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -42726,8 +43637,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 path9 = url.slice(start, end);
-      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
+      const path10 = url.slice(start, end);
+      return tryDecodeURI(path10.includes("%25") ? path10.replace(/%25/g, "%2525") : path10);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -42744,11 +43655,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path9) => {
-  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) {
+var checkOptionalParameter = (path10) => {
+  if (path10.charCodeAt(path10.length - 1) !== 63 || !path10.includes(":")) {
     return null;
   }
-  const segments = path9.split("/");
+  const segments = path10.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -42889,9 +43800,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path9 = "/", matchResult = [[]]) {
+  constructor(request, path10 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path9;
+    this.path = path10;
     this.#matchResult = matchResult;
     this.#validatedData = {};
   }
@@ -43628,8 +44539,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path9, ...handlers) => {
-      for (const p of [path9].flat()) {
+    this.on = (method, path10, ...handlers) => {
+      for (const p of [path10].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
@@ -43686,8 +44597,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path9, app) {
-    const subApp = this.basePath(path9);
+  route(path10, app) {
+    const subApp = this.basePath(path10);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -43713,9 +44624,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path9) {
+  basePath(path10) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path9);
+    subApp._basePath = mergePath(this._basePath, path10);
     return subApp;
   }
   /**
@@ -43789,7 +44700,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path9, applicationHandler, options) {
+  mount(path10, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -43816,7 +44727,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path9);
+      const mergedPath = mergePath(this._basePath, path10);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -43831,14 +44742,14 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path9, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path10, "*"), handler);
     return this;
   }
-  #addRoute(method, path9, handler) {
+  #addRoute(method, path10, handler) {
     method = method.toUpperCase();
-    path9 = mergePath(this._basePath, path9);
-    const r = { basePath: this._basePath, path: path9, method, handler };
-    this.router.add(method, path9, [handler, r]);
+    path10 = mergePath(this._basePath, path10);
+    const r = { basePath: this._basePath, path: path10, method, handler };
+    this.router.add(method, path10, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -43851,10 +44762,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path9 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path9);
+    const path10 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path10);
     const c = new Context(request, {
-      path: path9,
+      path: path10,
       matchResult,
       env,
       executionCtx,
@@ -43954,7 +44865,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, path9) {
+function match(method, path10) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -43970,7 +44881,7 @@ function match(method, path9) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path9);
+  return match2(method, path10);
 }
 
 // node_modules/.pnpm/hono@4.12.9/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -44085,12 +44996,12 @@ var Node = class _Node {
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
-  insert(path9, index, pathErrorCheckOnly) {
+  insert(path10, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
     for (let i = 0; ; ) {
       let replaced = false;
-      path9 = path9.replace(/\{[^}]+\}/g, (m) => {
+      path10 = path10.replace(/\{[^}]+\}/g, (m) => {
         const mark = `@\\${i}`;
         groups[i] = [mark, m];
         i++;
@@ -44101,7 +45012,7 @@ var Trie = class {
         break;
       }
     }
-    const tokens = path9.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    const tokens = path10.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
     for (let i = groups.length - 1; i >= 0; i--) {
       const [mark] = groups[i];
       for (let j = tokens.length - 1; j >= 0; j--) {
@@ -44140,9 +45051,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(path9) {
-  return wildcardRegExpCache[path9] ??= new RegExp(
-    path9 === "*" ? "" : `^${path9.replace(
+function buildWildcardRegExp(path10) {
+  return wildcardRegExpCache[path10] ??= new RegExp(
+    path10 === "*" ? "" : `^${path10.replace(
       /\/\*$|([.\\+*[^\]$()])/g,
       (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
     )}$`
@@ -44164,17 +45075,17 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   );
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path9, handlers] = routesWithStaticPathFlag[i];
+    const [pathErrorCheckOnly, path10, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path9] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path10] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
     } else {
       j++;
     }
     let paramAssoc;
     try {
-      paramAssoc = trie.insert(path9, j, pathErrorCheckOnly);
+      paramAssoc = trie.insert(path10, j, pathErrorCheckOnly);
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path10) : e;
     }
     if (pathErrorCheckOnly) {
       continue;
@@ -44208,12 +45119,12 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   }
   return [regexp, handlerMap, staticMap];
 }
-function findMiddleware(middleware, path9) {
+function findMiddleware(middleware, path10) {
   if (!middleware) {
     return void 0;
   }
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path9)) {
+    if (buildWildcardRegExp(k).test(path10)) {
       return [...middleware[k]];
     }
   }
@@ -44227,7 +45138,7 @@ var RegExpRouter = class {
     this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
     this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
-  add(method, path9, handler) {
+  add(method, path10, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware || !routes) {
@@ -44242,18 +45153,18 @@ var RegExpRouter = class {
         });
       });
     }
-    if (path9 === "/*") {
-      path9 = "*";
+    if (path10 === "/*") {
+      path10 = "*";
     }
-    const paramCount = (path9.match(/\/:/g) || []).length;
-    if (/\*$/.test(path9)) {
-      const re = buildWildcardRegExp(path9);
+    const paramCount = (path10.match(/\/:/g) || []).length;
+    if (/\*$/.test(path10)) {
+      const re = buildWildcardRegExp(path10);
       if (method === METHOD_NAME_ALL) {
         Object.keys(middleware).forEach((m) => {
-          middleware[m][path9] ||= findMiddleware(middleware[m], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
+          middleware[m][path10] ||= findMiddleware(middleware[m], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
         });
       } else {
-        middleware[method][path9] ||= findMiddleware(middleware[method], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
+        middleware[method][path10] ||= findMiddleware(middleware[method], path10) || findMiddleware(middleware[METHOD_NAME_ALL], path10) || [];
       }
       Object.keys(middleware).forEach((m) => {
         if (method === METHOD_NAME_ALL || method === m) {
@@ -44271,7 +45182,7 @@ var RegExpRouter = class {
       });
       return;
     }
-    const paths = checkOptionalParameter(path9) || [path9];
+    const paths = checkOptionalParameter(path10) || [path10];
     for (let i = 0, len = paths.length; i < len; i++) {
       const path22 = paths[i];
       Object.keys(routes).forEach((m) => {
@@ -44298,13 +45209,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((path9) => [path9, r[method][path9]]) : [];
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path10) => [path10, r[method][path10]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;
         routes.push(...ownRoute);
       } else if (method !== METHOD_NAME_ALL) {
         routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path9) => [path9, r[METHOD_NAME_ALL][path9]])
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path10) => [path10, r[METHOD_NAME_ALL][path10]])
         );
       }
     });
@@ -44324,13 +45235,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path9, handler) {
+  add(method, path10, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path9, handler]);
+    this.#routes.push([method, path10, handler]);
   }
-  match(method, path9) {
+  match(method, path10) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -44345,7 +45256,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path9);
+        res = router.match(method, path10);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -44395,10 +45306,10 @@ var Node2 = class _Node2 {
     }
     this.#patterns = [];
   }
-  insert(method, path9, handler) {
+  insert(method, path10, handler) {
     this.#order = ++this.#order;
     let curNode = this;
-    const parts = splitRoutingPath(path9);
+    const parts = splitRoutingPath(path10);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
@@ -44447,12 +45358,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path9) {
+  search(method, path10) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path9);
+    const parts = splitPath(path10);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -44494,13 +45405,13 @@ var Node2 = class _Node2 {
           if (matcher instanceof RegExp) {
             if (partOffsets === null) {
               partOffsets = new Array(len);
-              let offset = path9[0] === "/" ? 1 : 0;
+              let offset = path10[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path9.substring(partOffsets[i]);
+            const restPathString = path10.substring(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -44553,18 +45464,18 @@ var TrieRouter = class {
   constructor() {
     this.#node = new Node2();
   }
-  add(method, path9, handler) {
-    const results = checkOptionalParameter(path9);
+  add(method, path10, handler) {
+    const results = checkOptionalParameter(path10);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
         this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.#node.insert(method, path9, handler);
+    this.#node.insert(method, path10, handler);
   }
-  match(method, path9) {
-    return this.#node.search(method, path9);
+  match(method, path10) {
+    return this.#node.search(method, path10);
   }
 };
 
@@ -44588,7 +45499,7 @@ var import_http = require("http");
 var import_http2 = require("http2");
 var import_http22 = require("http2");
 var import_stream = require("stream");
-var import_crypto5 = __toESM(require("crypto"), 1);
+var import_crypto6 = __toESM(require("crypto"), 1);
 var RequestError = class extends Error {
   constructor(message, options) {
     super(message, options);
@@ -44905,7 +45816,7 @@ var buildOutgoingHttpHeaders = (headers) => {
 };
 var X_ALREADY_SENT = "x-hono-already-sent";
 if (typeof global.crypto === "undefined") {
-  global.crypto = import_crypto5.default;
+  global.crypto = import_crypto6.default;
 }
 var outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
 var handleRequestError = () => new Response(null, {
@@ -45228,8 +46139,8 @@ var _baseMimes = {
 var baseMimes = _baseMimes;
 
 // node_modules/.pnpm/@hono+node-server@1.19.11_hono@4.12.9/node_modules/@hono/node-server/dist/serve-static.mjs
-var import_fs11 = require("fs");
-var import_path17 = require("path");
+var import_fs12 = require("fs");
+var import_path18 = require("path");
 var import_process = require("process");
 var import_stream2 = require("stream");
 var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
@@ -45266,10 +46177,10 @@ var createStreamBody = (stream) => {
   });
   return body;
 };
-var getStats = (path9) => {
+var getStats = (path10) => {
   let stats;
   try {
-    stats = (0, import_fs11.statSync)(path9);
+    stats = (0, import_fs12.statSync)(path10);
   } catch {
   }
   return stats;
@@ -45291,7 +46202,7 @@ var tryDecodeURI2 = (str) => tryDecode2(str, decodeURI);
 var serveStatic = (options = { root: "" }) => {
   const root = options.root || "";
   const optionPath = options.path;
-  if (root !== "" && !(0, import_fs11.existsSync)(root)) {
+  if (root !== "" && !(0, import_fs12.existsSync)(root)) {
     console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
   }
   return async (c, next) => {
@@ -45312,21 +46223,21 @@ var serveStatic = (options = { root: "" }) => {
         return next();
       }
     }
-    let path9 = (0, import_path17.join)(
+    let path10 = (0, import_path18.join)(
       root,
       !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
     );
-    let stats = getStats(path9);
+    let stats = getStats(path10);
     if (stats && stats.isDirectory()) {
       const indexFile = options.index ?? "index.html";
-      path9 = (0, import_path17.join)(path9, indexFile);
-      stats = getStats(path9);
+      path10 = (0, import_path18.join)(path10, indexFile);
+      stats = getStats(path10);
     }
     if (!stats) {
-      await options.onNotFound?.(path9, c);
+      await options.onNotFound?.(path10, c);
       return next();
     }
-    const mimeType = getMimeType(path9);
+    const mimeType = getMimeType(path10);
     c.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
       const acceptEncodingSet = new Set(
@@ -45336,12 +46247,12 @@ var serveStatic = (options = { root: "" }) => {
         if (!acceptEncodingSet.has(encoding)) {
           continue;
         }
-        const precompressedStats = getStats(path9 + ENCODINGS[encoding]);
+        const precompressedStats = getStats(path10 + ENCODINGS[encoding]);
         if (precompressedStats) {
           c.header("Content-Encoding", encoding);
           c.header("Vary", "Accept-Encoding", { append: true });
           stats = precompressedStats;
-          path9 = path9 + ENCODINGS[encoding];
+          path10 = path10 + ENCODINGS[encoding];
           break;
         }
       }
@@ -45355,7 +46266,7 @@ var serveStatic = (options = { root: "" }) => {
       result = c.body(null);
     } else if (!range) {
       c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody((0, import_fs11.createReadStream)(path9)), 200);
+      result = c.body(createStreamBody((0, import_fs12.createReadStream)(path10)), 200);
     } else {
       c.header("Accept-Ranges", "bytes");
       c.header("Date", stats.birthtime.toUTCString());
@@ -45366,12 +46277,12 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = (0, import_fs11.createReadStream)(path9, { start, end });
+      const stream = (0, import_fs12.createReadStream)(path10, { 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?.(path9, c);
+    await options.onFound?.(path10, c);
     return result;
   };
 };
@@ -45467,12 +46378,12 @@ var cors = (options) => {
 // src/git/worktree.ts
 var import_child_process2 = require("child_process");
 var import_util = require("util");
-var import_path18 = __toESM(require("path"));
-var import_fs12 = require("fs");
+var import_path19 = __toESM(require("path"));
+var import_fs13 = require("fs");
 var execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
 var getProjectRoot = () => process.cwd();
-var getWorktreeBaseDir = () => import_path18.default.join(getProjectRoot(), ".worktrees");
-var getWorktreePath = (goalId, taskId) => import_path18.default.join(getWorktreeBaseDir(), goalId, taskId);
+var getWorktreeBaseDir = () => import_path19.default.join(getProjectRoot(), ".worktrees");
+var getWorktreePath = (goalId, taskId) => import_path19.default.join(getWorktreeBaseDir(), goalId, taskId);
 var getBranchName = (taskId) => `task/${taskId}`;
 async function git(args, cwd) {
   const { stdout } = await execFileAsync("git", args, {
@@ -45484,14 +46395,14 @@ async function git(args, cwd) {
 async function createWorktree(taskId, goalId, baseBranch = "main") {
   const wtPath = getWorktreePath(goalId, taskId);
   const branch = getBranchName(taskId);
-  const parentDir = import_path18.default.dirname(wtPath);
-  if (!(0, import_fs12.existsSync)(parentDir)) {
-    (0, import_fs12.mkdirSync)(parentDir, { recursive: true });
+  const parentDir = import_path19.default.dirname(wtPath);
+  if (!(0, import_fs13.existsSync)(parentDir)) {
+    (0, import_fs13.mkdirSync)(parentDir, { recursive: true });
   }
   await git(["worktree", "add", "-b", branch, wtPath, baseBranch]);
   return {
     branch,
-    path: import_path18.default.relative(getProjectRoot(), wtPath),
+    path: import_path19.default.relative(getProjectRoot(), wtPath),
     baseBranch,
     createdAt: getDate()
   };
@@ -45499,7 +46410,7 @@ async function createWorktree(taskId, goalId, baseBranch = "main") {
 async function deleteWorktree(taskId, goalId) {
   const wtPath = getWorktreePath(goalId, taskId);
   const branch = getBranchName(taskId);
-  if ((0, import_fs12.existsSync)(wtPath)) {
+  if ((0, import_fs13.existsSync)(wtPath)) {
     await git(["worktree", "remove", wtPath, "--force"]);
   }
   try {
@@ -45590,8 +46501,8 @@ async function listWorktrees() {
     const fullBranch = branchLine.replace("branch refs/heads/", "");
     if (!fullBranch.startsWith("task/")) continue;
     const taskId = fullBranch.replace("task/", "");
-    const relPath = import_path18.default.relative(getProjectRoot(), wtPath);
-    const parts = relPath.split(import_path18.default.sep);
+    const relPath = import_path19.default.relative(getProjectRoot(), wtPath);
+    const parts = relPath.split(import_path19.default.sep);
     const worktreeIdx = parts.indexOf(".worktrees");
     const goalId = worktreeIdx >= 0 && parts.length > worktreeIdx + 1 ? parts[worktreeIdx + 1] : "";
     worktrees.push({
@@ -45757,7 +46668,7 @@ worktreeRoutes.get("/goals/:gid/tasks/:tid/worktree/diff", async (c) => {
 });
 
 // src/server/routes/agent.ts
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 var agentRoutes = new Hono2();
 var runningTasks = /* @__PURE__ */ new Map();
 agentRoutes.post("/goals/:gid/tasks/:tid/run", async (c) => {
@@ -45794,7 +46705,7 @@ agentRoutes.post("/goals/:gid/tasks/:tid/run", async (c) => {
   prompt += `
 \u8BF7\u5F00\u59CB\u6267\u884C\u8FD9\u4E2A\u4EFB\u52A1\u3002\u5B8C\u6210\u540E\u8BF7\u603B\u7ED3\u4F60\u505A\u4E86\u4EC0\u4E48\u3002`;
   updateTask(gid, tid, { status: "in_progress" });
-  const requestId = (0, import_crypto6.randomUUID)().slice(0, 8);
+  const requestId = (0, import_crypto7.randomUUID)().slice(0, 8);
   const taskState = { aborted: false, logs: [] };
   runningTasks.set(runKey, taskState);
   const request = {
@@ -45884,7 +46795,7 @@ agentRoutes.post("/goals/:gid/tasks/:tid/chat", async (c) => {
   const prompt = `${context}
 ---
 \u7528\u6237\u6D88\u606F\uFF1A${message}`;
-  const requestId = (0, import_crypto6.randomUUID)().slice(0, 8);
+  const requestId = (0, import_crypto7.randomUUID)().slice(0, 8);
   const taskState = { aborted: false, logs: [] };
   runningTasks.set(runKey, taskState);
   const request = {
@@ -45920,9 +46831,9 @@ agentRoutes.get("/goals/:gid/tasks/:tid/logs", async (c) => {
     month: "2-digit",
     day: "2-digit"
   }).replace(/-/g, "");
-  let messages = await getMessages(storage, userId, 200, date);
+  let messages = await getMessages(storage, userId, 300, date);
   if (messages.length === 0) {
-    messages = await getMessages(storage, userId, 200);
+    messages = await getMessages(storage, userId, 300);
   }
   const runKey = `${gid}:${tid}`;
   const isRunning = runningTasks.has(runKey);
@@ -46125,14 +47036,14 @@ teamRoutes.get("/teams/:name/members/:memberName/context", async (c) => {
         month: "2-digit",
         day: "2-digit"
       }).replace(/-/g, "");
-      const msgs = await getMessages(storage, mailBoxId, 200, dateStr);
+      const msgs = await getMessages(storage, mailBoxId, 300, dateStr);
       if (msgs.length > 0) {
         allMessages = msgs;
         break;
       }
     }
     if (allMessages.length === 0) {
-      allMessages = await getMessages(storage, mailBoxId, 200);
+      allMessages = await getMessages(storage, mailBoxId, 300);
     }
     agentLogs = allMessages.map((msg, idx) => {
       const blocks = msg.content.map((block) => {
@@ -46174,7 +47085,7 @@ teamRoutes.get("/teams/:name/members/:memberName/context", async (c) => {
 });
 
 // src/server/routes/cron.ts
-var import_crypto7 = require("crypto");
+var import_crypto8 = require("crypto");
 var cronRoutes = new Hono2();
 cronRoutes.get("/cron/jobs", (c) => {
   try {
@@ -46200,7 +47111,7 @@ cronRoutes.post("/cron/jobs", async (c) => {
       {
         platform: body.delivery.channel,
         userId: body.delivery.to,
-        requestId: (0, import_crypto7.randomUUID)().slice(0, 8),
+        requestId: (0, import_crypto8.randomUUID)().slice(0, 8),
         teamAgentId: ""
       }
     );
@@ -46343,7 +47254,7 @@ var systemRoutes = new Hono2();
 var startTime = Date.now();
 systemRoutes.get("/system/info", (c) => {
   return c.json({
-    version: true ? "1.7.2" : "unknown",
+    version: true ? "1.7.4" : "unknown",
     uptime: Math.floor((Date.now() - startTime) / 1e3),
     env: process.env.NODE_ENV || "development",
     nodeVersion: process.version
@@ -46353,6 +47264,7 @@ systemRoutes.get("/system/info", (c) => {
 // src/server/index.ts
 function createServer() {
   const app = new Hono2();
+  const webDistRoot = resolveWebDistRoot();
   app.use("/api/*", cors());
   app.route("/api", goalRoutes);
   app.route("/api", taskRoutes);
@@ -46363,8 +47275,8 @@ function createServer() {
   app.route("/api", mailboxRoutes);
   app.route("/api", toolRoutes);
   app.route("/api", systemRoutes);
-  app.use("/*", serveStatic({ root: "./web/dist" }));
-  app.get("/*", serveStatic({ path: "./web/dist/index.html" }));
+  app.use("/*", serveStatic({ root: webDistRoot }));
+  app.get("/*", serveStatic({ path: `${webDistRoot}/index.html` }));
   return app;
 }
 function startServer(port = 3e3) {