openclaw-telegram-manager 2.0.2 → 2.2.0

package/dist/plugin.js

@@ -60,54 +60,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs12) {
+    function patch(fs14) {
       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(fs14);
+      }
+      if (!fs14.lutimes) {
+        patchLutimes(fs14);
+      }
+      fs14.chown = chownFix(fs14.chown);
+      fs14.fchown = chownFix(fs14.fchown);
+      fs14.lchown = chownFix(fs14.lchown);
+      fs14.chmod = chmodFix(fs14.chmod);
+      fs14.fchmod = chmodFix(fs14.fchmod);
+      fs14.lchmod = chmodFix(fs14.lchmod);
+      fs14.chownSync = chownFixSync(fs14.chownSync);
+      fs14.fchownSync = chownFixSync(fs14.fchownSync);
+      fs14.lchownSync = chownFixSync(fs14.lchownSync);
+      fs14.chmodSync = chmodFixSync(fs14.chmodSync);
+      fs14.fchmodSync = chmodFixSync(fs14.fchmodSync);
+      fs14.lchmodSync = chmodFixSync(fs14.lchmodSync);
+      fs14.stat = statFix(fs14.stat);
+      fs14.fstat = statFix(fs14.fstat);
+      fs14.lstat = statFix(fs14.lstat);
+      fs14.statSync = statFixSync(fs14.statSync);
+      fs14.fstatSync = statFixSync(fs14.fstatSync);
+      fs14.lstatSync = statFixSync(fs14.lstatSync);
+      if (fs14.chmod && !fs14.lchmod) {
+        fs14.lchmod = function(path15, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs12.lchmodSync = function() {
+        fs14.lchmodSync = function() {
         };
       }
-      if (fs12.chown && !fs12.lchown) {
-        fs12.lchown = function(path13, uid, gid, cb) {
+      if (fs14.chown && !fs14.lchown) {
+        fs14.lchown = function(path15, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs12.lchownSync = function() {
+        fs14.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs12.rename = typeof fs12.rename !== "function" ? fs12.rename : (function(fs$rename) {
+        fs14.rename = typeof fs14.rename !== "function" ? fs14.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) {
+                  fs14.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);
+        })(fs14.rename);
       }
-      fs12.read = typeof fs12.read !== "function" ? fs12.read : (function(fs$read) {
+      fs14.read = typeof fs14.read !== "function" ? fs14.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(fs14, 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(fs14, 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) {
+      })(fs14.read);
+      fs14.readSync = typeof fs14.readSync !== "function" ? fs14.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(fs14, 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,
+      })(fs14.readSync);
+      function patchLchmod(fs15) {
+        fs15.lchmod = function(path15, mode, callback) {
+          fs15.open(
+            path15,
             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) {
+              fs15.fchmod(fd, mode, function(err2) {
+                fs15.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);
+        fs15.lchmodSync = function(path15, mode) {
+          var fd = fs15.openSync(path15, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs13.fchmodSync(fd, mode);
+            ret = fs15.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs13.closeSync(fd);
+                fs15.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs13.closeSync(fd);
+              fs15.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(fs15) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs15.futimes) {
+          fs15.lutimes = function(path15, at, mt, cb) {
+            fs15.open(path15, 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) {
+              fs15.futimes(fd, at, mt, function(er2) {
+                fs15.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs13.lutimesSync = function(path13, at, mt) {
-            var fd = fs13.openSync(path13, constants.O_SYMLINK);
+          fs15.lutimesSync = function(path15, at, mt) {
+            var fd = fs15.openSync(path15, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs13.futimesSync(fd, at, mt);
+              ret = fs15.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs13.closeSync(fd);
+                  fs15.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs13.closeSync(fd);
+                fs15.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs13.futimes) {
-          fs13.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs15.futimes) {
+          fs15.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs13.lutimesSync = function() {
+          fs15.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(fs14, 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(fs14, 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(fs14, 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(fs14, 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(fs14, target, options, callback) : orig.call(fs14, 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(fs14, target, options) : orig.call(fs14, 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(fs14) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path13, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path13, options);
+      function ReadStream(path15, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
         Stream.call(this);
         var self = this;
-        this.path = path13;
+        this.path = path15;
         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) {
+        fs14.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(path15, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
         Stream.call(this);
-        this.path = path13;
+        this.path = path15;
         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 = fs14.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 fs14 = __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 (!fs14[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs12, queue);
-      fs12.close = (function(fs$close) {
+      publishQueue(fs14, queue);
+      fs14.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs12, fd, function(err) {
+          return fs$close.call(fs14, 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) {
+      })(fs14.close);
+      fs14.closeSync = (function(fs$closeSync) {
         function closeSync2(fd) {
-          fs$closeSync.apply(fs12, arguments);
+          fs$closeSync.apply(fs14, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync2, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync2;
-      })(fs12.closeSync);
+      })(fs14.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(fs14[gracefulQueue]);
+          __require("assert").equal(fs14[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, fs14[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs14));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs14.__patched) {
+      module.exports = patch(fs14);
+      fs14.__patched = true;
+    }
+    function patch(fs15) {
+      polyfills(fs15);
+      fs15.gracefulify = patch;
+      fs15.createReadStream = createReadStream;
+      fs15.createWriteStream = createWriteStream;
+      var fs$readFile = fs15.readFile;
+      fs15.readFile = readFile;
+      function readFile(path15, 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(path15, options, cb);
+        function go$readFile(path16, options2, cb2, startTime) {
+          return fs$readFile(path16, 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, [path16, 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 = fs15.writeFile;
+      fs15.writeFile = writeFile;
+      function writeFile(path15, 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(path15, data, options, cb);
+        function go$writeFile(path16, data2, options2, cb2, startTime) {
+          return fs$writeFile(path16, 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, [path16, 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 = fs15.appendFile;
       if (fs$appendFile)
-        fs13.appendFile = appendFile;
-      function appendFile(path13, data, options, cb) {
+        fs15.appendFile = appendFile;
+      function appendFile(path15, 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(path15, data, options, cb);
+        function go$appendFile(path16, data2, options2, cb2, startTime) {
+          return fs$appendFile(path16, 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, [path16, 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 = fs15.copyFile;
       if (fs$copyFile)
-        fs13.copyFile = copyFile;
+        fs15.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 = fs15.readdir;
+      fs15.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path13, options, cb) {
+      function readdir(path15, 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(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path14, options2, cb2, startTime) {
-          return fs$readdir(path14, options2, fs$readdirCallback(
-            path14,
+        } : function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, options2, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path13, options, cb);
-        function fs$readdirCallback(path14, options2, cb2, startTime) {
+        return go$readdir(path15, options, cb);
+        function fs$readdirCallback(path16, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path14, options2, cb2],
+                [path16, 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(fs15);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs13.ReadStream;
+      var fs$ReadStream = fs15.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs13.WriteStream;
+      var fs$WriteStream = fs15.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs13, "ReadStream", {
+      Object.defineProperty(fs15, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -663,7 +663,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs13, "WriteStream", {
+      Object.defineProperty(fs15, "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(fs15, "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(fs15, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -695,7 +695,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path13, options) {
+      function ReadStream(path15, 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(path15, 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(path15, options) {
+        return new fs15.ReadStream(path15, options);
       }
-      function createWriteStream(path13, options) {
-        return new fs13.WriteStream(path13, options);
+      function createWriteStream(path15, options) {
+        return new fs15.WriteStream(path15, options);
       }
-      var fs$open = fs13.open;
-      fs13.open = open;
-      function open(path13, flags, mode, cb) {
+      var fs$open = fs15.open;
+      fs15.open = open;
+      function open(path15, 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(path15, flags, mode, cb);
+        function go$open(path16, flags2, mode2, cb2, startTime) {
+          return fs$open(path16, 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, [path16, 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 fs15;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs12[gracefulQueue].push(elem);
+      fs14[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 < fs14[gracefulQueue].length; ++i) {
+        if (fs14[gracefulQueue][i].length > 2) {
+          fs14[gracefulQueue][i][3] = now;
+          fs14[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 (fs14[gracefulQueue].length === 0)
         return;
-      var elem = fs12[gracefulQueue].shift();
+      var elem = fs14[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);
+          fs14[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, fs14, callback) {
+      const cachedPrecision = fs14[cacheSymbol];
       if (cachedPrecision) {
-        return fs12.stat(file, (err, stat) => {
+        return fs14.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) => {
+      fs14.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs12.stat(file, (err2, stat) => {
+        fs14.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(fs14, 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 path15 = __require("path");
+    var fs14 = 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, path15.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -1409,7 +1409,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs12,
+        fs: fs14,
         onCompromised: (err) => {
           throw err;
         },
@@ -1453,7 +1453,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs12,
+        fs: fs14,
         realpath: true,
         ...options
       };
@@ -1475,7 +1475,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs12,
+        fs: fs14,
         ...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 fs14 = require_graceful_fs();
+    function createSyncFs(fs15) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs13 };
+      const newFs = { ...fs15 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs13[`${method}Sync`](...args);
+            ret = fs15[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1561,7 +1561,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs12);
+      options.fs = createSyncFs(options.fs || fs14);
       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 fs13 from "node:fs";
+import * as path14 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, path15, value, errors = []) {
   return {
     type: errorType,
     schema,
-    path: path13,
+    path: path15,
     value,
-    message: GetErrorFunction()({ errorType, path: path13, schema, value, errors }),
+    message: GetErrorFunction()({ errorType, path: path15, schema, value, errors }),
     errors
   };
 }
-function* FromAny3(schema, references, path13, value) {
+function* FromAny3(schema, references, path15, value) {
 }
-function* FromArgument3(schema, references, path13, value) {
+function* FromArgument3(schema, references, path15, value) {
 }
-function* FromArray8(schema, references, path13, value) {
+function* FromArray8(schema, references, path15, value) {
   if (!IsArray2(value)) {
-    return yield Create(ValueErrorType.Array, schema, path13, value);
+    return yield Create(ValueErrorType.Array, schema, path15, value);
   }
   if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield Create(ValueErrorType.ArrayMinItems, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMinItems, schema, path15, value);
   }
   if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield Create(ValueErrorType.ArrayMaxItems, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path15, value);
   }
   for (let i = 0; i < value.length; i++) {
-    yield* Visit6(schema.items, references, `${path13}/${i}`, value[i]);
+    yield* Visit6(schema.items, references, `${path15}/${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, path15, 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, `${path15}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
   if (containsCount === 0) {
-    yield Create(ValueErrorType.ArrayContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayContains, schema, path15, value);
   }
   if (IsNumber2(schema.minContains) && containsCount < schema.minContains) {
-    yield Create(ValueErrorType.ArrayMinContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMinContains, schema, path15, value);
   }
   if (IsNumber2(schema.maxContains) && containsCount > schema.maxContains) {
-    yield Create(ValueErrorType.ArrayMaxContains, schema, path13, value);
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path15, value);
   }
 }
-function* FromAsyncIterator5(schema, references, path13, value) {
+function* FromAsyncIterator5(schema, references, path15, value) {
   if (!IsAsyncIterator2(value))
-    yield Create(ValueErrorType.AsyncIterator, schema, path13, value);
+    yield Create(ValueErrorType.AsyncIterator, schema, path15, value);
 }
-function* FromBigInt3(schema, references, path13, value) {
+function* FromBigInt3(schema, references, path15, value) {
   if (!IsBigInt2(value))
-    return yield Create(ValueErrorType.BigInt, schema, path13, value);
+    return yield Create(ValueErrorType.BigInt, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.BigIntMaximum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.BigIntMinimum, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield Create(ValueErrorType.BigIntMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path15, value);
   }
 }
-function* FromBoolean3(schema, references, path13, value) {
+function* FromBoolean3(schema, references, path15, value) {
   if (!IsBoolean2(value))
-    yield Create(ValueErrorType.Boolean, schema, path13, value);
+    yield Create(ValueErrorType.Boolean, schema, path15, value);
 }
-function* FromConstructor5(schema, references, path13, value) {
-  yield* Visit6(schema.returns, references, path13, value.prototype);
+function* FromConstructor5(schema, references, path15, value) {
+  yield* Visit6(schema.returns, references, path15, value.prototype);
 }
-function* FromDate3(schema, references, path13, value) {
+function* FromDate3(schema, references, path15, value) {
   if (!IsDate2(value))
-    return yield Create(ValueErrorType.Date, schema, path13, value);
+    return yield Create(ValueErrorType.Date, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path13, value);
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path15, value);
   }
 }
-function* FromFunction5(schema, references, path13, value) {
+function* FromFunction5(schema, references, path15, value) {
   if (!IsFunction2(value))
-    yield Create(ValueErrorType.Function, schema, path13, value);
+    yield Create(ValueErrorType.Function, schema, path15, value);
 }
-function* FromImport2(schema, references, path13, value) {
+function* FromImport2(schema, references, path15, 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], path15, value);
 }
-function* FromInteger3(schema, references, path13, value) {
+function* FromInteger3(schema, references, path15, value) {
   if (!IsInteger(value))
-    return yield Create(ValueErrorType.Integer, schema, path13, value);
+    return yield Create(ValueErrorType.Integer, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.IntegerMaximum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.IntegerMinimum, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.IntegerMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path15, value);
   }
 }
-function* FromIntersect10(schema, references, path13, value) {
+function* FromIntersect10(schema, references, path15, 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, path15, value)) {
       hasError = true;
       yield error;
     }
   }
   if (hasError) {
-    return yield Create(ValueErrorType.Intersect, schema, path13, value);
+    return yield Create(ValueErrorType.Intersect, schema, path15, 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, `${path15}/${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, `${path15}/${valueKey}`, value[valueKey]).next();
         if (!next.done)
           yield next.value;
       }
     }
   }
 }
-function* FromIterator5(schema, references, path13, value) {
+function* FromIterator5(schema, references, path15, value) {
   if (!IsIterator2(value))
-    yield Create(ValueErrorType.Iterator, schema, path13, value);
+    yield Create(ValueErrorType.Iterator, schema, path15, value);
 }
-function* FromLiteral4(schema, references, path13, value) {
+function* FromLiteral4(schema, references, path15, value) {
   if (!(value === schema.const))
-    yield Create(ValueErrorType.Literal, schema, path13, value);
+    yield Create(ValueErrorType.Literal, schema, path15, value);
 }
-function* FromNever3(schema, references, path13, value) {
-  yield Create(ValueErrorType.Never, schema, path13, value);
+function* FromNever3(schema, references, path15, value) {
+  yield Create(ValueErrorType.Never, schema, path15, 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, path15, value) {
+  if (Visit6(schema.not, references, path15, value).next().done === true)
+    yield Create(ValueErrorType.Not, schema, path15, value);
 }
-function* FromNull3(schema, references, path13, value) {
+function* FromNull3(schema, references, path15, value) {
   if (!IsNull2(value))
-    yield Create(ValueErrorType.Null, schema, path13, value);
+    yield Create(ValueErrorType.Null, schema, path15, value);
 }
-function* FromNumber3(schema, references, path13, value) {
+function* FromNumber3(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsNumberLike(value))
-    return yield Create(ValueErrorType.Number, schema, path13, value);
+    return yield Create(ValueErrorType.Number, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path13, value);
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path13, value);
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.NumberMaximum, schema, path13, value);
+    yield Create(ValueErrorType.NumberMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.NumberMinimum, schema, path13, value);
+    yield Create(ValueErrorType.NumberMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.NumberMultipleOf, schema, path13, value);
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path15, value);
   }
 }
-function* FromObject9(schema, references, path13, value) {
+function* FromObject9(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsObjectLike(value))
-    return yield Create(ValueErrorType.Object, schema, path13, value);
+    return yield Create(ValueErrorType.Object, schema, path15, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path15, 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], `${path15}/${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, `${path15}/${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, `${path15}/${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, `${path15}/${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, `${path15}/${EscapeKey(knownKey)}`, void 0);
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit6(property, references, `${path13}/${EscapeKey(knownKey)}`, value[knownKey]);
+        yield* Visit6(property, references, `${path15}/${EscapeKey(knownKey)}`, value[knownKey]);
       }
     }
   }
 }
-function* FromPromise5(schema, references, path13, value) {
+function* FromPromise5(schema, references, path15, value) {
   if (!IsPromise(value))
-    yield Create(ValueErrorType.Promise, schema, path13, value);
+    yield Create(ValueErrorType.Promise, schema, path15, value);
 }
-function* FromRecord5(schema, references, path13, value) {
+function* FromRecord5(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsRecordLike(value))
-    return yield Create(ValueErrorType.Object, schema, path13, value);
+    return yield Create(ValueErrorType.Object, schema, path15, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path13, value);
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path15, 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, `${path15}/${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, `${path15}/${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, `${path15}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
 }
-function* FromRef6(schema, references, path13, value) {
-  yield* Visit6(Deref(schema, references), references, path13, value);
+function* FromRef6(schema, references, path15, value) {
+  yield* Visit6(Deref(schema, references), references, path15, value);
 }
-function* FromRegExp3(schema, references, path13, value) {
+function* FromRegExp3(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path15, 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, path15, value);
   }
 }
-function* FromString3(schema, references, path13, value) {
+function* FromString3(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path13, value);
+    yield Create(ValueErrorType.StringMaxLength, schema, path15, 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, path15, value);
     }
   }
   if (IsString2(schema.format)) {
     if (!format_exports.Has(schema.format)) {
-      yield Create(ValueErrorType.StringFormatUnknown, schema, path13, value);
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path15, value);
     } else {
       const format = format_exports.Get(schema.format);
       if (!format(value)) {
-        yield Create(ValueErrorType.StringFormat, schema, path13, value);
+        yield Create(ValueErrorType.StringFormat, schema, path15, value);
       }
     }
   }
 }
-function* FromSymbol3(schema, references, path13, value) {
+function* FromSymbol3(schema, references, path15, value) {
   if (!IsSymbol2(value))
-    yield Create(ValueErrorType.Symbol, schema, path13, value);
+    yield Create(ValueErrorType.Symbol, schema, path15, value);
 }
-function* FromTemplateLiteral5(schema, references, path13, value) {
+function* FromTemplateLiteral5(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path13, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   const regex = new RegExp(schema.pattern);
   if (!regex.test(value)) {
-    yield Create(ValueErrorType.StringPattern, schema, path13, value);
+    yield Create(ValueErrorType.StringPattern, schema, path15, value);
   }
 }
-function* FromThis2(schema, references, path13, value) {
-  yield* Visit6(Deref(schema, references), references, path13, value);
+function* FromThis2(schema, references, path15, value) {
+  yield* Visit6(Deref(schema, references), references, path15, value);
 }
-function* FromTuple7(schema, references, path13, value) {
+function* FromTuple7(schema, references, path15, value) {
   if (!IsArray2(value))
-    return yield Create(ValueErrorType.Tuple, schema, path13, value);
+    return yield Create(ValueErrorType.Tuple, schema, path15, value);
   if (schema.items === void 0 && !(value.length === 0)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path15, value);
   }
   if (!(value.length === schema.maxItems)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path13, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path15, 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, `${path15}/${i}`, value[i]);
   }
 }
-function* FromUndefined3(schema, references, path13, value) {
+function* FromUndefined3(schema, references, path15, value) {
   if (!IsUndefined2(value))
-    yield Create(ValueErrorType.Undefined, schema, path13, value);
+    yield Create(ValueErrorType.Undefined, schema, path15, value);
 }
-function* FromUnion12(schema, references, path13, value) {
+function* FromUnion12(schema, references, path15, 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, path15, value)));
+  yield Create(ValueErrorType.Union, schema, path15, value, errors);
 }
-function* FromUint8Array3(schema, references, path13, value) {
+function* FromUint8Array3(schema, references, path15, value) {
   if (!IsUint8Array2(value))
-    return yield Create(ValueErrorType.Uint8Array, schema, path13, value);
+    return yield Create(ValueErrorType.Uint8Array, schema, path15, value);
   if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path13, value);
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path15, value);
   }
   if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path13, value);
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path15, value);
   }
 }
-function* FromUnknown3(schema, references, path13, value) {
+function* FromUnknown3(schema, references, path15, value) {
 }
-function* FromVoid3(schema, references, path13, value) {
+function* FromVoid3(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsVoidLike(value))
-    yield Create(ValueErrorType.Void, schema, path13, value);
+    yield Create(ValueErrorType.Void, schema, path15, value);
 }
-function* FromKind2(schema, references, path13, value) {
+function* FromKind2(schema, references, path15, value) {
   const check2 = type_exports2.Get(schema[Kind]);
   if (!check2(schema, value))
-    yield Create(ValueErrorType.Kind, schema, path13, value);
+    yield Create(ValueErrorType.Kind, schema, path15, value);
 }
-function* Visit6(schema, references, path13, value) {
+function* Visit6(schema, references, path15, 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_, path15, value);
     case "Argument":
-      return yield* FromArgument3(schema_, references_, path13, value);
+      return yield* FromArgument3(schema_, references_, path15, value);
     case "Array":
-      return yield* FromArray8(schema_, references_, path13, value);
+      return yield* FromArray8(schema_, references_, path15, value);
     case "AsyncIterator":
-      return yield* FromAsyncIterator5(schema_, references_, path13, value);
+      return yield* FromAsyncIterator5(schema_, references_, path15, value);
     case "BigInt":
-      return yield* FromBigInt3(schema_, references_, path13, value);
+      return yield* FromBigInt3(schema_, references_, path15, value);
     case "Boolean":
-      return yield* FromBoolean3(schema_, references_, path13, value);
+      return yield* FromBoolean3(schema_, references_, path15, value);
     case "Constructor":
-      return yield* FromConstructor5(schema_, references_, path13, value);
+      return yield* FromConstructor5(schema_, references_, path15, value);
     case "Date":
-      return yield* FromDate3(schema_, references_, path13, value);
+      return yield* FromDate3(schema_, references_, path15, value);
     case "Function":
-      return yield* FromFunction5(schema_, references_, path13, value);
+      return yield* FromFunction5(schema_, references_, path15, value);
     case "Import":
-      return yield* FromImport2(schema_, references_, path13, value);
+      return yield* FromImport2(schema_, references_, path15, value);
     case "Integer":
-      return yield* FromInteger3(schema_, references_, path13, value);
+      return yield* FromInteger3(schema_, references_, path15, value);
     case "Intersect":
-      return yield* FromIntersect10(schema_, references_, path13, value);
+      return yield* FromIntersect10(schema_, references_, path15, value);
     case "Iterator":
-      return yield* FromIterator5(schema_, references_, path13, value);
+      return yield* FromIterator5(schema_, references_, path15, value);
     case "Literal":
-      return yield* FromLiteral4(schema_, references_, path13, value);
+      return yield* FromLiteral4(schema_, references_, path15, value);
     case "Never":
-      return yield* FromNever3(schema_, references_, path13, value);
+      return yield* FromNever3(schema_, references_, path15, value);
     case "Not":
-      return yield* FromNot3(schema_, references_, path13, value);
+      return yield* FromNot3(schema_, references_, path15, value);
     case "Null":
-      return yield* FromNull3(schema_, references_, path13, value);
+      return yield* FromNull3(schema_, references_, path15, value);
     case "Number":
-      return yield* FromNumber3(schema_, references_, path13, value);
+      return yield* FromNumber3(schema_, references_, path15, value);
     case "Object":
-      return yield* FromObject9(schema_, references_, path13, value);
+      return yield* FromObject9(schema_, references_, path15, value);
     case "Promise":
-      return yield* FromPromise5(schema_, references_, path13, value);
+      return yield* FromPromise5(schema_, references_, path15, value);
     case "Record":
-      return yield* FromRecord5(schema_, references_, path13, value);
+      return yield* FromRecord5(schema_, references_, path15, value);
     case "Ref":
-      return yield* FromRef6(schema_, references_, path13, value);
+      return yield* FromRef6(schema_, references_, path15, value);
     case "RegExp":
-      return yield* FromRegExp3(schema_, references_, path13, value);
+      return yield* FromRegExp3(schema_, references_, path15, value);
     case "String":
-      return yield* FromString3(schema_, references_, path13, value);
+      return yield* FromString3(schema_, references_, path15, value);
     case "Symbol":
-      return yield* FromSymbol3(schema_, references_, path13, value);
+      return yield* FromSymbol3(schema_, references_, path15, value);
     case "TemplateLiteral":
-      return yield* FromTemplateLiteral5(schema_, references_, path13, value);
+      return yield* FromTemplateLiteral5(schema_, references_, path15, value);
     case "This":
-      return yield* FromThis2(schema_, references_, path13, value);
+      return yield* FromThis2(schema_, references_, path15, value);
     case "Tuple":
-      return yield* FromTuple7(schema_, references_, path13, value);
+      return yield* FromTuple7(schema_, references_, path15, value);
     case "Undefined":
-      return yield* FromUndefined3(schema_, references_, path13, value);
+      return yield* FromUndefined3(schema_, references_, path15, value);
     case "Union":
-      return yield* FromUnion12(schema_, references_, path13, value);
+      return yield* FromUnion12(schema_, references_, path15, value);
     case "Uint8Array":
-      return yield* FromUint8Array3(schema_, references_, path13, value);
+      return yield* FromUint8Array3(schema_, references_, path15, value);
     case "Unknown":
-      return yield* FromUnknown3(schema_, references_, path13, value);
+      return yield* FromUnknown3(schema_, references_, path15, value);
     case "Void":
-      return yield* FromVoid3(schema_, references_, path13, value);
+      return yield* FromVoid3(schema_, references_, path15, value);
     default:
       if (!type_exports2.Has(schema_[Kind]))
         throw new ValueErrorsUnknownTypeError(schema);
-      return yield* FromKind2(schema_, references_, path13, value);
+      return yield* FromKind2(schema_, references_, path15, 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, path15, value, error) {
     super(error instanceof Error ? error.message : "Unknown error");
     this.schema = schema;
-    this.path = path13;
+    this.path = path15;
     this.value = value;
     this.error = error;
   }
 };
-function Default3(schema, path13, value) {
+function Default3(schema, path15, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
-    throw new TransformDecodeError(schema, path13, value, error);
+    throw new TransformDecodeError(schema, path15, 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, path15, value) {
+  return IsArray2(value) ? Default3(schema, path15, value.map((value2, index) => Visit11(schema.items, references, `${path15}/${index}`, value2))) : Default3(schema, path15, value);
 }
-function FromIntersect15(schema, references, path13, value) {
+function FromIntersect15(schema, references, path15, value) {
   if (!IsObject2(value) || IsValueType(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path15, 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, `${path15}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path15, 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, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromImport7(schema, references, path13, value) {
+function FromImport7(schema, references, path15, 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], path15, value);
+  return Default3(schema, path15, result);
 }
-function FromNot5(schema, references, path13, value) {
-  return Default3(schema, path13, Visit11(schema.not, references, path13, value));
+function FromNot5(schema, references, path15, value) {
+  return Default3(schema, path15, Visit11(schema.not, references, path15, value));
 }
-function FromObject15(schema, references, path13, value) {
+function FromObject15(schema, references, path15, value) {
   if (!IsObject2(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path15, 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, `${path15}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path15, 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, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromRecord10(schema, references, path13, value) {
+function FromRecord10(schema, references, path15, value) {
   if (!IsObject2(value))
-    return Default3(schema, path13, value);
+    return Default3(schema, path15, 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, `${path15}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path13, knownProperties);
+    return Default3(schema, path15, 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, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path13, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromRef11(schema, references, path13, value) {
+function FromRef11(schema, references, path15, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path13, Visit11(target, references, path13, value));
+  return Default3(schema, path15, Visit11(target, references, path15, value));
 }
-function FromThis7(schema, references, path13, value) {
+function FromThis7(schema, references, path15, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path13, Visit11(target, references, path13, value));
+  return Default3(schema, path15, Visit11(target, references, path15, 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, path15, value) {
+  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path15, schema.items.map((schema2, index) => Visit11(schema2, references, `${path15}/${index}`, value[index]))) : Default3(schema, path15, value);
 }
-function FromUnion17(schema, references, path13, value) {
+function FromUnion17(schema, references, path15, 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, path15, value);
+    return Default3(schema, path15, decoded);
   }
-  return Default3(schema, path13, value);
+  return Default3(schema, path15, value);
 }
-function Visit11(schema, references, path13, value) {
+function Visit11(schema, references, path15, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray14(schema_, references_, path13, value);
+      return FromArray14(schema_, references_, path15, value);
     case "Import":
-      return FromImport7(schema_, references_, path13, value);
+      return FromImport7(schema_, references_, path15, value);
     case "Intersect":
-      return FromIntersect15(schema_, references_, path13, value);
+      return FromIntersect15(schema_, references_, path15, value);
     case "Not":
-      return FromNot5(schema_, references_, path13, value);
+      return FromNot5(schema_, references_, path15, value);
     case "Object":
-      return FromObject15(schema_, references_, path13, value);
+      return FromObject15(schema_, references_, path15, value);
     case "Record":
-      return FromRecord10(schema_, references_, path13, value);
+      return FromRecord10(schema_, references_, path15, value);
     case "Ref":
-      return FromRef11(schema_, references_, path13, value);
+      return FromRef11(schema_, references_, path15, value);
     case "Symbol":
-      return Default3(schema_, path13, value);
+      return Default3(schema_, path15, value);
     case "This":
-      return FromThis7(schema_, references_, path13, value);
+      return FromThis7(schema_, references_, path15, value);
     case "Tuple":
-      return FromTuple12(schema_, references_, path13, value);
+      return FromTuple12(schema_, references_, path15, value);
     case "Union":
-      return FromUnion17(schema_, references_, path13, value);
+      return FromUnion17(schema_, references_, path15, value);
     default:
-      return Default3(schema_, path13, value);
+      return Default3(schema_, path15, 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, path15, value, error) {
     super(`${error instanceof Error ? error.message : "Unknown error"}`);
     this.schema = schema;
-    this.path = path13;
+    this.path = path15;
     this.value = value;
     this.error = error;
   }
 };
-function Default4(schema, path13, value) {
+function Default4(schema, path15, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
-    throw new TransformEncodeError(schema, path13, value, error);
+    throw new TransformEncodeError(schema, path15, 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, path15, value) {
+  const defaulted = Default4(schema, path15, value);
+  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path15}/${index}`, value2)) : defaulted;
 }
-function FromImport8(schema, references, path13, value) {
+function FromImport8(schema, references, path15, 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, path15, value);
+  return Visit12(target, [...references, ...additional], path15, result);
 }
-function FromIntersect16(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromIntersect16(schema, references, path15, value) {
+  const defaulted = Default4(schema, path15, 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, `${path15}/${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, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot6(schema, references, path13, value) {
-  return Default4(schema.not, path13, Default4(schema, path13, value));
+function FromNot6(schema, references, path15, value) {
+  return Default4(schema.not, path15, Default4(schema, path15, value));
 }
-function FromObject16(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromObject16(schema, references, path15, value) {
+  const defaulted = Default4(schema, path15, 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, `${path15}/${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, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord11(schema, references, path13, value) {
-  const defaulted = Default4(schema, path13, value);
+function FromRecord11(schema, references, path15, value) {
+  const defaulted = Default4(schema, path15, 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, `${path15}/${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, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef12(schema, references, path13, value) {
+function FromRef12(schema, references, path15, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path13, value);
-  return Default4(schema, path13, resolved);
+  const resolved = Visit12(target, references, path15, value);
+  return Default4(schema, path15, resolved);
 }
-function FromThis8(schema, references, path13, value) {
+function FromThis8(schema, references, path15, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path13, value);
-  return Default4(schema, path13, resolved);
+  const resolved = Visit12(target, references, path15, value);
+  return Default4(schema, path15, 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, path15, value) {
+  const value1 = Default4(schema, path15, value);
+  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path15}/${index}`, value1[index])) : [];
 }
-function FromUnion18(schema, references, path13, value) {
+function FromUnion18(schema, references, path15, 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, path15, value);
+    return Default4(schema, path15, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit12(subschema, references, path13, value);
+    const value1 = Visit12(subschema, references, path15, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default4(schema, path13, value1);
+    return Default4(schema, path15, value1);
   }
-  return Default4(schema, path13, value);
+  return Default4(schema, path15, value);
 }
-function Visit12(schema, references, path13, value) {
+function Visit12(schema, references, path15, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray15(schema_, references_, path13, value);
+      return FromArray15(schema_, references_, path15, value);
     case "Import":
-      return FromImport8(schema_, references_, path13, value);
+      return FromImport8(schema_, references_, path15, value);
     case "Intersect":
-      return FromIntersect16(schema_, references_, path13, value);
+      return FromIntersect16(schema_, references_, path15, value);
     case "Not":
-      return FromNot6(schema_, references_, path13, value);
+      return FromNot6(schema_, references_, path15, value);
     case "Object":
-      return FromObject16(schema_, references_, path13, value);
+      return FromObject16(schema_, references_, path15, value);
     case "Record":
-      return FromRecord11(schema_, references_, path13, value);
+      return FromRecord11(schema_, references_, path15, value);
     case "Ref":
-      return FromRef12(schema_, references_, path13, value);
+      return FromRef12(schema_, references_, path15, value);
     case "This":
-      return FromThis8(schema_, references_, path13, value);
+      return FromThis8(schema_, references_, path15, value);
     case "Tuple":
-      return FromTuple13(schema_, references_, path13, value);
+      return FromTuple13(schema_, references_, path15, value);
     case "Union":
-      return FromUnion18(schema_, references_, path13, value);
+      return FromUnion18(schema_, references_, path15, value);
     default:
-      return Default4(schema_, path13, value);
+      return Default4(schema_, path15, 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, path15, update) {
     super("Cannot set root value");
     this.value = value;
-    this.path = path13;
+    this.path = path15;
     this.update = update;
   }
 };
 var ValuePointerRootDeleteError = class extends TypeBoxError {
-  constructor(value, path13) {
+  constructor(value, path15) {
     super("Cannot delete root value");
     this.value = value;
-    this.path = path13;
+    this.path = path15;
   }
 };
 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(path15, value) {
+  return { type: "update", path: path15, value };
 }
-function CreateInsert(path13, value) {
-  return { type: "insert", path: path13, value };
+function CreateInsert(path15, value) {
+  return { type: "insert", path: path15, value };
 }
-function CreateDelete(path13) {
-  return { type: "delete", path: path13 };
+function CreateDelete(path15) {
+  return { type: "delete", path: path15 };
 }
 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(path15, current, next) {
   AssertDiffable(current);
   AssertDiffable(next);
   if (!IsStandardObject(next))
-    return yield CreateUpdate(path13, next);
+    return yield CreateUpdate(path15, 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(`${path15}/${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(`${path15}/${key}`, current[key], next[key]);
   }
   for (const key of currentKeys) {
     if (HasPropertyKey2(next, key))
       continue;
-    yield CreateDelete(`${path13}/${key}`);
+    yield CreateDelete(`${path15}/${key}`);
   }
 }
-function* ArrayType4(path13, current, next) {
+function* ArrayType4(path15, current, next) {
   if (!IsArray2(next))
-    return yield CreateUpdate(path13, next);
+    return yield CreateUpdate(path15, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path15}/${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(`${path15}/${i}`, next[i]);
   }
   for (let i = current.length - 1; i >= 0; i--) {
     if (i < next.length)
       continue;
-    yield CreateDelete(`${path13}/${i}`);
+    yield CreateDelete(`${path15}/${i}`);
   }
 }
-function* TypedArrayType2(path13, current, next) {
+function* TypedArrayType2(path15, 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(path15, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path13}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path15}/${i}`, current[i], next[i]);
   }
 }
-function* ValueType2(path13, current, next) {
+function* ValueType2(path15, current, next) {
   if (current === next)
     return;
-  yield CreateUpdate(path13, next);
+  yield CreateUpdate(path15, next);
 }
-function* Visit15(path13, current, next) {
+function* Visit15(path15, current, next) {
   if (IsStandardObject(current))
-    return yield* ObjectType4(path13, current, next);
+    return yield* ObjectType4(path15, current, next);
   if (IsArray2(current))
-    return yield* ArrayType4(path13, current, next);
+    return yield* ArrayType4(path15, current, next);
   if (IsTypedArray(current))
-    return yield* TypedArrayType2(path13, current, next);
+    return yield* TypedArrayType2(path15, current, next);
   if (IsValueType(current))
-    return yield* ValueType2(path13, current, next);
+    return yield* ValueType2(path15, 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, path15, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path13, Clone2(next));
+    pointer_exports.Set(root, path15, 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, `${path15}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
-function ArrayType5(root, path13, current, next) {
+function ArrayType5(root, path15, current, next) {
   if (!IsArray2(current)) {
-    pointer_exports.Set(root, path13, Clone2(next));
+    pointer_exports.Set(root, path15, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path13}/${index}`, current[index], next[index]);
+      Visit16(root, `${path15}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
-function TypedArrayType3(root, path13, current, next) {
+function TypedArrayType3(root, path15, 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, path15, Clone2(next));
   }
 }
-function ValueType3(root, path13, current, next) {
+function ValueType3(root, path15, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path13, next);
+  pointer_exports.Set(root, path15, next);
 }
-function Visit16(root, path13, current, next) {
+function Visit16(root, path15, current, next) {
   if (IsArray2(next))
-    return ArrayType5(root, path13, current, next);
+    return ArrayType5(root, path15, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path13, current, next);
+    return TypedArrayType3(root, path15, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path13, current, next);
+    return ObjectType5(root, path15, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path13, current, next);
+    return ValueType3(root, path15, 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 = 4;
+var CAPSULE_VERSION = 3;
 var MAX_POST_ERROR_LENGTH = 500;
 var MAX_NAME_LENGTH = 100;
 var DOCTOR_ALL_COOLDOWN_MS = 60 * 60 * 1e3;
@@ -8850,6 +8850,7 @@ var TopicEntrySchema = Type.Object({
   lastMessageAt: Type.Union([Type.String(), Type.Null()]),
   lastDoctorReportAt: Type.Union([Type.String(), Type.Null()]),
   lastDoctorRunAt: Type.Union([Type.String(), Type.Null()]),
+  lastCapsuleWriteAt: Type.Union([Type.String(), Type.Null()]),
   snoozeUntil: Type.Union([Type.String(), Type.Null()]),
   ignoreChecks: Type.Array(Type.String()),
   consecutiveSilentDoctors: Type.Integer({ minimum: 0 }),
@@ -8861,6 +8862,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 +8879,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 +8911,23 @@ var migrations = {
       }
     }
     return data;
+  },
+  "2_to_3": (data) => {
+    if (data["autopilotEnabled"] === void 0) {
+      data["autopilotEnabled"] = false;
+    }
+    return data;
+  },
+  "3_to_4": (data) => {
+    const topics = data["topics"];
+    if (topics && typeof topics === "object" && !Array.isArray(topics)) {
+      for (const entry of Object.values(topics)) {
+        if (entry["lastCapsuleWriteAt"] === void 0) {
+          entry["lastCapsuleWriteAt"] = null;
+        }
+      }
+    }
+    return data;
   }
 };
 function migrateRegistry(data) {
@@ -9098,62 +9118,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 +9128,29 @@ _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 actions (now)
 
-## Next 3 actions
+1. _e.g. Set up project scaffolding_
 
-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_
+## Upcoming actions
+
+_See TODO.md for full backlog._
 `,
   "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 +9171,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,8 +9270,93 @@ 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;
+function buildDailyReport(data) {
+  const n = htmlEscape(data.name);
+  const lines = [
+    `<b>Daily Report: ${n}</b>`,
+    "",
+    `<b>Done today</b>`,
+    htmlEscape(data.doneContent),
+    "",
+    `<b>New learnings</b>`,
+    htmlEscape(data.learningsContent),
+    "",
+    `<b>Blockers/Risks</b>`,
+    htmlEscape(data.blockersContent),
+    "",
+    `<b>Next actions (now)</b>`,
+    htmlEscape(data.nextContent),
+    "",
+    `<b>Upcoming</b>`,
+    htmlEscape(data.upcomingContent),
+    "",
+    `<b>Health:</b> ${data.health}`
+  ];
+  return truncateMessage(lines.join("\n"));
+}
+var DEFAULT_RATE_LIMIT = {
+  sameGroupDelayMs: 4e3,
+  crossGroupDelayMs: 1e3
+};
 function buildInlineKeyboard(rows) {
   return { inline_keyboard: rows };
 }
@@ -9329,37 +9387,58 @@ function buildInitTypeButtons(groupId, threadId, secret, userId) {
     ]
   ]);
 }
+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);
-  const t = htmlEscape(type);
-  const v = htmlEscape(String(capsuleVersion));
   return [
-    `<b>Topic: ${n}</b>`,
-    `Type: ${t} | Version: ${v}`,
-    `Capsule: projects/${s}/`,
+    `**Topic: ${name}**`,
+    `Type: ${type} | Version: ${capsuleVersion}`,
+    `Capsule: projects/${slug}/`,
     "",
-    "<b>Commands:</b>",
-    "/tm doctor \u2014 health checks",
-    "/tm status \u2014 quick view",
-    "/tm sync \u2014 re-apply config",
+    "**How it works**",
+    "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.",
+    "",
+    "**Commands:**",
+    "/tm status \u2014 quick STATUS.md view",
+    "/tm doctor \u2014 run health checks",
+    "/tm rename <name> \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) {
-  const n = htmlEscape(name);
-  const lines = [`<b>Doctor: ${n}</b>`, ""];
+function buildDoctorReport(name, results, format = "markdown") {
+  const isHtml = format === "html";
+  const n = isHtml ? htmlEscape(name) : name;
+  const bold = (s) => isHtml ? `<b>${s}</b>` : `**${s}**`;
+  const code = (s) => isHtml ? `<code>${s}</code>` : `\`${s}\``;
+  const lines = [bold(`Doctor: ${n}`), ""];
   if (results.length === 0) {
     lines.push("All checks passed.");
     return lines.join("\n");
   }
   for (const r of results) {
     const icon = severityIcon(r.severity);
-    const msg = htmlEscape(r.message);
+    const msg = isHtml ? htmlEscape(r.message) : r.message;
+    const checkId = isHtml ? htmlEscape(r.checkId) : r.checkId;
     const fix = r.fixable ? " [fixable]" : "";
-    lines.push(`${icon} <code>${htmlEscape(r.checkId)}</code>: ${msg}${fix}`);
+    lines.push(`${icon} ${code(checkId)}: ${msg}${fix}`);
+    if (r.remediation) {
+      const rem = isHtml ? htmlEscape(r.remediation) : r.remediation;
+      lines.push(`   \u2192 ${rem}`);
+    }
   }
   lines.push("");
   lines.push("Reply /tm doctor to re-check, or use the buttons below.");
@@ -9382,37 +9461,39 @@ function severityIcon(severity) {
 }
 function buildHelpCard() {
   return [
-    "<b>Topic Manager Commands</b>",
+    "**Topic Manager Commands**",
     "",
     "/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 <name> \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 snooze <Nd> \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 daily-report \u2014 generate daily status report",
     "/tm help \u2014 this message"
   ].join("\n");
 }
 function buildListMessage(topics) {
   if (topics.length === 0) {
-    return "<b>Topic Registry</b> (0 topics)\n\nNo topics registered.";
+    return "**Topic Registry** (0 topics)\n\nNo topics registered.";
   }
   const sorted = [...topics].sort((a, b) => {
     const order = { active: 0, snoozed: 1, archived: 2 };
     return (order[a.status] ?? 3) - (order[b.status] ?? 3);
   });
-  const lines = [`<b>Topic Registry</b> (${topics.length} topics)`, ""];
+  const lines = [`**Topic Registry** (${topics.length} topics)`, ""];
   let rendered = 0;
   for (const t of sorted) {
     const entry = [
-      `<b>${htmlEscape(t.name)}</b> [${htmlEscape(t.type)}] ${htmlEscape(t.status)}`,
+      `**${t.name}** [${t.type}] ${t.status}`,
       `  Last active: ${t.lastMessageAt ? relativeTime(t.lastMessageAt) : "never"}`,
-      `  Thread: #${htmlEscape(t.threadId)}`
+      `  Thread: #${t.threadId}`
     ].join("\n");
     const tentative = [...lines, entry, ""].join("\n");
     if (tentative.length > TELEGRAM_MSG_LIMIT - 40) {
@@ -9436,14 +9517,52 @@ 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((resolve4) => setTimeout(resolve4, 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)";
-  let truncated = msg.slice(0, limit - suffix.length);
-  const lastOpen = truncated.lastIndexOf("<");
-  if (lastOpen !== -1 && lastOpen > truncated.lastIndexOf(">")) {
-    truncated = truncated.slice(0, lastOpen);
-  }
+  const truncated = msg.slice(0, limit - suffix.length);
   return truncated + suffix;
 }
 
@@ -9460,20 +9579,36 @@ 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.
+  "Next actions (now)") so compaction cannot erase critical state.
   Use the standard file write tool directly \u2014 do not route through /tm.
-- Keep STATUS.md accurate: always maintain "Last done (UTC)" and "Next 3 actions".
+- Keep STATUS.md accurate: always maintain "Last done (UTC)", "Next actions (now)",
+  and "Upcoming actions".
 - When new commands appear, add them to COMMANDS.md (don't leave them only in chat).
 - When new links/paths/services appear, add them to LINKS.md.
 - 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.
+- STATUS.md has two priority sections: "Next actions (now)" for immediate work
+  and "Upcoming actions" for the near-future pipeline.
+
+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.
+- Your workspace is strictly projects/${slug}/. Do not read, write, or reference
+  files in any other topic's capsule directory.
+- If the user mentions another topic by name or slug, ask for explicit
+  confirmation before mixing work: "This references topic X \u2014 switch context?"
+- Never copy data between topic capsules without explicit user instruction.
 - Ask one clarifying question if the next action is ambiguous.`;
 }
 function computeRegistryHash(topics) {
@@ -9627,7 +9762,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,7 +9790,7 @@ function isHashMismatchError(err) {
   }
   return false;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function getConfigWrites(rpc) {
@@ -9673,6 +9808,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) {
@@ -9698,8 +9848,7 @@ async function handleInit(ctx, args) {
   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"
+      text: `This topic is already registered as "${registry.topics[key].name}".`
     };
   }
   const parts = args.trim().split(/\s+/);
@@ -9711,18 +9860,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");
@@ -9733,7 +9871,7 @@ async function handleInit(ctx, args) {
     return { text: "Projects base is a symlink. Aborting for security." };
   }
   if (fs6.existsSync(path6.join(projectsBase, finalSlug))) {
-    return { text: `Directory projects/${htmlEscape(finalSlug)}/ already exists on disk.` };
+    return { text: `Directory projects/${finalSlug}/ already exists on disk.` };
   }
   const targetPath = path6.join(projectsBase, finalSlug);
   if (rejectSymlink(targetPath)) {
@@ -9754,6 +9892,7 @@ async function handleInit(ctx, args) {
         lastMessageAt: (/* @__PURE__ */ new Date()).toISOString(),
         lastDoctorReportAt: null,
         lastDoctorRunAt: null,
+        lastCapsuleWriteAt: null,
         snoozeUntil: null,
         ignoreChecks: [],
         consecutiveSilentDoctors: 0,
@@ -9767,7 +9906,7 @@ async function handleInit(ctx, args) {
     });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return { text: `Failed to initialize topic: ${htmlEscape(msg)}` };
+    return { text: `Failed to initialize topic: ${msg}` };
   }
   let restartMsg = "";
   const configWritesEnabled = await getConfigWrites(ctx.rpc);
@@ -9782,7 +9921,7 @@ async function handleInit(ctx, args) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       restartMsg = `
-Warning: include generation failed: ${htmlEscape(msg)}`;
+Warning: include generation failed: ${msg}`;
     }
   }
   appendAudit(
@@ -9794,9 +9933,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}`,
-    parseMode: "HTML",
+    text: `${topicCard}${adminNote}${restartMsg}${autopilotTip}`,
     pin: true
   };
 }
@@ -9829,40 +9968,79 @@ async function buildTypePicker(ctx) {
   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"
+      text: `This topic is already registered as "${registry.topics[key].name}".`
     };
   }
   const keyboard = buildInitTypeButtons(groupId, threadId, registry.callbackSecret, userId);
   return {
     text: "Pick a topic type:",
-    parseMode: "HTML",
     inlineKeyboard: keyboard
   };
 }
 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 "${registry.topics[key].name}".`
+    };
+  }
+  const name = deriveTopicName("", messageContext, threadId);
+  const keyboard = buildInitConfirmButton(groupId, threadId, registry.callbackSecret, userId, type);
+  return {
+    text: buildInitConfirmMessage(name, type),
+    inlineKeyboard: keyboard
+  };
+}
+async function handleInitNameConfirm(ctx, type) {
   return handleInit(ctx, type);
 }
+function buildInitConfirmMessage(name, type) {
+  return [
+    `Name: **${name}** | Type: ${type}`,
+    "",
+    `To use a different name: /tm init <name> ${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) {
   return entry.ignoreChecks.includes(checkId);
 }
-function check(severity, checkId, message, fixable) {
-  return { severity, checkId, message, fixable };
+function check(severity, checkId, message, fixable, remediation) {
+  return remediation ? { severity, checkId, message, fixable, remediation } : { severity, checkId, message, fixable };
 }
 function runRegistryChecks(entry, projectsBase) {
   const results = [];
   const capsuleDir = path7.join(projectsBase, entry.slug);
   if (!fs7.existsSync(capsuleDir)) {
     results.push(
-      check(Severity.ERROR, "pathMissing", `Capsule path does not exist: projects/${entry.slug}/`, false)
+      check(Severity.ERROR, "pathMissing", `Capsule path does not exist: projects/${entry.slug}/`, false, "Run /tm init to create the capsule, or remove the registry entry")
     );
     return results;
   }
@@ -9886,13 +10064,13 @@ function runCapsuleChecks(entry, projectsBase) {
   if (!fs7.existsSync(capsuleDir)) return results;
   if (!fs7.existsSync(path7.join(capsuleDir, "STATUS.md"))) {
     results.push(
-      check(Severity.ERROR, "statusMissing", "STATUS.md is missing from capsule", true)
+      check(Severity.ERROR, "statusMissing", "STATUS.md is missing from capsule", true, "Run /tm upgrade to recreate STATUS.md, or restore from .tm-backup/STATUS.md if available")
     );
   }
   if (!fs7.existsSync(path7.join(capsuleDir, "TODO.md"))) {
     if (!isIgnored(entry, "todoMissing")) {
       results.push(
-        check(Severity.WARN, "todoMissing", "TODO.md is missing from capsule", true)
+        check(Severity.WARN, "todoMissing", "TODO.md is missing from capsule", true, "Run /tm upgrade to recreate TODO.md")
       );
     }
   }
@@ -9913,7 +10091,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
         )
       );
@@ -9922,7 +10100,7 @@ function runCapsuleChecks(entry, projectsBase) {
   return results;
 }
 var LAST_DONE_RE = /^##\s*Last done\s*\(UTC\)/im;
-var NEXT_ACTIONS_RE = /^##\s*Next 3 actions/im;
+var NEXT_ACTIONS_RE = /^##\s*Next (?:3 )?actions(?: \(now\))?/im;
 var TIMESTAMP_RE = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
 var TASK_ID_RE = /\[T-\d+\]/g;
 var ADHOC_RE = /\[AD-HOC\]/g;
@@ -9931,7 +10109,7 @@ function runStatusQualityChecks(statusContent, entry) {
   if (!LAST_DONE_RE.test(statusContent)) {
     if (!isIgnored(entry, "lastDoneMissing")) {
       results.push(
-        check(Severity.ERROR, "lastDoneMissing", 'STATUS.md missing "Last done (UTC)" section', true)
+        check(Severity.ERROR, "lastDoneMissing", 'STATUS.md missing "Last done (UTC)" section', true, 'Add "## Last done (UTC)" section with a timestamp to STATUS.md, or restore from .tm-backup/STATUS.md if available')
       );
     }
   } else {
@@ -9942,7 +10120,7 @@ function runStatusQualityChecks(statusContent, entry) {
     if (!TIMESTAMP_RE.test(lastDoneSection)) {
       if (!isIgnored(entry, "lastDoneNoTimestamp")) {
         results.push(
-          check(Severity.ERROR, "lastDoneNoTimestamp", 'STATUS.md "Last done" section has no timestamp', true)
+          check(Severity.ERROR, "lastDoneNoTimestamp", 'STATUS.md "Last done" section has no timestamp', true, 'Add a YYYY-MM-DDTHH:MM timestamp under "Last done (UTC)" in STATUS.md, or restore from .tm-backup/STATUS.md if available')
         );
       }
     } else if (entry.status === "active") {
@@ -9957,7 +10135,8 @@ function runStatusQualityChecks(statusContent, entry) {
                 Severity.WARN,
                 "lastDoneStale",
                 `STATUS.md "Last done" timestamp is ${Math.floor(ageDays)} days old`,
-                false
+                false,
+                'Update the "Last done (UTC)" timestamp in STATUS.md or /tm snooze 7d'
               )
             );
           }
@@ -9968,7 +10147,7 @@ function runStatusQualityChecks(statusContent, entry) {
   if (!NEXT_ACTIONS_RE.test(statusContent)) {
     if (!isIgnored(entry, "nextActionsMissing")) {
       results.push(
-        check(Severity.ERROR, "nextActionsMissing", 'STATUS.md missing "Next 3 actions" section', true)
+        check(Severity.ERROR, "nextActionsMissing", 'STATUS.md missing "Next actions (now)" section', true, 'Add "## Next actions (now)" section with task IDs to STATUS.md')
       );
     }
   } else {
@@ -9984,8 +10163,9 @@ function runStatusQualityChecks(statusContent, entry) {
           check(
             Severity.WARN,
             "nextActionsEmpty",
-            '"Next 3 actions" has no task IDs or entries',
-            false
+            '"Next actions (now)" has no task IDs or entries',
+            false,
+            'Add task IDs like [T-1] under "Next actions (now)" in STATUS.md'
           )
         );
       }
@@ -10009,8 +10189,9 @@ function runNextVsTodoChecks(statusContent, todoContent) {
       check(
         Severity.WARN,
         "nextNotInTodo",
-        `${missing.length} task IDs in "Next 3 actions" not found in TODO.md: ${missing.join(", ")}`,
-        false
+        `${missing.length} task IDs in "Next actions (now)" not found in TODO.md: ${missing.join(", ")}`,
+        false,
+        "Add missing task IDs to TODO.md or remove stale ones from STATUS.md"
       )
     );
   }
@@ -10023,7 +10204,7 @@ function runCommandsLinksChecks(entry, capsuleFiles) {
     if (commandsContent !== void 0 && isEffectivelyEmpty(commandsContent)) {
       if (!isIgnored(entry, "commandsEmpty")) {
         results.push(
-          check(Severity.INFO, "commandsEmpty", "COMMANDS.md is empty for a coding topic", false)
+          check(Severity.INFO, "commandsEmpty", "COMMANDS.md is empty for a coding topic", false, "Add build/test/deploy commands to COMMANDS.md")
         );
       }
     }
@@ -10033,7 +10214,7 @@ function runCommandsLinksChecks(entry, capsuleFiles) {
     if (linksContent !== void 0 && isEffectivelyEmpty(linksContent)) {
       if (!isIgnored(entry, "linksEmpty")) {
         results.push(
-          check(Severity.INFO, "linksEmpty", "LINKS.md is empty for a coding/research topic", false)
+          check(Severity.INFO, "linksEmpty", "LINKS.md is empty for a coding/research topic", false, "Add URLs and endpoints to LINKS.md")
         );
       }
     }
@@ -10083,8 +10264,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;
   }
@@ -10092,7 +10272,7 @@ function runConfigChecks(entry, includeContent, registry) {
   if (!groupConfig) {
     if (!isIgnored(entry, "configGroupMissing")) {
       results.push(
-        check(Severity.WARN, "configGroupMissing", `Group ${entry.groupId} missing from generated include`, false)
+        check(Severity.WARN, "configGroupMissing", `Group ${entry.groupId} missing from generated include`, false, "Run /tm sync to add group to generated include")
       );
     }
     return results;
@@ -10102,7 +10282,7 @@ function runConfigChecks(entry, includeContent, registry) {
   if (!topicConfig) {
     if (!isIgnored(entry, "configTopicMissing")) {
       results.push(
-        check(Severity.WARN, "configTopicMissing", `Topic config missing for thread ${entry.threadId}`, false)
+        check(Severity.WARN, "configTopicMissing", `Topic config missing for thread ${entry.threadId}`, false, "Run /tm sync to add topic config to generated include")
       );
     }
     return results;
@@ -10110,14 +10290,14 @@ function runConfigChecks(entry, includeContent, registry) {
   if (!topicConfig["systemPrompt"]) {
     if (!isIgnored(entry, "configNoSystemPrompt")) {
       results.push(
-        check(Severity.WARN, "configNoSystemPrompt", "Per-topic systemPrompt is missing in generated include", false)
+        check(Severity.WARN, "configNoSystemPrompt", "Per-topic systemPrompt is missing in generated include", false, "Run /tm sync to regenerate systemPrompt in config")
       );
     }
   }
   if (!topicConfig["skills"] || !Array.isArray(topicConfig["skills"])) {
     if (!isIgnored(entry, "configNoSkills")) {
       results.push(
-        check(Severity.WARN, "configNoSkills", "Per-topic skills list is missing in generated include", false)
+        check(Severity.WARN, "configNoSkills", "Per-topic skills list is missing in generated include", false, "Run /tm sync to regenerate skills list in config")
       );
     }
   }
@@ -10132,7 +10312,8 @@ function runIncludeDriftCheck(includeFileContent, registry) {
         Severity.WARN,
         "includeDrift",
         "Generated include file has no registry-hash comment. Run /tm sync.",
-        false
+        false,
+        "Run /tm sync to regenerate the config include"
       )
     );
     return results;
@@ -10144,7 +10325,8 @@ function runIncludeDriftCheck(includeFileContent, registry) {
         Severity.WARN,
         "includeDrift",
         "Generated include is out of sync with registry. Run /tm sync.",
-        false
+        false,
+        "Run /tm sync to regenerate the config include"
       )
     );
   }
@@ -10158,7 +10340,8 @@ function runSpamControlCheck(entry) {
         Severity.INFO,
         "spamControl",
         `${entry.consecutiveSilentDoctors} consecutive doctor reports with no user interaction. Auto-snoozing for 30 days.`,
-        true
+        true,
+        "Interact with the topic or /tm snooze 30d to silence reports"
       )
     );
   }
@@ -10193,6 +10376,24 @@ function runAllChecksForTopic(entry, projectsBase, includeContent, registry, cro
   results.push(...runSpamControlCheck(entry));
   return results;
 }
+var BACKUP_DIR = ".tm-backup";
+var BACKUP_FILES = ["STATUS.md", "TODO.md"];
+function backupCapsuleIfHealthy(projectsBase, slug, results) {
+  const hasIssues = results.some((r) => r.severity === Severity.ERROR || r.severity === Severity.WARN);
+  if (hasIssues) return;
+  const capsuleDir = path7.join(projectsBase, slug);
+  const backupDir = path7.join(capsuleDir, BACKUP_DIR);
+  if (!fs7.existsSync(backupDir)) {
+    fs7.mkdirSync(backupDir, { recursive: true });
+  }
+  for (const file of BACKUP_FILES) {
+    const src = path7.join(capsuleDir, file);
+    const dst = path7.join(backupDir, file);
+    if (fs7.existsSync(src)) {
+      fs7.copyFileSync(src, dst);
+    }
+  }
+}
 function readCapsuleFiles(capsuleDir) {
   const files = /* @__PURE__ */ new Map();
   const filenames = [
@@ -10203,6 +10404,7 @@ function readCapsuleFiles(capsuleDir) {
     "CRON.md",
     "NOTES.md",
     "README.md",
+    "LEARNINGS.md",
     "ARCHITECTURE.md",
     "DEPLOY.md",
     "SOURCES.md",
@@ -10262,6 +10464,7 @@ async function handleDoctor(ctx) {
     registry,
     cronJobsPath
   );
+  backupCapsuleIfHealthy(projectsBase, entry.slug, results);
   const reportText = buildDoctorReport(entry.name, results);
   const keyboard = buildDoctorButtons(
     groupId,
@@ -10284,7 +10487,6 @@ async function handleDoctor(ctx) {
   });
   return {
     text: reportText + textCommands,
-    parseMode: "HTML",
     inlineKeyboard: keyboard
   };
 }
@@ -10346,7 +10548,8 @@ async function handleDoctorAll(ctx) {
       if (isSpam) {
         logger.info(`[doctor-all] Auto-snoozing ${entry.slug} (${entry.consecutiveSilentDoctors} silent runs)`);
       }
-      const reportText = buildDoctorReport(entry.name, results);
+      backupCapsuleIfHealthy(projectsBase, entry.slug, results);
+      const reportText = buildDoctorReport(entry.name, results, "html");
       const keyboard = buildDoctorButtons(
         entry.groupId,
         entry.threadId,
@@ -10386,6 +10589,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)) {
@@ -10410,17 +10643,20 @@ async function handleDoctorAll(ctx) {
     }
   });
   const lines = [
-    `<b>Doctor All Summary</b>`,
+    `**Doctor All Summary**`,
     "",
     `Processed: ${processed}`,
     `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>`);
+    lines.push(`**Errors (${errors.length}):**`);
     for (const e of errors.slice(0, 10)) {
-      lines.push(`- ${htmlEscape(e)}`);
+      lines.push(`- ${e}`);
     }
     if (errors.length > 10) {
       lines.push(`... and ${errors.length - 10} more`);
@@ -10428,14 +10664,13 @@ async function handleDoctorAll(ctx) {
   }
   if (migrationGroups.length > 0) {
     lines.push("");
-    lines.push("<b>Possible group migrations detected:</b>");
+    lines.push("**Possible group migrations detected:**");
     for (const gid of migrationGroups) {
-      lines.push(`- Group ${htmlEscape(gid)}: all topics failed. Check for group migration.`);
+      lines.push(`- Group ${gid}: all topics failed. Check for group migration.`);
     }
   }
   return {
-    text: lines.join("\n"),
-    parseMode: "HTML"
+    text: lines.join("\n")
   };
 }
 function isEligible(entry, now) {
@@ -10467,8 +10702,7 @@ async function handleList(ctx) {
   const topics = Object.values(registry.topics);
   const text = buildListMessage(topics);
   return {
-    text,
-    parseMode: "HTML"
+    text
   };
 }
 
@@ -10509,7 +10743,7 @@ async function handleStatus(ctx) {
     };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return { text: `Failed to read STATUS.md: ${htmlEscape(msg)}` };
+    return { text: `Failed to read STATUS.md: ${msg}` };
   }
 }
 
@@ -10529,8 +10763,7 @@ async function handleSync(ctx) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return {
-      text: `Sync failed: ${htmlEscape(msg)}`,
-      parseMode: "HTML"
+      text: `Sync failed: ${msg}`
     };
   }
   const restartResult = await triggerRestart(rpc, logger);
@@ -10540,8 +10773,7 @@ async function handleSync(ctx) {
     text += "\n" + restartResult.fallbackMessage;
   }
   return {
-    text,
-    parseMode: "HTML"
+    text
   };
 }
 
@@ -10553,7 +10785,7 @@ async function handleRename(ctx, newName) {
   }
   const trimmedName = newName.trim();
   if (!trimmedName) {
-    return { text: "Usage: /tm rename &lt;new-name&gt;" };
+    return { text: "Usage: /tm rename <new-name>" };
   }
   if (trimmedName.length > MAX_NAME_LENGTH) {
     return { text: `Name too long (max ${MAX_NAME_LENGTH} characters).` };
@@ -10570,7 +10802,7 @@ async function handleRename(ctx, newName) {
   }
   const oldName = entry.name;
   if (oldName === trimmedName) {
-    return { text: `Topic is already named <b>${htmlEscape(oldName)}</b>.`, parseMode: "HTML" };
+    return { text: `Topic is already named **${oldName}**.` };
   }
   await withRegistry(workspaceDir, (data) => {
     const topic = data.topics[key];
@@ -10587,7 +10819,7 @@ async function handleRename(ctx, newName) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       restartMsg = `
-Warning: include generation failed: ${htmlEscape(msg)}`;
+Warning: include generation failed: ${msg}`;
     }
     const result = await triggerRestart(rpc, logger);
     if (!result.success && result.fallbackMessage) {
@@ -10600,10 +10832,9 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   );
   const topicCard = buildTopicCard(trimmedName, entry.slug, entry.type, entry.capsuleVersion);
   return {
-    text: `Topic renamed from <b>${htmlEscape(oldName)}</b> to <b>${htmlEscape(trimmedName)}</b>.
+    text: `Topic renamed from **${oldName}** to **${trimmedName}**.
 
-${topicCard}${restartMsg}`,
-    parseMode: "HTML"
+${topicCard}${restartMsg}`
   };
 }
 
@@ -10626,16 +10857,14 @@ async function handleUpgrade(ctx) {
   }
   if (entry.capsuleVersion >= CAPSULE_VERSION) {
     return {
-      text: `Topic <b>${htmlEscape(entry.name)}</b> is already at capsule version ${CAPSULE_VERSION}. No upgrade needed.`,
-      parseMode: "HTML"
+      text: `Topic **${entry.name}** is already at capsule version ${CAPSULE_VERSION}. No upgrade needed.`
     };
   }
   const projectsBase = path11.join(workspaceDir, "projects");
   const result = upgradeCapsule(projectsBase, entry.slug, entry.name, entry.type, entry.capsuleVersion);
   if (!result.upgraded) {
     return {
-      text: `No upgrade needed for <b>${htmlEscape(entry.name)}</b>.`,
-      parseMode: "HTML"
+      text: `No upgrade needed for **${entry.name}**.`
     };
   }
   await withRegistry(workspaceDir, (data) => {
@@ -10645,10 +10874,9 @@ async function handleUpgrade(ctx) {
     }
   });
   const addedList = result.addedFiles.length > 0 ? `
-Added files: ${result.addedFiles.map((f) => htmlEscape(f)).join(", ")}` : "\nNo new files added.";
+Added files: ${result.addedFiles.join(", ")}` : "\nNo new files added.";
   return {
-    text: `Topic <b>${htmlEscape(entry.name)}</b> upgraded from v${entry.capsuleVersion} to v${result.newVersion}.${addedList}`,
-    parseMode: "HTML"
+    text: `Topic **${entry.name}** upgraded from v${entry.capsuleVersion} to v${result.newVersion}.${addedList}`
   };
 }
 
@@ -10661,11 +10889,11 @@ async function handleSnooze(ctx, args) {
   }
   const trimmed = args.trim();
   if (!trimmed) {
-    return { text: "Usage: /tm snooze &lt;Nd&gt; (e.g., 7d, 30d)" };
+    return { text: "Usage: /tm snooze <Nd> (e.g., 7d, 30d)" };
   }
   const match = DURATION_RE.exec(trimmed);
   if (!match) {
-    return { text: `Invalid duration "${htmlEscape(trimmed)}". Use format: 7d, 30d, etc.` };
+    return { text: `Invalid duration "${trimmed}". Use format: 7d, 30d, etc.` };
   }
   const days = parseInt(match[1], 10);
   if (days <= 0 || days > 365) {
@@ -10695,8 +10923,7 @@ async function handleSnooze(ctx, args) {
     buildAuditEntry(userId, "snooze", entry.slug, `Snoozed for ${days} days until ${snoozeUntil}`)
   );
   return {
-    text: `Topic <b>${htmlEscape(entry.name)}</b> snoozed for ${days} days (until ${htmlEscape(snoozeUntil)}).`,
-    parseMode: "HTML"
+    text: `Topic **${entry.name}** snoozed for ${days} days (until ${snoozeUntil}).`
   };
 }
 
@@ -10724,10 +10951,10 @@ async function handleArchiveToggle(ctx, archive) {
     return { text: "This topic is not registered. Run /tm init first." };
   }
   if (archive && entry.status === "archived") {
-    return { text: `Topic <b>${htmlEscape(entry.name)}</b> is already archived.`, parseMode: "HTML" };
+    return { text: `Topic **${entry.name}** is already archived.` };
   }
   if (!archive && entry.status !== "archived") {
-    return { text: `Topic <b>${htmlEscape(entry.name)}</b> is not archived.`, parseMode: "HTML" };
+    return { text: `Topic **${entry.name}** is not archived.` };
   }
   const newStatus = archive ? "archived" : "active";
   await withRegistry(workspaceDir, (data) => {
@@ -10748,7 +10975,7 @@ async function handleArchiveToggle(ctx, archive) {
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       restartMsg = `
-Warning: include generation failed: ${htmlEscape(msg)}`;
+Warning: include generation failed: ${msg}`;
     }
     const result = await triggerRestart(rpc, logger);
     if (!result.success && result.fallbackMessage) {
@@ -10761,16 +10988,261 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   );
   const action = archive ? "archived" : "unarchived";
   return {
-    text: `Topic <b>${htmlEscape(entry.name)}</b> ${action}.${restartMsg}`,
-    parseMode: "HTML"
+    text: `Topic **${entry.name}** ${action}.${restartMsg}`
   };
 }
 
+// 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 \u2014 Balanced Autopilot
+
+Execute these steps IN ORDER. Do not skip steps.
+
+1. CALL \`topic_manager\` with command "doctor --all" to health-check all active topics.
+   This handles stale timestamps, task ID mismatches, and posting errors automatically.
+2. For each topic where STATUS.md "Last done (UTC)" is >3 days old:
+   post a brief nudge in that topic asking the user for a status update.
+3. If no actions were taken in steps 1-2, do nothing (HEARTBEAT_OK).
+${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: "${subCommand}". Use enable, disable, or status.` };
+  }
+}
+async function handleEnable(ctx) {
+  const { workspaceDir } = ctx;
+  const heartbeatPath = path12.join(workspaceDir, HEARTBEAT_FILENAME);
+  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" + HEARTBEAT_BLOCK + "\n" : HEARTBEAT_BLOCK + "\n";
+  fs11.writeFileSync(heartbeatPath, newContent, { mode: 416 });
+  await withRegistry(workspaceDir, (data) => {
+    data.autopilotEnabled = true;
+  });
+  return {
+    text: "**Autopilot enabled.**\nDaily health sweeps will run via the OpenClaw heartbeat."
+  };
+}
+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: "**Autopilot disabled.**\nDaily sweeps will no longer run automatically."
+  };
+}
+async function handleStatus2(ctx) {
+  const { workspaceDir } = ctx;
+  const registry = readRegistry(workspaceDir);
+  const enabled = registry.autopilotEnabled;
+  const lastRun = registry.lastDoctorAllRunAt ?? "never";
+  const lines = [
+    `**Autopilot:** ${enabled ? "enabled" : "disabled"}`,
+    `**Last doctor-all run:** ${lastRun}`
+  ];
+  return {
+    text: lines.join("\n")
+  };
+}
+
+// src/commands/daily-report.ts
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
+async function handleDailyReport(ctx) {
+  const { workspaceDir, groupId, threadId, logger } = ctx;
+  if (!groupId || !threadId) {
+    return { text: "Missing context: must be called from a topic thread." };
+  }
+  const key = topicKey(groupId, threadId);
+  const registry = readRegistry(workspaceDir);
+  const entry = registry.topics[key];
+  if (!entry) {
+    return { text: "This topic is not registered. Run /tm init first." };
+  }
+  if (entry.lastDoctorReportAt) {
+    const lastReport = new Date(entry.lastDoctorReportAt);
+    const now = /* @__PURE__ */ new Date();
+    if (lastReport.getUTCFullYear() === now.getUTCFullYear() && lastReport.getUTCMonth() === now.getUTCMonth() && lastReport.getUTCDate() === now.getUTCDate()) {
+      return { text: "Daily report already generated today. Try again tomorrow." };
+    }
+  }
+  const projectsBase = path13.join(workspaceDir, "projects");
+  const capsuleDir = path13.join(projectsBase, entry.slug);
+  if (!fs12.existsSync(capsuleDir)) {
+    return { text: `Capsule directory not found: projects/${entry.slug}/` };
+  }
+  const statusContent = readFileOrNull(path13.join(capsuleDir, "STATUS.md"));
+  const todoContent = readFileOrNull(path13.join(capsuleDir, "TODO.md"));
+  const learningsContent = readFileOrNull(path13.join(capsuleDir, "LEARNINGS.md"));
+  const doneContent = extractDoneSection(statusContent);
+  const newLearnings = extractTodayLearnings(learningsContent);
+  const blockers = extractBlockers(todoContent);
+  const nextContent = extractNextActions(statusContent);
+  const upcomingContent = extractUpcoming(statusContent);
+  const health = computeHealth(entry.lastMessageAt, statusContent, blockers);
+  const reportText = buildDailyReport({
+    name: entry.name,
+    doneContent,
+    learningsContent: newLearnings,
+    blockersContent: blockers,
+    nextContent,
+    upcomingContent,
+    health
+  });
+  if (ctx.postFn) {
+    try {
+      await ctx.postFn(groupId, threadId, reportText);
+      await withRegistry(workspaceDir, (data) => {
+        const e = data.topics[key];
+        if (e) {
+          e.lastDoctorReportAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error(`[daily-report] Post failed: ${msg}`);
+      return { text: `Daily report generated but post failed: ${msg}` };
+    }
+  } else {
+    await withRegistry(workspaceDir, (data) => {
+      const e = data.topics[key];
+      if (e) {
+        e.lastDoctorReportAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    });
+  }
+  return { text: reportText };
+}
+function readFileOrNull(filePath) {
+  try {
+    return fs12.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function extractDoneSection(statusContent) {
+  if (!statusContent) return "_No STATUS.md found._";
+  const match = statusContent.match(/^##\s*Last done\s*\(UTC\)\s*\n([\s\S]*?)(?=\n##\s|\n*$)/im);
+  if (!match) return '_No "Last done" section found._';
+  const text = match[1]?.trim();
+  return text || "_Empty._";
+}
+function extractTodayLearnings(learningsContent) {
+  if (!learningsContent) return "_No LEARNINGS.md found._";
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const lines = learningsContent.split("\n");
+  const todayLines = [];
+  let inTodaySection = false;
+  for (const line of lines) {
+    if (line.startsWith("## ") && line.includes(today)) {
+      inTodaySection = true;
+      continue;
+    }
+    if (inTodaySection && line.startsWith("## ")) {
+      break;
+    }
+    if (inTodaySection && line.trim()) {
+      todayLines.push(line);
+    }
+  }
+  return todayLines.length > 0 ? todayLines.join("\n") : "_None today._";
+}
+function extractBlockers(todoContent) {
+  if (!todoContent) return "_No TODO.md found._";
+  const lines = todoContent.split("\n");
+  const blockerLines = lines.filter(
+    (l) => /\[BLOCKED\]/i.test(l) || /\bblocked\b/i.test(l)
+  );
+  return blockerLines.length > 0 ? blockerLines.join("\n") : "_None._";
+}
+function extractNextActions(statusContent) {
+  if (!statusContent) return "_No STATUS.md found._";
+  const match = statusContent.match(/^##\s*Next (?:3 )?actions(?: \(now\))?\s*\n([\s\S]*?)(?=\n##\s|\n*$)/im);
+  if (!match) return '_No "Next actions" section found._';
+  const text = match[1]?.trim();
+  return text || "_Empty._";
+}
+function extractUpcoming(statusContent) {
+  if (!statusContent) return "_No STATUS.md found._";
+  const match = statusContent.match(/^##\s*Upcoming actions\s*\n([\s\S]*?)(?=\n##\s|\n*$)/im);
+  if (!match) return '_No "Upcoming actions" section found._';
+  const text = match[1]?.trim();
+  return text || "_Empty._";
+}
+function computeHealth(lastMessageAt, statusContent, blockers) {
+  if (blockers && blockers !== "_None._" && blockers !== "_No TODO.md found._") {
+    return "blocked";
+  }
+  if (!lastMessageAt) return "stale";
+  const hoursSinceActivity = (Date.now() - new Date(lastMessageAt).getTime()) / 36e5;
+  if (hoursSinceActivity > 72) return "stale";
+  return "fresh";
+}
+
 // src/commands/help.ts
 function handleHelp(_ctx) {
   return {
-    text: buildHelpCard(),
-    parseMode: "HTML"
+    text: buildHelpCard()
   };
 }
 
@@ -10788,6 +11260,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":
@@ -10815,18 +11310,22 @@ function createTopicManagerTool(deps) {
             return await handleArchive(ctx);
           case "unarchive":
             return await handleUnarchive(ctx);
+          case "autopilot":
+            return await handleAutopilot(ctx, args);
+          case "daily-report":
+            return await handleDailyReport(ctx);
           case "help":
             return await handleHelp(ctx);
           default:
             return {
-              text: `Unknown command: "${htmlEscape(subCommand)}". Try /tm help for available commands.`
+              text: `Unknown command: "${subCommand}". Try /tm help for available commands.`
             };
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         logger.error(`[topic_manager] Command "${subCommand}" failed: ${msg}`);
         return {
-          text: `Command failed: ${htmlEscape(msg)}`
+          text: `Command failed: ${msg}`
         };
       }
     }
@@ -10863,7 +11362,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) {
@@ -10902,10 +11402,19 @@ async function handleCallback(data, ctx) {
     im: "marketing",
     ix: "custom"
   };
+  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) {
@@ -10926,7 +11435,7 @@ async function handleCallback(data, ctx) {
       };
     }
     default:
-      return { text: `Unknown callback action: ${htmlEscape(action)}` };
+      return { text: `Unknown callback action: ${action}` };
   }
 }
 async function handleCallbackFix(ctx) {
@@ -10943,40 +11452,72 @@ 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(path14.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(path14.sep);
+    if (fs13.existsSync(path14.join(candidate, "openclaw.json")) || fs13.existsSync(path14.join(candidate, "extensions"))) {
       return candidate;
     }
   }
   const envDir = process.env["OPENCLAW_CONFIG_DIR"];
-  if (envDir && fs11.existsSync(envDir)) return path12.resolve(envDir);
+  if (envDir && fs13.existsSync(envDir)) return path14.resolve(envDir);
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const defaultDir = path12.join(homeDir, ".openclaw");
-  if (fs11.existsSync(defaultDir)) return defaultDir;
+  const defaultDir = path14.join(homeDir, ".openclaw");
+  if (fs13.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 ? path14.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) throw new Error("openclaw SDK unavailable \u2013 cannot post");
+    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) throw new Error("openclaw SDK unavailable \u2013 cannot post");
+    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')"
@@ -10992,30 +11533,25 @@ 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
         };
-        const telegramData = {};
         if (result.inlineKeyboard) {
-          telegramData.buttons = result.inlineKeyboard.inline_keyboard;
-        }
-        if (result.parseMode) {
-          telegramData.parse_mode = result.parseMode;
-        }
-        if (Object.keys(telegramData).length > 0) {
-          reply.channelData = { telegram: telegramData };
+          reply.channelData = { telegram: { buttons: result.inlineKeyboard.inline_keyboard } };
         }
         return reply;
       }