openclaw-telegram-manager 2.0.1 → 2.1.0

package/dist/plugin.js

@@ -60,54 +60,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs12) {
+    function patch(fs13) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs12);
-      }
-      if (!fs12.lutimes) {
-        patchLutimes(fs12);
-      }
-      fs12.chown = chownFix(fs12.chown);
-      fs12.fchown = chownFix(fs12.fchown);
-      fs12.lchown = chownFix(fs12.lchown);
-      fs12.chmod = chmodFix(fs12.chmod);
-      fs12.fchmod = chmodFix(fs12.fchmod);
-      fs12.lchmod = chmodFix(fs12.lchmod);
-      fs12.chownSync = chownFixSync(fs12.chownSync);
-      fs12.fchownSync = chownFixSync(fs12.fchownSync);
-      fs12.lchownSync = chownFixSync(fs12.lchownSync);
-      fs12.chmodSync = chmodFixSync(fs12.chmodSync);
-      fs12.fchmodSync = chmodFixSync(fs12.fchmodSync);
-      fs12.lchmodSync = chmodFixSync(fs12.lchmodSync);
-      fs12.stat = statFix(fs12.stat);
-      fs12.fstat = statFix(fs12.fstat);
-      fs12.lstat = statFix(fs12.lstat);
-      fs12.statSync = statFixSync(fs12.statSync);
-      fs12.fstatSync = statFixSync(fs12.fstatSync);
-      fs12.lstatSync = statFixSync(fs12.lstatSync);
-      if (fs12.chmod && !fs12.lchmod) {
-        fs12.lchmod = function(path13, mode, cb) {
+        patchLchmod(fs13);
+      }
+      if (!fs13.lutimes) {
+        patchLutimes(fs13);
+      }
+      fs13.chown = chownFix(fs13.chown);
+      fs13.fchown = chownFix(fs13.fchown);
+      fs13.lchown = chownFix(fs13.lchown);
+      fs13.chmod = chmodFix(fs13.chmod);
+      fs13.fchmod = chmodFix(fs13.fchmod);
+      fs13.lchmod = chmodFix(fs13.lchmod);
+      fs13.chownSync = chownFixSync(fs13.chownSync);
+      fs13.fchownSync = chownFixSync(fs13.fchownSync);
+      fs13.lchownSync = chownFixSync(fs13.lchownSync);
+      fs13.chmodSync = chmodFixSync(fs13.chmodSync);
+      fs13.fchmodSync = chmodFixSync(fs13.fchmodSync);
+      fs13.lchmodSync = chmodFixSync(fs13.lchmodSync);
+      fs13.stat = statFix(fs13.stat);
+      fs13.fstat = statFix(fs13.fstat);
+      fs13.lstat = statFix(fs13.lstat);
+      fs13.statSync = statFixSync(fs13.statSync);
+      fs13.fstatSync = statFixSync(fs13.fstatSync);
+      fs13.lstatSync = statFixSync(fs13.lstatSync);
+      if (fs13.chmod && !fs13.lchmod) {
+        fs13.lchmod = function(path14, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs12.lchmodSync = function() {
+        fs13.lchmodSync = function() {
         };
       }
-      if (fs12.chown && !fs12.lchown) {
-        fs12.lchown = function(path13, uid, gid, cb) {
+      if (fs13.chown && !fs13.lchown) {
+        fs13.lchown = function(path14, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs12.lchownSync = function() {
+        fs13.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs12.rename = typeof fs12.rename !== "function" ? fs12.rename : (function(fs$rename) {
+        fs13.rename = typeof fs13.rename !== "function" ? fs13.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs12.stat(to, function(stater, st) {
+                  fs13.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -123,9 +123,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs12.rename);
+        })(fs13.rename);
       }
-      fs12.read = typeof fs12.read !== "function" ? fs12.read : (function(fs$read) {
+      fs13.read = typeof fs13.read !== "function" ? fs13.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -133,22 +133,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs12, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs13, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs12.read);
-      fs12.readSync = typeof fs12.readSync !== "function" ? fs12.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs13.read);
+      fs13.readSync = typeof fs13.readSync !== "function" ? fs13.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs12, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs13, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -158,11 +158,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs12.readSync);
-      function patchLchmod(fs13) {
-        fs13.lchmod = function(path13, mode, callback) {
-          fs13.open(
-            path13,
+      })(fs13.readSync);
+      function patchLchmod(fs14) {
+        fs14.lchmod = function(path14, mode, callback) {
+          fs14.open(
+            path14,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -170,80 +170,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs13.fchmod(fd, mode, function(err2) {
-                fs13.close(fd, function(err22) {
+              fs14.fchmod(fd, mode, function(err2) {
+                fs14.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs13.lchmodSync = function(path13, mode) {
-          var fd = fs13.openSync(path13, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs14.lchmodSync = function(path14, mode) {
+          var fd = fs14.openSync(path14, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs13.fchmodSync(fd, mode);
+            ret = fs14.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs13.closeSync(fd);
+                fs14.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs13.closeSync(fd);
+              fs14.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs13) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs13.futimes) {
-          fs13.lutimes = function(path13, at, mt, cb) {
-            fs13.open(path13, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs14) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs14.futimes) {
+          fs14.lutimes = function(path14, at, mt, cb) {
+            fs14.open(path14, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs13.futimes(fd, at, mt, function(er2) {
-                fs13.close(fd, function(er22) {
+              fs14.futimes(fd, at, mt, function(er2) {
+                fs14.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs13.lutimesSync = function(path13, at, mt) {
-            var fd = fs13.openSync(path13, constants.O_SYMLINK);
+          fs14.lutimesSync = function(path14, at, mt) {
+            var fd = fs14.openSync(path14, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs13.futimesSync(fd, at, mt);
+              ret = fs14.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs13.closeSync(fd);
+                  fs14.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs13.closeSync(fd);
+                fs14.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs13.futimes) {
-          fs13.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs14.futimes) {
+          fs14.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs13.lutimesSync = function() {
+          fs14.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs12, target, mode, function(er) {
+          return orig.call(fs13, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -253,7 +253,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs12, target, mode);
+            return orig.call(fs13, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -262,7 +262,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs12, target, uid, gid, function(er) {
+          return orig.call(fs13, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -272,7 +272,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs12, target, uid, gid);
+            return orig.call(fs13, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -292,13 +292,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs12, target, options, callback) : orig.call(fs12, target, callback);
+          return options ? orig.call(fs13, target, options, callback) : orig.call(fs13, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs12, target, options) : orig.call(fs12, target);
+          var stats = options ? orig.call(fs13, target, options) : orig.call(fs13, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -327,16 +327,16 @@ var require_legacy_streams = __commonJS({
   "node_modules/graceful-fs/legacy-streams.js"(exports, module) {
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs12) {
+    function legacy(fs13) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path13, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
+      function ReadStream(path14, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
         Stream.call(this);
         var self = this;
-        this.path = path13;
+        this.path = path14;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -370,7 +370,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs12.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs13.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -381,10 +381,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path13, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path13, options);
+      function WriteStream(path14, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
         Stream.call(this);
-        this.path = path13;
+        this.path = path14;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -409,7 +409,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs12.open;
+          this._open = fs13.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -444,7 +444,7 @@ var require_clone = __commonJS({
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports, module) {
-    var fs12 = __require("fs");
+    var fs13 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -476,12 +476,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs12[gracefulQueue]) {
+    if (!fs13[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs12, queue);
-      fs12.close = (function(fs$close) {
+      publishQueue(fs13, queue);
+      fs13.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs12, fd, function(err) {
+          return fs$close.call(fs13, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -493,48 +493,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs12.close);
-      fs12.closeSync = (function(fs$closeSync) {
+      })(fs13.close);
+      fs13.closeSync = (function(fs$closeSync) {
         function closeSync2(fd) {
-          fs$closeSync.apply(fs12, arguments);
+          fs$closeSync.apply(fs13, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync2, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync2;
-      })(fs12.closeSync);
+      })(fs13.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs12[gracefulQueue]);
-          __require("assert").equal(fs12[gracefulQueue].length, 0);
+          debug(fs13[gracefulQueue]);
+          __require("assert").equal(fs13[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs12[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs12));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs12.__patched) {
-      module.exports = patch(fs12);
-      fs12.__patched = true;
-    }
-    function patch(fs13) {
-      polyfills(fs13);
-      fs13.gracefulify = patch;
-      fs13.createReadStream = createReadStream;
-      fs13.createWriteStream = createWriteStream;
-      var fs$readFile = fs13.readFile;
-      fs13.readFile = readFile;
-      function readFile(path13, options, cb) {
+      publishQueue(global, fs13[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs13));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs13.__patched) {
+      module.exports = patch(fs13);
+      fs13.__patched = true;
+    }
+    function patch(fs14) {
+      polyfills(fs14);
+      fs14.gracefulify = patch;
+      fs14.createReadStream = createReadStream;
+      fs14.createWriteStream = createWriteStream;
+      var fs$readFile = fs14.readFile;
+      fs14.readFile = readFile;
+      function readFile(path14, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path13, options, cb);
-        function go$readFile(path14, options2, cb2, startTime) {
-          return fs$readFile(path14, options2, function(err) {
+        return go$readFile(path14, options, cb);
+        function go$readFile(path15, options2, cb2, startTime) {
+          return fs$readFile(path15, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path14, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path15, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -542,16 +542,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs13.writeFile;
-      fs13.writeFile = writeFile;
-      function writeFile(path13, data, options, cb) {
+      var fs$writeFile = fs14.writeFile;
+      fs14.writeFile = writeFile;
+      function writeFile(path14, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path13, data, options, cb);
-        function go$writeFile(path14, data2, options2, cb2, startTime) {
-          return fs$writeFile(path14, data2, options2, function(err) {
+        return go$writeFile(path14, data, options, cb);
+        function go$writeFile(path15, data2, options2, cb2, startTime) {
+          return fs$writeFile(path15, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -559,17 +559,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs13.appendFile;
+      var fs$appendFile = fs14.appendFile;
       if (fs$appendFile)
-        fs13.appendFile = appendFile;
-      function appendFile(path13, data, options, cb) {
+        fs14.appendFile = appendFile;
+      function appendFile(path14, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path13, data, options, cb);
-        function go$appendFile(path14, data2, options2, cb2, startTime) {
-          return fs$appendFile(path14, data2, options2, function(err) {
+        return go$appendFile(path14, data, options, cb);
+        function go$appendFile(path15, data2, options2, cb2, startTime) {
+          return fs$appendFile(path15, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path14, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path15, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -577,9 +577,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs13.copyFile;
+      var fs$copyFile = fs14.copyFile;
       if (fs$copyFile)
-        fs13.copyFile = copyFile;
+        fs14.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -597,34 +597,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs13.readdir;
-      fs13.readdir = readdir;
+      var fs$readdir = fs14.readdir;
+      fs14.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path13, options, cb) {
+      function readdir(path14, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path14, options2, cb2, startTime) {
-          return fs$readdir(path14, fs$readdirCallback(
-            path14,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path15, options2, cb2, startTime) {
+          return fs$readdir(path15, fs$readdirCallback(
+            path15,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path14, options2, cb2, startTime) {
-          return fs$readdir(path14, options2, fs$readdirCallback(
-            path14,
+        } : function go$readdir2(path15, options2, cb2, startTime) {
+          return fs$readdir(path15, options2, fs$readdirCallback(
+            path15,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path13, options, cb);
-        function fs$readdirCallback(path14, options2, cb2, startTime) {
+        return go$readdir(path14, options, cb);
+        function fs$readdirCallback(path15, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path14, options2, cb2],
+                [path15, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -639,21 +639,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs13);
+        var legStreams = legacy(fs14);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs13.ReadStream;
+      var fs$ReadStream = fs14.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs13.WriteStream;
+      var fs$WriteStream = fs14.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs13, "ReadStream", {
+      Object.defineProperty(fs14, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -663,7 +663,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs13, "WriteStream", {
+      Object.defineProperty(fs14, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -674,7 +674,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs13, "FileReadStream", {
+      Object.defineProperty(fs14, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -685,7 +685,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs13, "FileWriteStream", {
+      Object.defineProperty(fs14, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -695,7 +695,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path13, options) {
+      function ReadStream(path14, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -715,7 +715,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path13, options) {
+      function WriteStream(path14, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -733,22 +733,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path13, options) {
-        return new fs13.ReadStream(path13, options);
+      function createReadStream(path14, options) {
+        return new fs14.ReadStream(path14, options);
       }
-      function createWriteStream(path13, options) {
-        return new fs13.WriteStream(path13, options);
+      function createWriteStream(path14, options) {
+        return new fs14.WriteStream(path14, options);
       }
-      var fs$open = fs13.open;
-      fs13.open = open;
-      function open(path13, flags, mode, cb) {
+      var fs$open = fs14.open;
+      fs14.open = open;
+      function open(path14, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path13, flags, mode, cb);
-        function go$open(path14, flags2, mode2, cb2, startTime) {
-          return fs$open(path14, flags2, mode2, function(err, fd) {
+        return go$open(path14, flags, mode, cb);
+        function go$open(path15, flags2, mode2, cb2, startTime) {
+          return fs$open(path15, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path14, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path15, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -756,20 +756,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs13;
+      return fs14;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs12[gracefulQueue].push(elem);
+      fs13[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs12[gracefulQueue].length; ++i) {
-        if (fs12[gracefulQueue][i].length > 2) {
-          fs12[gracefulQueue][i][3] = now;
-          fs12[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs13[gracefulQueue].length; ++i) {
+        if (fs13[gracefulQueue][i].length > 2) {
+          fs13[gracefulQueue][i][3] = now;
+          fs13[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -777,9 +777,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs12[gracefulQueue].length === 0)
+      if (fs13[gracefulQueue].length === 0)
         return;
-      var elem = fs12[gracefulQueue].shift();
+      var elem = fs13[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -801,7 +801,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs12[gracefulQueue].push(elem);
+          fs13[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -1236,10 +1236,10 @@ var require_mtime_precision = __commonJS({
   "node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
     "use strict";
     var cacheSymbol = Symbol();
-    function probe(file, fs12, callback) {
-      const cachedPrecision = fs12[cacheSymbol];
+    function probe(file, fs13, callback) {
+      const cachedPrecision = fs13[cacheSymbol];
       if (cachedPrecision) {
-        return fs12.stat(file, (err, stat) => {
+        return fs13.stat(file, (err, stat) => {
           if (err) {
             return callback(err);
           }
@@ -1247,16 +1247,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs12.utimes(file, mtime, mtime, (err) => {
+      fs13.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs12.stat(file, (err2, stat) => {
+        fs13.stat(file, (err2, stat) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs12, cacheSymbol, { value: precision });
+          Object.defineProperty(fs13, cacheSymbol, { value: precision });
           callback(null, stat.mtime, precision);
         });
       });
@@ -1277,8 +1277,8 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path13 = __require("path");
-    var fs12 = require_graceful_fs();
+    var path14 = __require("path");
+    var fs13 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -1288,7 +1288,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path13.resolve(file));
+        return callback(null, path14.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -1409,7 +1409,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs12,
+        fs: fs13,
         onCompromised: (err) => {
           throw err;
         },
@@ -1453,7 +1453,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs12,
+        fs: fs13,
         realpath: true,
         ...options
       };
@@ -1475,7 +1475,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs12,
+        fs: fs13,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -1514,16 +1514,16 @@ var require_lockfile = __commonJS({
 var require_adapter = __commonJS({
   "node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
     "use strict";
-    var fs12 = require_graceful_fs();
-    function createSyncFs(fs13) {
+    var fs13 = require_graceful_fs();
+    function createSyncFs(fs14) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs13 };
+      const newFs = { ...fs14 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs13[`${method}Sync`](...args);
+            ret = fs14[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1533,12 +1533,12 @@ var require_adapter = __commonJS({
       return newFs;
     }
     function toPromise(method) {
-      return (...args) => new Promise((resolve4, reject) => {
+      return (...args) => new Promise((resolve5, reject) => {
         args.push((err, result) => {
           if (err) {
             reject(err);
           } else {
-            resolve4(result);
+            resolve5(result);
           }
         });
         method(...args);
@@ -1561,7 +1561,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs12);
+      options.fs = createSyncFs(options.fs || fs13);
       if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
         throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
       }
@@ -2715,17 +2715,17 @@ var require_lib = __commonJS({
   "node_modules/json5/lib/index.js"(exports, module) {
     var parse = require_parse();
     var stringify = require_stringify();
-    var JSON52 = {
+    var JSON53 = {
       parse,
       stringify
     };
-    module.exports = JSON52;
+    module.exports = JSON53;
   }
 });
 
 // src/index.ts
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
@@ -6298,32 +6298,32 @@ var ValueErrorIterator = class {
     return next.done ? void 0 : next.value;
   }
 };
-function Create(errorType, schema, path13, value, errors = []) {
+function Create(errorType, schema, path14, value, errors = []) {
   return {
     type: errorType,
     schema,
-    path: path13,
+    path: path14,
     value,
-    message: GetErrorFunction()({ errorType, path: path13, schema, value, errors }),
+    message: GetErrorFunction()({ errorType, path: path14, schema, value, errors }),
     errors
   };
 }
-function* FromAny3(schema, references, path13, value) {
+function* FromAny3(schema, references, path14, value) {
 }
-function* FromArgument3(schema, references, path13, value) {
+function* FromArgument3(schema, references, path14, value) {
 }
-function* FromArray8(schema, references, path13, value) {
+function* FromArray8(schema, references, path14, value) {
   if (!IsArray2(value)) {
-    return yield Create(ValueErrorType.Array, schema, path13, value);
+    return yield Create(ValueErrorType.Array, schema, path14, value);
   }
   if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield Create(ValueErrorType.ArrayMinItems, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMinItems, schema, path14, value);
   }
   if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield Create(ValueErrorType.ArrayMaxItems, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path14, value);
   }
   for (let i = 0; i < value.length; i++) {
-    yield* Visit6(schema.items, references, `${path13}/${i}`, value[i]);
+    yield* Visit6(schema.items, references, `${path14}/${i}`, value[i]);
   }
   if (schema.uniqueItems === true && !(function() {
     const set = /* @__PURE__ */ new Set();
@@ -6337,116 +6337,116 @@ function* FromArray8(schema, references, path13, value) {
     }
     return true;
   })()) {
-    yield Create(ValueErrorType.ArrayUniqueItems, schema, path13, value);
+    yield Create(ValueErrorType.ArrayUniqueItems, schema, path14, value);
   }
   if (!(IsDefined2(schema.contains) || IsDefined2(schema.minContains) || IsDefined2(schema.maxContains))) {
     return;
   }
   const containsSchema = IsDefined2(schema.contains) ? schema.contains : Never();
-  const containsCount = value.reduce((acc, value2, index) => Visit6(containsSchema, references, `${path13}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+  const containsCount = value.reduce((acc, value2, index) => Visit6(containsSchema, references, `${path14}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
   if (containsCount === 0) {
-    yield Create(ValueErrorType.ArrayContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayContains, schema, path14, value);
   }
   if (IsNumber2(schema.minContains) && containsCount < schema.minContains) {
-    yield Create(ValueErrorType.ArrayMinContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMinContains, schema, path14, value);
   }
   if (IsNumber2(schema.maxContains) && containsCount > schema.maxContains) {
-    yield Create(ValueErrorType.ArrayMaxContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path14, value);
   }
 }
-function* FromAsyncIterator5(schema, references, path13, value) {
+function* FromAsyncIterator5(schema, references, path14, value) {
   if (!IsAsyncIterator2(value))
-    yield Create(ValueErrorType.AsyncIterator, schema, path13, value);
+    yield Create(ValueErrorType.AsyncIterator, schema, path14, value);
 }
-function* FromBigInt3(schema, references, path13, value) {
+function* FromBigInt3(schema, references, path14, value) {
   if (!IsBigInt2(value))
-    return yield Create(ValueErrorType.BigInt, schema, path13, value);
+    return yield Create(ValueErrorType.BigInt, schema, path14, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.BigIntMaximum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.BigIntMinimum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield Create(ValueErrorType.BigIntMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path14, value);
   }
 }
-function* FromBoolean3(schema, references, path13, value) {
+function* FromBoolean3(schema, references, path14, value) {
   if (!IsBoolean2(value))
-    yield Create(ValueErrorType.Boolean, schema, path13, value);
+    yield Create(ValueErrorType.Boolean, schema, path14, value);
 }
-function* FromConstructor5(schema, references, path13, value) {
-  yield* Visit6(schema.returns, references, path13, value.prototype);
+function* FromConstructor5(schema, references, path14, value) {
+  yield* Visit6(schema.returns, references, path14, value.prototype);
 }
-function* FromDate3(schema, references, path13, value) {
+function* FromDate3(schema, references, path14, value) {
   if (!IsDate2(value))
-    return yield Create(ValueErrorType.Date, schema, path13, value);
+    return yield Create(ValueErrorType.Date, schema, path14, value);
   if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path14, value);
   }
   if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path14, value);
   }
   if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path14, value);
   }
   if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path14, value);
   }
   if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path14, value);
   }
 }
-function* FromFunction5(schema, references, path13, value) {
+function* FromFunction5(schema, references, path14, value) {
   if (!IsFunction2(value))
-    yield Create(ValueErrorType.Function, schema, path13, value);
+    yield Create(ValueErrorType.Function, schema, path14, value);
 }
-function* FromImport2(schema, references, path13, value) {
+function* FromImport2(schema, references, path14, value) {
   const definitions = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  yield* Visit6(target, [...references, ...definitions], path13, value);
+  yield* Visit6(target, [...references, ...definitions], path14, value);
 }
-function* FromInteger3(schema, references, path13, value) {
+function* FromInteger3(schema, references, path14, value) {
   if (!IsInteger(value))
-    return yield Create(ValueErrorType.Integer, schema, path13, value);
+    return yield Create(ValueErrorType.Integer, schema, path14, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.IntegerMaximum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.IntegerMinimum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.IntegerMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path14, value);
   }
 }
-function* FromIntersect10(schema, references, path13, value) {
+function* FromIntersect10(schema, references, path14, value) {
   let hasError = false;
   for (const inner of schema.allOf) {
-    for (const error of Visit6(inner, references, path13, value)) {
+    for (const error of Visit6(inner, references, path14, value)) {
       hasError = true;
       yield error;
     }
   }
   if (hasError) {
-    return yield Create(ValueErrorType.Intersect, schema, path13, value);
+    return yield Create(ValueErrorType.Intersect, schema, path14, value);
   }
   if (schema.unevaluatedProperties === false) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path13}/${valueKey}`, value);
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path14}/${valueKey}`, value);
       }
     }
   }
@@ -6454,59 +6454,59 @@ function* FromIntersect10(schema, references, path13, value) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        const next = Visit6(schema.unevaluatedProperties, references, `${path13}/${valueKey}`, value[valueKey]).next();
+        const next = Visit6(schema.unevaluatedProperties, references, `${path14}/${valueKey}`, value[valueKey]).next();
         if (!next.done)
           yield next.value;
       }
     }
   }
 }
-function* FromIterator5(schema, references, path13, value) {
+function* FromIterator5(schema, references, path14, value) {
   if (!IsIterator2(value))
-    yield Create(ValueErrorType.Iterator, schema, path13, value);
+    yield Create(ValueErrorType.Iterator, schema, path14, value);
 }
-function* FromLiteral4(schema, references, path13, value) {
+function* FromLiteral4(schema, references, path14, value) {
   if (!(value === schema.const))
-    yield Create(ValueErrorType.Literal, schema, path13, value);
+    yield Create(ValueErrorType.Literal, schema, path14, value);
 }
-function* FromNever3(schema, references, path13, value) {
-  yield Create(ValueErrorType.Never, schema, path13, value);
+function* FromNever3(schema, references, path14, value) {
+  yield Create(ValueErrorType.Never, schema, path14, value);
 }
-function* FromNot3(schema, references, path13, value) {
-  if (Visit6(schema.not, references, path13, value).next().done === true)
-    yield Create(ValueErrorType.Not, schema, path13, value);
+function* FromNot3(schema, references, path14, value) {
+  if (Visit6(schema.not, references, path14, value).next().done === true)
+    yield Create(ValueErrorType.Not, schema, path14, value);
 }
-function* FromNull3(schema, references, path13, value) {
+function* FromNull3(schema, references, path14, value) {
   if (!IsNull2(value))
-    yield Create(ValueErrorType.Null, schema, path13, value);
+    yield Create(ValueErrorType.Null, schema, path14, value);
 }
-function* FromNumber3(schema, references, path13, value) {
+function* FromNumber3(schema, references, path14, value) {
   if (!TypeSystemPolicy.IsNumberLike(value))
-    return yield Create(ValueErrorType.Number, schema, path13, value);
+    return yield Create(ValueErrorType.Number, schema, path14, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.NumberMaximum, schema, path13, value);
+    yield Create(ValueErrorType.NumberMaximum, schema, path14, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.NumberMinimum, schema, path13, value);
+    yield Create(ValueErrorType.NumberMinimum, schema, path14, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.NumberMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path14, value);
   }
 }
-function* FromObject9(schema, references, path13, value) {
+function* FromObject9(schema, references, path14, value) {
   if (!TypeSystemPolicy.IsObjectLike(value))
-    return yield Create(ValueErrorType.Object, schema, path13, value);
+    return yield Create(ValueErrorType.Object, schema, path14, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, value);
   }
   const requiredKeys = Array.isArray(schema.required) ? schema.required : [];
   const knownKeys = Object.getOwnPropertyNames(schema.properties);
@@ -6514,12 +6514,12 @@ function* FromObject9(schema, references, path13, value) {
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey))
       continue;
-    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path13}/${EscapeKey(requiredKey)}`, void 0);
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path14}/${EscapeKey(requiredKey)}`, void 0);
   }
   if (schema.additionalProperties === false) {
     for (const valueKey of unknownKeys) {
       if (!knownKeys.includes(valueKey)) {
-        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path13}/${EscapeKey(valueKey)}`, value[valueKey]);
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path14}/${EscapeKey(valueKey)}`, value[valueKey]);
       }
     }
   }
@@ -6527,235 +6527,235 @@ function* FromObject9(schema, references, path13, value) {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey))
         continue;
-      yield* Visit6(schema.additionalProperties, references, `${path13}/${EscapeKey(valueKey)}`, value[valueKey]);
+      yield* Visit6(schema.additionalProperties, references, `${path14}/${EscapeKey(valueKey)}`, value[valueKey]);
     }
   }
   for (const knownKey of knownKeys) {
     const property = schema.properties[knownKey];
     if (schema.required && schema.required.includes(knownKey)) {
-      yield* Visit6(property, references, `${path13}/${EscapeKey(knownKey)}`, value[knownKey]);
+      yield* Visit6(property, references, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
       if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
-        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path13}/${EscapeKey(knownKey)}`, void 0);
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path14}/${EscapeKey(knownKey)}`, void 0);
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit6(property, references, `${path13}/${EscapeKey(knownKey)}`, value[knownKey]);
+        yield* Visit6(property, references, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
       }
     }
   }
 }
-function* FromPromise5(schema, references, path13, value) {
+function* FromPromise5(schema, references, path14, value) {
   if (!IsPromise(value))
-    yield Create(ValueErrorType.Promise, schema, path13, value);
+    yield Create(ValueErrorType.Promise, schema, path14, value);
 }
-function* FromRecord5(schema, references, path13, value) {
+function* FromRecord5(schema, references, path14, value) {
   if (!TypeSystemPolicy.IsRecordLike(value))
-    return yield Create(ValueErrorType.Object, schema, path13, value);
+    return yield Create(ValueErrorType.Object, schema, path14, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, value);
   }
   const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
   const regex = new RegExp(patternKey);
   for (const [propertyKey, propertyValue] of Object.entries(value)) {
     if (regex.test(propertyKey))
-      yield* Visit6(patternSchema, references, `${path13}/${EscapeKey(propertyKey)}`, propertyValue);
+      yield* Visit6(patternSchema, references, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
   }
   if (typeof schema.additionalProperties === "object") {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
       if (!regex.test(propertyKey))
-        yield* Visit6(schema.additionalProperties, references, `${path13}/${EscapeKey(propertyKey)}`, propertyValue);
+        yield* Visit6(schema.additionalProperties, references, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
   if (schema.additionalProperties === false) {
     for (const [propertyKey, propertyValue] of Object.entries(value)) {
       if (regex.test(propertyKey))
         continue;
-      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path13}/${EscapeKey(propertyKey)}`, propertyValue);
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
 }
-function* FromRef6(schema, references, path13, value) {
-  yield* Visit6(Deref(schema, references), references, path13, value);
+function* FromRef6(schema, references, path14, value) {
+  yield* Visit6(Deref(schema, references), references, path14, value);
 }
-function* FromRegExp3(schema, references, path13, value) {
+function* FromRegExp3(schema, references, path14, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path14, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path14, value);
   }
   const regex = new RegExp(schema.source, schema.flags);
   if (!regex.test(value)) {
-    return yield Create(ValueErrorType.RegExp, schema, path13, value);
+    return yield Create(ValueErrorType.RegExp, schema, path14, value);
   }
 }
-function* FromString3(schema, references, path13, value) {
+function* FromString3(schema, references, path14, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path14, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path14, value);
   }
   if (IsString2(schema.pattern)) {
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
-      yield Create(ValueErrorType.StringPattern, schema, path13, value);
+      yield Create(ValueErrorType.StringPattern, schema, path14, value);
     }
   }
   if (IsString2(schema.format)) {
     if (!format_exports.Has(schema.format)) {
-      yield Create(ValueErrorType.StringFormatUnknown, schema, path13, value);
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path14, value);
     } else {
       const format = format_exports.Get(schema.format);
       if (!format(value)) {
-        yield Create(ValueErrorType.StringFormat, schema, path13, value);
+        yield Create(ValueErrorType.StringFormat, schema, path14, value);
       }
     }
   }
 }
-function* FromSymbol3(schema, references, path13, value) {
+function* FromSymbol3(schema, references, path14, value) {
   if (!IsSymbol2(value))
-    yield Create(ValueErrorType.Symbol, schema, path13, value);
+    yield Create(ValueErrorType.Symbol, schema, path14, value);
 }
-function* FromTemplateLiteral5(schema, references, path13, value) {
+function* FromTemplateLiteral5(schema, references, path14, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path14, value);
   const regex = new RegExp(schema.pattern);
   if (!regex.test(value)) {
-    yield Create(ValueErrorType.StringPattern, schema, path13, value);
+    yield Create(ValueErrorType.StringPattern, schema, path14, value);
   }
 }
-function* FromThis2(schema, references, path13, value) {
-  yield* Visit6(Deref(schema, references), references, path13, value);
+function* FromThis2(schema, references, path14, value) {
+  yield* Visit6(Deref(schema, references), references, path14, value);
 }
-function* FromTuple7(schema, references, path13, value) {
+function* FromTuple7(schema, references, path14, value) {
   if (!IsArray2(value))
-    return yield Create(ValueErrorType.Tuple, schema, path13, value);
+    return yield Create(ValueErrorType.Tuple, schema, path14, value);
   if (schema.items === void 0 && !(value.length === 0)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path14, value);
   }
   if (!(value.length === schema.maxItems)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path14, value);
   }
   if (!schema.items) {
     return;
   }
   for (let i = 0; i < schema.items.length; i++) {
-    yield* Visit6(schema.items[i], references, `${path13}/${i}`, value[i]);
+    yield* Visit6(schema.items[i], references, `${path14}/${i}`, value[i]);
   }
 }
-function* FromUndefined3(schema, references, path13, value) {
+function* FromUndefined3(schema, references, path14, value) {
   if (!IsUndefined2(value))
-    yield Create(ValueErrorType.Undefined, schema, path13, value);
+    yield Create(ValueErrorType.Undefined, schema, path14, value);
 }
-function* FromUnion12(schema, references, path13, value) {
+function* FromUnion12(schema, references, path14, value) {
   if (Check(schema, references, value))
     return;
-  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path13, value)));
-  yield Create(ValueErrorType.Union, schema, path13, value, errors);
+  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path14, value)));
+  yield Create(ValueErrorType.Union, schema, path14, value, errors);
 }
-function* FromUint8Array3(schema, references, path13, value) {
+function* FromUint8Array3(schema, references, path14, value) {
   if (!IsUint8Array2(value))
-    return yield Create(ValueErrorType.Uint8Array, schema, path13, value);
+    return yield Create(ValueErrorType.Uint8Array, schema, path14, value);
   if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path13, value);
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path14, value);
   }
   if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path13, value);
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path14, value);
   }
 }
-function* FromUnknown3(schema, references, path13, value) {
+function* FromUnknown3(schema, references, path14, value) {
 }
-function* FromVoid3(schema, references, path13, value) {
+function* FromVoid3(schema, references, path14, value) {
   if (!TypeSystemPolicy.IsVoidLike(value))
-    yield Create(ValueErrorType.Void, schema, path13, value);
+    yield Create(ValueErrorType.Void, schema, path14, value);
 }
-function* FromKind2(schema, references, path13, value) {
+function* FromKind2(schema, references, path14, value) {
   const check2 = type_exports2.Get(schema[Kind]);
   if (!check2(schema, value))
-    yield Create(ValueErrorType.Kind, schema, path13, value);
+    yield Create(ValueErrorType.Kind, schema, path14, value);
 }
-function* Visit6(schema, references, path13, value) {
+function* Visit6(schema, references, path14, value) {
   const references_ = IsDefined2(schema.$id) ? [...references, schema] : references;
   const schema_ = schema;
   switch (schema_[Kind]) {
     case "Any":
-      return yield* FromAny3(schema_, references_, path13, value);
+      return yield* FromAny3(schema_, references_, path14, value);
     case "Argument":
-      return yield* FromArgument3(schema_, references_, path13, value);
+      return yield* FromArgument3(schema_, references_, path14, value);
     case "Array":
-      return yield* FromArray8(schema_, references_, path13, value);
+      return yield* FromArray8(schema_, references_, path14, value);
     case "AsyncIterator":
-      return yield* FromAsyncIterator5(schema_, references_, path13, value);
+      return yield* FromAsyncIterator5(schema_, references_, path14, value);
     case "BigInt":
-      return yield* FromBigInt3(schema_, references_, path13, value);
+      return yield* FromBigInt3(schema_, references_, path14, value);
     case "Boolean":
-      return yield* FromBoolean3(schema_, references_, path13, value);
+      return yield* FromBoolean3(schema_, references_, path14, value);
     case "Constructor":
-      return yield* FromConstructor5(schema_, references_, path13, value);
+      return yield* FromConstructor5(schema_, references_, path14, value);
     case "Date":
-      return yield* FromDate3(schema_, references_, path13, value);
+      return yield* FromDate3(schema_, references_, path14, value);
     case "Function":
-      return yield* FromFunction5(schema_, references_, path13, value);
+      return yield* FromFunction5(schema_, references_, path14, value);
     case "Import":
-      return yield* FromImport2(schema_, references_, path13, value);
+      return yield* FromImport2(schema_, references_, path14, value);
     case "Integer":
-      return yield* FromInteger3(schema_, references_, path13, value);
+      return yield* FromInteger3(schema_, references_, path14, value);
     case "Intersect":
-      return yield* FromIntersect10(schema_, references_, path13, value);
+      return yield* FromIntersect10(schema_, references_, path14, value);
     case "Iterator":
-      return yield* FromIterator5(schema_, references_, path13, value);
+      return yield* FromIterator5(schema_, references_, path14, value);
     case "Literal":
-      return yield* FromLiteral4(schema_, references_, path13, value);
+      return yield* FromLiteral4(schema_, references_, path14, value);
     case "Never":
-      return yield* FromNever3(schema_, references_, path13, value);
+      return yield* FromNever3(schema_, references_, path14, value);
     case "Not":
-      return yield* FromNot3(schema_, references_, path13, value);
+      return yield* FromNot3(schema_, references_, path14, value);
     case "Null":
-      return yield* FromNull3(schema_, references_, path13, value);
+      return yield* FromNull3(schema_, references_, path14, value);
     case "Number":
-      return yield* FromNumber3(schema_, references_, path13, value);
+      return yield* FromNumber3(schema_, references_, path14, value);
     case "Object":
-      return yield* FromObject9(schema_, references_, path13, value);
+      return yield* FromObject9(schema_, references_, path14, value);
     case "Promise":
-      return yield* FromPromise5(schema_, references_, path13, value);
+      return yield* FromPromise5(schema_, references_, path14, value);
     case "Record":
-      return yield* FromRecord5(schema_, references_, path13, value);
+      return yield* FromRecord5(schema_, references_, path14, value);
     case "Ref":
-      return yield* FromRef6(schema_, references_, path13, value);
+      return yield* FromRef6(schema_, references_, path14, value);
     case "RegExp":
-      return yield* FromRegExp3(schema_, references_, path13, value);
+      return yield* FromRegExp3(schema_, references_, path14, value);
     case "String":
-      return yield* FromString3(schema_, references_, path13, value);
+      return yield* FromString3(schema_, references_, path14, value);
     case "Symbol":
-      return yield* FromSymbol3(schema_, references_, path13, value);
+      return yield* FromSymbol3(schema_, references_, path14, value);
     case "TemplateLiteral":
-      return yield* FromTemplateLiteral5(schema_, references_, path13, value);
+      return yield* FromTemplateLiteral5(schema_, references_, path14, value);
     case "This":
-      return yield* FromThis2(schema_, references_, path13, value);
+      return yield* FromThis2(schema_, references_, path14, value);
     case "Tuple":
-      return yield* FromTuple7(schema_, references_, path13, value);
+      return yield* FromTuple7(schema_, references_, path14, value);
     case "Undefined":
-      return yield* FromUndefined3(schema_, references_, path13, value);
+      return yield* FromUndefined3(schema_, references_, path14, value);
     case "Union":
-      return yield* FromUnion12(schema_, references_, path13, value);
+      return yield* FromUnion12(schema_, references_, path14, value);
     case "Uint8Array":
-      return yield* FromUint8Array3(schema_, references_, path13, value);
+      return yield* FromUint8Array3(schema_, references_, path14, value);
     case "Unknown":
-      return yield* FromUnknown3(schema_, references_, path13, value);
+      return yield* FromUnknown3(schema_, references_, path14, value);
     case "Void":
-      return yield* FromVoid3(schema_, references_, path13, value);
+      return yield* FromVoid3(schema_, references_, path14, value);
     default:
       if (!type_exports2.Has(schema_[Kind]))
         throw new ValueErrorsUnknownTypeError(schema);
-      return yield* FromKind2(schema_, references_, path13, value);
+      return yield* FromKind2(schema_, references_, path14, value);
   }
 }
 function Errors(...args) {
@@ -7797,58 +7797,58 @@ var TransformDecodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformDecodeError = class extends TypeBoxError {
-  constructor(schema, path13, value, error) {
+  constructor(schema, path14, value, error) {
     super(error instanceof Error ? error.message : "Unknown error");
     this.schema = schema;
-    this.path = path13;
+    this.path = path14;
     this.value = value;
     this.error = error;
   }
 };
-function Default3(schema, path13, value) {
+function Default3(schema, path14, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
-    throw new TransformDecodeError(schema, path13, value, error);
+    throw new TransformDecodeError(schema, path14, value, error);
   }
 }
-function FromArray14(schema, references, path13, value) {
-  return IsArray2(value) ? Default3(schema, path13, value.map((value2, index) => Visit11(schema.items, references, `${path13}/${index}`, value2))) : Default3(schema, path13, value);
+function FromArray14(schema, references, path14, value) {
+  return IsArray2(value) ? Default3(schema, path14, value.map((value2, index) => Visit11(schema.items, references, `${path14}/${index}`, value2))) : Default3(schema, path14, value);
 }
-function FromIntersect15(schema, references, path13, value) {
+function FromIntersect15(schema, references, path14, value) {
   if (!IsObject2(value) || IsValueType(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path14, value);
   const knownEntries = KeyOfPropertyEntries(schema);
   const knownKeys = knownEntries.map((entry) => entry[0]);
   const knownProperties = { ...value };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit11(knownSchema, references, `${path13}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit11(knownSchema, references, `${path14}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path14, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const unevaluatedProperties = schema.unevaluatedProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default3(unevaluatedProperties, `${path13}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(unevaluatedProperties, `${path14}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path14, unknownProperties);
 }
-function FromImport7(schema, references, path13, value) {
+function FromImport7(schema, references, path14, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Visit11(target, [...references, ...additional], path13, value);
-  return Default3(schema, path13, result);
+  const result = Visit11(target, [...references, ...additional], path14, value);
+  return Default3(schema, path14, result);
 }
-function FromNot5(schema, references, path13, value) {
-  return Default3(schema, path13, Visit11(schema.not, references, path13, value));
+function FromNot5(schema, references, path14, value) {
+  return Default3(schema, path14, Visit11(schema.not, references, path14, value));
 }
-function FromObject15(schema, references, path13, value) {
+function FromObject15(schema, references, path14, value) {
   if (!IsObject2(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path14, value);
   const knownKeys = KeyOfPropertyKeys(schema);
   const knownProperties = { ...value };
   for (const key of knownKeys) {
@@ -7856,90 +7856,90 @@ function FromObject15(schema, references, path13, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit11(schema.properties[key], references, `${path13}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit11(schema.properties[key], references, `${path14}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path14, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const additionalProperties = schema.additionalProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default3(additionalProperties, `${path13}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path14}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path14, unknownProperties);
 }
-function FromRecord10(schema, references, path13, value) {
+function FromRecord10(schema, references, path14, value) {
   if (!IsObject2(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path14, value);
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
   const knownKeys = new RegExp(pattern);
   const knownProperties = { ...value };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path13}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path14}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path14, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
   const additionalProperties = schema.additionalProperties;
   const unknownProperties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      unknownProperties[key] = Default3(additionalProperties, `${path13}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path14}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path14, unknownProperties);
 }
-function FromRef11(schema, references, path13, value) {
+function FromRef11(schema, references, path14, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path13, Visit11(target, references, path13, value));
+  return Default3(schema, path14, Visit11(target, references, path14, value));
 }
-function FromThis7(schema, references, path13, value) {
+function FromThis7(schema, references, path14, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path13, Visit11(target, references, path13, value));
+  return Default3(schema, path14, Visit11(target, references, path14, value));
 }
-function FromTuple12(schema, references, path13, value) {
-  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path13, schema.items.map((schema2, index) => Visit11(schema2, references, `${path13}/${index}`, value[index]))) : Default3(schema, path13, value);
+function FromTuple12(schema, references, path14, value) {
+  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path14, schema.items.map((schema2, index) => Visit11(schema2, references, `${path14}/${index}`, value[index]))) : Default3(schema, path14, value);
 }
-function FromUnion17(schema, references, path13, value) {
+function FromUnion17(schema, references, path14, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const decoded = Visit11(subschema, references, path13, value);
-    return Default3(schema, path13, decoded);
+    const decoded = Visit11(subschema, references, path14, value);
+    return Default3(schema, path14, decoded);
   }
-  return Default3(schema, path13, value);
+  return Default3(schema, path14, value);
 }
-function Visit11(schema, references, path13, value) {
+function Visit11(schema, references, path14, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray14(schema_, references_, path13, value);
+      return FromArray14(schema_, references_, path14, value);
     case "Import":
-      return FromImport7(schema_, references_, path13, value);
+      return FromImport7(schema_, references_, path14, value);
     case "Intersect":
-      return FromIntersect15(schema_, references_, path13, value);
+      return FromIntersect15(schema_, references_, path14, value);
     case "Not":
-      return FromNot5(schema_, references_, path13, value);
+      return FromNot5(schema_, references_, path14, value);
     case "Object":
-      return FromObject15(schema_, references_, path13, value);
+      return FromObject15(schema_, references_, path14, value);
     case "Record":
-      return FromRecord10(schema_, references_, path13, value);
+      return FromRecord10(schema_, references_, path14, value);
     case "Ref":
-      return FromRef11(schema_, references_, path13, value);
+      return FromRef11(schema_, references_, path14, value);
     case "Symbol":
-      return Default3(schema_, path13, value);
+      return Default3(schema_, path14, value);
     case "This":
-      return FromThis7(schema_, references_, path13, value);
+      return FromThis7(schema_, references_, path14, value);
     case "Tuple":
-      return FromTuple12(schema_, references_, path13, value);
+      return FromTuple12(schema_, references_, path14, value);
     case "Union":
-      return FromUnion17(schema_, references_, path13, value);
+      return FromUnion17(schema_, references_, path14, value);
     default:
-      return Default3(schema_, path13, value);
+      return Default3(schema_, path14, value);
   }
 }
 function TransformDecode(schema, references, value) {
@@ -7956,33 +7956,33 @@ var TransformEncodeCheckError = class extends TypeBoxError {
   }
 };
 var TransformEncodeError = class extends TypeBoxError {
-  constructor(schema, path13, value, error) {
+  constructor(schema, path14, value, error) {
     super(`${error instanceof Error ? error.message : "Unknown error"}`);
     this.schema = schema;
-    this.path = path13;
+    this.path = path14;
     this.value = value;
     this.error = error;
   }
 };
-function Default4(schema, path13, value) {
+function Default4(schema, path14, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
-    throw new TransformEncodeError(schema, path13, value, error);
+    throw new TransformEncodeError(schema, path14, value, error);
   }
 }
-function FromArray15(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
-  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path13}/${index}`, value2)) : defaulted;
+function FromArray15(schema, references, path14, value) {
+  const defaulted = Default4(schema, path14, value);
+  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path14}/${index}`, value2)) : defaulted;
 }
-function FromImport8(schema, references, path13, value) {
+function FromImport8(schema, references, path14, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Default4(schema, path13, value);
-  return Visit12(target, [...references, ...additional], path13, result);
+  const result = Default4(schema, path14, value);
+  return Visit12(target, [...references, ...additional], path14, result);
 }
-function FromIntersect16(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromIntersect16(schema, references, path14, value) {
+  const defaulted = Default4(schema, path14, value);
   if (!IsObject2(value) || IsValueType(value))
     return defaulted;
   const knownEntries = KeyOfPropertyEntries(schema);
@@ -7990,7 +7990,7 @@ function FromIntersect16(schema, references, path13, value) {
   const knownProperties = { ...defaulted };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit12(knownSchema, references, `${path13}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit12(knownSchema, references, `${path14}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return knownProperties;
@@ -8000,15 +8000,15 @@ function FromIntersect16(schema, references, path13, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(unevaluatedProperties, `${path13}/${key}`, properties[key]);
+      properties[key] = Default4(unevaluatedProperties, `${path14}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot6(schema, references, path13, value) {
-  return Default4(schema.not, path13, Default4(schema, path13, value));
+function FromNot6(schema, references, path14, value) {
+  return Default4(schema.not, path14, Default4(schema, path14, value));
 }
-function FromObject16(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromObject16(schema, references, path14, value) {
+  const defaulted = Default4(schema, path14, value);
   if (!IsObject2(defaulted))
     return defaulted;
   const knownKeys = KeyOfPropertyKeys(schema);
@@ -8018,7 +8018,7 @@ function FromObject16(schema, references, path13, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit12(schema.properties[key], references, `${path13}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit12(schema.properties[key], references, `${path14}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8028,12 +8028,12 @@ function FromObject16(schema, references, path13, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(additionalProperties, `${path13}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord11(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromRecord11(schema, references, path14, value) {
+  const defaulted = Default4(schema, path14, value);
   if (!IsObject2(value))
     return defaulted;
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -8041,7 +8041,7 @@ function FromRecord11(schema, references, path13, value) {
   const knownProperties = { ...defaulted };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path13}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path14}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -8051,65 +8051,65 @@ function FromRecord11(schema, references, path13, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      properties[key] = Default4(additionalProperties, `${path13}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef12(schema, references, path13, value) {
+function FromRef12(schema, references, path14, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path13, value);
-  return Default4(schema, path13, resolved);
+  const resolved = Visit12(target, references, path14, value);
+  return Default4(schema, path14, resolved);
 }
-function FromThis8(schema, references, path13, value) {
+function FromThis8(schema, references, path14, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path13, value);
-  return Default4(schema, path13, resolved);
+  const resolved = Visit12(target, references, path14, value);
+  return Default4(schema, path14, resolved);
 }
-function FromTuple13(schema, references, path13, value) {
-  const value1 = Default4(schema, path13, value);
-  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path13}/${index}`, value1[index])) : [];
+function FromTuple13(schema, references, path14, value) {
+  const value1 = Default4(schema, path14, value);
+  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path14}/${index}`, value1[index])) : [];
 }
-function FromUnion18(schema, references, path13, value) {
+function FromUnion18(schema, references, path14, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const value1 = Visit12(subschema, references, path13, value);
-    return Default4(schema, path13, value1);
+    const value1 = Visit12(subschema, references, path14, value);
+    return Default4(schema, path14, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit12(subschema, references, path13, value);
+    const value1 = Visit12(subschema, references, path14, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default4(schema, path13, value1);
+    return Default4(schema, path14, value1);
   }
-  return Default4(schema, path13, value);
+  return Default4(schema, path14, value);
 }
-function Visit12(schema, references, path13, value) {
+function Visit12(schema, references, path14, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray15(schema_, references_, path13, value);
+      return FromArray15(schema_, references_, path14, value);
     case "Import":
-      return FromImport8(schema_, references_, path13, value);
+      return FromImport8(schema_, references_, path14, value);
     case "Intersect":
-      return FromIntersect16(schema_, references_, path13, value);
+      return FromIntersect16(schema_, references_, path14, value);
     case "Not":
-      return FromNot6(schema_, references_, path13, value);
+      return FromNot6(schema_, references_, path14, value);
     case "Object":
-      return FromObject16(schema_, references_, path13, value);
+      return FromObject16(schema_, references_, path14, value);
     case "Record":
-      return FromRecord11(schema_, references_, path13, value);
+      return FromRecord11(schema_, references_, path14, value);
     case "Ref":
-      return FromRef12(schema_, references_, path13, value);
+      return FromRef12(schema_, references_, path14, value);
     case "This":
-      return FromThis8(schema_, references_, path13, value);
+      return FromThis8(schema_, references_, path14, value);
     case "Tuple":
-      return FromTuple13(schema_, references_, path13, value);
+      return FromTuple13(schema_, references_, path14, value);
     case "Union":
-      return FromUnion18(schema_, references_, path13, value);
+      return FromUnion18(schema_, references_, path14, value);
     default:
-      return Default4(schema_, path13, value);
+      return Default4(schema_, path14, value);
   }
 }
 function TransformEncode(schema, references, value) {
@@ -8377,18 +8377,18 @@ __export(pointer_exports, {
   ValuePointerRootSetError: () => ValuePointerRootSetError
 });
 var ValuePointerRootSetError = class extends TypeBoxError {
-  constructor(value, path13, update) {
+  constructor(value, path14, update) {
     super("Cannot set root value");
     this.value = value;
-    this.path = path13;
+    this.path = path14;
     this.update = update;
   }
 };
 var ValuePointerRootDeleteError = class extends TypeBoxError {
-  constructor(value, path13) {
+  constructor(value, path14) {
     super("Cannot delete root value");
     this.value = value;
-    this.path = path13;
+    this.path = path14;
   }
 };
 function Escape2(component) {
@@ -8532,82 +8532,82 @@ var ValueDiffError = class extends TypeBoxError {
     this.value = value;
   }
 };
-function CreateUpdate(path13, value) {
-  return { type: "update", path: path13, value };
+function CreateUpdate(path14, value) {
+  return { type: "update", path: path14, value };
 }
-function CreateInsert(path13, value) {
-  return { type: "insert", path: path13, value };
+function CreateInsert(path14, value) {
+  return { type: "insert", path: path14, value };
 }
-function CreateDelete(path13) {
-  return { type: "delete", path: path13 };
+function CreateDelete(path14) {
+  return { type: "delete", path: path14 };
 }
 function AssertDiffable(value) {
   if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
     throw new ValueDiffError(value, "Cannot diff objects with symbols");
 }
-function* ObjectType4(path13, current, next) {
+function* ObjectType4(path14, current, next) {
   AssertDiffable(current);
   AssertDiffable(next);
   if (!IsStandardObject(next))
-    return yield CreateUpdate(path13, next);
+    return yield CreateUpdate(path14, next);
   const currentKeys = globalThis.Object.getOwnPropertyNames(current);
   const nextKeys = globalThis.Object.getOwnPropertyNames(next);
   for (const key of nextKeys) {
     if (HasPropertyKey2(current, key))
       continue;
-    yield CreateInsert(`${path13}/${key}`, next[key]);
+    yield CreateInsert(`${path14}/${key}`, next[key]);
   }
   for (const key of currentKeys) {
     if (!HasPropertyKey2(next, key))
       continue;
     if (Equal(current, next))
       continue;
-    yield* Visit15(`${path13}/${key}`, current[key], next[key]);
+    yield* Visit15(`${path14}/${key}`, current[key], next[key]);
   }
   for (const key of currentKeys) {
     if (HasPropertyKey2(next, key))
       continue;
-    yield CreateDelete(`${path13}/${key}`);
+    yield CreateDelete(`${path14}/${key}`);
   }
 }
-function* ArrayType4(path13, current, next) {
+function* ArrayType4(path14, current, next) {
   if (!IsArray2(next))
-    return yield CreateUpdate(path13, next);
+    return yield CreateUpdate(path14, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path14}/${i}`, current[i], next[i]);
   }
   for (let i = 0; i < next.length; i++) {
     if (i < current.length)
       continue;
-    yield CreateInsert(`${path13}/${i}`, next[i]);
+    yield CreateInsert(`${path14}/${i}`, next[i]);
   }
   for (let i = current.length - 1; i >= 0; i--) {
     if (i < next.length)
       continue;
-    yield CreateDelete(`${path13}/${i}`);
+    yield CreateDelete(`${path14}/${i}`);
   }
 }
-function* TypedArrayType2(path13, current, next) {
+function* TypedArrayType2(path14, current, next) {
   if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-    return yield CreateUpdate(path13, next);
+    return yield CreateUpdate(path14, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path14}/${i}`, current[i], next[i]);
   }
 }
-function* ValueType2(path13, current, next) {
+function* ValueType2(path14, current, next) {
   if (current === next)
     return;
-  yield CreateUpdate(path13, next);
+  yield CreateUpdate(path14, next);
 }
-function* Visit15(path13, current, next) {
+function* Visit15(path14, current, next) {
   if (IsStandardObject(current))
-    return yield* ObjectType4(path13, current, next);
+    return yield* ObjectType4(path14, current, next);
   if (IsArray2(current))
-    return yield* ArrayType4(path13, current, next);
+    return yield* ArrayType4(path14, current, next);
   if (IsTypedArray(current))
-    return yield* TypedArrayType2(path13, current, next);
+    return yield* TypedArrayType2(path14, current, next);
   if (IsValueType(current))
-    return yield* ValueType2(path13, current, next);
+    return yield* ValueType2(path14, current, next);
   throw new ValueDiffError(current, "Unable to diff value");
 }
 function Diff(current, next) {
@@ -8664,9 +8664,9 @@ var ValueMutateError = class extends TypeBoxError {
     super(message);
   }
 };
-function ObjectType5(root, path13, current, next) {
+function ObjectType5(root, path14, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path13, Clone2(next));
+    pointer_exports.Set(root, path14, Clone2(next));
   } else {
     const currentKeys = Object.getOwnPropertyNames(current);
     const nextKeys = Object.getOwnPropertyNames(next);
@@ -8681,43 +8681,43 @@ function ObjectType5(root, path13, current, next) {
       }
     }
     for (const nextKey of nextKeys) {
-      Visit16(root, `${path13}/${nextKey}`, current[nextKey], next[nextKey]);
+      Visit16(root, `${path14}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
-function ArrayType5(root, path13, current, next) {
+function ArrayType5(root, path14, current, next) {
   if (!IsArray2(current)) {
-    pointer_exports.Set(root, path13, Clone2(next));
+    pointer_exports.Set(root, path14, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path13}/${index}`, current[index], next[index]);
+      Visit16(root, `${path14}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
-function TypedArrayType3(root, path13, current, next) {
+function TypedArrayType3(root, path14, current, next) {
   if (IsTypedArray(current) && current.length === next.length) {
     for (let i = 0; i < current.length; i++) {
       current[i] = next[i];
     }
   } else {
-    pointer_exports.Set(root, path13, Clone2(next));
+    pointer_exports.Set(root, path14, Clone2(next));
   }
 }
-function ValueType3(root, path13, current, next) {
+function ValueType3(root, path14, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path13, next);
+  pointer_exports.Set(root, path14, next);
 }
-function Visit16(root, path13, current, next) {
+function Visit16(root, path14, current, next) {
   if (IsArray2(next))
-    return ArrayType5(root, path13, current, next);
+    return ArrayType5(root, path14, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path13, current, next);
+    return TypedArrayType3(root, path14, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path13, current, next);
+    return ObjectType5(root, path14, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path13, current, next);
+    return ValueType3(root, path14, current, next);
 }
 function IsNonMutableValue(value) {
   return IsTypedArray(value) || IsValueType(value);
@@ -8815,8 +8815,8 @@ __export(value_exports2, {
 });
 
 // src/lib/types.ts
-var CURRENT_REGISTRY_VERSION = 2;
-var CAPSULE_VERSION = 1;
+var CURRENT_REGISTRY_VERSION = 3;
+var CAPSULE_VERSION = 2;
 var MAX_POST_ERROR_LENGTH = 500;
 var MAX_NAME_LENGTH = 100;
 var DOCTOR_ALL_COOLDOWN_MS = 60 * 60 * 1e3;
@@ -8861,6 +8861,7 @@ var RegistrySchema = Type.Object({
   topicManagerAdmins: Type.Array(Type.String()),
   callbackSecret: Type.String(),
   lastDoctorAllRunAt: Type.Union([Type.String(), Type.Null()]),
+  autopilotEnabled: Type.Boolean(),
   maxTopics: Type.Integer({ minimum: 1 }),
   topics: Type.Record(Type.String(), TopicEntrySchema)
 });
@@ -8877,7 +8878,8 @@ var BASE_FILES = [
   "COMMANDS.md",
   "LINKS.md",
   "CRON.md",
-  "NOTES.md"
+  "NOTES.md",
+  "LEARNINGS.md"
 ];
 function topicKey(groupId, threadId) {
   return `${groupId}:${threadId}`;
@@ -8908,6 +8910,12 @@ var migrations = {
       }
     }
     return data;
+  },
+  "2_to_3": (data) => {
+    if (data["autopilotEnabled"] === void 0) {
+      data["autopilotEnabled"] = false;
+    }
+    return data;
   }
 };
 function migrateRegistry(data) {
@@ -9055,21 +9063,21 @@ function validateGroupId(id) {
 function validateThreadId(id) {
   return THREAD_ID_RE.test(id);
 }
-var CALLBACK_RE = /^tm:[a-z0-9]+:-?\d+:\d+:[a-f0-9]+$/;
-function buildCallbackData(action, groupId, threadId, secret) {
-  const payload = `tm:${action}:${groupId}:${threadId}`;
+var CALLBACK_RE = /^tm:[a-z0-9]+:-?\d+:\d+:\d+:[a-f0-9]+$/;
+function buildCallbackData(action, groupId, threadId, secret, userId) {
+  const payload = `tm:${action}:${groupId}:${threadId}:${userId}`;
   const sig = hmacSign(secret, payload);
   return `${payload}:${sig}`;
 }
 function parseAndVerifyCallback(data, secret, contextGroupId, contextThreadId) {
   if (!CALLBACK_RE.test(data)) return null;
   const parts = data.split(":");
-  if (parts.length !== 5) return null;
-  const [, action, groupId, threadId, signature] = parts;
+  if (parts.length !== 6) return null;
+  const [, action, groupId, threadId, userId, signature] = parts;
   if (groupId !== contextGroupId || threadId !== contextThreadId) return null;
-  const payload = `tm:${action}:${groupId}:${threadId}`;
+  const payload = `tm:${action}:${groupId}:${threadId}:${userId}`;
   if (!hmacVerify(secret, payload, signature)) return null;
-  return { action, groupId, threadId };
+  return { action, groupId, threadId, userId };
 }
 
 // src/lib/audit.ts
@@ -9098,62 +9106,6 @@ function buildAuditEntry(userId, cmd, slug, detail) {
   };
 }
 
-// src/commands/init.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
-
-// src/lib/auth.ts
-var AuthTier = {
-  User: "User",
-  Admin: "Admin"
-};
-var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
-  "doctor --all",
-  "doctor-all",
-  "list",
-  "sync",
-  "rename",
-  "archive",
-  "unarchive"
-]);
-var USER_COMMANDS = /* @__PURE__ */ new Set([
-  "init",
-  "doctor",
-  "status",
-  "help",
-  "upgrade",
-  "snooze"
-]);
-function getCommandTier(command) {
-  const normalized = command.toLowerCase().trim();
-  if (USER_COMMANDS.has(normalized)) return AuthTier.User;
-  if (ADMIN_COMMANDS.has(normalized)) return AuthTier.Admin;
-  return AuthTier.Admin;
-}
-function checkAuthorization(userId, command, registry, topicAllowFrom) {
-  const tier = getCommandTier(command);
-  const admins = registry.topicManagerAdmins;
-  if (admins.length === 0 && tier === AuthTier.User) {
-    return { authorized: true };
-  }
-  const isAdmin = admins.includes(userId);
-  if (tier === AuthTier.Admin) {
-    if (isAdmin) return { authorized: true };
-    return {
-      authorized: false,
-      message: "Not authorized. Ask a telegram-manager admin to run this command."
-    };
-  }
-  if (isAdmin) return { authorized: true };
-  if (topicAllowFrom && topicAllowFrom.includes(userId)) {
-    return { authorized: true };
-  }
-  return {
-    authorized: false,
-    message: "Not authorized. Ask a telegram-manager admin to run this command."
-  };
-}
-
 // src/lib/capsule.ts
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
@@ -9164,25 +9116,27 @@ _Describe what this topic is about._
 `,
   "STATUS.md": (name) => `# Status: ${name}
 
+> This file is maintained by the agent \u2014 just send messages in the chat.
+
 ## Last done (UTC)
 
 ${(/* @__PURE__ */ new Date()).toISOString()}
 
-_No work recorded yet._
+_Waiting for first instructions._
 
 ## Next 3 actions
 
-1. [T-1] _Define first task in TODO.md_
-2. [T-2] _Define second task in TODO.md_
-3. [T-3] _Define third task in TODO.md_
+1. [T-1] _e.g. Set up project scaffolding_
+2. [T-2] _Waiting for next task_
+3. [T-3] _Waiting for next task_
 `,
   "TODO.md": (name) => `# TODO: ${name}
 
 ## Backlog
 
-- [T-1] _First task placeholder \u2014 replace with actual task_
-- [T-2] _Second task placeholder \u2014 replace with actual task_
-- [T-3] _Third task placeholder \u2014 replace with actual task_
+- [T-1] _e.g. Set up project scaffolding_
+- [T-2] _Waiting for next task_
+- [T-3] _Waiting for next task_
 
 ## Completed
 
@@ -9203,6 +9157,11 @@ _Cron job IDs and schedules for this topic._
   "NOTES.md": (name) => `# Notes: ${name}
 
 _Anything worth remembering about this topic._
+`,
+  "LEARNINGS.md": (name) => `# Learnings: ${name}
+
+_Hard-won insights, mistakes, and workarounds._
+_Agent prepends here automatically. Most recent entries first._
 `
 };
 var OVERLAY_TEMPLATES = {
@@ -9297,13 +9256,74 @@ function upgradeCapsule(projectsBase, slug, name, type, currentVersion) {
   };
 }
 
+// src/commands/init.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+
+// src/lib/auth.ts
+var AuthTier = {
+  User: "User",
+  Admin: "Admin"
+};
+var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
+  "doctor --all",
+  "doctor-all",
+  "list",
+  "sync",
+  "rename",
+  "archive",
+  "unarchive",
+  "autopilot"
+]);
+var USER_COMMANDS = /* @__PURE__ */ new Set([
+  "init",
+  "doctor",
+  "status",
+  "help",
+  "upgrade",
+  "snooze"
+]);
+function getCommandTier(command) {
+  const normalized = command.toLowerCase().trim();
+  if (USER_COMMANDS.has(normalized)) return AuthTier.User;
+  if (ADMIN_COMMANDS.has(normalized)) return AuthTier.Admin;
+  return AuthTier.Admin;
+}
+function checkAuthorization(userId, command, registry, topicAllowFrom) {
+  const tier = getCommandTier(command);
+  const admins = registry.topicManagerAdmins;
+  if (admins.length === 0 && tier === AuthTier.User) {
+    return { authorized: true };
+  }
+  const isAdmin = admins.includes(userId);
+  if (tier === AuthTier.Admin) {
+    if (isAdmin) return { authorized: true };
+    return {
+      authorized: false,
+      message: "Not authorized. Ask a telegram-manager admin to run this command."
+    };
+  }
+  if (isAdmin) return { authorized: true };
+  if (topicAllowFrom && topicAllowFrom.includes(userId)) {
+    return { authorized: true };
+  }
+  return {
+    authorized: false,
+    message: "Not authorized. Ask a telegram-manager admin to run this command."
+  };
+}
+
 // src/lib/telegram.ts
 var TELEGRAM_MSG_LIMIT = 4096;
+var DEFAULT_RATE_LIMIT = {
+  sameGroupDelayMs: 4e3,
+  crossGroupDelayMs: 1e3
+};
 function buildInlineKeyboard(rows) {
   return { inline_keyboard: rows };
 }
-function buildDoctorButtons(groupId, threadId, secret) {
-  const cb = (action) => buildCallbackData(action, groupId, threadId, secret);
+function buildDoctorButtons(groupId, threadId, secret, userId) {
+  const cb = (action) => buildCallbackData(action, groupId, threadId, secret, userId);
   return buildInlineKeyboard([
     [
       { text: "Fix", callback_data: cb("fix") },
@@ -9316,8 +9336,8 @@ function buildDoctorButtons(groupId, threadId, secret) {
     ]
   ]);
 }
-function buildInitTypeButtons(groupId, threadId, secret) {
-  const cb = (action) => buildCallbackData(action, groupId, threadId, secret);
+function buildInitTypeButtons(groupId, threadId, secret, userId) {
+  const cb = (action) => buildCallbackData(action, groupId, threadId, secret, userId);
   return buildInlineKeyboard([
     [
       { text: "Coding", callback_data: cb("ic") },
@@ -9329,6 +9349,16 @@ function buildInitTypeButtons(groupId, threadId, secret) {
     ]
   ]);
 }
+function buildInitConfirmButton(groupId, threadId, secret, userId, type) {
+  const actionMap = {
+    coding: "yc",
+    research: "yr",
+    marketing: "ym",
+    custom: "yx"
+  };
+  const cb = buildCallbackData(actionMap[type], groupId, threadId, secret, userId);
+  return buildInlineKeyboard([[{ text: "Confirm", callback_data: cb }]]);
+}
 function buildTopicCard(name, slug, type, capsuleVersion) {
   const n = htmlEscape(name);
   const s = htmlEscape(slug);
@@ -9339,13 +9369,20 @@ function buildTopicCard(name, slug, type, capsuleVersion) {
     `Type: ${t} | Version: ${v}`,
     `Capsule: projects/${s}/`,
     "",
+    "<b>How it works</b>",
+    "Just send your instructions in this topic. The agent",
+    "maintains STATUS.md and TODO.md automatically as it",
+    "works \u2014 nothing is lost on reset or context compaction.",
+    "Doctor checks run periodically and alert you if anything",
+    "needs attention.",
+    "",
     "<b>Commands:</b>",
-    "/tm doctor \u2014 health checks",
-    "/tm status \u2014 quick view",
-    "/tm sync \u2014 re-apply config",
+    "/tm status \u2014 quick STATUS.md view",
+    "/tm doctor \u2014 run health checks",
+    "/tm rename &lt;name&gt; \u2014 rename this topic",
     "/tm list \u2014 all topics",
     "/tm archive \u2014 archive this topic",
-    "/tm help \u2014 command reference"
+    "/tm help \u2014 full command reference"
   ].join("\n");
 }
 function buildDoctorReport(name, results) {
@@ -9385,16 +9422,17 @@ function buildHelpCard() {
     "<b>Topic Manager Commands</b>",
     "",
     "/tm init \u2014 register this topic",
+    "/tm status \u2014 quick STATUS.md view",
     "/tm doctor \u2014 run health checks",
     "/tm doctor --all \u2014 check all topics",
-    "/tm status \u2014 quick STATUS.md view",
-    "/tm list \u2014 show all topics",
+    "/tm rename &lt;name&gt; \u2014 rename this topic",
+    "/tm list \u2014 all topics",
     "/tm sync \u2014 re-apply config",
-    "/tm rename &lt;name&gt; \u2014 rename topic",
     "/tm upgrade \u2014 update capsule template",
     "/tm snooze &lt;Nd&gt; \u2014 snooze doctor (7d, 30d, etc.)",
     "/tm archive \u2014 archive topic",
     "/tm unarchive \u2014 reactivate topic",
+    "/tm autopilot [enable|disable|status] \u2014 daily sweeps",
     "/tm help \u2014 this message"
   ].join("\n");
 }
@@ -9436,6 +9474,48 @@ function relativeTime(iso) {
   const days = Math.floor(hours / 24);
   return `${days}d ago`;
 }
+function createRateLimitedPoster(postFn, config = DEFAULT_RATE_LIMIT) {
+  let lastPostTime = 0;
+  let lastGroupId = "";
+  return async (groupId, threadId, text, keyboard) => {
+    const now = Date.now();
+    const delay = groupId === lastGroupId ? config.sameGroupDelayMs : config.crossGroupDelayMs;
+    const elapsed = now - lastPostTime;
+    if (elapsed < delay) {
+      await sleep(delay - elapsed);
+    }
+    try {
+      await postFn(groupId, threadId, text, keyboard);
+    } catch (err) {
+      if (isTooManyRequestsError(err)) {
+        const retryAfter = getRetryAfter(err);
+        await sleep(retryAfter * 1e3);
+        await postFn(groupId, threadId, text, keyboard);
+      } else {
+        throw err;
+      }
+    }
+    lastPostTime = Date.now();
+    lastGroupId = groupId;
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+function isTooManyRequestsError(err) {
+  if (err && typeof err === "object" && "status" in err) {
+    const status = err["status"];
+    return typeof status === "number" && status === 429;
+  }
+  return false;
+}
+function getRetryAfter(err) {
+  if (err && typeof err === "object" && "retryAfter" in err) {
+    const val = err.retryAfter;
+    if (typeof val === "number" && val > 0) return val;
+  }
+  return 5;
+}
 function truncateMessage(msg, limit = TELEGRAM_MSG_LIMIT) {
   if (msg.length <= limit) return msg;
   const suffix = "\n\n... (truncated)";
@@ -9460,8 +9540,9 @@ function getSystemPromptTemplate(name, slug, absoluteWorkspacePath) {
 Determinism rules:
 - Source of truth is the project capsule at: ${absoluteWorkspacePath}/projects/${slug}/
 - After /reset, /new, or context compaction: ALWAYS re-read STATUS.md,
-  then TODO.md, then COMMANDS.md before continuing work. Do not rely on
-  summarized memory for paths, commands, or task state.
+  then TODO.md, then LEARNINGS.md (last 20 entries), then COMMANDS.md
+  before continuing work. Do not rely on summarized memory for paths,
+  commands, or task state.
 - Before context compaction or when the conversation is long: proactively
   flush current progress to STATUS.md (update "Last done (UTC)" and
   "Next 3 actions") so compaction cannot erase critical state.
@@ -9472,6 +9553,14 @@ Determinism rules:
 - If automation/cron is involved, record job IDs + schedules in CRON.md.
 - Task IDs (e.g., [T-1]) must stay consistent between STATUS.md and TODO.md.
 
+Learning capture:
+- When you discover something unexpected, a mistake, a workaround, or a
+  constraint \u2014 prepend a dated entry to LEARNINGS.md.
+- Format: ## YYYY-MM-DD\\n- source: (chat/debug/research)\\n- insight text
+- Most recent first (prepend after the header, before existing entries).
+- Only write when a genuinely new insight exists \u2014 avoid restating known facts.
+- If LEARNINGS.md exceeds ~200 lines, archive older entries to LEARNINGS-archive.md.
+
 Separation:
 - Do not mix in other topics' work unless explicitly requested.
 - Ask one clarifying question if the next action is ambiguous.`;
@@ -9627,7 +9716,7 @@ async function triggerRestart(rpc, logger) {
         logger.warn(
           `config.patch baseHash mismatch (attempt ${attempt + 1}/${MAX_RETRIES + 1}). Retrying in ${delay}ms...`
         );
-        await sleep(delay);
+        await sleep2(delay);
         continue;
       }
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -9655,8 +9744,8 @@ function isHashMismatchError(err) {
   }
   return false;
 }
-function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+function sleep2(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 async function getConfigWrites(rpc) {
   if (!rpc) return false;
@@ -9673,6 +9762,21 @@ async function getConfigWrites(rpc) {
 
 // src/commands/init.ts
 var VALID_TYPES = /* @__PURE__ */ new Set(["coding", "research", "marketing", "custom"]);
+function deriveTopicName(nameArg, messageContext, threadId) {
+  const topicTitle = messageContext?.["topicTitle"] ?? "";
+  let name;
+  if (nameArg) {
+    name = nameArg;
+  } else if (topicTitle) {
+    name = topicTitle;
+  } else {
+    name = `Topic ${threadId}`;
+  }
+  if (name.length > MAX_NAME_LENGTH) {
+    name = name.slice(0, MAX_NAME_LENGTH);
+  }
+  return name;
+}
 async function handleInit(ctx, args) {
   const { workspaceDir, configDir, userId, groupId, threadId, rpc, logger, messageContext } = ctx;
   if (!userId || !groupId || !threadId) {
@@ -9711,18 +9815,7 @@ async function handleInit(ctx, args) {
   } else {
     nameArg = parts.join(" ");
   }
-  const topicTitle = messageContext?.["topicTitle"] ?? "";
-  let name;
-  if (nameArg) {
-    name = nameArg;
-  } else if (topicTitle) {
-    name = topicTitle;
-  } else {
-    name = `Topic ${threadId}`;
-  }
-  if (name.length > MAX_NAME_LENGTH) {
-    name = name.slice(0, MAX_NAME_LENGTH);
-  }
+  const name = deriveTopicName(nameArg, messageContext, threadId);
   const existingSlugs = new Set(Object.values(registry.topics).map((t) => t.slug));
   const finalSlug = generateSlug(threadId, groupId, existingSlugs);
   const projectsBase = path6.join(workspaceDir, "projects");
@@ -9794,8 +9887,9 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   if (isFirstUser) {
     adminNote = "\n\nYou are the first user and have been added as a telegram-manager admin.";
   }
+  const autopilotTip = "\n\nTip: Enable daily health sweeps with /tm autopilot enable";
   return {
-    text: `${topicCard}${adminNote}${restartMsg}`,
+    text: `${topicCard}${adminNote}${restartMsg}${autopilotTip}`,
     parseMode: "HTML",
     pin: true
   };
@@ -9833,7 +9927,7 @@ async function buildTypePicker(ctx) {
       parseMode: "HTML"
     };
   }
-  const keyboard = buildInitTypeButtons(groupId, threadId, registry.callbackSecret);
+  const keyboard = buildInitTypeButtons(groupId, threadId, registry.callbackSecret, userId);
   return {
     text: "Pick a topic type:",
     parseMode: "HTML",
@@ -9841,14 +9935,57 @@ async function buildTypePicker(ctx) {
   };
 }
 async function handleInitTypeSelect(ctx, type) {
+  const { workspaceDir, userId, groupId, threadId, messageContext } = ctx;
+  if (!userId || !groupId || !threadId) {
+    return { text: "Missing context: groupId, threadId, or userId not available. Run this command inside a Telegram forum topic." };
+  }
+  if (!validateGroupId(groupId)) {
+    return { text: "Invalid groupId format." };
+  }
+  if (!validateThreadId(threadId)) {
+    return { text: "Invalid threadId format." };
+  }
+  const registry = readRegistry(workspaceDir);
+  const auth = checkAuthorization(userId, "init", registry);
+  if (!auth.authorized) {
+    return { text: auth.message ?? "Not authorized." };
+  }
+  const topicCount = Object.keys(registry.topics).length;
+  if (topicCount >= registry.maxTopics) {
+    return { text: `Maximum number of topics (${registry.maxTopics}) reached. Archive or remove existing topics first.` };
+  }
+  const key = topicKey(groupId, threadId);
+  if (registry.topics[key]) {
+    return {
+      text: `This topic is already registered as <b>${htmlEscape(registry.topics[key].name)}</b>.`,
+      parseMode: "HTML"
+    };
+  }
+  const name = deriveTopicName("", messageContext, threadId);
+  const keyboard = buildInitConfirmButton(groupId, threadId, registry.callbackSecret, userId, type);
+  return {
+    text: buildInitConfirmMessage(name, type),
+    parseMode: "HTML",
+    inlineKeyboard: keyboard
+  };
+}
+async function handleInitNameConfirm(ctx, type) {
   return handleInit(ctx, type);
 }
+function buildInitConfirmMessage(name, type) {
+  return [
+    `Name: <b>${htmlEscape(name)}</b> | Type: ${htmlEscape(type)}`,
+    "",
+    `To use a different name: /tm init &lt;name&gt; ${htmlEscape(type)}`
+  ].join("\n");
+}
 
 // src/commands/doctor.ts
 import * as fs8 from "node:fs";
 import * as path8 from "node:path";
 
 // src/lib/doctor-checks.ts
+var import_json52 = __toESM(require_lib(), 1);
 import * as fs7 from "node:fs";
 import * as path7 from "node:path";
 function isIgnored(entry, checkId) {
@@ -9913,7 +10050,7 @@ function runCapsuleChecks(entry, projectsBase) {
         check(
           Severity.INFO,
           "capsuleVersionBehind",
-          `Capsule version ${entry.capsuleVersion} is behind current ${CAPSULE_VERSION}. Run /tm upgrade.`,
+          `Capsule version ${entry.capsuleVersion} is behind current ${CAPSULE_VERSION}. Will auto-upgrade on next command.`,
           false
         )
       );
@@ -10083,8 +10220,7 @@ function runConfigChecks(entry, includeContent, registry) {
   const results = [];
   let includeObj;
   try {
-    const stripped = includeContent.split("\n").filter((l) => !l.startsWith("//")).join("\n");
-    includeObj = JSON.parse(stripped);
+    includeObj = import_json52.default.parse(includeContent);
   } catch {
     return results;
   }
@@ -10203,6 +10339,7 @@ function readCapsuleFiles(capsuleDir) {
     "CRON.md",
     "NOTES.md",
     "README.md",
+    "LEARNINGS.md",
     "ARCHITECTURE.md",
     "DEPLOY.md",
     "SOURCES.md",
@@ -10266,7 +10403,8 @@ async function handleDoctor(ctx) {
   const keyboard = buildDoctorButtons(
     groupId,
     threadId,
-    registry.callbackSecret
+    registry.callbackSecret,
+    userId
   );
   const textCommands = [
     "",
@@ -10349,7 +10487,8 @@ async function handleDoctorAll(ctx) {
       const keyboard = buildDoctorButtons(
         entry.groupId,
         entry.threadId,
-        registry.callbackSecret
+        registry.callbackSecret,
+        userId
       );
       reports.push({
         slug: entry.slug,
@@ -10384,6 +10523,36 @@ async function handleDoctorAll(ctx) {
       migrationGroups.push(gid);
     }
   }
+  let postErrors = 0;
+  let postSuccesses = 0;
+  if (ctx.postFn && reports.length > 0) {
+    const rateLimitedPost = createRateLimitedPoster(ctx.postFn);
+    for (const report of reports) {
+      try {
+        await rateLimitedPost(report.groupId, report.threadId, report.text, report.keyboard);
+        postSuccesses++;
+        await withRegistry(workspaceDir, (data) => {
+          const key = `${report.groupId}:${report.threadId}`;
+          const entry = data.topics[key];
+          if (entry) {
+            entry.lastDoctorReportAt = now.toISOString();
+            entry.lastPostError = null;
+          }
+        });
+      } catch (err) {
+        postErrors++;
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`[doctor-all] Post failed for ${report.slug}: ${msg}`);
+        await withRegistry(workspaceDir, (data) => {
+          const key = `${report.groupId}:${report.threadId}`;
+          const entry = data.topics[key];
+          if (entry) {
+            entry.lastPostError = msg.slice(0, MAX_POST_ERROR_LENGTH);
+          }
+        });
+      }
+    }
+  }
   await withRegistry(workspaceDir, (data) => {
     data.lastDoctorAllRunAt = now.toISOString();
     for (const [_key, entry] of Object.entries(data.topics)) {
@@ -10400,6 +10569,9 @@ async function handleDoctorAll(ctx) {
         entry.consecutiveSilentDoctors++;
       }
       entry.lastDoctorRunAt = now.toISOString();
+      if (!ctx.postFn) {
+        entry.lastDoctorReportAt = now.toISOString();
+      }
       if (entry.consecutiveSilentDoctors >= SPAM_THRESHOLD) {
         entry.snoozeUntil = new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString();
         entry.status = "snoozed";
@@ -10414,6 +10586,9 @@ async function handleDoctorAll(ctx) {
     `Skipped (ineligible): ${skipped}`,
     `Total: ${allEntries.length}`
   ];
+  if (ctx.postFn) {
+    lines.push(`Posted: ${postSuccesses}, Post failures: ${postErrors}`);
+  }
   if (errors.length > 0) {
     lines.push("");
     lines.push(`<b>Errors (${errors.length}):</b>`);
@@ -10764,6 +10939,118 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   };
 }
 
+// src/commands/autopilot.ts
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
+var MARKER_START = "<!-- TM_AUTOPILOT_START -->";
+var MARKER_END = "<!-- TM_AUTOPILOT_END -->";
+var HEARTBEAT_BLOCK = `${MARKER_START}
+## Topic Manager Daily Sweep
+- [ ] If 24+ hours since the last topic sweep (check \`lastDoctorAllRunAt\` in
+      {workspace}/projects/topics.json), call \`topic_manager\` with command
+      "doctor --all" to health-check all active topics.
+${MARKER_END}`;
+var HEARTBEAT_FILENAME = "HEARTBEAT.md";
+async function handleAutopilot(ctx, args) {
+  const { workspaceDir, userId } = ctx;
+  if (!userId) {
+    return { text: "Missing context: userId not available." };
+  }
+  const registry = readRegistry(workspaceDir);
+  const auth = checkAuthorization(userId, "autopilot", registry);
+  if (!auth.authorized) {
+    return { text: auth.message ?? "Not authorized." };
+  }
+  const subCommand = args.trim().toLowerCase() || "enable";
+  switch (subCommand) {
+    case "enable":
+      return handleEnable(ctx);
+    case "disable":
+      return handleDisable(ctx);
+    case "status":
+      return handleStatus2(ctx);
+    default:
+      return { text: `Unknown autopilot sub-command: "${htmlEscape(subCommand)}". Use enable, disable, or status.` };
+  }
+}
+async function handleEnable(ctx) {
+  const { workspaceDir } = ctx;
+  const heartbeatPath = path12.join(workspaceDir, HEARTBEAT_FILENAME);
+  const block = HEARTBEAT_BLOCK.replace("{workspace}", path12.resolve(workspaceDir));
+  let content = "";
+  try {
+    if (fs11.existsSync(heartbeatPath)) {
+      content = fs11.readFileSync(heartbeatPath, "utf-8");
+    }
+  } catch {
+  }
+  if (content.includes(MARKER_START)) {
+    await withRegistry(workspaceDir, (data) => {
+      data.autopilotEnabled = true;
+    });
+    return { text: "Autopilot is already enabled." };
+  }
+  const newContent = content ? content.trimEnd() + "\n\n" + block + "\n" : block + "\n";
+  fs11.writeFileSync(heartbeatPath, newContent, { mode: 416 });
+  await withRegistry(workspaceDir, (data) => {
+    data.autopilotEnabled = true;
+  });
+  return {
+    text: "<b>Autopilot enabled.</b>\nDaily health sweeps will run via the OpenClaw heartbeat.",
+    parseMode: "HTML"
+  };
+}
+async function handleDisable(ctx) {
+  const { workspaceDir } = ctx;
+  const heartbeatPath = path12.join(workspaceDir, HEARTBEAT_FILENAME);
+  if (!fs11.existsSync(heartbeatPath)) {
+    await withRegistry(workspaceDir, (data) => {
+      data.autopilotEnabled = false;
+    });
+    return { text: "Autopilot is not enabled (no HEARTBEAT.md found)." };
+  }
+  let content = fs11.readFileSync(heartbeatPath, "utf-8");
+  if (!content.includes(MARKER_START)) {
+    await withRegistry(workspaceDir, (data) => {
+      data.autopilotEnabled = false;
+    });
+    return { text: "Autopilot is not enabled (no marker found in HEARTBEAT.md)." };
+  }
+  const startIdx = content.indexOf(MARKER_START);
+  const endIdx = content.indexOf(MARKER_END);
+  if (startIdx >= 0 && endIdx >= 0) {
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + MARKER_END.length);
+    content = (before + after).replace(/\n{3,}/g, "\n\n").trim();
+    if (content) {
+      fs11.writeFileSync(heartbeatPath, content + "\n", { mode: 416 });
+    } else {
+      fs11.unlinkSync(heartbeatPath);
+    }
+  }
+  await withRegistry(workspaceDir, (data) => {
+    data.autopilotEnabled = false;
+  });
+  return {
+    text: "<b>Autopilot disabled.</b>\nDaily sweeps will no longer run automatically.",
+    parseMode: "HTML"
+  };
+}
+async function handleStatus2(ctx) {
+  const { workspaceDir } = ctx;
+  const registry = readRegistry(workspaceDir);
+  const enabled = registry.autopilotEnabled;
+  const lastRun = registry.lastDoctorAllRunAt ?? "never";
+  const lines = [
+    `<b>Autopilot:</b> ${enabled ? "enabled" : "disabled"}`,
+    `<b>Last doctor-all run:</b> ${htmlEscape(lastRun)}`
+  ];
+  return {
+    text: lines.join("\n"),
+    parseMode: "HTML"
+  };
+}
+
 // src/commands/help.ts
 function handleHelp(_ctx) {
   return {
@@ -10786,6 +11073,29 @@ function createTopicManagerTool(deps) {
         return handleCallback(commandStr, ctx);
       }
       const { subCommand, args, flags } = parseCommand(commandStr);
+      if (ctx.groupId && ctx.threadId) {
+        const key = topicKey(ctx.groupId, ctx.threadId);
+        const projectsBase = `${workspaceDir}/projects`;
+        void withRegistry(workspaceDir, (data) => {
+          const entry = data.topics[key];
+          if (!entry) return;
+          entry.lastMessageAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (entry.capsuleVersion < CAPSULE_VERSION) {
+            const oldVersion = entry.capsuleVersion;
+            try {
+              upgradeCapsule(projectsBase, entry.slug, entry.name, entry.type, entry.capsuleVersion);
+              entry.capsuleVersion = CAPSULE_VERSION;
+              logger.info(`[auto-upgrade] ${entry.slug} v${oldVersion} \u2192 v${CAPSULE_VERSION}`);
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              logger.error(`[auto-upgrade] ${entry.slug} failed: ${msg}`);
+            }
+          }
+        }).catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger.error(`[activity-tracking] Failed: ${msg}`);
+        });
+      }
       try {
         switch (subCommand) {
           case "init":
@@ -10813,6 +11123,8 @@ function createTopicManagerTool(deps) {
             return await handleArchive(ctx);
           case "unarchive":
             return await handleUnarchive(ctx);
+          case "autopilot":
+            return await handleAutopilot(ctx, args);
           case "help":
             return await handleHelp(ctx);
           default:
@@ -10861,7 +11173,8 @@ function buildContext(deps, execContext) {
     groupId: groupId ?? void 0,
     threadId: threadId ?? void 0,
     userId: userId ?? void 0,
-    messageContext: execContext
+    messageContext: execContext,
+    postFn: deps.postFn
   };
 }
 function extractString(obj, key) {
@@ -10881,11 +11194,11 @@ function extractNestedString(obj, ...keys) {
   return String(current);
 }
 async function handleCallback(data, ctx) {
-  const { workspaceDir, userId } = ctx;
+  const { workspaceDir } = ctx;
   const cbParts = data.split(":");
   const cbGroupId = cbParts[2];
   const cbThreadId = cbParts[3];
-  if (!cbGroupId || !cbThreadId || !userId) {
+  if (!cbGroupId || !cbThreadId) {
     return { text: "Cannot verify callback: missing context." };
   }
   const registry = readRegistry(workspaceDir);
@@ -10893,17 +11206,26 @@ async function handleCallback(data, ctx) {
   if (!parsed) {
     return { text: "Invalid or expired callback." };
   }
-  const { action } = parsed;
+  const { action, userId: cbUserId } = parsed;
   const initTypeMap = {
     ic: "coding",
     ir: "research",
     im: "marketing",
     ix: "custom"
   };
-  const cbCtx = { ...ctx, groupId: cbGroupId, threadId: cbThreadId };
+  const initConfirmMap = {
+    yc: "coding",
+    yr: "research",
+    ym: "marketing",
+    yx: "custom"
+  };
+  const cbCtx = { ...ctx, groupId: cbGroupId, threadId: cbThreadId, userId: cbUserId };
   if (action in initTypeMap) {
     return handleInitTypeSelect(cbCtx, initTypeMap[action]);
   }
+  if (action in initConfirmMap) {
+    return handleInitNameConfirm(cbCtx, initConfirmMap[action]);
+  }
   const key = topicKey(cbGroupId, cbThreadId);
   const entry = registry.topics[key];
   if (!entry) {
@@ -10941,40 +11263,71 @@ async function handleCallbackFix(ctx) {
 // src/index.ts
 function resolveConfigDir() {
   const thisFile = new URL(import.meta.url).pathname;
-  const parts = thisFile.split(path12.sep);
+  const parts = thisFile.split(path13.sep);
   const extIndex = parts.lastIndexOf("extensions");
   if (extIndex > 0) {
-    const candidate = parts.slice(0, extIndex).join(path12.sep);
-    if (fs11.existsSync(path12.join(candidate, "openclaw.json")) || fs11.existsSync(path12.join(candidate, "extensions"))) {
+    const candidate = parts.slice(0, extIndex).join(path13.sep);
+    if (fs12.existsSync(path13.join(candidate, "openclaw.json")) || fs12.existsSync(path13.join(candidate, "extensions"))) {
       return candidate;
     }
   }
   const envDir = process.env["OPENCLAW_CONFIG_DIR"];
-  if (envDir && fs11.existsSync(envDir)) return path12.resolve(envDir);
+  if (envDir && fs12.existsSync(envDir)) return path13.resolve(envDir);
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const defaultDir = path12.join(homeDir, ".openclaw");
-  if (fs11.existsSync(defaultDir)) return defaultDir;
+  const defaultDir = path13.join(homeDir, ".openclaw");
+  if (fs12.existsSync(defaultDir)) return defaultDir;
   return void 0;
 }
 function register(api) {
   const resolvedConfigDir = resolveConfigDir();
   const configDir = api.configDir ?? api.pluginConfig?.configDir ?? resolvedConfigDir;
-  const workspaceDir = api.workspaceDir ?? api.pluginConfig?.workspaceDir ?? (resolvedConfigDir ? path12.join(resolvedConfigDir, "workspace") : void 0);
+  const workspaceDir = api.workspaceDir ?? api.pluginConfig?.workspaceDir ?? (resolvedConfigDir ? path13.join(resolvedConfigDir, "workspace") : void 0);
   if (!configDir || !workspaceDir) {
     api.logger.error(
       "telegram-manager: configDir or workspaceDir not available. Plugin cannot initialize."
     );
     return;
   }
+  let resolvedPostFn;
+  const lazyPostFn = async (groupId, threadId, text, keyboard) => {
+    if (resolvedPostFn === null) return;
+    if (resolvedPostFn === void 0) {
+      try {
+        const sdkPath = ["openclaw", "dist", "plugin-sdk", "index.js"].join("/");
+        const sdk = await import(
+          /* @vite-ignore */
+          sdkPath
+        );
+        if (typeof sdk["sendMessageTelegram"] === "function") {
+          const sendMsg = sdk["sendMessageTelegram"];
+          resolvedPostFn = async (gId, tId, txt, kb) => {
+            const opts = {
+              messageThreadId: Number(tId),
+              textMode: "html"
+            };
+            if (kb) opts.buttons = kb.inline_keyboard;
+            await sendMsg(gId, txt, opts);
+          };
+          api.logger.info("telegram-manager: postFn wired via plugin-sdk");
+        } else {
+          resolvedPostFn = null;
+        }
+      } catch {
+        resolvedPostFn = null;
+      }
+    }
+    if (resolvedPostFn) await resolvedPostFn(groupId, threadId, text, keyboard);
+  };
   const tool = createTopicManagerTool({
     logger: api.logger,
     configDir,
     workspaceDir,
-    rpc: api.rpc
+    rpc: api.rpc,
+    postFn: lazyPostFn
   });
   api.registerTool({
     name: "topic_manager",
-    description: "Manage Telegram forum topics as deterministic workcells. Sub-commands: init, doctor, list, status, sync, rename, upgrade, snooze, archive, unarchive, help.",
+    description: "Manage Telegram forum topics as deterministic workcells. Sub-commands: init, doctor, list, status, sync, rename, upgrade, snooze, archive, unarchive, autopilot, help.",
     parameters: Type.Object({
       command: Type.String({
         description: "Sub-command and arguments (e.g., 'init', 'doctor --all', 'rename new-name')"
@@ -10990,17 +11343,19 @@ function register(api) {
   if (api.registerCommand) {
     api.registerCommand({
       name: "tm",
-      description: "Manage Telegram forum topics as deterministic workcells. Sub-commands: init, doctor, list, status, sync, rename, upgrade, snooze, archive, unarchive, help.",
+      description: "Manage Telegram forum topics as deterministic workcells. Sub-commands: init, doctor, list, status, sync, rename, upgrade, snooze, archive, unarchive, autopilot, help.",
       acceptsArgs: true,
       requireAuth: false,
       async handler(ctx) {
         const userId = ctx.senderId;
         const groupId = ctx.from?.replace(/^telegram:(?:group:)?/, "").split(":topic:")[0] || void 0;
         const threadId = ctx.messageThreadId != null ? String(ctx.messageThreadId) : void 0;
+        const topicTitle = ctx["topicTitle"] ?? ctx["topicName"];
         const execContext = {};
         if (userId) execContext.userId = userId;
         if (groupId) execContext.groupId = groupId;
         if (threadId) execContext.threadId = threadId;
+        if (topicTitle != null) execContext.topicTitle = String(topicTitle);
         const result = await tool.execute("cmd", { command: ctx.args }, execContext);
         const reply = {
           text: result.text