openclaw-telegram-manager 2.1.0 → 2.2.0

package/dist/plugin.js

@@ -60,54 +60,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs13) {
+    function patch(fs14) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs13);
-      }
-      if (!fs13.lutimes) {
-        patchLutimes(fs13);
-      }
-      fs13.chown = chownFix(fs13.chown);
-      fs13.fchown = chownFix(fs13.fchown);
-      fs13.lchown = chownFix(fs13.lchown);
-      fs13.chmod = chmodFix(fs13.chmod);
-      fs13.fchmod = chmodFix(fs13.fchmod);
-      fs13.lchmod = chmodFix(fs13.lchmod);
-      fs13.chownSync = chownFixSync(fs13.chownSync);
-      fs13.fchownSync = chownFixSync(fs13.fchownSync);
-      fs13.lchownSync = chownFixSync(fs13.lchownSync);
-      fs13.chmodSync = chmodFixSync(fs13.chmodSync);
-      fs13.fchmodSync = chmodFixSync(fs13.fchmodSync);
-      fs13.lchmodSync = chmodFixSync(fs13.lchmodSync);
-      fs13.stat = statFix(fs13.stat);
-      fs13.fstat = statFix(fs13.fstat);
-      fs13.lstat = statFix(fs13.lstat);
-      fs13.statSync = statFixSync(fs13.statSync);
-      fs13.fstatSync = statFixSync(fs13.fstatSync);
-      fs13.lstatSync = statFixSync(fs13.lstatSync);
-      if (fs13.chmod && !fs13.lchmod) {
-        fs13.lchmod = function(path14, mode, cb) {
+        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);
         };
-        fs13.lchmodSync = function() {
+        fs14.lchmodSync = function() {
         };
       }
-      if (fs13.chown && !fs13.lchown) {
-        fs13.lchown = function(path14, uid, gid, cb) {
+      if (fs14.chown && !fs14.lchown) {
+        fs14.lchown = function(path15, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs13.lchownSync = function() {
+        fs14.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs13.rename = typeof fs13.rename !== "function" ? fs13.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() {
-                  fs13.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;
-        })(fs13.rename);
+        })(fs14.rename);
       }
-      fs13.read = typeof fs13.read !== "function" ? fs13.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(fs13, 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(fs13, 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;
-      })(fs13.read);
-      fs13.readSync = typeof fs13.readSync !== "function" ? fs13.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(fs13, 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({
             }
           }
         };
-      })(fs13.readSync);
-      function patchLchmod(fs14) {
-        fs14.lchmod = function(path14, mode, callback) {
-          fs14.open(
-            path14,
+      })(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;
               }
-              fs14.fchmod(fd, mode, function(err2) {
-                fs14.close(fd, function(err22) {
+              fs15.fchmod(fd, mode, function(err2) {
+                fs15.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs14.lchmodSync = function(path14, mode) {
-          var fd = fs14.openSync(path14, 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 = fs14.fchmodSync(fd, mode);
+            ret = fs15.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs14.closeSync(fd);
+              fs15.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs14) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs14.futimes) {
-          fs14.lutimes = function(path14, at, mt, cb) {
-            fs14.open(path14, constants.O_SYMLINK, function(er, fd) {
+      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;
               }
-              fs14.futimes(fd, at, mt, function(er2) {
-                fs14.close(fd, function(er22) {
+              fs15.futimes(fd, at, mt, function(er2) {
+                fs15.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs14.lutimesSync = function(path14, at, mt) {
-            var fd = fs14.openSync(path14, constants.O_SYMLINK);
+          fs15.lutimesSync = function(path15, at, mt) {
+            var fd = fs15.openSync(path15, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs14.futimesSync(fd, at, mt);
+              ret = fs15.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs14.closeSync(fd);
+                  fs15.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs14.closeSync(fd);
+                fs15.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs14.futimes) {
-          fs14.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs15.futimes) {
+          fs15.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs14.lutimesSync = function() {
+          fs15.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs13, 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(fs13, 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(fs13, 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(fs13, 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(fs13, target, options, callback) : orig.call(fs13, 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(fs13, target, options) : orig.call(fs13, 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(fs13) {
+    function legacy(fs14) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path14, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path14, options);
+      function ReadStream(path15, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path15, options);
         Stream.call(this);
         var self = this;
-        this.path = path14;
+        this.path = path15;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -370,7 +370,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs13.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(path14, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path14, options);
+      function WriteStream(path15, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path15, options);
         Stream.call(this);
-        this.path = path14;
+        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 = fs13.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 fs13 = __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 (!fs13[gracefulQueue]) {
+    if (!fs14[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs13, queue);
-      fs13.close = (function(fs$close) {
+      publishQueue(fs14, queue);
+      fs14.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs13, 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;
-      })(fs13.close);
-      fs13.closeSync = (function(fs$closeSync) {
+      })(fs14.close);
+      fs14.closeSync = (function(fs$closeSync) {
         function closeSync2(fd) {
-          fs$closeSync.apply(fs13, arguments);
+          fs$closeSync.apply(fs14, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync2, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync2;
-      })(fs13.closeSync);
+      })(fs14.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs13[gracefulQueue]);
-          __require("assert").equal(fs13[gracefulQueue].length, 0);
+          debug(fs14[gracefulQueue]);
+          __require("assert").equal(fs14[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs13[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs13));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs13.__patched) {
-      module.exports = patch(fs13);
-      fs13.__patched = true;
-    }
-    function patch(fs14) {
-      polyfills(fs14);
-      fs14.gracefulify = patch;
-      fs14.createReadStream = createReadStream;
-      fs14.createWriteStream = createWriteStream;
-      var fs$readFile = fs14.readFile;
-      fs14.readFile = readFile;
-      function readFile(path14, options, cb) {
+      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(path14, options, cb);
-        function go$readFile(path15, options2, cb2, startTime) {
-          return fs$readFile(path15, 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, [path15, 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 = fs14.writeFile;
-      fs14.writeFile = writeFile;
-      function writeFile(path14, 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(path14, data, options, cb);
-        function go$writeFile(path15, data2, options2, cb2, startTime) {
-          return fs$writeFile(path15, 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, [path15, 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 = fs14.appendFile;
+      var fs$appendFile = fs15.appendFile;
       if (fs$appendFile)
-        fs14.appendFile = appendFile;
-      function appendFile(path14, data, options, cb) {
+        fs15.appendFile = appendFile;
+      function appendFile(path15, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path14, data, options, cb);
-        function go$appendFile(path15, data2, options2, cb2, startTime) {
-          return fs$appendFile(path15, 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, [path15, 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 = fs14.copyFile;
+      var fs$copyFile = fs15.copyFile;
       if (fs$copyFile)
-        fs14.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 = fs14.readdir;
-      fs14.readdir = readdir;
+      var fs$readdir = fs15.readdir;
+      fs15.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path14, 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(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, fs$readdirCallback(
-            path15,
+        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(path15, options2, cb2, startTime) {
-          return fs$readdir(path15, options2, fs$readdirCallback(
-            path15,
+        } : function go$readdir2(path16, options2, cb2, startTime) {
+          return fs$readdir(path16, options2, fs$readdirCallback(
+            path16,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path14, options, cb);
-        function fs$readdirCallback(path15, 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,
-                [path15, 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(fs14);
+        var legStreams = legacy(fs15);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs14.ReadStream;
+      var fs$ReadStream = fs15.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs14.WriteStream;
+      var fs$WriteStream = fs15.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs14, "ReadStream", {
+      Object.defineProperty(fs15, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -663,7 +663,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs14, "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(fs14, "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(fs14, "FileWriteStream", {
+      Object.defineProperty(fs15, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -695,7 +695,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path14, 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(path14, 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(path14, options) {
-        return new fs14.ReadStream(path14, options);
+      function createReadStream(path15, options) {
+        return new fs15.ReadStream(path15, options);
       }
-      function createWriteStream(path14, options) {
-        return new fs14.WriteStream(path14, options);
+      function createWriteStream(path15, options) {
+        return new fs15.WriteStream(path15, options);
       }
-      var fs$open = fs14.open;
-      fs14.open = open;
-      function open(path14, 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(path14, flags, mode, cb);
-        function go$open(path15, flags2, mode2, cb2, startTime) {
-          return fs$open(path15, 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, [path15, 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 fs14;
+      return fs15;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs13[gracefulQueue].push(elem);
+      fs14[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs13[gracefulQueue].length; ++i) {
-        if (fs13[gracefulQueue][i].length > 2) {
-          fs13[gracefulQueue][i][3] = now;
-          fs13[gracefulQueue][i][4] = now;
+      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 (fs13[gracefulQueue].length === 0)
+      if (fs14[gracefulQueue].length === 0)
         return;
-      var elem = fs13[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 {
-          fs13[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, fs13, callback) {
-      const cachedPrecision = fs13[cacheSymbol];
+    function probe(file, fs14, callback) {
+      const cachedPrecision = fs14[cacheSymbol];
       if (cachedPrecision) {
-        return fs13.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);
-      fs13.utimes(file, mtime, mtime, (err) => {
+      fs14.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs13.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(fs13, 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 path14 = __require("path");
-    var fs13 = 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, path14.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: fs13,
+        fs: fs14,
         onCompromised: (err) => {
           throw err;
         },
@@ -1453,7 +1453,7 @@ var require_lockfile = __commonJS({
     }
     function unlock(file, options, callback) {
       options = {
-        fs: fs13,
+        fs: fs14,
         realpath: true,
         ...options
       };
@@ -1475,7 +1475,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs13,
+        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 fs13 = require_graceful_fs();
-    function createSyncFs(fs14) {
+    var fs14 = require_graceful_fs();
+    function createSyncFs(fs15) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs14 };
+      const newFs = { ...fs15 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs14[`${method}Sync`](...args);
+            ret = fs15[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1533,12 +1533,12 @@ var require_adapter = __commonJS({
       return newFs;
     }
     function toPromise(method) {
-      return (...args) => new Promise((resolve5, reject) => {
+      return (...args) => new Promise((resolve4, reject) => {
         args.push((err, result) => {
           if (err) {
             reject(err);
           } else {
-            resolve5(result);
+            resolve4(result);
           }
         });
         method(...args);
@@ -1561,7 +1561,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs13);
+      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" });
       }
@@ -2724,8 +2724,8 @@ var require_lib = __commonJS({
 });
 
 // src/index.ts
-import * as fs12 from "node:fs";
-import * as path13 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, path14, value, errors = []) {
+function Create(errorType, schema, path15, value, errors = []) {
   return {
     type: errorType,
     schema,
-    path: path14,
+    path: path15,
     value,
-    message: GetErrorFunction()({ errorType, path: path14, schema, value, errors }),
+    message: GetErrorFunction()({ errorType, path: path15, schema, value, errors }),
     errors
   };
 }
-function* FromAny3(schema, references, path14, value) {
+function* FromAny3(schema, references, path15, value) {
 }
-function* FromArgument3(schema, references, path14, value) {
+function* FromArgument3(schema, references, path15, value) {
 }
-function* FromArray8(schema, references, path14, value) {
+function* FromArray8(schema, references, path15, value) {
   if (!IsArray2(value)) {
-    return yield Create(ValueErrorType.Array, schema, path14, value);
+    return yield Create(ValueErrorType.Array, schema, path15, value);
   }
   if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
-    yield Create(ValueErrorType.ArrayMinItems, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMinItems, schema, path15, value);
   }
   if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
-    yield Create(ValueErrorType.ArrayMaxItems, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path15, value);
   }
   for (let i = 0; i < value.length; i++) {
-    yield* Visit6(schema.items, references, `${path14}/${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, path14, value) {
     }
     return true;
   })()) {
-    yield Create(ValueErrorType.ArrayUniqueItems, schema, path14, 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, `${path14}${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, path14, value);
+    yield Create(ValueErrorType.ArrayContains, schema, path15, value);
   }
   if (IsNumber2(schema.minContains) && containsCount < schema.minContains) {
-    yield Create(ValueErrorType.ArrayMinContains, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMinContains, schema, path15, value);
   }
   if (IsNumber2(schema.maxContains) && containsCount > schema.maxContains) {
-    yield Create(ValueErrorType.ArrayMaxContains, schema, path14, value);
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path15, value);
   }
 }
-function* FromAsyncIterator5(schema, references, path14, value) {
+function* FromAsyncIterator5(schema, references, path15, value) {
   if (!IsAsyncIterator2(value))
-    yield Create(ValueErrorType.AsyncIterator, schema, path14, value);
+    yield Create(ValueErrorType.AsyncIterator, schema, path15, value);
 }
-function* FromBigInt3(schema, references, path14, value) {
+function* FromBigInt3(schema, references, path15, value) {
   if (!IsBigInt2(value))
-    return yield Create(ValueErrorType.BigInt, schema, path14, value);
+    return yield Create(ValueErrorType.BigInt, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.BigIntMaximum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.BigIntMinimum, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
-    yield Create(ValueErrorType.BigIntMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path15, value);
   }
 }
-function* FromBoolean3(schema, references, path14, value) {
+function* FromBoolean3(schema, references, path15, value) {
   if (!IsBoolean2(value))
-    yield Create(ValueErrorType.Boolean, schema, path14, value);
+    yield Create(ValueErrorType.Boolean, schema, path15, value);
 }
-function* FromConstructor5(schema, references, path14, value) {
-  yield* Visit6(schema.returns, references, path14, value.prototype);
+function* FromConstructor5(schema, references, path15, value) {
+  yield* Visit6(schema.returns, references, path15, value.prototype);
 }
-function* FromDate3(schema, references, path14, value) {
+function* FromDate3(schema, references, path15, value) {
   if (!IsDate2(value))
-    return yield Create(ValueErrorType.Date, schema, path14, value);
+    return yield Create(ValueErrorType.Date, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
-    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
-    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
-    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
-    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path14, value);
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path15, value);
   }
 }
-function* FromFunction5(schema, references, path14, value) {
+function* FromFunction5(schema, references, path15, value) {
   if (!IsFunction2(value))
-    yield Create(ValueErrorType.Function, schema, path14, value);
+    yield Create(ValueErrorType.Function, schema, path15, value);
 }
-function* FromImport2(schema, references, path14, 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], path14, value);
+  yield* Visit6(target, [...references, ...definitions], path15, value);
 }
-function* FromInteger3(schema, references, path14, value) {
+function* FromInteger3(schema, references, path15, value) {
   if (!IsInteger(value))
-    return yield Create(ValueErrorType.Integer, schema, path14, value);
+    return yield Create(ValueErrorType.Integer, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.IntegerMaximum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.IntegerMinimum, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.IntegerMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path15, value);
   }
 }
-function* FromIntersect10(schema, references, path14, value) {
+function* FromIntersect10(schema, references, path15, value) {
   let hasError = false;
   for (const inner of schema.allOf) {
-    for (const error of Visit6(inner, references, path14, value)) {
+    for (const error of Visit6(inner, references, path15, value)) {
       hasError = true;
       yield error;
     }
   }
   if (hasError) {
-    return yield Create(ValueErrorType.Intersect, schema, path14, 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, `${path14}/${valueKey}`, value);
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path15}/${valueKey}`, value);
       }
     }
   }
@@ -6454,59 +6454,59 @@ function* FromIntersect10(schema, references, path14, value) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     for (const valueKey of Object.getOwnPropertyNames(value)) {
       if (!keyCheck.test(valueKey)) {
-        const next = Visit6(schema.unevaluatedProperties, references, `${path14}/${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, path14, value) {
+function* FromIterator5(schema, references, path15, value) {
   if (!IsIterator2(value))
-    yield Create(ValueErrorType.Iterator, schema, path14, value);
+    yield Create(ValueErrorType.Iterator, schema, path15, value);
 }
-function* FromLiteral4(schema, references, path14, value) {
+function* FromLiteral4(schema, references, path15, value) {
   if (!(value === schema.const))
-    yield Create(ValueErrorType.Literal, schema, path14, value);
+    yield Create(ValueErrorType.Literal, schema, path15, value);
 }
-function* FromNever3(schema, references, path14, value) {
-  yield Create(ValueErrorType.Never, schema, path14, value);
+function* FromNever3(schema, references, path15, value) {
+  yield Create(ValueErrorType.Never, schema, path15, value);
 }
-function* FromNot3(schema, references, path14, value) {
-  if (Visit6(schema.not, references, path14, value).next().done === true)
-    yield Create(ValueErrorType.Not, schema, path14, value);
+function* 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, path14, value) {
+function* FromNull3(schema, references, path15, value) {
   if (!IsNull2(value))
-    yield Create(ValueErrorType.Null, schema, path14, value);
+    yield Create(ValueErrorType.Null, schema, path15, value);
 }
-function* FromNumber3(schema, references, path14, value) {
+function* FromNumber3(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsNumberLike(value))
-    return yield Create(ValueErrorType.Number, schema, path14, value);
+    return yield Create(ValueErrorType.Number, schema, path15, value);
   if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
-    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path14, value);
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
-    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path14, value);
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
-    yield Create(ValueErrorType.NumberMaximum, schema, path14, value);
+    yield Create(ValueErrorType.NumberMaximum, schema, path15, value);
   }
   if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
-    yield Create(ValueErrorType.NumberMinimum, schema, path14, value);
+    yield Create(ValueErrorType.NumberMinimum, schema, path15, value);
   }
   if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
-    yield Create(ValueErrorType.NumberMultipleOf, schema, path14, value);
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path15, value);
   }
 }
-function* FromObject9(schema, references, path14, value) {
+function* FromObject9(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsObjectLike(value))
-    return yield Create(ValueErrorType.Object, schema, path14, value);
+    return yield Create(ValueErrorType.Object, schema, path15, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, 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, path14, value) {
   for (const requiredKey of requiredKeys) {
     if (unknownKeys.includes(requiredKey))
       continue;
-    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path14}/${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, `${path14}/${EscapeKey(valueKey)}`, value[valueKey]);
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path15}/${EscapeKey(valueKey)}`, value[valueKey]);
       }
     }
   }
@@ -6527,235 +6527,235 @@ function* FromObject9(schema, references, path14, value) {
     for (const valueKey of unknownKeys) {
       if (knownKeys.includes(valueKey))
         continue;
-      yield* Visit6(schema.additionalProperties, references, `${path14}/${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, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
+      yield* Visit6(property, references, `${path15}/${EscapeKey(knownKey)}`, value[knownKey]);
       if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
-        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path14}/${EscapeKey(knownKey)}`, void 0);
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path15}/${EscapeKey(knownKey)}`, void 0);
       }
     } else {
       if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
-        yield* Visit6(property, references, `${path14}/${EscapeKey(knownKey)}`, value[knownKey]);
+        yield* Visit6(property, references, `${path15}/${EscapeKey(knownKey)}`, value[knownKey]);
       }
     }
   }
 }
-function* FromPromise5(schema, references, path14, value) {
+function* FromPromise5(schema, references, path15, value) {
   if (!IsPromise(value))
-    yield Create(ValueErrorType.Promise, schema, path14, value);
+    yield Create(ValueErrorType.Promise, schema, path15, value);
 }
-function* FromRecord5(schema, references, path14, value) {
+function* FromRecord5(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsRecordLike(value))
-    return yield Create(ValueErrorType.Object, schema, path14, value);
+    return yield Create(ValueErrorType.Object, schema, path15, value);
   if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
-    yield Create(ValueErrorType.ObjectMinProperties, schema, path14, value);
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path15, value);
   }
   if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
-    yield Create(ValueErrorType.ObjectMaxProperties, schema, path14, 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, `${path14}/${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, `${path14}/${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, `${path14}/${EscapeKey(propertyKey)}`, propertyValue);
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path15}/${EscapeKey(propertyKey)}`, propertyValue);
     }
   }
 }
-function* FromRef6(schema, references, path14, value) {
-  yield* Visit6(Deref(schema, references), references, path14, value);
+function* FromRef6(schema, references, path15, value) {
+  yield* Visit6(Deref(schema, references), references, path15, value);
 }
-function* FromRegExp3(schema, references, path14, value) {
+function* FromRegExp3(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path14, 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, path14, value);
+    return yield Create(ValueErrorType.RegExp, schema, path15, value);
   }
 }
-function* FromString3(schema, references, path14, value) {
+function* FromString3(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
-    yield Create(ValueErrorType.StringMinLength, schema, path14, value);
+    yield Create(ValueErrorType.StringMinLength, schema, path15, value);
   }
   if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
-    yield Create(ValueErrorType.StringMaxLength, schema, path14, 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, path14, value);
+      yield Create(ValueErrorType.StringPattern, schema, path15, value);
     }
   }
   if (IsString2(schema.format)) {
     if (!format_exports.Has(schema.format)) {
-      yield Create(ValueErrorType.StringFormatUnknown, schema, path14, value);
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path15, value);
     } else {
       const format = format_exports.Get(schema.format);
       if (!format(value)) {
-        yield Create(ValueErrorType.StringFormat, schema, path14, value);
+        yield Create(ValueErrorType.StringFormat, schema, path15, value);
       }
     }
   }
 }
-function* FromSymbol3(schema, references, path14, value) {
+function* FromSymbol3(schema, references, path15, value) {
   if (!IsSymbol2(value))
-    yield Create(ValueErrorType.Symbol, schema, path14, value);
+    yield Create(ValueErrorType.Symbol, schema, path15, value);
 }
-function* FromTemplateLiteral5(schema, references, path14, value) {
+function* FromTemplateLiteral5(schema, references, path15, value) {
   if (!IsString2(value))
-    return yield Create(ValueErrorType.String, schema, path14, value);
+    return yield Create(ValueErrorType.String, schema, path15, value);
   const regex = new RegExp(schema.pattern);
   if (!regex.test(value)) {
-    yield Create(ValueErrorType.StringPattern, schema, path14, value);
+    yield Create(ValueErrorType.StringPattern, schema, path15, value);
   }
 }
-function* FromThis2(schema, references, path14, value) {
-  yield* Visit6(Deref(schema, references), references, path14, value);
+function* FromThis2(schema, references, path15, value) {
+  yield* Visit6(Deref(schema, references), references, path15, value);
 }
-function* FromTuple7(schema, references, path14, value) {
+function* FromTuple7(schema, references, path15, value) {
   if (!IsArray2(value))
-    return yield Create(ValueErrorType.Tuple, schema, path14, value);
+    return yield Create(ValueErrorType.Tuple, schema, path15, value);
   if (schema.items === void 0 && !(value.length === 0)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path14, value);
+    return yield Create(ValueErrorType.TupleLength, schema, path15, value);
   }
   if (!(value.length === schema.maxItems)) {
-    return yield Create(ValueErrorType.TupleLength, schema, path14, 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, `${path14}/${i}`, value[i]);
+    yield* Visit6(schema.items[i], references, `${path15}/${i}`, value[i]);
   }
 }
-function* FromUndefined3(schema, references, path14, value) {
+function* FromUndefined3(schema, references, path15, value) {
   if (!IsUndefined2(value))
-    yield Create(ValueErrorType.Undefined, schema, path14, value);
+    yield Create(ValueErrorType.Undefined, schema, path15, value);
 }
-function* FromUnion12(schema, references, path14, value) {
+function* FromUnion12(schema, references, path15, value) {
   if (Check(schema, references, value))
     return;
-  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit6(variant, references, path14, value)));
-  yield Create(ValueErrorType.Union, schema, path14, 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, path14, value) {
+function* FromUint8Array3(schema, references, path15, value) {
   if (!IsUint8Array2(value))
-    return yield Create(ValueErrorType.Uint8Array, schema, path14, value);
+    return yield Create(ValueErrorType.Uint8Array, schema, path15, value);
   if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path14, value);
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path15, value);
   }
   if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
-    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path14, value);
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path15, value);
   }
 }
-function* FromUnknown3(schema, references, path14, value) {
+function* FromUnknown3(schema, references, path15, value) {
 }
-function* FromVoid3(schema, references, path14, value) {
+function* FromVoid3(schema, references, path15, value) {
   if (!TypeSystemPolicy.IsVoidLike(value))
-    yield Create(ValueErrorType.Void, schema, path14, value);
+    yield Create(ValueErrorType.Void, schema, path15, value);
 }
-function* FromKind2(schema, references, path14, value) {
+function* FromKind2(schema, references, path15, value) {
   const check2 = type_exports2.Get(schema[Kind]);
   if (!check2(schema, value))
-    yield Create(ValueErrorType.Kind, schema, path14, value);
+    yield Create(ValueErrorType.Kind, schema, path15, value);
 }
-function* Visit6(schema, references, path14, 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_, path14, value);
+      return yield* FromAny3(schema_, references_, path15, value);
     case "Argument":
-      return yield* FromArgument3(schema_, references_, path14, value);
+      return yield* FromArgument3(schema_, references_, path15, value);
     case "Array":
-      return yield* FromArray8(schema_, references_, path14, value);
+      return yield* FromArray8(schema_, references_, path15, value);
     case "AsyncIterator":
-      return yield* FromAsyncIterator5(schema_, references_, path14, value);
+      return yield* FromAsyncIterator5(schema_, references_, path15, value);
     case "BigInt":
-      return yield* FromBigInt3(schema_, references_, path14, value);
+      return yield* FromBigInt3(schema_, references_, path15, value);
     case "Boolean":
-      return yield* FromBoolean3(schema_, references_, path14, value);
+      return yield* FromBoolean3(schema_, references_, path15, value);
     case "Constructor":
-      return yield* FromConstructor5(schema_, references_, path14, value);
+      return yield* FromConstructor5(schema_, references_, path15, value);
     case "Date":
-      return yield* FromDate3(schema_, references_, path14, value);
+      return yield* FromDate3(schema_, references_, path15, value);
     case "Function":
-      return yield* FromFunction5(schema_, references_, path14, value);
+      return yield* FromFunction5(schema_, references_, path15, value);
     case "Import":
-      return yield* FromImport2(schema_, references_, path14, value);
+      return yield* FromImport2(schema_, references_, path15, value);
     case "Integer":
-      return yield* FromInteger3(schema_, references_, path14, value);
+      return yield* FromInteger3(schema_, references_, path15, value);
     case "Intersect":
-      return yield* FromIntersect10(schema_, references_, path14, value);
+      return yield* FromIntersect10(schema_, references_, path15, value);
     case "Iterator":
-      return yield* FromIterator5(schema_, references_, path14, value);
+      return yield* FromIterator5(schema_, references_, path15, value);
     case "Literal":
-      return yield* FromLiteral4(schema_, references_, path14, value);
+      return yield* FromLiteral4(schema_, references_, path15, value);
     case "Never":
-      return yield* FromNever3(schema_, references_, path14, value);
+      return yield* FromNever3(schema_, references_, path15, value);
     case "Not":
-      return yield* FromNot3(schema_, references_, path14, value);
+      return yield* FromNot3(schema_, references_, path15, value);
     case "Null":
-      return yield* FromNull3(schema_, references_, path14, value);
+      return yield* FromNull3(schema_, references_, path15, value);
     case "Number":
-      return yield* FromNumber3(schema_, references_, path14, value);
+      return yield* FromNumber3(schema_, references_, path15, value);
     case "Object":
-      return yield* FromObject9(schema_, references_, path14, value);
+      return yield* FromObject9(schema_, references_, path15, value);
     case "Promise":
-      return yield* FromPromise5(schema_, references_, path14, value);
+      return yield* FromPromise5(schema_, references_, path15, value);
     case "Record":
-      return yield* FromRecord5(schema_, references_, path14, value);
+      return yield* FromRecord5(schema_, references_, path15, value);
     case "Ref":
-      return yield* FromRef6(schema_, references_, path14, value);
+      return yield* FromRef6(schema_, references_, path15, value);
     case "RegExp":
-      return yield* FromRegExp3(schema_, references_, path14, value);
+      return yield* FromRegExp3(schema_, references_, path15, value);
     case "String":
-      return yield* FromString3(schema_, references_, path14, value);
+      return yield* FromString3(schema_, references_, path15, value);
     case "Symbol":
-      return yield* FromSymbol3(schema_, references_, path14, value);
+      return yield* FromSymbol3(schema_, references_, path15, value);
     case "TemplateLiteral":
-      return yield* FromTemplateLiteral5(schema_, references_, path14, value);
+      return yield* FromTemplateLiteral5(schema_, references_, path15, value);
     case "This":
-      return yield* FromThis2(schema_, references_, path14, value);
+      return yield* FromThis2(schema_, references_, path15, value);
     case "Tuple":
-      return yield* FromTuple7(schema_, references_, path14, value);
+      return yield* FromTuple7(schema_, references_, path15, value);
     case "Undefined":
-      return yield* FromUndefined3(schema_, references_, path14, value);
+      return yield* FromUndefined3(schema_, references_, path15, value);
     case "Union":
-      return yield* FromUnion12(schema_, references_, path14, value);
+      return yield* FromUnion12(schema_, references_, path15, value);
     case "Uint8Array":
-      return yield* FromUint8Array3(schema_, references_, path14, value);
+      return yield* FromUint8Array3(schema_, references_, path15, value);
     case "Unknown":
-      return yield* FromUnknown3(schema_, references_, path14, value);
+      return yield* FromUnknown3(schema_, references_, path15, value);
     case "Void":
-      return yield* FromVoid3(schema_, references_, path14, value);
+      return yield* FromVoid3(schema_, references_, path15, value);
     default:
       if (!type_exports2.Has(schema_[Kind]))
         throw new ValueErrorsUnknownTypeError(schema);
-      return yield* FromKind2(schema_, references_, path14, 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, path14, value, error) {
+  constructor(schema, path15, value, error) {
     super(error instanceof Error ? error.message : "Unknown error");
     this.schema = schema;
-    this.path = path14;
+    this.path = path15;
     this.value = value;
     this.error = error;
   }
 };
-function Default3(schema, path14, value) {
+function Default3(schema, path15, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
-    throw new TransformDecodeError(schema, path14, value, error);
+    throw new TransformDecodeError(schema, path15, value, error);
   }
 }
-function FromArray14(schema, references, path14, value) {
-  return IsArray2(value) ? Default3(schema, path14, value.map((value2, index) => Visit11(schema.items, references, `${path14}/${index}`, value2))) : Default3(schema, path14, value);
+function 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, path14, value) {
+function FromIntersect15(schema, references, path15, value) {
   if (!IsObject2(value) || IsValueType(value))
-    return Default3(schema, path14, 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, `${path14}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit11(knownSchema, references, `${path15}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default3(schema, path14, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(unevaluatedProperties, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromImport7(schema, references, path14, 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], path14, value);
-  return Default3(schema, path14, result);
+  const result = Visit11(target, [...references, ...additional], path15, value);
+  return Default3(schema, path15, result);
 }
-function FromNot5(schema, references, path14, value) {
-  return Default3(schema, path14, Visit11(schema.not, references, path14, value));
+function FromNot5(schema, references, path15, value) {
+  return Default3(schema, path15, Visit11(schema.not, references, path15, value));
 }
-function FromObject15(schema, references, path14, value) {
+function FromObject15(schema, references, path15, value) {
   if (!IsObject2(value))
-    return Default3(schema, path14, 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, path14, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit11(schema.properties[key], references, `${path14}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit11(schema.properties[key], references, `${path15}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path14, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromRecord10(schema, references, path14, value) {
+function FromRecord10(schema, references, path15, value) {
   if (!IsObject2(value))
-    return Default3(schema, path14, 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, `${path14}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path15}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
-    return Default3(schema, path14, 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, `${path14}/${key}`, unknownProperties[key]);
+      unknownProperties[key] = Default3(additionalProperties, `${path15}/${key}`, unknownProperties[key]);
     }
-  return Default3(schema, path14, unknownProperties);
+  return Default3(schema, path15, unknownProperties);
 }
-function FromRef11(schema, references, path14, value) {
+function FromRef11(schema, references, path15, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path14, Visit11(target, references, path14, value));
+  return Default3(schema, path15, Visit11(target, references, path15, value));
 }
-function FromThis7(schema, references, path14, value) {
+function FromThis7(schema, references, path15, value) {
   const target = Deref(schema, references);
-  return Default3(schema, path14, Visit11(target, references, path14, value));
+  return Default3(schema, path15, Visit11(target, references, path15, value));
 }
-function FromTuple12(schema, references, path14, value) {
-  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path14, schema.items.map((schema2, index) => Visit11(schema2, references, `${path14}/${index}`, value[index]))) : Default3(schema, path14, value);
+function 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, path14, value) {
+function FromUnion17(schema, references, path15, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const decoded = Visit11(subschema, references, path14, value);
-    return Default3(schema, path14, decoded);
+    const decoded = Visit11(subschema, references, path15, value);
+    return Default3(schema, path15, decoded);
   }
-  return Default3(schema, path14, value);
+  return Default3(schema, path15, value);
 }
-function Visit11(schema, references, path14, value) {
+function Visit11(schema, references, path15, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray14(schema_, references_, path14, value);
+      return FromArray14(schema_, references_, path15, value);
     case "Import":
-      return FromImport7(schema_, references_, path14, value);
+      return FromImport7(schema_, references_, path15, value);
     case "Intersect":
-      return FromIntersect15(schema_, references_, path14, value);
+      return FromIntersect15(schema_, references_, path15, value);
     case "Not":
-      return FromNot5(schema_, references_, path14, value);
+      return FromNot5(schema_, references_, path15, value);
     case "Object":
-      return FromObject15(schema_, references_, path14, value);
+      return FromObject15(schema_, references_, path15, value);
     case "Record":
-      return FromRecord10(schema_, references_, path14, value);
+      return FromRecord10(schema_, references_, path15, value);
     case "Ref":
-      return FromRef11(schema_, references_, path14, value);
+      return FromRef11(schema_, references_, path15, value);
     case "Symbol":
-      return Default3(schema_, path14, value);
+      return Default3(schema_, path15, value);
     case "This":
-      return FromThis7(schema_, references_, path14, value);
+      return FromThis7(schema_, references_, path15, value);
     case "Tuple":
-      return FromTuple12(schema_, references_, path14, value);
+      return FromTuple12(schema_, references_, path15, value);
     case "Union":
-      return FromUnion17(schema_, references_, path14, value);
+      return FromUnion17(schema_, references_, path15, value);
     default:
-      return Default3(schema_, path14, 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, path14, value, error) {
+  constructor(schema, path15, value, error) {
     super(`${error instanceof Error ? error.message : "Unknown error"}`);
     this.schema = schema;
-    this.path = path14;
+    this.path = path15;
     this.value = value;
     this.error = error;
   }
 };
-function Default4(schema, path14, value) {
+function Default4(schema, path15, value) {
   try {
     return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
-    throw new TransformEncodeError(schema, path14, value, error);
+    throw new TransformEncodeError(schema, path15, value, error);
   }
 }
-function FromArray15(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, value);
-  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path14}/${index}`, value2)) : defaulted;
+function 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, path14, value) {
+function FromImport8(schema, references, path15, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Default4(schema, path14, value);
-  return Visit12(target, [...references, ...additional], path14, result);
+  const result = Default4(schema, path15, value);
+  return Visit12(target, [...references, ...additional], path15, result);
 }
-function FromIntersect16(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, 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, path14, value) {
   const knownProperties = { ...defaulted };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit12(knownSchema, references, `${path14}/${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, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(unevaluatedProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(unevaluatedProperties, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot6(schema, references, path14, value) {
-  return Default4(schema.not, path14, Default4(schema, path14, value));
+function FromNot6(schema, references, path15, value) {
+  return Default4(schema.not, path15, Default4(schema, path15, value));
 }
-function FromObject16(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, 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, path14, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit12(schema.properties[key], references, `${path14}/${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, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord11(schema, references, path14, value) {
-  const defaulted = Default4(schema, path14, 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, path14, value) {
   const knownProperties = { ...defaulted };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path14}/${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, path14, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      properties[key] = Default4(additionalProperties, `${path14}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path15}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef12(schema, references, path14, value) {
+function FromRef12(schema, references, path15, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path14, value);
-  return Default4(schema, path14, resolved);
+  const resolved = Visit12(target, references, path15, value);
+  return Default4(schema, path15, resolved);
 }
-function FromThis8(schema, references, path14, value) {
+function FromThis8(schema, references, path15, value) {
   const target = Deref(schema, references);
-  const resolved = Visit12(target, references, path14, value);
-  return Default4(schema, path14, resolved);
+  const resolved = Visit12(target, references, path15, value);
+  return Default4(schema, path15, resolved);
 }
-function FromTuple13(schema, references, path14, value) {
-  const value1 = Default4(schema, path14, value);
-  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path14}/${index}`, value1[index])) : [];
+function 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, path14, value) {
+function FromUnion18(schema, references, path15, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const value1 = Visit12(subschema, references, path14, value);
-    return Default4(schema, path14, value1);
+    const value1 = Visit12(subschema, references, path15, value);
+    return Default4(schema, path15, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit12(subschema, references, path14, value);
+    const value1 = Visit12(subschema, references, path15, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default4(schema, path14, value1);
+    return Default4(schema, path15, value1);
   }
-  return Default4(schema, path14, value);
+  return Default4(schema, path15, value);
 }
-function Visit12(schema, references, path14, value) {
+function Visit12(schema, references, path15, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray15(schema_, references_, path14, value);
+      return FromArray15(schema_, references_, path15, value);
     case "Import":
-      return FromImport8(schema_, references_, path14, value);
+      return FromImport8(schema_, references_, path15, value);
     case "Intersect":
-      return FromIntersect16(schema_, references_, path14, value);
+      return FromIntersect16(schema_, references_, path15, value);
     case "Not":
-      return FromNot6(schema_, references_, path14, value);
+      return FromNot6(schema_, references_, path15, value);
     case "Object":
-      return FromObject16(schema_, references_, path14, value);
+      return FromObject16(schema_, references_, path15, value);
     case "Record":
-      return FromRecord11(schema_, references_, path14, value);
+      return FromRecord11(schema_, references_, path15, value);
     case "Ref":
-      return FromRef12(schema_, references_, path14, value);
+      return FromRef12(schema_, references_, path15, value);
     case "This":
-      return FromThis8(schema_, references_, path14, value);
+      return FromThis8(schema_, references_, path15, value);
     case "Tuple":
-      return FromTuple13(schema_, references_, path14, value);
+      return FromTuple13(schema_, references_, path15, value);
     case "Union":
-      return FromUnion18(schema_, references_, path14, value);
+      return FromUnion18(schema_, references_, path15, value);
     default:
-      return Default4(schema_, path14, 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, path14, update) {
+  constructor(value, path15, update) {
     super("Cannot set root value");
     this.value = value;
-    this.path = path14;
+    this.path = path15;
     this.update = update;
   }
 };
 var ValuePointerRootDeleteError = class extends TypeBoxError {
-  constructor(value, path14) {
+  constructor(value, path15) {
     super("Cannot delete root value");
     this.value = value;
-    this.path = path14;
+    this.path = path15;
   }
 };
 function Escape2(component) {
@@ -8532,82 +8532,82 @@ var ValueDiffError = class extends TypeBoxError {
     this.value = value;
   }
 };
-function CreateUpdate(path14, value) {
-  return { type: "update", path: path14, value };
+function CreateUpdate(path15, value) {
+  return { type: "update", path: path15, value };
 }
-function CreateInsert(path14, value) {
-  return { type: "insert", path: path14, value };
+function CreateInsert(path15, value) {
+  return { type: "insert", path: path15, value };
 }
-function CreateDelete(path14) {
-  return { type: "delete", path: path14 };
+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(path14, current, next) {
+function* ObjectType4(path15, current, next) {
   AssertDiffable(current);
   AssertDiffable(next);
   if (!IsStandardObject(next))
-    return yield CreateUpdate(path14, 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(`${path14}/${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(`${path14}/${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(`${path14}/${key}`);
+    yield CreateDelete(`${path15}/${key}`);
   }
 }
-function* ArrayType4(path14, current, next) {
+function* ArrayType4(path15, current, next) {
   if (!IsArray2(next))
-    return yield CreateUpdate(path14, next);
+    return yield CreateUpdate(path15, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path14}/${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(`${path14}/${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(`${path14}/${i}`);
+    yield CreateDelete(`${path15}/${i}`);
   }
 }
-function* TypedArrayType2(path14, 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(path14, next);
+    return yield CreateUpdate(path15, next);
   for (let i = 0; i < Math.min(current.length, next.length); i++) {
-    yield* Visit15(`${path14}/${i}`, current[i], next[i]);
+    yield* Visit15(`${path15}/${i}`, current[i], next[i]);
   }
 }
-function* ValueType2(path14, current, next) {
+function* ValueType2(path15, current, next) {
   if (current === next)
     return;
-  yield CreateUpdate(path14, next);
+  yield CreateUpdate(path15, next);
 }
-function* Visit15(path14, current, next) {
+function* Visit15(path15, current, next) {
   if (IsStandardObject(current))
-    return yield* ObjectType4(path14, current, next);
+    return yield* ObjectType4(path15, current, next);
   if (IsArray2(current))
-    return yield* ArrayType4(path14, current, next);
+    return yield* ArrayType4(path15, current, next);
   if (IsTypedArray(current))
-    return yield* TypedArrayType2(path14, current, next);
+    return yield* TypedArrayType2(path15, current, next);
   if (IsValueType(current))
-    return yield* ValueType2(path14, 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, path14, current, next) {
+function ObjectType5(root, path15, current, next) {
   if (!IsStandardObject2(current)) {
-    pointer_exports.Set(root, path14, 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, path14, current, next) {
       }
     }
     for (const nextKey of nextKeys) {
-      Visit16(root, `${path14}/${nextKey}`, current[nextKey], next[nextKey]);
+      Visit16(root, `${path15}/${nextKey}`, current[nextKey], next[nextKey]);
     }
   }
 }
-function ArrayType5(root, path14, current, next) {
+function ArrayType5(root, path15, current, next) {
   if (!IsArray2(current)) {
-    pointer_exports.Set(root, path14, Clone2(next));
+    pointer_exports.Set(root, path15, Clone2(next));
   } else {
     for (let index = 0; index < next.length; index++) {
-      Visit16(root, `${path14}/${index}`, current[index], next[index]);
+      Visit16(root, `${path15}/${index}`, current[index], next[index]);
     }
     current.splice(next.length);
   }
 }
-function TypedArrayType3(root, path14, 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, path14, Clone2(next));
+    pointer_exports.Set(root, path15, Clone2(next));
   }
 }
-function ValueType3(root, path14, current, next) {
+function ValueType3(root, path15, current, next) {
   if (current === next)
     return;
-  pointer_exports.Set(root, path14, next);
+  pointer_exports.Set(root, path15, next);
 }
-function Visit16(root, path14, current, next) {
+function Visit16(root, path15, current, next) {
   if (IsArray2(next))
-    return ArrayType5(root, path14, current, next);
+    return ArrayType5(root, path15, current, next);
   if (IsTypedArray(next))
-    return TypedArrayType3(root, path14, current, next);
+    return TypedArrayType3(root, path15, current, next);
   if (IsStandardObject2(next))
-    return ObjectType5(root, path14, current, next);
+    return ObjectType5(root, path15, current, next);
   if (IsValueType(next))
-    return ValueType3(root, path14, 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 = 3;
-var CAPSULE_VERSION = 2;
+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 }),
@@ -8916,6 +8917,17 @@ var migrations = {
       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) {
@@ -9124,11 +9136,13 @@ ${(/* @__PURE__ */ new Date()).toISOString()}
 
 _Waiting for first instructions._
 
-## Next 3 actions
+## Next actions (now)
+
+1. _e.g. Set up project scaffolding_
+
+## Upcoming actions
 
-1. [T-1] _e.g. Set up project scaffolding_
-2. [T-2] _Waiting for next task_
-3. [T-3] _Waiting for next task_
+_See TODO.md for full backlog._
 `,
   "TODO.md": (name) => `# TODO: ${name}
 
@@ -9315,6 +9329,30 @@ function checkAuthorization(userId, command, registry, topicAllowFrom) {
 
 // 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
@@ -9360,43 +9398,47 @@ function buildInitConfirmButton(groupId, threadId, secret, userId, type) {
   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>How it works</b>",
+    "**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.",
     "",
-    "<b>Commands:</b>",
+    "**Commands:**",
     "/tm status \u2014 quick STATUS.md view",
     "/tm doctor \u2014 run health checks",
-    "/tm rename &lt;name&gt; \u2014 rename this topic",
+    "/tm rename <name> \u2014 rename this topic",
     "/tm list \u2014 all topics",
     "/tm archive \u2014 archive this topic",
     "/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.");
@@ -9419,38 +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 rename &lt;name&gt; \u2014 rename this topic",
+    "/tm rename <name> \u2014 rename this topic",
     "/tm list \u2014 all topics",
     "/tm sync \u2014 re-apply config",
     "/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) {
@@ -9500,7 +9543,7 @@ function createRateLimitedPoster(postFn, config = DEFAULT_RATE_LIMIT) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function isTooManyRequestsError(err) {
   if (err && typeof err === "object" && "status" in err) {
@@ -9519,11 +9562,7 @@ function getRetryAfter(err) {
 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;
 }
 
@@ -9545,13 +9584,16 @@ Determinism rules:
   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
@@ -9562,7 +9604,11 @@ Learning capture:
 - 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) {
@@ -9745,7 +9791,7 @@ function isHashMismatchError(err) {
   return false;
 }
 function sleep2(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function getConfigWrites(rpc) {
   if (!rpc) return false;
@@ -9802,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+/);
@@ -9826,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)) {
@@ -9847,6 +9892,7 @@ async function handleInit(ctx, args) {
         lastMessageAt: (/* @__PURE__ */ new Date()).toISOString(),
         lastDoctorReportAt: null,
         lastDoctorRunAt: null,
+        lastCapsuleWriteAt: null,
         snoozeUntil: null,
         ignoreChecks: [],
         consecutiveSilentDoctors: 0,
@@ -9860,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);
@@ -9875,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(
@@ -9890,7 +9936,6 @@ Warning: include generation failed: ${htmlEscape(msg)}`;
   const autopilotTip = "\n\nTip: Enable daily health sweeps with /tm autopilot enable";
   return {
     text: `${topicCard}${adminNote}${restartMsg}${autopilotTip}`,
-    parseMode: "HTML",
     pin: true
   };
 }
@@ -9923,14 +9968,12 @@ 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
   };
 }
@@ -9957,15 +10000,13 @@ async function handleInitTypeSelect(ctx, type) {
   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 name = deriveTopicName("", messageContext, threadId);
   const keyboard = buildInitConfirmButton(groupId, threadId, registry.callbackSecret, userId, type);
   return {
     text: buildInitConfirmMessage(name, type),
-    parseMode: "HTML",
     inlineKeyboard: keyboard
   };
 }
@@ -9974,9 +10015,9 @@ async function handleInitNameConfirm(ctx, type) {
 }
 function buildInitConfirmMessage(name, type) {
   return [
-    `Name: <b>${htmlEscape(name)}</b> | Type: ${htmlEscape(type)}`,
+    `Name: **${name}** | Type: ${type}`,
     "",
-    `To use a different name: /tm init &lt;name&gt; ${htmlEscape(type)}`
+    `To use a different name: /tm init <name> ${type}`
   ].join("\n");
 }
 
@@ -9991,15 +10032,15 @@ 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;
   }
@@ -10023,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")
       );
     }
   }
@@ -10059,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;
@@ -10068,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 {
@@ -10079,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") {
@@ -10094,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'
               )
             );
           }
@@ -10105,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 {
@@ -10121,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'
           )
         );
       }
@@ -10146,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"
       )
     );
   }
@@ -10160,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")
         );
       }
     }
@@ -10170,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")
         );
       }
     }
@@ -10228,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;
@@ -10238,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;
@@ -10246,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")
       );
     }
   }
@@ -10268,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;
@@ -10280,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"
       )
     );
   }
@@ -10294,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"
       )
     );
   }
@@ -10329,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 = [
@@ -10399,6 +10464,7 @@ async function handleDoctor(ctx) {
     registry,
     cronJobsPath
   );
+  backupCapsuleIfHealthy(projectsBase, entry.slug, results);
   const reportText = buildDoctorReport(entry.name, results);
   const keyboard = buildDoctorButtons(
     groupId,
@@ -10421,7 +10487,6 @@ async function handleDoctor(ctx) {
   });
   return {
     text: reportText + textCommands,
-    parseMode: "HTML",
     inlineKeyboard: keyboard
   };
 }
@@ -10483,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,
@@ -10569,9 +10635,6 @@ async function handleDoctorAll(ctx) {
         entry.consecutiveSilentDoctors++;
       }
       entry.lastDoctorRunAt = now.toISOString();
-      if (!ctx.postFn) {
-        entry.lastDoctorReportAt = now.toISOString();
-      }
       if (entry.consecutiveSilentDoctors >= SPAM_THRESHOLD) {
         entry.snoozeUntil = new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3).toISOString();
         entry.status = "snoozed";
@@ -10580,7 +10643,7 @@ async function handleDoctorAll(ctx) {
     }
   });
   const lines = [
-    `<b>Doctor All Summary</b>`,
+    `**Doctor All Summary**`,
     "",
     `Processed: ${processed}`,
     `Skipped (ineligible): ${skipped}`,
@@ -10591,9 +10654,9 @@ async function handleDoctorAll(ctx) {
   }
   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`);
@@ -10601,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) {
@@ -10640,8 +10702,7 @@ async function handleList(ctx) {
   const topics = Object.values(registry.topics);
   const text = buildListMessage(topics);
   return {
-    text,
-    parseMode: "HTML"
+    text
   };
 }
 
@@ -10682,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}` };
   }
 }
 
@@ -10702,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);
@@ -10713,8 +10773,7 @@ async function handleSync(ctx) {
     text += "\n" + restartResult.fallbackMessage;
   }
   return {
-    text,
-    parseMode: "HTML"
+    text
   };
 }
 
@@ -10726,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).` };
@@ -10743,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];
@@ -10760,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) {
@@ -10773,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}`
   };
 }
 
@@ -10799,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) => {
@@ -10818,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}`
   };
 }
 
@@ -10834,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) {
@@ -10868,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}).`
   };
 }
 
@@ -10897,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) => {
@@ -10921,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) {
@@ -10934,8 +10988,7 @@ 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}`
   };
 }
 
@@ -10945,10 +10998,15 @@ import * as path12 from "node:path";
 var MARKER_START = "<!-- TM_AUTOPILOT_START -->";
 var MARKER_END = "<!-- TM_AUTOPILOT_END -->";
 var HEARTBEAT_BLOCK = `${MARKER_START}
-## Topic Manager Daily Sweep
-- [ ] If 24+ hours since the last topic sweep (check \`lastDoctorAllRunAt\` in
-      {workspace}/projects/topics.json), call \`topic_manager\` with command
-      "doctor --all" to health-check all active topics.
+## 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) {
@@ -10970,13 +11028,12 @@ async function handleAutopilot(ctx, args) {
     case "status":
       return handleStatus2(ctx);
     default:
-      return { text: `Unknown autopilot sub-command: "${htmlEscape(subCommand)}". Use enable, disable, or status.` };
+      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);
-  const block = HEARTBEAT_BLOCK.replace("{workspace}", path12.resolve(workspaceDir));
   let content = "";
   try {
     if (fs11.existsSync(heartbeatPath)) {
@@ -10990,14 +11047,13 @@ async function handleEnable(ctx) {
     });
     return { text: "Autopilot is already enabled." };
   }
-  const newContent = content ? content.trimEnd() + "\n\n" + block + "\n" : block + "\n";
+  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: "<b>Autopilot enabled.</b>\nDaily health sweeps will run via the OpenClaw heartbeat.",
-    parseMode: "HTML"
+    text: "**Autopilot enabled.**\nDaily health sweeps will run via the OpenClaw heartbeat."
   };
 }
 async function handleDisable(ctx) {
@@ -11032,8 +11088,7 @@ async function handleDisable(ctx) {
     data.autopilotEnabled = false;
   });
   return {
-    text: "<b>Autopilot disabled.</b>\nDaily sweeps will no longer run automatically.",
-    parseMode: "HTML"
+    text: "**Autopilot disabled.**\nDaily sweeps will no longer run automatically."
   };
 }
 async function handleStatus2(ctx) {
@@ -11042,20 +11097,152 @@ async function handleStatus2(ctx) {
   const enabled = registry.autopilotEnabled;
   const lastRun = registry.lastDoctorAllRunAt ?? "never";
   const lines = [
-    `<b>Autopilot:</b> ${enabled ? "enabled" : "disabled"}`,
-    `<b>Last doctor-all run:</b> ${htmlEscape(lastRun)}`
+    `**Autopilot:** ${enabled ? "enabled" : "disabled"}`,
+    `**Last doctor-all run:** ${lastRun}`
   ];
   return {
-    text: lines.join("\n"),
-    parseMode: "HTML"
+    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()
   };
 }
 
@@ -11125,18 +11312,20 @@ function createTopicManagerTool(deps) {
             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}`
         };
       }
     }
@@ -11246,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) {
@@ -11263,25 +11452,25 @@ async function handleCallbackFix(ctx) {
 // src/index.ts
 function resolveConfigDir() {
   const thisFile = new URL(import.meta.url).pathname;
-  const parts = thisFile.split(path13.sep);
+  const parts = thisFile.split(path14.sep);
   const extIndex = parts.lastIndexOf("extensions");
   if (extIndex > 0) {
-    const candidate = parts.slice(0, extIndex).join(path13.sep);
-    if (fs12.existsSync(path13.join(candidate, "openclaw.json")) || fs12.existsSync(path13.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 && fs12.existsSync(envDir)) return path13.resolve(envDir);
+  if (envDir && fs13.existsSync(envDir)) return path14.resolve(envDir);
   const homeDir = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
-  const defaultDir = path13.join(homeDir, ".openclaw");
-  if (fs12.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 ? path13.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."
@@ -11290,7 +11479,7 @@ function register(api) {
   }
   let resolvedPostFn;
   const lazyPostFn = async (groupId, threadId, text, keyboard) => {
-    if (resolvedPostFn === null) return;
+    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("/");
@@ -11316,7 +11505,8 @@ function register(api) {
         resolvedPostFn = null;
       }
     }
-    if (resolvedPostFn) await resolvedPostFn(groupId, threadId, text, keyboard);
+    if (!resolvedPostFn) throw new Error("openclaw SDK unavailable \u2013 cannot post");
+    await resolvedPostFn(groupId, threadId, text, keyboard);
   };
   const tool = createTopicManagerTool({
     logger: api.logger,
@@ -11360,15 +11550,8 @@ function register(api) {
         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;
       }