@mtreeai/msapling-cli 2.3.6-beta.1 → 2.3.6-beta.3

package/dist/index.js

@@ -3479,7 +3479,7 @@ async function copyDir(src, dst) {
 }
 async function backupFile(absPath) {
   try {
-    const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir10 } = await import("fs/promises");
+    const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir9 } = await import("fs/promises");
     const { homedir: homedir15 } = await import("os");
     const { join: join27 } = await import("path");
     const filename = absPath.split(/[\\/]/).pop() ?? "file";
@@ -3489,7 +3489,7 @@ async function backupFile(absPath) {
       "backups",
       `${filename}.${Date.now()}.bak`
     );
-    await mkdir10(join27(homedir15(), ".msapling", "backups"), { recursive: true });
+    await mkdir9(join27(homedir15(), ".msapling", "backups"), { recursive: true });
     const content = await readFile23(absPath, "utf8");
     await writeFile12(backupPath, content, "utf8");
     return backupPath;
@@ -3715,12 +3715,12 @@ var init_DeleteFileTool = __esm({
         let backedUpTo = null;
         if (isFile) {
           try {
-            const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir10 } = await import("fs/promises");
+            const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir9 } = await import("fs/promises");
             const { homedir: homedir15 } = await import("os");
             const existingContent = await readFile23(abs, "utf8");
             const filename = abs.split(/[\\/]/).pop() ?? "file";
             const backupPath = join10(homedir15(), ".msapling", "backups", `${filename}.${Date.now()}.bak`);
-            await mkdir10(join10(homedir15(), ".msapling", "backups"), { recursive: true });
+            await mkdir9(join10(homedir15(), ".msapling", "backups"), { recursive: true });
             await writeFile12(backupPath, existingContent, "utf8");
             backedUpTo = backupPath;
           } catch {
@@ -5132,54 +5132,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs) {
+    function patch(fs2) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs);
-      }
-      if (!fs.lutimes) {
-        patchLutimes(fs);
-      }
-      fs.chown = chownFix(fs.chown);
-      fs.fchown = chownFix(fs.fchown);
-      fs.lchown = chownFix(fs.lchown);
-      fs.chmod = chmodFix(fs.chmod);
-      fs.fchmod = chmodFix(fs.fchmod);
-      fs.lchmod = chmodFix(fs.lchmod);
-      fs.chownSync = chownFixSync(fs.chownSync);
-      fs.fchownSync = chownFixSync(fs.fchownSync);
-      fs.lchownSync = chownFixSync(fs.lchownSync);
-      fs.chmodSync = chmodFixSync(fs.chmodSync);
-      fs.fchmodSync = chmodFixSync(fs.fchmodSync);
-      fs.lchmodSync = chmodFixSync(fs.lchmodSync);
-      fs.stat = statFix(fs.stat);
-      fs.fstat = statFix(fs.fstat);
-      fs.lstat = statFix(fs.lstat);
-      fs.statSync = statFixSync(fs.statSync);
-      fs.fstatSync = statFixSync(fs.fstatSync);
-      fs.lstatSync = statFixSync(fs.lstatSync);
-      if (fs.chmod && !fs.lchmod) {
-        fs.lchmod = function(path2, mode, cb) {
+        patchLchmod(fs2);
+      }
+      if (!fs2.lutimes) {
+        patchLutimes(fs2);
+      }
+      fs2.chown = chownFix(fs2.chown);
+      fs2.fchown = chownFix(fs2.fchown);
+      fs2.lchown = chownFix(fs2.lchown);
+      fs2.chmod = chmodFix(fs2.chmod);
+      fs2.fchmod = chmodFix(fs2.fchmod);
+      fs2.lchmod = chmodFix(fs2.lchmod);
+      fs2.chownSync = chownFixSync(fs2.chownSync);
+      fs2.fchownSync = chownFixSync(fs2.fchownSync);
+      fs2.lchownSync = chownFixSync(fs2.lchownSync);
+      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
+      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
+      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
+      fs2.stat = statFix(fs2.stat);
+      fs2.fstat = statFix(fs2.fstat);
+      fs2.lstat = statFix(fs2.lstat);
+      fs2.statSync = statFixSync(fs2.statSync);
+      fs2.fstatSync = statFixSync(fs2.fstatSync);
+      fs2.lstatSync = statFixSync(fs2.lstatSync);
+      if (fs2.chmod && !fs2.lchmod) {
+        fs2.lchmod = function(path2, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs.lchmodSync = function() {
+        fs2.lchmodSync = function() {
         };
       }
-      if (fs.chown && !fs.lchown) {
-        fs.lchown = function(path2, uid, gid, cb) {
+      if (fs2.chown && !fs2.lchown) {
+        fs2.lchown = function(path2, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs.lchownSync = function() {
+        fs2.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : (function(fs$rename) {
           function rename2(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() {
-                  fs.stat(to, function(stater, st) {
+                  fs2.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -5195,9 +5195,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
           return rename2;
-        })(fs.rename);
+        })(fs2.rename);
       }
-      fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+      fs2.read = typeof fs2.read !== "function" ? fs2.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -5205,22 +5205,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs.read);
-      fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs2.read);
+      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -5230,10 +5230,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs.readSync);
-      function patchLchmod(fs2) {
-        fs2.lchmod = function(path2, mode, callback) {
-          fs2.open(
+      })(fs2.readSync);
+      function patchLchmod(fs3) {
+        fs3.lchmod = function(path2, mode, callback) {
+          fs3.open(
             path2,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -5242,80 +5242,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs2.fchmod(fd, mode, function(err2) {
-                fs2.close(fd, function(err22) {
+              fs3.fchmod(fd, mode, function(err2) {
+                fs3.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs2.lchmodSync = function(path2, mode) {
-          var fd = fs2.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs3.lchmodSync = function(path2, mode) {
+          var fd = fs3.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs2.fchmodSync(fd, mode);
+            ret = fs3.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs2.closeSync(fd);
+              fs3.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs2) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs2.futimes) {
-          fs2.lutimes = function(path2, at, mt, cb) {
-            fs2.open(path2, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs3) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
+          fs3.lutimes = function(path2, at, mt, cb) {
+            fs3.open(path2, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs2.futimes(fd, at, mt, function(er2) {
-                fs2.close(fd, function(er22) {
+              fs3.futimes(fd, at, mt, function(er2) {
+                fs3.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs2.lutimesSync = function(path2, at, mt) {
-            var fd = fs2.openSync(path2, constants.O_SYMLINK);
+          fs3.lutimesSync = function(path2, at, mt) {
+            var fd = fs3.openSync(path2, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs2.futimesSync(fd, at, mt);
+              ret = fs3.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs2.closeSync(fd);
+                  fs3.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs2.closeSync(fd);
+                fs3.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs2.futimes) {
-          fs2.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs3.futimes) {
+          fs3.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs2.lutimesSync = function() {
+          fs3.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs, target, mode, function(er) {
+          return orig.call(fs2, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -5325,7 +5325,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs, target, mode);
+            return orig.call(fs2, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -5334,7 +5334,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs, target, uid, gid, function(er) {
+          return orig.call(fs2, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -5344,7 +5344,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs, target, uid, gid);
+            return orig.call(fs2, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -5364,13 +5364,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -5401,7 +5401,7 @@ var require_legacy_streams = __commonJS({
     init_esm_shims();
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs) {
+    function legacy(fs2) {
       return {
         ReadStream,
         WriteStream
@@ -5444,7 +5444,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = false;
@@ -5483,7 +5483,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs.open;
+          this._open = fs2.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -5521,7 +5521,7 @@ var require_graceful_fs = __commonJS({
   "../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -5553,12 +5553,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs[gracefulQueue]) {
+    if (!fs2[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs, queue);
-      fs.close = (function(fs$close) {
+      publishQueue(fs2, queue);
+      fs2.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs, fd, function(err) {
+          return fs$close.call(fs2, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -5570,40 +5570,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs.close);
-      fs.closeSync = (function(fs$closeSync) {
+      })(fs2.close);
+      fs2.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs, arguments);
+          fs$closeSync.apply(fs2, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs.closeSync);
+      })(fs2.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs[gracefulQueue]);
-          __require("assert").equal(fs[gracefulQueue].length, 0);
+          debug(fs2[gracefulQueue]);
+          __require("assert").equal(fs2[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
-      module.exports = patch(fs);
-      fs.__patched = true;
-    }
-    function patch(fs2) {
-      polyfills(fs2);
-      fs2.gracefulify = patch;
-      fs2.createReadStream = createReadStream;
-      fs2.createWriteStream = createWriteStream;
-      var fs$readFile = fs2.readFile;
-      fs2.readFile = readFile23;
+      publishQueue(global, fs2[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs2));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
+      module.exports = patch(fs2);
+      fs2.__patched = true;
+    }
+    function patch(fs3) {
+      polyfills(fs3);
+      fs3.gracefulify = patch;
+      fs3.createReadStream = createReadStream;
+      fs3.createWriteStream = createWriteStream;
+      var fs$readFile = fs3.readFile;
+      fs3.readFile = readFile23;
       function readFile23(path2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5619,8 +5619,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs2.writeFile;
-      fs2.writeFile = writeFile12;
+      var fs$writeFile = fs3.writeFile;
+      fs3.writeFile = writeFile12;
       function writeFile12(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5636,9 +5636,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs2.appendFile;
+      var fs$appendFile = fs3.appendFile;
       if (fs$appendFile)
-        fs2.appendFile = appendFile;
+        fs3.appendFile = appendFile;
       function appendFile(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5654,9 +5654,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs2.copyFile;
+      var fs$copyFile = fs3.copyFile;
       if (fs$copyFile)
-        fs2.copyFile = copyFile2;
+        fs3.copyFile = copyFile2;
       function copyFile2(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -5674,8 +5674,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs2.readdir;
-      fs2.readdir = readdir4;
+      var fs$readdir = fs3.readdir;
+      fs3.readdir = readdir4;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir4(path2, options, cb) {
         if (typeof options === "function")
@@ -5716,21 +5716,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs2);
+        var legStreams = legacy(fs3);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs2.ReadStream;
+      var fs$ReadStream = fs3.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs2.WriteStream;
+      var fs$WriteStream = fs3.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs2, "ReadStream", {
+      Object.defineProperty(fs3, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -5740,7 +5740,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs2, "WriteStream", {
+      Object.defineProperty(fs3, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -5751,7 +5751,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs2, "FileReadStream", {
+      Object.defineProperty(fs3, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -5762,7 +5762,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs2, "FileWriteStream", {
+      Object.defineProperty(fs3, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5811,13 +5811,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path2, options) {
-        return new fs2.ReadStream(path2, options);
+        return new fs3.ReadStream(path2, options);
       }
       function createWriteStream(path2, options) {
-        return new fs2.WriteStream(path2, options);
+        return new fs3.WriteStream(path2, options);
       }
-      var fs$open = fs2.open;
-      fs2.open = open;
+      var fs$open = fs3.open;
+      fs3.open = open;
       function open(path2, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -5833,20 +5833,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs2;
+      return fs3;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs[gracefulQueue].push(elem);
+      fs2[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs[gracefulQueue].length; ++i) {
-        if (fs[gracefulQueue][i].length > 2) {
-          fs[gracefulQueue][i][3] = now;
-          fs[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
+        if (fs2[gracefulQueue][i].length > 2) {
+          fs2[gracefulQueue][i][3] = now;
+          fs2[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -5854,9 +5854,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs[gracefulQueue].length === 0)
+      if (fs2[gracefulQueue].length === 0)
         return;
-      var elem = fs[gracefulQueue].shift();
+      var elem = fs2[gracefulQueue].shift();
       var fn = elem[0];
       var args2 = elem[1];
       var err = elem[2];
@@ -5878,7 +5878,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args2);
           fn.apply(null, args2.concat([startTime]));
         } else {
-          fs[gracefulQueue].push(elem);
+          fs2[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -6324,10 +6324,10 @@ var require_mtime_precision = __commonJS({
     "use strict";
     init_esm_shims();
     var cacheSymbol = /* @__PURE__ */ Symbol();
-    function probe(file, fs, callback) {
-      const cachedPrecision = fs[cacheSymbol];
+    function probe(file, fs2, callback) {
+      const cachedPrecision = fs2[cacheSymbol];
       if (cachedPrecision) {
-        return fs.stat(file, (err, stat5) => {
+        return fs2.stat(file, (err, stat5) => {
           if (err) {
             return callback(err);
           }
@@ -6335,16 +6335,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs.utimes(file, mtime, mtime, (err) => {
+      fs2.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs.stat(file, (err2, stat5) => {
+        fs2.stat(file, (err2, stat5) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat5.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs, cacheSymbol, { value: precision });
+          Object.defineProperty(fs2, cacheSymbol, { value: precision });
           callback(null, stat5.mtime, precision);
         });
       });
@@ -6367,7 +6367,7 @@ var require_lockfile = __commonJS({
     "use strict";
     init_esm_shims();
     var path2 = __require("path");
-    var fs = require_graceful_fs();
+    var fs2 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -6498,7 +6498,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs,
+        fs: fs2,
         onCompromised: (err) => {
           throw err;
         },
@@ -6542,7 +6542,7 @@ var require_lockfile = __commonJS({
     }
     function unlock2(file, options, callback) {
       options = {
-        fs,
+        fs: fs2,
         realpath: true,
         ...options
       };
@@ -6564,7 +6564,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs,
+        fs: fs2,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -6604,16 +6604,16 @@ var require_adapter = __commonJS({
   "../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs = require_graceful_fs();
-    function createSyncFs(fs2) {
+    var fs2 = require_graceful_fs();
+    function createSyncFs(fs3) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs2 };
+      const newFs = { ...fs3 };
       methods.forEach((method) => {
         newFs[method] = (...args2) => {
           const callback = args2.pop();
           let ret;
           try {
-            ret = fs2[`${method}Sync`](...args2);
+            ret = fs3[`${method}Sync`](...args2);
           } catch (err) {
             return callback(err);
           }
@@ -6651,7 +6651,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs);
+      options.fs = createSyncFs(options.fs || fs2);
       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" });
       }
@@ -6763,11 +6763,142 @@ var require_keytar2 = __commonJS({
   }
 });
 
-// ../core/src/Storage.ts
-import { join as join13 } from "path";
+// ../core/src/Settings.ts
 import { homedir as homedir7 } from "os";
-import { chmodSync, existsSync as existsSync12, renameSync, unlinkSync } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile6, readFile as readFile11 } from "fs/promises";
+import { join as join13 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import * as fs from "fs";
+import { readFile as readFile11 } from "fs/promises";
+function ensureConfigDir(p) {
+  try {
+    fs.mkdirSync(p, { recursive: true, mode: 448 });
+  } catch (e) {
+    if (e.code === "EEXIST" || e.code === "ENOTDIR") {
+      const stat5 = fs.statSync(p);
+      if (!stat5.isDirectory()) {
+        fs.renameSync(p, `${p}.broken-${Date.now()}`);
+        fs.mkdirSync(p, { recursive: true, mode: 448 });
+      }
+    } else {
+      throw e;
+    }
+  }
+}
+async function readJson(path2) {
+  try {
+    if (!existsSync12(path2)) return null;
+    const text = await readFile11(path2, "utf8");
+    if (!text.trim()) return null;
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function fromEnv(env) {
+  const out = {};
+  for (const [envKey, settingKey] of Object.entries(ENV_MAP)) {
+    const raw = env[envKey];
+    if (raw === void 0) continue;
+    if (settingKey === "maxTokens") {
+      const n = Number.parseInt(raw, 10);
+      if (Number.isFinite(n)) out.maxTokens = n;
+    } else if (settingKey === "temperature") {
+      const n = Number.parseFloat(raw);
+      if (Number.isFinite(n)) out.temperature = n;
+    } else if (settingKey === "ollamaEnabled" || settingKey === "telemetryEnabled") {
+      out[settingKey] = raw === "true" || raw === "1";
+    } else if (settingKey === "defaultMode") {
+      const v = raw;
+      if (["default", "plan", "acceptEdits", "bypassPermissions"].includes(v)) {
+        out.defaultMode = v;
+      }
+    } else {
+      out[settingKey] = raw;
+    }
+  }
+  return out;
+}
+function mergeSettings(base, override) {
+  const out = { ...base, ...override };
+  if (override.mcpServers) {
+    out.mcpServers = { ...base.mcpServers, ...override.mcpServers };
+  }
+  if (override.hooks) {
+    out.hooks = { ...base.hooks, ...override.hooks };
+  }
+  if (override.trustedCommands) {
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const c of [...base.trustedCommands, ...override.trustedCommands]) {
+      if (!seen.has(c)) {
+        seen.add(c);
+        merged.push(c);
+      }
+    }
+    out.trustedCommands = merged;
+  }
+  return out;
+}
+async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
+  const sources = [];
+  const userPath = join13(homedir7() || ".", ".msapling", "settings.json");
+  const projectPath = join13(cwd, ".msapling", "settings.json");
+  const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
+  if (user) sources.push(userPath);
+  if (project) sources.push(projectPath);
+  let settings = DEFAULT_SETTINGS;
+  if (user) settings = mergeSettings(settings, user);
+  if (project) settings = mergeSettings(settings, project);
+  settings = mergeSettings(settings, fromEnv(env));
+  if (settings.temperature < 0 || settings.temperature > 2) {
+    warn?.(`Settings: temperature out of range (${settings.temperature}); clamping to 0.7`);
+    settings = { ...settings, temperature: 0.7 };
+  }
+  if (settings.maxTokens <= 0) {
+    warn?.(`Settings: maxTokens must be positive; resetting to ${DEFAULT_SETTINGS.maxTokens}`);
+    settings = { ...settings, maxTokens: DEFAULT_SETTINGS.maxTokens };
+  }
+  return { settings, sources };
+}
+var DEFAULT_SETTINGS, ENV_MAP;
+var init_Settings = __esm({
+  "../core/src/Settings.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_SETTINGS = {
+      apiUrl: "https://api.msapling.com",
+      defaultModel: "google/gemini-2.0-flash-001",
+      defaultMode: "default",
+      theme: "diamond",
+      maxTokens: 4096,
+      temperature: 0.7,
+      ollamaEnabled: true,
+      ollamaBaseUrl: "http://127.0.0.1:11434",
+      telemetryEnabled: true,
+      mcpServers: {},
+      hooks: {},
+      trustedCommands: [],
+      shellEscapeEnabled: true
+    };
+    ENV_MAP = {
+      MSAPLING_API_URL: "apiUrl",
+      MSAPLING_DEFAULT_MODEL: "defaultModel",
+      MSAPLING_DEFAULT_MODE: "defaultMode",
+      MSAPLING_THEME: "theme",
+      MSAPLING_MAX_TOKENS: "maxTokens",
+      MSAPLING_TEMPERATURE: "temperature",
+      MSAPLING_OLLAMA_ENABLED: "ollamaEnabled",
+      MSAPLING_OLLAMA_BASE_URL: "ollamaBaseUrl",
+      MSAPLING_TELEMETRY_ENABLED: "telemetryEnabled"
+    };
+  }
+});
+
+// ../core/src/Storage.ts
+import { join as join14 } from "path";
+import { homedir as homedir8 } from "os";
+import { chmodSync, existsSync as existsSync13, renameSync as renameSync2, unlinkSync } from "fs";
+import { writeFile as writeFile6, readFile as readFile12 } from "fs/promises";
 var lockfile, keytar, StorageManager;
 var init_Storage = __esm({
   "../core/src/Storage.ts"() {
@@ -6776,6 +6907,7 @@ var init_Storage = __esm({
     init_Mutex();
     lockfile = __toESM(require_proper_lockfile(), 1);
     keytar = __toESM(require_keytar2(), 1);
+    init_Settings();
     StorageManager = class {
       baseDir;
       /**
@@ -6794,16 +6926,16 @@ var init_Storage = __esm({
        */
       _ready;
       constructor() {
-        this.baseDir = join13(homedir7(), ".msapling");
+        this.baseDir = join14(homedir8(), ".msapling");
         this._ready = this.ensureDirs();
       }
       async ensureDirs() {
         try {
-          await mkdir6(this.baseDir, { recursive: true });
-          const subdirs = ["history", "backups", "cache", "vault"];
+          ensureConfigDir(this.baseDir);
+          const subdirs = ["history", "backups", "cache", "vault", "mcp"];
           for (const sub of subdirs) {
-            const path2 = join13(this.baseDir, sub);
-            await mkdir6(path2, { recursive: true });
+            const path2 = join14(this.baseDir, sub);
+            ensureConfigDir(path2);
           }
           if (process.platform !== "win32") {
             chmodSync(this.baseDir, 448);
@@ -6820,11 +6952,11 @@ var init_Storage = __esm({
         await this._ready;
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join13(this.baseDir, "vault", "token");
+        const filePath = join14(this.baseDir, "vault", "token");
         try {
           await keytar.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, token);
           try {
-            if (existsSync12(filePath)) {
+            if (existsSync13(filePath)) {
               unlinkSync(filePath);
             }
           } catch {
@@ -6840,7 +6972,7 @@ var init_Storage = __esm({
       async loadToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join13(this.baseDir, "vault", "token");
+        const filePath = join14(this.baseDir, "vault", "token");
         try {
           const keychainToken = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
           if (keychainToken) {
@@ -6849,8 +6981,8 @@ var init_Storage = __esm({
         } catch (e) {
           console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)}), falling back to file storage`);
         }
-        if (existsSync12(filePath)) {
-          const text = await readFile11(filePath, "utf8");
+        if (existsSync13(filePath)) {
+          const text = await readFile12(filePath, "utf8");
           return text.trim();
         }
         return null;
@@ -6861,16 +6993,16 @@ var init_Storage = __esm({
       async clearToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join13(this.baseDir, "vault", "token");
+        const filePath = join14(this.baseDir, "vault", "token");
         try {
           await keytar.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
         } catch (e) {
           console.debug(`Keychain unavailable for deletion (${e instanceof Error ? e.message : String(e)})`);
         }
         try {
-          if (existsSync12(filePath)) {
-            const fs = await import("fs/promises");
-            await fs.unlink(filePath);
+          if (existsSync13(filePath)) {
+            const fs2 = await import("fs/promises");
+            await fs2.unlink(filePath);
           }
         } catch (e) {
           console.warn(`Failed to delete token file: ${e}`);
@@ -6884,23 +7016,26 @@ var init_Storage = __esm({
        * This ensures:
        * 1. Only one process writes at a time (file lock)
        * 2. Partial writes don't corrupt the JSON (atomic rename)
+       *
+       * CLI-LSTAT-HISTORY-01: Pass realpath:false so lockfile never calls lstat on a
+       * path that may not exist yet (first run before any history has been written).
        */
       async saveHistory(history) {
-        const path2 = join13(this.baseDir, "history", "shell_history.json");
+        const path2 = join14(this.baseDir, "history", "shell_history.json");
         let release2;
         try {
-          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
+          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50, realpath: false });
           await this.historyMutex.run(async () => {
             const tmpPath = `${path2}.tmp`;
             const content = JSON.stringify(history, null, 2);
             await writeFile6(tmpPath, content, "utf8");
             try {
-              renameSync(tmpPath, path2);
+              renameSync2(tmpPath, path2);
             } catch (e) {
               try {
-                if (existsSync12(tmpPath)) {
-                  const fs = await import("fs/promises");
-                  await fs.unlink(tmpPath);
+                if (existsSync13(tmpPath)) {
+                  const fs2 = await import("fs/promises");
+                  await fs2.unlink(tmpPath);
                 }
               } catch {
               }
@@ -6910,7 +7045,7 @@ var init_Storage = __esm({
         } finally {
           if (release2) {
             try {
-              await lockfile.unlock(path2, { skipStale: true });
+              await lockfile.unlock(path2, { skipStale: true, realpath: false });
             } catch (e) {
               console.warn(`Failed to unlock history file: ${e}`);
             }
@@ -6921,23 +7056,41 @@ var init_Storage = __esm({
        * SYNC-01: Serialised history read with file-based locking.
        * Reads are gated behind the file lock so a read that overlaps with an
        * in-progress write from another process always sees a complete, valid JSON.
+       *
+       * CLI-LSTAT-HISTORY-01: Short-circuit before locking when the file is absent
+       * so lockfile never calls lstat/realpath on a nonexistent path (ENOENT crash
+       * on fresh install).  Corrupt JSON is caught, backed up, and treated as empty
+       * rather than propagating a parse error.
        */
       async loadHistory() {
-        const path2 = join13(this.baseDir, "history", "shell_history.json");
+        const path2 = join14(this.baseDir, "history", "shell_history.json");
+        if (!existsSync13(path2)) {
+          return [];
+        }
         let release2;
         try {
-          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
-          return this.historyMutex.run(async () => {
-            if (existsSync12(path2)) {
-              const text = await readFile11(path2, "utf8");
+          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50, realpath: false });
+          return await this.historyMutex.run(async () => {
+            if (!existsSync13(path2)) {
+              return [];
+            }
+            const text = await readFile12(path2, "utf8");
+            try {
               return JSON.parse(text);
+            } catch {
+              console.warn("[msapling] shell_history.json is corrupt; resetting to empty history.");
+              const backupPath = `${path2}.corrupt.${Date.now()}.bak`;
+              try {
+                renameSync2(path2, backupPath);
+              } catch {
+              }
+              return [];
             }
-            return [];
           });
         } finally {
           if (release2) {
             try {
-              await lockfile.unlock(path2, { skipStale: true });
+              await lockfile.unlock(path2, { skipStale: true, realpath: false });
             } catch (e) {
               console.warn(`Failed to unlock history file: ${e}`);
             }
@@ -6946,23 +7099,24 @@ var init_Storage = __esm({
       }
       /**
        * SYNC-01: Serialised permissions write with file-based locking.
+       * CLI-LSTAT-HISTORY-01: realpath:false prevents ENOENT lstat on first run.
        */
       async savePermissions(permissions) {
-        const path2 = join13(this.baseDir, "vault", "permissions.json");
+        const path2 = join14(this.baseDir, "vault", "permissions.json");
         let release2;
         try {
-          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
+          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50, realpath: false });
           await this.permissionsMutex.run(async () => {
             const tmpPath = `${path2}.tmp`;
             const content = JSON.stringify(permissions, null, 2);
             await writeFile6(tmpPath, content, "utf8");
             try {
-              renameSync(tmpPath, path2);
+              renameSync2(tmpPath, path2);
             } catch (e) {
               try {
-                if (existsSync12(tmpPath)) {
-                  const fs = await import("fs/promises");
-                  await fs.unlink(tmpPath);
+                if (existsSync13(tmpPath)) {
+                  const fs2 = await import("fs/promises");
+                  await fs2.unlink(tmpPath);
                 }
               } catch {
               }
@@ -6972,7 +7126,7 @@ var init_Storage = __esm({
         } finally {
           if (release2) {
             try {
-              await lockfile.unlock(path2, { skipStale: true });
+              await lockfile.unlock(path2, { skipStale: true, realpath: false });
             } catch (e) {
               console.warn(`Failed to unlock permissions file: ${e}`);
             }
@@ -6981,23 +7135,28 @@ var init_Storage = __esm({
       }
       /**
        * SYNC-01: Serialised permissions read with file-based locking.
+       * CLI-LSTAT-HISTORY-01: Short-circuit on missing file; realpath:false avoids
+       * lstat on a path that may not exist yet on a fresh install.
        */
       async loadPermissions() {
-        const path2 = join13(this.baseDir, "vault", "permissions.json");
+        const path2 = join14(this.baseDir, "vault", "permissions.json");
+        if (!existsSync13(path2)) {
+          return { trustedCommands: [], trustedPaths: [] };
+        }
         let release2;
         try {
-          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
-          return this.permissionsMutex.run(async () => {
-            if (existsSync12(path2)) {
-              const text = await readFile11(path2, "utf8");
-              return JSON.parse(text);
+          release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50, realpath: false });
+          return await this.permissionsMutex.run(async () => {
+            if (!existsSync13(path2)) {
+              return { trustedCommands: [], trustedPaths: [] };
             }
-            return { trustedCommands: [], trustedPaths: [] };
+            const text = await readFile12(path2, "utf8");
+            return JSON.parse(text);
           });
         } finally {
           if (release2) {
             try {
-              await lockfile.unlock(path2, { skipStale: true });
+              await lockfile.unlock(path2, { skipStale: true, realpath: false });
             } catch (e) {
               console.warn(`Failed to unlock permissions file: ${e}`);
             }
@@ -7012,7 +7171,7 @@ var init_Storage = __esm({
       async backup(filePath, content) {
         const filename = filePath.split("/").pop() || "file";
         const timestamp = Date.now();
-        const backupPath = join13(this.baseDir, "backups", `${filename}.${timestamp}.bak`);
+        const backupPath = join14(this.baseDir, "backups", `${filename}.${timestamp}.bak`);
         await writeFile6(backupPath, content, "utf8");
         if (process.platform !== "win32") {
           chmodSync(backupPath, 384);
@@ -7023,121 +7182,6 @@ var init_Storage = __esm({
   }
 });
 
-// ../core/src/Settings.ts
-import { homedir as homedir8 } from "os";
-import { join as join14 } from "path";
-import { existsSync as existsSync13 } from "fs";
-import { readFile as readFile12 } from "fs/promises";
-async function readJson(path2) {
-  try {
-    if (!existsSync13(path2)) return null;
-    const text = await readFile12(path2, "utf8");
-    if (!text.trim()) return null;
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-function fromEnv(env) {
-  const out = {};
-  for (const [envKey, settingKey] of Object.entries(ENV_MAP)) {
-    const raw = env[envKey];
-    if (raw === void 0) continue;
-    if (settingKey === "maxTokens") {
-      const n = Number.parseInt(raw, 10);
-      if (Number.isFinite(n)) out.maxTokens = n;
-    } else if (settingKey === "temperature") {
-      const n = Number.parseFloat(raw);
-      if (Number.isFinite(n)) out.temperature = n;
-    } else if (settingKey === "ollamaEnabled" || settingKey === "telemetryEnabled") {
-      out[settingKey] = raw === "true" || raw === "1";
-    } else if (settingKey === "defaultMode") {
-      const v = raw;
-      if (["default", "plan", "acceptEdits", "bypassPermissions"].includes(v)) {
-        out.defaultMode = v;
-      }
-    } else {
-      out[settingKey] = raw;
-    }
-  }
-  return out;
-}
-function mergeSettings(base, override) {
-  const out = { ...base, ...override };
-  if (override.mcpServers) {
-    out.mcpServers = { ...base.mcpServers, ...override.mcpServers };
-  }
-  if (override.hooks) {
-    out.hooks = { ...base.hooks, ...override.hooks };
-  }
-  if (override.trustedCommands) {
-    const seen = /* @__PURE__ */ new Set();
-    const merged = [];
-    for (const c of [...base.trustedCommands, ...override.trustedCommands]) {
-      if (!seen.has(c)) {
-        seen.add(c);
-        merged.push(c);
-      }
-    }
-    out.trustedCommands = merged;
-  }
-  return out;
-}
-async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
-  const sources = [];
-  const userPath = join14(homedir8() || ".", ".msapling", "settings.json");
-  const projectPath = join14(cwd, ".msapling", "settings.json");
-  const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
-  if (user) sources.push(userPath);
-  if (project) sources.push(projectPath);
-  let settings = DEFAULT_SETTINGS;
-  if (user) settings = mergeSettings(settings, user);
-  if (project) settings = mergeSettings(settings, project);
-  settings = mergeSettings(settings, fromEnv(env));
-  if (settings.temperature < 0 || settings.temperature > 2) {
-    warn?.(`Settings: temperature out of range (${settings.temperature}); clamping to 0.7`);
-    settings = { ...settings, temperature: 0.7 };
-  }
-  if (settings.maxTokens <= 0) {
-    warn?.(`Settings: maxTokens must be positive; resetting to ${DEFAULT_SETTINGS.maxTokens}`);
-    settings = { ...settings, maxTokens: DEFAULT_SETTINGS.maxTokens };
-  }
-  return { settings, sources };
-}
-var DEFAULT_SETTINGS, ENV_MAP;
-var init_Settings = __esm({
-  "../core/src/Settings.ts"() {
-    "use strict";
-    init_esm_shims();
-    DEFAULT_SETTINGS = {
-      apiUrl: "https://api.msapling.com",
-      defaultModel: "google/gemini-2.0-flash-001",
-      defaultMode: "default",
-      theme: "diamond",
-      maxTokens: 4096,
-      temperature: 0.7,
-      ollamaEnabled: true,
-      ollamaBaseUrl: "http://127.0.0.1:11434",
-      telemetryEnabled: true,
-      mcpServers: {},
-      hooks: {},
-      trustedCommands: [],
-      shellEscapeEnabled: true
-    };
-    ENV_MAP = {
-      MSAPLING_API_URL: "apiUrl",
-      MSAPLING_DEFAULT_MODEL: "defaultModel",
-      MSAPLING_DEFAULT_MODE: "defaultMode",
-      MSAPLING_THEME: "theme",
-      MSAPLING_MAX_TOKENS: "maxTokens",
-      MSAPLING_TEMPERATURE: "temperature",
-      MSAPLING_OLLAMA_ENABLED: "ollamaEnabled",
-      MSAPLING_OLLAMA_BASE_URL: "ollamaBaseUrl",
-      MSAPLING_TELEMETRY_ENABLED: "telemetryEnabled"
-    };
-  }
-});
-
 // ../core/src/mcp/client.ts
 import { spawn as spawn8 } from "child_process";
 var PROTOCOL_VERSION, CLIENT_INFO, MCPClientError, MCPClient, MCPRegistry;
@@ -8592,13 +8636,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync19, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
 import { readFile as readFile17 } from "fs/promises";
 import { join as join19, resolve as resolve14 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
     const full = resolve14(cwd, candidate);
-    if (existsSync19(full) && statSync4(full).isDirectory()) return full;
+    if (existsSync19(full) && statSync5(full).isDirectory()) return full;
   }
   return null;
 }
@@ -8614,7 +8658,7 @@ function listAllSkills(root) {
     const dir = join19(root, domain);
     let s;
     try {
-      s = statSync4(dir);
+      s = statSync5(dir);
     } catch {
       continue;
     }
@@ -8718,7 +8762,7 @@ ${prompt}`;
 // src/commands/benchmark.ts
 import { homedir as homedir11 } from "os";
 import { join as join20 } from "path";
-import { mkdirSync as mkdirSync3, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync4, writeFileSync } from "fs";
 function parseArgs(args2) {
   let models = null;
   let rounds = 1;
@@ -8834,7 +8878,7 @@ HW at start: ${hw.cores}-core ${hw.platform} | CPU ${hw.cpuPct}% | RAM ${hw.ramP
         );
         try {
           const dir = join20(homedir11(), ".msapling", "benchmarks");
-          mkdirSync3(dir, { recursive: true });
+          mkdirSync4(dir, { recursive: true });
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
           const file = join20(dir, `${ts}.json`);
           const run = {
@@ -9085,7 +9129,7 @@ var init_theme = __esm({
 import { join as join21 } from "path";
 import { homedir as homedir12 } from "os";
 import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile18, writeFile as writeFile9, mkdir as mkdir8 } from "fs/promises";
+import { readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
 async function persistTheme(storage, themeName) {
   const settingsPath = join21(homedir12(), ".msapling", "settings.json");
   let existing = {};
@@ -9097,7 +9141,7 @@ async function persistTheme(storage, themeName) {
   } catch {
   }
   existing["theme"] = themeName;
-  await mkdir8(join21(homedir12(), ".msapling"), { recursive: true });
+  ensureConfigDir(join21(homedir12(), ".msapling"));
   await writeFile9(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
@@ -9106,6 +9150,7 @@ var init_theme2 = __esm({
     "use strict";
     init_esm_shims();
     init_theme();
+    init_src3();
     VALID_THEMES = ["diamond", "onyx", "mono"];
     themeCommand = {
       name: "theme",
@@ -9258,7 +9303,7 @@ var init_feedback = __esm({
 // src/commands/export.ts
 import { homedir as homedir13 } from "os";
 import { join as join24 } from "path";
-import { writeFile as writeFile10, mkdir as mkdir9 } from "fs/promises";
+import { writeFile as writeFile10, mkdir as mkdir8 } from "fs/promises";
 function formatTimestamp(date) {
   return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
 }
@@ -9323,7 +9368,7 @@ var init_export = __esm({
         }
         try {
           const dir = join24(outputPath, "..");
-          await mkdir9(dir, { recursive: true });
+          await mkdir8(dir, { recursive: true });
           await writeFile10(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
         } catch (e) {
@@ -9519,7 +9564,7 @@ var init_plan = __esm({
 // src/commands/note.ts
 import { homedir as homedir14 } from "os";
 import { join as join25 } from "path";
-import { mkdirSync as mkdirSync4, existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
 function getNotesFilePath() {
   return join25(homedir14(), ".msapling", "notes.json");
@@ -9537,7 +9582,7 @@ async function readNotes(filePath = getNotesFilePath()) {
 }
 async function writeNotes(notes, filePath = getNotesFilePath()) {
   const dir = join25(homedir14(), ".msapling");
-  mkdirSync4(dir, { recursive: true });
+  ensureConfigDir(dir);
   await writeFile11(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
 function formatTimestamp2(iso) {
@@ -11288,7 +11333,7 @@ __export(server_exports, {
   runStdio: () => runStdio,
   runStdioWithRegistry: () => runStdioWithRegistry
 });
-import { readdirSync as readdirSync3, readFileSync, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync3, readFileSync, statSync as statSync6 } from "fs";
 import { join as join26, relative as relative14, resolve as resolve16 } from "path";
 function asResult2(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
@@ -11312,7 +11357,7 @@ function buildFileTree(root, maxFiles) {
       const full = join26(dir, name);
       let s;
       try {
-        s = statSync5(full);
+        s = statSync6(full);
       } catch {
         continue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtreeai/msapling-cli",
-  "version": "2.3.6-beta.1",
+  "version": "2.3.6-beta.3",
   "description": "MSapling CLI — React/Ink terminal client for the MSapling backend (chat, projects, MDrive, agent tools). Proprietary, see LICENSE.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "MSapling Team",