@clawos-dev/clawd 0.2.371 → 0.2.373

package/dist/cli.cjs

@@ -450,8 +450,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path85, errorMaps, issueData } = params;
-      const fullPath = [...path85, ...issueData.path || []];
+      const { data, path: path86, errorMaps, issueData } = params;
+      const fullPath = [...path86, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -762,11 +762,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path85, key) {
+      constructor(parent, value, path86, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path85;
+        this._path = path86;
         this._key = key;
       }
       get path() {
@@ -9003,8 +9003,8 @@ var require_req = __commonJS({
       if (req.originalUrl) {
         _req.url = req.originalUrl;
       } else {
-        const path85 = req.path;
-        _req.url = typeof path85 === "string" ? path85 : req.url ? req.url.path || req.url : void 0;
+        const path86 = req.path;
+        _req.url = typeof path86 === "string" ? path86 : req.url ? req.url.path || req.url : void 0;
       }
       if (req.query) {
         _req.query = req.query;
@@ -9169,14 +9169,14 @@ var require_redact = __commonJS({
       }
       return obj;
     }
-    function parsePath(path85) {
+    function parsePath(path86) {
       const parts = [];
       let current = "";
       let inBrackets = false;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path85.length; i++) {
-        const char = path85[i];
+      for (let i = 0; i < path86.length; i++) {
+        const char = path86[i];
         if (!inBrackets && char === ".") {
           if (current) {
             parts.push(current);
@@ -9307,10 +9307,10 @@ var require_redact = __commonJS({
       return current;
     }
     function redactPaths(obj, paths, censor, remove = false) {
-      for (const path85 of paths) {
-        const parts = parsePath(path85);
+      for (const path86 of paths) {
+        const parts = parsePath(path86);
         if (parts.includes("*")) {
-          redactWildcardPath(obj, parts, censor, path85, remove);
+          redactWildcardPath(obj, parts, censor, path86, remove);
         } else {
           if (remove) {
             removeKey(obj, parts);
@@ -9395,8 +9395,8 @@ var require_redact = __commonJS({
           }
         } else {
           if (afterWildcard.includes("*")) {
-            const wrappedCensor = typeof censor === "function" ? (value, path85) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path85];
+            const wrappedCensor = typeof censor === "function" ? (value, path86) => {
+              const fullPath = [...pathArray.slice(0, pathLength), ...path86];
               return censor(value, fullPath);
             } : censor;
             redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
@@ -9431,8 +9431,8 @@ var require_redact = __commonJS({
         return null;
       }
       const pathStructure = /* @__PURE__ */ new Map();
-      for (const path85 of pathsToClone) {
-        const parts = parsePath(path85);
+      for (const path86 of pathsToClone) {
+        const parts = parsePath(path86);
         let current = pathStructure;
         for (let i = 0; i < parts.length; i++) {
           const part = parts[i];
@@ -9484,24 +9484,24 @@ var require_redact = __commonJS({
       }
       return cloneSelectively(obj, pathStructure);
     }
-    function validatePath(path85) {
-      if (typeof path85 !== "string") {
+    function validatePath(path86) {
+      if (typeof path86 !== "string") {
         throw new Error("Paths must be (non-empty) strings");
       }
-      if (path85 === "") {
+      if (path86 === "") {
         throw new Error("Invalid redaction path ()");
       }
-      if (path85.includes("..")) {
-        throw new Error(`Invalid redaction path (${path85})`);
+      if (path86.includes("..")) {
+        throw new Error(`Invalid redaction path (${path86})`);
       }
-      if (path85.includes(",")) {
-        throw new Error(`Invalid redaction path (${path85})`);
+      if (path86.includes(",")) {
+        throw new Error(`Invalid redaction path (${path86})`);
       }
       let bracketCount = 0;
       let inQuotes = false;
       let quoteChar = "";
-      for (let i = 0; i < path85.length; i++) {
-        const char = path85[i];
+      for (let i = 0; i < path86.length; i++) {
+        const char = path86[i];
         if ((char === '"' || char === "'") && bracketCount > 0) {
           if (!inQuotes) {
             inQuotes = true;
@@ -9515,20 +9515,20 @@ var require_redact = __commonJS({
         } else if (char === "]" && !inQuotes) {
           bracketCount--;
           if (bracketCount < 0) {
-            throw new Error(`Invalid redaction path (${path85})`);
+            throw new Error(`Invalid redaction path (${path86})`);
           }
         }
       }
       if (bracketCount !== 0) {
-        throw new Error(`Invalid redaction path (${path85})`);
+        throw new Error(`Invalid redaction path (${path86})`);
       }
     }
     function validatePaths(paths) {
       if (!Array.isArray(paths)) {
         throw new TypeError("paths must be an array");
       }
-      for (const path85 of paths) {
-        validatePath(path85);
+      for (const path86 of paths) {
+        validatePath(path86);
       }
     }
     function slowRedact(options = {}) {
@@ -9696,8 +9696,8 @@ var require_redaction = __commonJS({
         if (shape[k2] === null) {
           o[k2] = (value) => topCensor(value, [k2]);
         } else {
-          const wrappedCensor = typeof censor === "function" ? (value, path85) => {
-            return censor(value, [k2, ...path85]);
+          const wrappedCensor = typeof censor === "function" ? (value, path86) => {
+            return censor(value, [k2, ...path86]);
           } : censor;
           o[k2] = Redact({
             paths: shape[k2],
@@ -9915,10 +9915,10 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "../node_modules/.pnpm/sonic-boom@4.2.1/node_modules/sonic-boom/index.js"(exports2, module2) {
     "use strict";
-    var fs76 = require("fs");
+    var fs77 = require("fs");
     var EventEmitter3 = require("events");
     var inherits = require("util").inherits;
-    var path85 = require("path");
+    var path86 = require("path");
     var sleep2 = require_atomic_sleep();
     var assert = require("assert");
     var BUSY_WRITE_TIMEOUT = 100;
@@ -9972,20 +9972,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs76.mkdirSync(path85.dirname(file), { recursive: true });
-          const fd = fs76.openSync(file, flags, mode);
+          if (sonic.mkdir) fs77.mkdirSync(path86.dirname(file), { recursive: true });
+          const fd = fs77.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs76.mkdir(path85.dirname(file), { recursive: true }, (err) => {
+        fs77.mkdir(path86.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs76.open(file, flags, mode, fileOpened);
+          fs77.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs76.open(file, flags, mode, fileOpened);
+        fs77.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -10026,8 +10026,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs76.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs76.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs77.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs77.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -10036,15 +10036,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs76.writeSync(this.fd, this._writingBuf);
+            return fs77.writeSync(this.fd, this._writingBuf);
           }
-          return fs76.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs77.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs76.write(this.fd, this._writingBuf, this.release);
+            return fs77.write(this.fd, this._writingBuf, this.release);
           }
-          return fs76.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs77.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -10101,7 +10101,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs76.fsyncSync(this.fd);
+          fs77.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -10215,7 +10215,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs76.fsync(this.fd, (err) => {
+            fs77.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -10317,7 +10317,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs76.close(fd, (err) => {
+          fs77.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -10366,7 +10366,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n = Buffer.isBuffer(buf) ? fs76.writeSync(this.fd, buf) : fs76.writeSync(this.fd, buf, "utf8");
+          const n = Buffer.isBuffer(buf) ? fs77.writeSync(this.fd, buf) : fs77.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -10382,7 +10382,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs76.fsyncSync(this.fd);
+        fs77.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -10403,7 +10403,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n = fs76.writeSync(this.fd, buf);
+          const n = fs77.writeSync(this.fd, buf);
           buf = buf.subarray(n);
           this._len = Math.max(this._len - n, 0);
           if (buf.length <= 0) {
@@ -10431,13 +10431,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs76.writeSync(this.fd, this._writingBuf) : fs76.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs77.writeSync(this.fd, this._writingBuf) : fs77.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs76.write(this.fd, this._writingBuf, release);
+        fs77.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -10446,7 +10446,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs76.writeSync(this.fd, this._writingBuf);
+          const written = fs77.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -10455,7 +10455,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs76.write(this.fd, this._writingBuf, release);
+        fs77.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -10471,12 +10471,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs76.fsync(sonic.fd, closeWrapped);
+        fs77.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs76.close(sonic.fd, done);
+          fs77.close(sonic.fd, done);
         } else {
           done();
         }
@@ -10733,7 +10733,7 @@ var require_thread_stream = __commonJS({
     var { version: version2 } = require_package();
     var { EventEmitter: EventEmitter3 } = require("events");
     var { Worker } = require("worker_threads");
-    var { join: join18 } = require("path");
+    var { join: join19 } = require("path");
     var { pathToFileURL } = require("url");
     var { wait } = require_wait();
     var {
@@ -10769,7 +10769,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join18(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join19(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         trackUnmanagedFds: false,
@@ -11155,7 +11155,7 @@ var require_transport = __commonJS({
     "use strict";
     var { createRequire: createRequire2 } = require("module");
     var getCallers = require_caller();
-    var { join: join18, isAbsolute: isAbsolute4, sep: sep5 } = require("path");
+    var { join: join19, isAbsolute: isAbsolute4, sep: sep5 } = require("path");
     var sleep2 = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
     var ThreadStream = require_thread_stream();
@@ -11218,7 +11218,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join18(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join19(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -11236,7 +11236,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline3) {
-        target = bundlerOverrides["pino-worker"] || join18(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join19(__dirname, "worker.js");
         options.pipelines = [pipeline3.map((dest) => {
           return {
             ...dest,
@@ -11258,7 +11258,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join18(__dirname, "..", "file.js");
+          return join19(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -12248,7 +12248,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join18 = ",";
+            let join19 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -12262,7 +12262,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join18 = `,
+                join19 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -12270,13 +12270,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join18;
+                res += join19;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -12297,7 +12297,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -12311,13 +12311,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join18;
+              separator = join19;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -12358,7 +12358,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join18 = ",";
+            let join19 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -12371,7 +12371,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join18 = `,
+                join19 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -12379,13 +12379,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join18;
+                res += join19;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join18}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -12398,7 +12398,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join18 = `,
+              join19 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -12407,7 +12407,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -12465,20 +12465,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join19 = `,
+              const join20 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join19;
+                res2 += join20;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join19}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join20}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -12494,16 +12494,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join18 = `,
+            const join19 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join18, maximumBreadth);
+              res += stringifyTypedArray(value, join19, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join18;
+              separator = join19;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -12514,13 +12514,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join18;
+                separator = join19;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join18;
+              separator = join19;
             }
             if (separator !== "") {
               res = `
@@ -13611,11 +13611,11 @@ var init_lib = __esm({
           }
         }
       },
-      addToPath: function addToPath(path85, added, removed, oldPosInc, options) {
-        var last = path85.lastComponent;
+      addToPath: function addToPath(path86, added, removed, oldPosInc, options) {
+        var last = path86.lastComponent;
         if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
           return {
-            oldPos: path85.oldPos + oldPosInc,
+            oldPos: path86.oldPos + oldPosInc,
             lastComponent: {
               count: last.count + 1,
               added,
@@ -13625,7 +13625,7 @@ var init_lib = __esm({
           };
         } else {
           return {
-            oldPos: path85.oldPos + oldPosInc,
+            oldPos: path86.oldPos + oldPosInc,
             lastComponent: {
               count: 1,
               added,
@@ -14157,10 +14157,10 @@ function attachmentToHistoryMessage(o, ts) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec4 = m2;
-      const path85 = typeof rec4.path === "string" ? rec4.path : null;
+      const path86 = typeof rec4.path === "string" ? rec4.path : null;
       const content = typeof rec4.content === "string" ? rec4.content : null;
-      if (!path85 || content == null) return null;
-      const entry = { path: path85, content };
+      if (!path86 || content == null) return null;
+      const entry = { path: path86, content };
       if (typeof rec4.mtimeMs === "number") entry.mtimeMs = rec4.mtimeMs;
       return entry;
     }).filter((m2) => m2 !== null);
@@ -15011,10 +15011,10 @@ function parseAttachment(obj) {
     const memories = raw.map((m2) => {
       if (!m2 || typeof m2 !== "object") return null;
       const rec4 = m2;
-      const path85 = typeof rec4.path === "string" ? rec4.path : null;
+      const path86 = typeof rec4.path === "string" ? rec4.path : null;
       const content = typeof rec4.content === "string" ? rec4.content : null;
-      if (!path85 || content == null) return null;
-      const out = { path: path85, content };
+      if (!path86 || content == null) return null;
+      const out = { path: path86, content };
       if (typeof rec4.mtimeMs === "number") out.mtimeMs = rec4.mtimeMs;
       return out;
     }).filter((m2) => m2 !== null);
@@ -29396,8 +29396,8 @@ var require_CronFileParser = __commonJS({
        * @throws If file cannot be read
        */
       static parseFileSync(filePath) {
-        const { readFileSync: readFileSync9 } = require("fs");
-        const data = readFileSync9(filePath, "utf8");
+        const { readFileSync: readFileSync10 } = require("fs");
+        const data = readFileSync10(filePath, "utf8");
         return _CronFileParser.#parseContent(data);
       }
       /**
@@ -33398,7 +33398,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join18(s) {
+      BufferList.prototype.join = function join19(s) {
         if (this.length === 0) return "";
         var p2 = this.head;
         var ret = "" + p2.data;
@@ -35988,8 +35988,8 @@ var require_utils = __commonJS({
       var result = transform[inputType][outputType](input);
       return result;
     };
-    exports2.resolve = function(path85) {
-      var parts = path85.split("/");
+    exports2.resolve = function(path86) {
+      var parts = path86.split("/");
       var result = [];
       for (var index = 0; index < parts.length; index++) {
         var part = parts[index];
@@ -41842,18 +41842,18 @@ var require_object = __commonJS({
       var object = new ZipObject(name, zipObjectContent, o);
       this.files[name] = object;
     };
-    var parentFolder = function(path85) {
-      if (path85.slice(-1) === "/") {
-        path85 = path85.substring(0, path85.length - 1);
+    var parentFolder = function(path86) {
+      if (path86.slice(-1) === "/") {
+        path86 = path86.substring(0, path86.length - 1);
       }
-      var lastSlash = path85.lastIndexOf("/");
-      return lastSlash > 0 ? path85.substring(0, lastSlash) : "";
+      var lastSlash = path86.lastIndexOf("/");
+      return lastSlash > 0 ? path86.substring(0, lastSlash) : "";
     };
-    var forceTrailingSlash = function(path85) {
-      if (path85.slice(-1) !== "/") {
-        path85 += "/";
+    var forceTrailingSlash = function(path86) {
+      if (path86.slice(-1) !== "/") {
+        path86 += "/";
       }
-      return path85;
+      return path86;
     };
     var folderAdd = function(name, createFolders) {
       createFolders = typeof createFolders !== "undefined" ? createFolders : defaults.createFolders;
@@ -50229,8 +50229,8 @@ function turnStartInput(text) {
   const items = [];
   let leftover = text;
   for (const m2 of text.matchAll(SKILL_RE)) {
-    const [marker, name, path85] = m2;
-    items.push({ type: "skill", name, path: path85 });
+    const [marker, name, path86] = m2;
+    items.push({ type: "skill", name, path: path86 });
     leftover = leftover.replace(marker, "");
   }
   for (const m2 of text.matchAll(ATTACHMENT_RE2)) {
@@ -50493,7 +50493,7 @@ function stringValue2(value) {
 // src/tools/codex-app-server-query.ts
 var import_node_child_process5 = require("child_process");
 var DEFAULT_CODEX_QUERY_TIMEOUT_MS = 8e3;
-async function queryCodexAppServer(cwd, method, params, deps = {}) {
+async function withCodexAppServerClient(cwd, operation, run, deps = {}) {
   const cmd = process.env.CODEX_BIN ?? "codex";
   const args = ["app-server", "--listen", "stdio://"];
   const proc = deps.spawnOverride ? deps.spawnOverride(cmd, args, cwd) : (0, import_node_child_process5.spawn)(cmd, args, { cwd, env: process.env, stdio: ["pipe", "pipe", "pipe"] });
@@ -50502,7 +50502,7 @@ async function queryCodexAppServer(cwd, method, params, deps = {}) {
   let timer;
   const timeout = new Promise((_2, reject) => {
     timer = setTimeout(
-      () => reject(new Error(`codex app-server ${method} timed out after ${timeoutMs}ms`)),
+      () => reject(new Error(`codex app-server ${operation} timed out after ${timeoutMs}ms`)),
       timeoutMs
     );
     proc.on(
@@ -50522,12 +50522,20 @@ async function queryCodexAppServer(cwd, method, params, deps = {}) {
       timeout
     ]);
     deps.beforeRequest?.(client);
-    return await Promise.race([client.request(method, params), timeout]);
+    return await Promise.race([run(client), timeout]);
   } finally {
     if (timer) clearTimeout(timer);
     if (proc.exitCode === null && proc.signalCode === null) proc.kill("SIGTERM");
   }
 }
+async function queryCodexAppServer(cwd, method, params, deps = {}) {
+  return withCodexAppServerClient(
+    cwd,
+    method,
+    (client) => client.request(method, params),
+    deps
+  );
+}
 
 // src/tools/codex-model-list.ts
 var CODEX_CONTEXT_WINDOW = 258400;
@@ -54097,11 +54105,73 @@ function threadItems(thread) {
   }
   return items;
 }
-function threadMessages(thread) {
+function threadMessages(thread, subagentResults = /* @__PURE__ */ new Map()) {
   const messages = [];
-  for (const item of threadItems(thread)) messages.push(...threadItemToHistoryMessages(item));
+  for (const item of threadItems(thread)) {
+    messages.push(...threadItemToHistoryMessages(item));
+    const value = rec2(item);
+    const started = value && nativeSubagentStart(value);
+    const result = started && subagentResults.get(started.toolUseId);
+    if (result) messages.push(result);
+  }
   return messages;
 }
+function threadFromReadResponse(value, threadId) {
+  const res = rec2(value);
+  const thread = res && rec2(res.thread);
+  if (!thread) throw new Error(`Codex thread/read returned no thread for ${threadId}`);
+  return thread;
+}
+async function readThreadWithClient(client, threadId, timeoutMs) {
+  const request = client.request("thread/read", { threadId, includeTurns: true });
+  let timer;
+  const response = timeoutMs === void 0 ? await request : await Promise.race([
+    request,
+    new Promise((_2, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new Error(
+            `Codex child thread/read ${threadId} timed out after ${timeoutMs}ms`
+          )
+        ),
+        timeoutMs
+      );
+    })
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+  return threadFromReadResponse(response, threadId);
+}
+function terminalSubagentResult(started, child, parentThreadId) {
+  const actualId = str2(child.id);
+  const actualParentThreadId = str2(child.parentThreadId);
+  if (actualId !== started.agentId || actualParentThreadId !== parentThreadId) {
+    throw new Error(
+      `Codex subagent thread ${started.agentId} does not belong to parent thread ${parentThreadId} (returned id ${actualId ?? "missing"}, parent ${actualParentThreadId ?? "missing"})`
+    );
+  }
+  const turns = Array.isArray(child.turns) ? child.turns : [];
+  for (const value of turns) {
+    const turn = rec2(value);
+    const status = str2(turn?.status);
+    if (status === "completed") {
+      return {
+        kind: "tool_result",
+        toolUseId: started.toolUseId
+      };
+    }
+    if (status === "failed" || status === "interrupted") {
+      const rawError = turn?.error;
+      const error = str2(rawError) ?? str2(rec2(rawError)?.message);
+      return {
+        kind: "tool_result",
+        toolUseId: started.toolUseId,
+        error: error ?? `Codex subagent ${status}`
+      };
+    }
+  }
+  return void 0;
+}
 function userInputText(content) {
   if (!Array.isArray(content)) return "";
   return content.map((c) => {
@@ -54211,8 +54281,43 @@ var CodexHistoryReader = class {
     return out;
   }
   async read(args) {
-    const thread = await this.readThread(args.cwd, args.toolSessionId);
-    const messages = threadMessages(thread);
+    const queryTimeoutMs = this.deps.timeoutMs ?? DEFAULT_CODEX_QUERY_TIMEOUT_MS;
+    const queryStartedAt = Date.now();
+    const messages = await withCodexAppServerClient(
+      args.cwd,
+      "history/read",
+      async (client) => {
+        const parent = await readThreadWithClient(client, args.toolSessionId);
+        const starts = threadItems(parent).map((item) => {
+          const value = rec2(item);
+          return value && nativeSubagentStart(value);
+        }).filter((value) => value !== void 0);
+        const results = /* @__PURE__ */ new Map();
+        const childTimeoutMs = Math.floor(
+          (queryTimeoutMs - (Date.now() - queryStartedAt)) / 2
+        );
+        await Promise.all(
+          starts.map(async (started) => {
+            try {
+              if (childTimeoutMs <= 0) {
+                throw new Error(`Codex child thread/read ${started.agentId} timed out before request`);
+              }
+              const child = await readThreadWithClient(client, started.agentId, childTimeoutMs);
+              const result = terminalSubagentResult(started, child, args.toolSessionId);
+              if (result) results.set(started.toolUseId, result);
+            } catch (error) {
+              this.deps.logger?.warn("codex subagent history terminal unavailable", {
+                parentThreadId: args.toolSessionId,
+                childThreadId: started.agentId,
+                message: error.message
+              });
+            }
+          })
+        );
+        return threadMessages(parent, results);
+      },
+      this.deps
+    );
     const total = messages.length;
     const limit = args.limit ?? total;
     const offset = typeof args.offset === "number" ? Math.min(Math.max(0, args.offset), total) : Math.max(0, total - limit);
@@ -54254,17 +54359,15 @@ var CodexHistoryReader = class {
     return [];
   }
   async readThread(cwd, threadId) {
-    const res = rec2(
+    return threadFromReadResponse(
       await queryCodexAppServer(
         cwd,
         "thread/read",
         { threadId, includeTurns: true },
         this.deps
-      )
+      ),
+      threadId
     );
-    const thread = res && rec2(res.thread);
-    if (!thread) throw new Error(`Codex thread/read returned no thread for ${threadId}`);
-    return thread;
   }
 };
 
@@ -54284,13 +54387,13 @@ function mapSkillsListResponse(res) {
       const r = s ?? {};
       const name = str3(r.name);
       if (!name) continue;
-      const path85 = str3(r.path);
+      const path86 = str3(r.path);
       const description = str3(r.description);
       const isPlugin = name.includes(":");
       out.push({
         name,
         source: isPlugin ? "plugin" : "project",
-        ...path85 ? { path: path85 } : {},
+        ...path86 ? { path: path86 } : {},
         ...description ? { description } : {},
         ...isPlugin ? { plugin: name.split(":")[0] } : {}
       });
@@ -56392,6 +56495,36 @@ function rmdirIfEmpty(p2) {
   }
 }
 
+// src/migrations/2026-08-18-drop-seeded-projects.ts
+var fs44 = __toESM(require("fs"), 1);
+var path45 = __toESM(require("path"), 1);
+var DROP_SEEDED_PROJECTS_FLAG = ".projects-seed-dropped.v1.done";
+function dropSeededProjects(opts) {
+  fs44.mkdirSync(opts.dataDir, { recursive: true });
+  const flag = path45.join(opts.dataDir, DROP_SEEDED_PROJECTS_FLAG);
+  if (fs44.existsSync(flag)) return { skipped: true, dropped: 0, backup: null };
+  const file = path45.join(opts.dataDir, "projects.json");
+  let raw = null;
+  let dropped = 0;
+  try {
+    raw = fs44.readFileSync(file, "utf8");
+    dropped = JSON.parse(raw).projects?.length ?? 0;
+  } catch {
+  }
+  let backup = null;
+  if (raw != null && dropped > 0) {
+    const dir = path45.join(opts.dataDir, "backups");
+    fs44.mkdirSync(dir, { recursive: true });
+    backup = path45.join(dir, `projects.seed-dropped.${(opts.now ?? Date.now)()}.json`);
+    fs44.writeFileSync(backup, raw);
+  }
+  if (raw != null || dropped > 0) {
+    fs44.writeFileSync(file, JSON.stringify({ projects: [] }, null, 2));
+  }
+  fs44.writeFileSync(flag, (/* @__PURE__ */ new Date()).toISOString());
+  return { skipped: false, dropped, backup };
+}
+
 // src/transport/http-router.ts
 var import_node_fs34 = __toESM(require("fs"), 1);
 var import_node_path38 = __toESM(require("path"), 1);
@@ -58554,9 +58687,9 @@ var CentralClientError = class extends Error {
   code;
   cause;
 };
-async function centralRequest(opts, path85, init) {
+async function centralRequest(opts, path86, init) {
   const f = opts.fetchImpl ?? globalThis.fetch;
-  const url = `${opts.api.replace(/\/+$/, "")}${path85}`;
+  const url = `${opts.api.replace(/\/+$/, "")}${path86}`;
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 15e3);
   let res;
@@ -58750,8 +58883,8 @@ function verifyConnectToken(args) {
 }
 
 // src/feishu-auth/server-key.ts
-var fs57 = __toESM(require("fs"), 1);
-var path60 = __toESM(require("path"), 1);
+var fs58 = __toESM(require("fs"), 1);
+var path61 = __toESM(require("path"), 1);
 var FILE_NAME2 = "server-signing-key.json";
 var ServerKeyStore = class {
   constructor(dataDir) {
@@ -58759,12 +58892,12 @@ var ServerKeyStore = class {
   }
   dataDir;
   filePath() {
-    return path60.join(this.dataDir, FILE_NAME2);
+    return path61.join(this.dataDir, FILE_NAME2);
   }
   /** 读缓存的公钥；无缓存 / 损坏 → null（调用方决定是否触发拉取） */
   read() {
     try {
-      const raw = fs57.readFileSync(this.filePath(), "utf8");
+      const raw = fs58.readFileSync(this.filePath(), "utf8");
       const parsed = JSON.parse(raw);
       if (typeof parsed.publicKeyPem === "string" && parsed.publicKeyPem.includes("PUBLIC KEY")) {
         return parsed.publicKeyPem;
@@ -58779,12 +58912,12 @@ var ServerKeyStore = class {
       publicKeyPem,
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs57.mkdirSync(this.dataDir, { recursive: true });
-    fs57.writeFileSync(this.filePath(), JSON.stringify(content, null, 2), { mode: 384 });
+    fs58.mkdirSync(this.dataDir, { recursive: true });
+    fs58.writeFileSync(this.filePath(), JSON.stringify(content, null, 2), { mode: 384 });
   }
   clear() {
     try {
-      fs57.unlinkSync(this.filePath());
+      fs58.unlinkSync(this.filePath());
     } catch {
     }
   }
@@ -59676,7 +59809,7 @@ function buildPermissionHandlers(deps) {
 }
 
 // src/handlers/history.ts
-var path65 = __toESM(require("path"), 1);
+var path66 = __toESM(require("path"), 1);
 init_protocol();
 
 // src/session/recent-dirs.ts
@@ -59694,7 +59827,7 @@ function listRecentDirs(store, limit = 50) {
 }
 
 // src/permission/persona-paths.ts
-var path64 = __toESM(require("path"), 1);
+var path65 = __toESM(require("path"), 1);
 function getAllowedPersonaIds(grants, action) {
   const ids = /* @__PURE__ */ new Set();
   for (const g2 of grants) {
@@ -59707,42 +59840,42 @@ function getAllowedPersonaIds(grants, action) {
   return ids;
 }
 function isGuestPathAllowed(grants, absPath, personaRoot, action = "read", userWorkDir) {
-  const target = path64.resolve(absPath);
+  const target = path65.resolve(absPath);
   if (userWorkDir) {
-    const u = path64.resolve(userWorkDir);
-    const usep = u.endsWith(path64.sep) ? "" : path64.sep;
+    const u = path65.resolve(userWorkDir);
+    const usep = u.endsWith(path65.sep) ? "" : path65.sep;
     if (target === u || target.startsWith(u + usep)) return true;
   }
-  const root = path64.resolve(personaRoot);
-  const sep5 = root.endsWith(path64.sep) ? "" : path64.sep;
+  const root = path65.resolve(personaRoot);
+  const sep5 = root.endsWith(path65.sep) ? "" : path65.sep;
   if (!target.startsWith(root + sep5)) return false;
-  const rel = path64.relative(root, target);
+  const rel = path65.relative(root, target);
   if (!rel || rel.startsWith("..")) return false;
-  const personaId2 = rel.split(path64.sep)[0];
+  const personaId2 = rel.split(path65.sep)[0];
   if (!personaId2) return false;
   const allowed = getAllowedPersonaIds(grants, action);
   if (allowed === "*") return true;
   return allowed.has(personaId2);
 }
 function personaIdFromPath(absPath, personaRoot) {
-  const root = path64.resolve(personaRoot);
-  const target = path64.resolve(absPath);
-  const sep5 = root.endsWith(path64.sep) ? "" : path64.sep;
+  const root = path65.resolve(personaRoot);
+  const target = path65.resolve(absPath);
+  const sep5 = root.endsWith(path65.sep) ? "" : path65.sep;
   if (!target.startsWith(root + sep5)) return null;
-  const rel = path64.relative(root, target);
+  const rel = path65.relative(root, target);
   if (!rel || rel.startsWith("..")) return null;
-  const id = rel.split(path64.sep)[0];
+  const id = rel.split(path65.sep)[0];
   return id || null;
 }
 function isPathWithin(dir, absPath) {
-  const d = path64.resolve(dir);
-  const t = path64.resolve(absPath);
-  const sep5 = d.endsWith(path64.sep) ? "" : path64.sep;
+  const d = path65.resolve(dir);
+  const t = path65.resolve(absPath);
+  const sep5 = d.endsWith(path65.sep) ? "" : path65.sep;
   return t === d || t.startsWith(d + sep5);
 }
 function isPathInGuestBoundary(personaRoot, personaId2, userWorkDir, absPath) {
   if (userWorkDir && isPathWithin(userWorkDir, absPath)) return true;
-  return personaIdFromPath(path64.resolve(absPath), personaRoot) === personaId2;
+  return personaIdFromPath(path65.resolve(absPath), personaRoot) === personaId2;
 }
 
 // src/handlers/history.ts
@@ -59795,7 +59928,7 @@ function buildHistoryHandlers(deps) {
         if (!pid) return false;
         return isGuestPathAllowed(
           ctx.grants,
-          path65.join(personaRoot, pid),
+          path66.join(personaRoot, pid),
           personaRoot,
           "read",
           userWorkDir
@@ -59807,7 +59940,7 @@ function buildHistoryHandlers(deps) {
   };
   const list = async (frame, _client, ctx) => {
     const args = HistoryListArgs.parse(frame);
-    assertGuestPath(ctx, path65.resolve(args.projectPath), personaRoot, "history:list", usersRoot);
+    assertGuestPath(ctx, path66.resolve(args.projectPath), personaRoot, "history:list", usersRoot);
     const sessions = await history.listSessions(args);
     return { response: { type: "history:list", sessions } };
   };
@@ -59855,14 +59988,14 @@ function buildHistoryHandlers(deps) {
   };
   const subagents = async (frame, _client, ctx) => {
     const args = HistorySubagentsArgs.parse(frame);
-    assertGuestPath(ctx, path65.resolve(args.cwd), personaRoot, "history:subagents", usersRoot);
+    assertGuestPath(ctx, path66.resolve(args.cwd), personaRoot, "history:subagents", usersRoot);
     assertGuestOwnsToolSession(ctx, args.toolSessionId, "history:subagents");
     const subs = await historyReaderForToolSession(args.toolSessionId).listSubagents(args);
     return { response: { type: "history:subagents", subagents: subs } };
   };
   const subagentRead = async (frame, _client, ctx) => {
     const args = HistorySubagentReadArgs.parse(frame);
-    assertGuestPath(ctx, path65.resolve(args.cwd), personaRoot, "history:subagent-read", usersRoot);
+    assertGuestPath(ctx, path66.resolve(args.cwd), personaRoot, "history:subagent-read", usersRoot);
     assertGuestOwnsToolSession(ctx, args.toolSessionId, "history:subagent-read");
     const res = await historyReaderForToolSession(args.toolSessionId).readSubagent(args);
     return { response: { type: "history:subagent-read", ...res } };
@@ -59872,7 +60005,7 @@ function buildHistoryHandlers(deps) {
     if (ctx?.principal.kind === "guest" && personaRoot) {
       const userWorkDir = usersRoot ? deriveUserWorkDir(ctx.principal.id, usersRoot) : void 0;
       const filtered = dirs.filter(
-        (d) => isGuestPathAllowed(ctx.grants, path65.resolve(d.cwd), personaRoot, "read", userWorkDir)
+        (d) => isGuestPathAllowed(ctx.grants, path66.resolve(d.cwd), personaRoot, "read", userWorkDir)
       );
       return { response: { type: "history:recentDirs", dirs: filtered } };
     }
@@ -59889,17 +60022,17 @@ function buildHistoryHandlers(deps) {
 }
 
 // src/handlers/projects.ts
-var fs61 = __toESM(require("fs"), 1);
+var fs62 = __toESM(require("fs"), 1);
 var os19 = __toESM(require("os"), 1);
-var path66 = __toESM(require("path"), 1);
+var path67 = __toESM(require("path"), 1);
 var import_node_child_process13 = require("child_process");
 init_protocol();
-var DEFAULT_PROJECTS_ROOT = path66.join(os19.homedir(), "Documents", "ChatGPT");
+var DEFAULT_PROJECTS_ROOT = path67.join(os19.homedir(), "Documents", "ChatGPT");
 function allocateDir(root, name) {
-  let candidate = path66.join(root, name);
+  let candidate = path67.join(root, name);
   let n = 2;
-  while (fs61.existsSync(candidate)) {
-    candidate = path66.join(root, `${name} ${n}`);
+  while (fs62.existsSync(candidate)) {
+    candidate = path67.join(root, `${name} ${n}`);
     n += 1;
   }
   return candidate;
@@ -59920,7 +60053,7 @@ function buildProjectHandlers(deps) {
     let target;
     if (args.path) {
       try {
-        if (!fs61.statSync(args.path).isDirectory()) throw new Error("not dir");
+        if (!fs62.statSync(args.path).isDirectory()) throw new Error("not dir");
       } catch {
         throw new ClawdError(ERROR_CODES.INVALID_CWD, `not a directory: ${args.path}`);
       }
@@ -59928,15 +60061,15 @@ function buildProjectHandlers(deps) {
     } else {
       const name = args.name;
       try {
-        fs61.mkdirSync(root, { recursive: true });
+        fs62.mkdirSync(root, { recursive: true });
         target = allocateDir(root, name);
-        fs61.mkdirSync(target);
+        fs62.mkdirSync(target);
       } catch (err) {
         throw new ClawdError(ERROR_CODES.INVALID_CWD, `\u521B\u5EFA\u9879\u76EE\u76EE\u5F55\u5931\u8D25: ${String(err)}`);
       }
       const git = (0, import_node_child_process13.spawnSync)("git", ["init"], { cwd: target, stdio: "ignore" });
       if (git.status !== 0) {
-        fs61.rmSync(target, { recursive: true, force: true });
+        fs62.rmSync(target, { recursive: true, force: true });
         throw new ClawdError(
           ERROR_CODES.INVALID_CWD,
           `git init \u5931\u8D25\uFF08${git.error ? String(git.error) : `exit ${git.status}`}\uFF09: ${target}`
@@ -59956,7 +60089,7 @@ function buildProjectHandlers(deps) {
 }
 
 // src/handlers/workspace.ts
-var path67 = __toESM(require("path"), 1);
+var path68 = __toESM(require("path"), 1);
 var os20 = __toESM(require("os"), 1);
 init_protocol();
 init_protocol();
@@ -59998,22 +60131,22 @@ function buildWorkspaceHandlers(deps) {
     const args = WorkspaceListArgs.parse(frame);
     const isGuest = ctx?.principal.kind === "guest";
     const fallbackCwd = isGuest && personaRoot ? personaRoot : os20.homedir();
-    const resolvedCwd = path67.resolve(args.cwd ?? fallbackCwd);
-    const target = args.path ? path67.resolve(resolvedCwd, args.path) : resolvedCwd;
+    const resolvedCwd = path68.resolve(args.cwd ?? fallbackCwd);
+    const target = args.path ? path68.resolve(resolvedCwd, args.path) : resolvedCwd;
     assertGuestPath2(ctx, target, personaRoot, "workspace:list", usersRoot);
     const res = workspace.list({ ...args, cwd: resolvedCwd });
     return { response: { type: "workspace:list", ...res } };
   };
   const read = async (frame, _client, ctx) => {
     const args = WorkspaceReadArgs.parse(frame);
-    const target = path67.isAbsolute(args.path) ? path67.resolve(args.path) : path67.resolve(args.cwd, args.path);
+    const target = path68.isAbsolute(args.path) ? path68.resolve(args.path) : path68.resolve(args.cwd, args.path);
     assertGuestPath2(ctx, target, personaRoot, "workspace:read", usersRoot);
     const res = workspace.read(args);
     return { response: { type: "workspace:read", ...res } };
   };
   const skillsList = async (frame, _client, ctx) => {
     const args = SkillsListArgs.parse(frame);
-    const cwdAbs = path67.resolve(args.cwd);
+    const cwdAbs = path68.resolve(args.cwd);
     assertGuestPath2(ctx, cwdAbs, personaRoot, "skills:list", usersRoot);
     const list2 = await getSkillsForTool(args.tool ?? "claude", cwdAbs);
     if (ctx?.principal.kind === "guest" && personaRoot) {
@@ -60025,7 +60158,7 @@ function buildWorkspaceHandlers(deps) {
   };
   const agentsList = async (frame, _client, ctx) => {
     const args = AgentsListArgs.parse(frame);
-    const cwdAbs = path67.resolve(args.cwd);
+    const cwdAbs = path68.resolve(args.cwd);
     assertGuestPath2(ctx, cwdAbs, personaRoot, "agents:list", usersRoot);
     if (args.tool === "codex") {
       return { response: { type: "agents:list", agents: [] } };
@@ -60047,7 +60180,7 @@ function buildWorkspaceHandlers(deps) {
 }
 
 // src/handlers/git.ts
-var path69 = __toESM(require("path"), 1);
+var path70 = __toESM(require("path"), 1);
 init_protocol();
 init_protocol();
 
@@ -60134,7 +60267,7 @@ async function listGitBranches(cwd) {
 function assertGuestCwd(ctx, cwd, personaRoot, method, usersRoot) {
   if (!ctx || ctx.principal.kind !== "guest" || !personaRoot) return;
   const userWorkDir = usersRoot ? deriveUserWorkDir(ctx.principal.id, usersRoot) : void 0;
-  if (!isGuestPathAllowed(ctx.grants, path69.resolve(cwd), personaRoot, "read", userWorkDir)) {
+  if (!isGuestPathAllowed(ctx.grants, path70.resolve(cwd), personaRoot, "read", userWorkDir)) {
     throw new ClawdError(
       ERROR_CODES.UNAUTHORIZED,
       `guest ${ctx.principal.id} cannot ${method} cwd ${cwd}`
@@ -61035,21 +61168,21 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.371".length > 0 ? "0.2.371" : "dev";
+var version = "0.2.373".length > 0 ? "0.2.373" : "dev";
 
 // src/cli-probe/probe.ts
-var fs63 = __toESM(require("fs"), 1);
-var path70 = __toESM(require("path"), 1);
+var fs64 = __toESM(require("fs"), 1);
+var path71 = __toESM(require("path"), 1);
 var PKG_NAME = "@clawos-dev/clawd";
 var BIN_NAME = "clawd";
 var MAX_PARENT_HOPS = 5;
 function probeGlobalCli(pathEnv) {
   if (!pathEnv) return null;
-  for (const dir of pathEnv.split(path70.delimiter)) {
+  for (const dir of pathEnv.split(path71.delimiter)) {
     if (!dir) continue;
     let real;
     try {
-      real = fs63.realpathSync(path70.join(dir, BIN_NAME));
+      real = fs64.realpathSync(path71.join(dir, BIN_NAME));
     } catch {
       continue;
     }
@@ -61059,15 +61192,15 @@ function probeGlobalCli(pathEnv) {
   return null;
 }
 function readOwnPackageVersion(entryPath) {
-  let dir = path70.dirname(entryPath);
+  let dir = path71.dirname(entryPath);
   for (let i = 0; i < MAX_PARENT_HOPS; i++) {
     try {
-      const raw = fs63.readFileSync(path70.join(dir, "package.json"), "utf8");
+      const raw = fs64.readFileSync(path71.join(dir, "package.json"), "utf8");
       const pkg = JSON.parse(raw);
       if (pkg.name !== PKG_NAME) return null;
       return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
     } catch {
-      const parent = path70.dirname(dir);
+      const parent = path71.dirname(dir);
       if (parent === dir) return null;
       dir = parent;
     }
@@ -64959,6 +65092,10 @@ async function startDaemon(config) {
       }
     }
   });
+  const droppedSeed = dropSeededProjects({ dataDir: config.dataDir });
+  if (!droppedSeed.skipped) {
+    logger.info("projects.seed-dropped", { dropped: droppedSeed.dropped, backup: droppedSeed.backup });
+  }
   const projectsStore = new ProjectsStore({
     file: import_node_path68.default.join(config.dataDir, "projects.json"),
     clawdDir: config.dataDir,
@@ -65037,12 +65174,14 @@ async function startDaemon(config) {
     "codex",
     new CodexAdapter({
       logger,
-      historyReader: new CodexHistoryReader(),
+      historyReader: new CodexHistoryReader({ logger }),
       // projectPaths 每次调用现取 —— 用户新建 project 后立即生效，不用重启 daemon
       codexHomeFor: (cwd) => resolveCodexHome({
         cwd,
         personaRoot: import_node_path68.default.join(config.dataDir, "personas"),
-        projectPaths: projectsStore.list().map((x) => x.path),
+        // 必须用 listMerged（Codex registry ∪ 叠加层）：只用本地 list() 的话，用户在
+        // Codex 里建的 project 不在表里，在它下面开的会话会被误判成隔离 → Codex 侧看不到
+        projectPaths: projectsStore.listMerged().map((x) => x.path),
         sharedHome: import_node_path68.default.join(import_node_os24.default.homedir(), ".codex"),
         isolatedHome: codexIsolatedHome
       })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.371",
+  "version": "0.2.373",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",