@mtreeai/msapling-cli 2.3.6-beta.43 → 2.3.6-beta.45

package/dist/index.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -15,9 +13,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,22 +25,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.bun/tsup@8.5.1+2af0484081a85c02/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
-  "../../node_modules/.bun/tsup@8.5.1+2af0484081a85c02/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -304,17 +291,61 @@ import {
   renameSync,
   writeFileSync
 } from "fs";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+function configureJournalCrypto(provider) {
+  _journalKeyProvider = provider;
+}
+function resetJournalCrypto() {
+  _journalKeyProvider = null;
+}
+function requireKey() {
+  const key = _journalKeyProvider ? _journalKeyProvider() : null;
+  if (!key || key.length !== 32) throw new JournalEncryptionUnavailableError();
+  return key;
+}
+function encryptContent(plaintext) {
+  const key = requireKey();
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return ENC_PREFIX + Buffer.concat([iv, tag, ct]).toString("base64");
+}
+function isEncrypted(value) {
+  return typeof value === "string" && value.startsWith(ENC_PREFIX);
+}
+function decryptContent(stored) {
+  if (!isEncrypted(stored)) return stored;
+  const key = requireKey();
+  const buf = Buffer.from(stored.slice(ENC_PREFIX.length), "base64");
+  const iv = buf.subarray(0, 12);
+  const tag = buf.subarray(12, 28);
+  const ct = buf.subarray(28);
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ct), decipher.final()]).toString("utf8");
+}
 function getJournal() {
   if (!journalInstance) {
     journalInstance = new Journal();
   }
   return journalInstance;
 }
-var DatabaseConnection, Journal, journalInstance;
+var ENC_PREFIX, _journalKeyProvider, JournalEncryptionUnavailableError, DatabaseConnection, Journal, journalInstance;
 var init_journal = __esm({
   "../api-client/src/journal.ts"() {
     "use strict";
     init_esm_shims();
+    ENC_PREFIX = "enc:v1:";
+    _journalKeyProvider = null;
+    JournalEncryptionUnavailableError = class extends Error {
+      constructor() {
+        super(
+          "Cannot write offline journal entry: no encryption key is available. The journal refuses to persist chat content in plaintext. Ensure the OS keychain is reachable (so the journal key can be stored) and retry."
+        );
+        this.name = "JournalEncryptionUnavailableError";
+      }
+    };
     try {
       const sqlite = __require("sqlite");
       DatabaseConnection = sqlite;
@@ -328,7 +359,7 @@ var init_journal = __esm({
       db = null;
       jsonlEntries = [];
       constructor() {
-        const home = homedir2();
+        const home = process.env.HOME || process.env.USERPROFILE || homedir2();
         const msaplingDir = join2(home, ".msapling");
         this.dbPath = join2(msaplingDir, "journal.sqlite");
         this.jsonlPath = join2(msaplingDir, "journal.jsonl");
@@ -385,11 +416,14 @@ var init_journal = __esm({
           for (const line of content.split("\n")) {
             const trimmed = line.trim();
             if (!trimmed) continue;
+            let parsed;
             try {
-              this.jsonlEntries.push(JSON.parse(trimmed));
+              parsed = JSON.parse(trimmed);
             } catch {
               malformed++;
+              continue;
             }
+            this.jsonlEntries.push(parsed);
           }
           if (malformed > 0) {
             console.warn(`[Journal] Skipped ${malformed} malformed JSONL line(s)`);
@@ -399,10 +433,21 @@ var init_journal = __esm({
         }
       }
       async journalAppend(entry) {
+        let encryptedContent;
+        try {
+          encryptedContent = encryptContent(entry.content);
+        } catch (e) {
+          if (e instanceof JournalEncryptionUnavailableError) {
+            console.warn("[Journal] Skipping append: encryption key unavailable (refusing to write plaintext).");
+            return;
+          }
+          throw e;
+        }
         if (this.useJsonl) {
-          this.jsonlEntries.push(entry);
+          const onDisk = { ...entry, content: encryptedContent };
+          this.jsonlEntries.push(onDisk);
           try {
-            appendFileSync(this.jsonlPath, JSON.stringify(entry) + "\n", "utf8");
+            appendFileSync(this.jsonlPath, JSON.stringify(onDisk) + "\n", "utf8");
           } catch (e) {
             console.warn("[Journal] Failed to append JSONL entry", e);
           }
@@ -417,7 +462,7 @@ var init_journal = __esm({
               entry.chat_id,
               entry.project_id || null,
               entry.role,
-              entry.content,
+              encryptedContent,
               entry.ts,
               entry.model || null,
               entry.token_count || null,
@@ -429,8 +474,15 @@ var init_journal = __esm({
         }
       }
       async journalListPending() {
+        const decryptEntry = (e) => {
+          try {
+            return { ...e, content: decryptContent(e.content) };
+          } catch {
+            return { ...e, content: "[encrypted \u2014 key unavailable]" };
+          }
+        };
         if (this.useJsonl) {
-          return this.jsonlEntries.filter((e) => !e.synced_at);
+          return this.jsonlEntries.filter((e) => !e.synced_at).map(decryptEntry);
         }
         if (!this.db) return [];
         try {
@@ -441,7 +493,7 @@ var init_journal = __esm({
         ORDER BY ts ASC
       `);
           const rows = stmt.all();
-          return rows.map((r) => ({
+          return rows.map((r) => decryptEntry({
             id: r.id,
             chat_id: r.chat_id,
             project_id: r.project_id,
@@ -521,18 +573,18 @@ var init_journal = __esm({
 });
 
 // ../api-client/src/oauth.ts
-import { randomBytes, createHash } from "crypto";
+import { randomBytes as randomBytes2, createHash } from "crypto";
 function base64url(buf) {
   return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 function generateState() {
-  return base64url(randomBytes(32));
+  return base64url(randomBytes2(32));
 }
 function generateNonce() {
-  return base64url(randomBytes(24));
+  return base64url(randomBytes2(24));
 }
 function generatePKCE() {
-  const verifier = base64url(randomBytes(32));
+  const verifier = base64url(randomBytes2(32));
   const challenge = base64url(createHash("sha256").update(verifier).digest());
   return { verifier, challenge, method: "S256" };
 }
@@ -720,19 +772,24 @@ var init_refreshFamily = __esm({
 var src_exports = {};
 __export(src_exports, {
   Journal: () => Journal,
+  JournalEncryptionUnavailableError: () => JournalEncryptionUnavailableError,
   LocalLlmClient: () => LocalLlmClient,
   MSaplingClient: () => MSaplingClient,
   MSaplingError: () => MSaplingError,
   OllamaClient: () => OllamaClient,
   RefreshTokenFamilyStore: () => RefreshTokenFamilyStore,
+  configureJournalCrypto: () => configureJournalCrypto,
   decodeJwtClaims: () => decodeJwtClaims,
+  decryptContent: () => decryptContent,
   detectLocalLlm: () => detectLocalLlm,
+  encryptContent: () => encryptContent,
   generateNonce: () => generateNonce,
   generatePKCE: () => generatePKCE,
   generateState: () => generateState,
   getJournal: () => getJournal,
   newTransaction: () => newTransaction,
   probeDialect: () => probeDialect,
+  resetJournalCrypto: () => resetJournalCrypto,
   timingSafeEquals: () => timingSafeEquals,
   validateJwtClaims: () => validateJwtClaims
 });
@@ -803,10 +860,14 @@ var init_src = __esm({
        *   controller.abort();
        */
       _clientSignal;
+      // CLI-STREAM-IDLE-TIMEOUT-01: per-chunk idle deadline for streamChat's
+      // reader loop (see ClientOptions.streamIdleTimeoutMs). Defaults to 60s.
+      _streamIdleTimeoutMs;
       constructor(options = {}) {
         this.apiUrl = (options.apiUrl || "https://api.msapling.com").replace(/\/$/, "");
         this.token = options.token || null;
         this._clientSignal = options.signal;
+        this._streamIdleTimeoutMs = options.streamIdleTimeoutMs ?? 6e4;
       }
       setToken(token) {
         this.token = token;
@@ -871,6 +932,9 @@ var init_src = __esm({
         if (!headers.has("Content-Type")) {
           headers.set("Content-Type", "application/json");
         }
+        if (!headers.has("X-Client-Type")) {
+          headers.set("X-Client-Type", "cli");
+        }
         if (this.cookies.size > 0) {
           headers.set("Cookie", this.serializeCookies());
         }
@@ -923,6 +987,12 @@ var init_src = __esm({
             }
           }
           return response.json();
+        } catch (e) {
+          if (e instanceof MSaplingError) throw e;
+          if (e?.name === "AbortError") {
+            throw new MSaplingError("Request timed out after 30s.", 408, "timeout");
+          }
+          throw e;
         } finally {
           clearTimeout(timeout);
         }
@@ -1598,10 +1668,25 @@ var init_src = __esm({
           else this._clientSignal.addEventListener("abort", externalAbortHandler);
         }
         const timeout = setTimeout(() => controller.abort(), 3e4);
+        let idleTimer;
+        let idleAborted = false;
+        const idleMs = this._streamIdleTimeoutMs;
+        const armIdleTimer = () => {
+          if (!idleMs || idleMs <= 0) return;
+          if (idleTimer) clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => {
+            idleAborted = true;
+            controller.abort();
+          }, idleMs);
+        };
         try {
           const headers = {
             "Authorization": `Bearer ${this.token}`,
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
+            // CLI-CLIENT-TYPE-HEADER-01: identify the chat-stream surface as "cli"
+            // so the backend's active-stream registry / 423 lock-owner message
+            // attributes the slot correctly instead of defaulting to "web".
+            "X-Client-Type": "cli"
           };
           if (this.cookies.size > 0) {
             headers["Cookie"] = this.serializeCookies();
@@ -1639,21 +1724,29 @@ var init_src = __esm({
           if (!response.body) throw new Error("No response body");
           const reader = response.body.getReader();
           const decoder = new TextDecoder();
+          armIdleTimer();
           let pending = "";
           const yieldLine = function* (raw) {
             const line = raw.replace(/\r$/, "").trim();
             if (!line) return;
+            let parsed;
             try {
-              yield JSON.parse(line);
+              parsed = JSON.parse(line);
             } catch {
               if (line.startsWith("{")) {
                 console.warn(`[Stream] Dropped malformed JSON: ${line}`);
               }
+              return;
+            }
+            if (parsed && typeof parsed === "object" && typeof parsed.error === "string" && parsed.error) {
+              throw new MSaplingError(parsed.error, void 0, "stream_error");
             }
+            yield parsed;
           };
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;
+            armIdleTimer();
             pending += decoder.decode(value, { stream: true });
             let nlIdx;
             while ((nlIdx = pending.indexOf("\n")) !== -1) {
@@ -1669,12 +1762,20 @@ var init_src = __esm({
           }
         } catch (e) {
           if (e.name === "AbortError") {
+            if (idleAborted) {
+              throw new MSaplingError(
+                `Stream stalled \u2014 no data for ${Math.round(idleMs / 1e3)}s.`,
+                408,
+                "stream_idle_timeout"
+              );
+            }
             if (externalSignal?.aborted || this._clientSignal?.aborted) throw e;
             throw new MSaplingError("Request timed out after 30s.", 408, "timeout");
           }
           throw e;
         } finally {
           clearTimeout(timeout);
+          if (idleTimer) clearTimeout(idleTimer);
           if (externalSignal) {
             externalSignal.removeEventListener("abort", externalAbortHandler);
           }
@@ -1899,7 +2000,7 @@ import { resolve as resolve2, normalize as normalize2, relative as relative2, is
 import { writeFile, readFile as readFile3, mkdir } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 var MAX_CONTENT_BYTES, WriteFileTool;
 var init_WriteFileTool = __esm({
   "../core/src/tools/WriteFileTool.ts"() {
@@ -1976,7 +2077,7 @@ var init_WriteFileTool = __esm({
             const existingContent = await readFile3(resolvedTarget, "utf8");
             const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-            const suffix = randomBytes2(4).toString("hex");
+            const suffix = randomBytes3(4).toString("hex");
             const backupPath = join4(homedir3(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
             await mkdir(join4(homedir3(), ".msapling", "backups"), { recursive: true });
             await writeFile(backupPath, existingContent, "utf8");
@@ -2004,236 +2105,17 @@ Previous content backed up to: ${backedUpTo}`;
   }
 });
 
-// ../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/quote.js
-var require_quote = __commonJS({
-  "../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/quote.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = function quote(xs) {
-      return xs.map(function(s) {
-        if (s === "") {
-          return "''";
-        }
-        if (s && typeof s === "object") {
-          return s.op.replace(/(.)/g, "\\$1");
-        }
-        if (/["\s\\]/.test(s) && !/'/.test(s)) {
-          return "'" + s.replace(/(['])/g, "\\$1") + "'";
-        }
-        if (/["'\s]/.test(s)) {
-          return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
-        }
-        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
-      }).join(" ");
-    };
-  }
-});
-
-// ../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/parse.js
-var require_parse = __commonJS({
-  "../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/parse.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var CONTROL = "(?:" + [
-      "\\|\\|",
-      "\\&\\&",
-      ";;",
-      "\\|\\&",
-      "\\<\\(",
-      "\\<\\<\\<",
-      ">>",
-      ">\\&",
-      "<\\&",
-      "[&;()|<>]"
-    ].join("|") + ")";
-    var controlRE = new RegExp("^" + CONTROL + "$");
-    var META = "|&;()<> \\t";
-    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
-    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
-    var hash = /^#$/;
-    var SQ = "'";
-    var DQ = '"';
-    var DS = "$";
-    var TOKEN = "";
-    var mult = 4294967296;
-    for (i = 0; i < 4; i++) {
-      TOKEN += (mult * Math.random()).toString(16);
-    }
-    var i;
-    var startsWithToken = new RegExp("^" + TOKEN);
-    function matchAll(s, r) {
-      var origIndex = r.lastIndex;
-      var matches2 = [];
-      var matchObj;
-      while (matchObj = r.exec(s)) {
-        matches2.push(matchObj);
-        if (r.lastIndex === matchObj.index) {
-          r.lastIndex += 1;
-        }
-      }
-      r.lastIndex = origIndex;
-      return matches2;
-    }
-    function getVar(env, pre, key) {
-      var r = typeof env === "function" ? env(key) : env[key];
-      if (typeof r === "undefined" && key != "") {
-        r = "";
-      } else if (typeof r === "undefined") {
-        r = "$";
-      }
-      if (typeof r === "object") {
-        return pre + TOKEN + JSON.stringify(r) + TOKEN;
-      }
-      return pre + r;
-    }
-    function parseInternal(string, env, opts) {
-      if (!opts) {
-        opts = {};
-      }
-      var BS = opts.escape || "\\";
-      var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
-      var chunker = new RegExp([
-        "(" + CONTROL + ")",
-        // control chars
-        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
-      ].join("|"), "g");
-      var matches2 = matchAll(string, chunker);
-      if (matches2.length === 0) {
-        return [];
-      }
-      if (!env) {
-        env = {};
-      }
-      var commented = false;
-      return matches2.map(function(match) {
-        var s = match[0];
-        if (!s || commented) {
-          return void 0;
-        }
-        if (controlRE.test(s)) {
-          return { op: s };
-        }
-        var quote = false;
-        var esc = false;
-        var out = "";
-        var isGlob = false;
-        var i2;
-        function parseEnvVar() {
-          i2 += 1;
-          var varend;
-          var varname;
-          var char = s.charAt(i2);
-          if (char === "{") {
-            i2 += 1;
-            if (s.charAt(i2) === "}") {
-              throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
-            }
-            varend = s.indexOf("}", i2);
-            if (varend < 0) {
-              throw new Error("Bad substitution: " + s.slice(i2));
-            }
-            varname = s.slice(i2, varend);
-            i2 = varend;
-          } else if (/[*@#?$!_-]/.test(char)) {
-            varname = char;
-            i2 += 1;
-          } else {
-            var slicedFromI = s.slice(i2);
-            varend = slicedFromI.match(/[^\w\d_]/);
-            if (!varend) {
-              varname = slicedFromI;
-              i2 = s.length;
-            } else {
-              varname = slicedFromI.slice(0, varend.index);
-              i2 += varend.index - 1;
-            }
-          }
-          return getVar(env, "", varname);
-        }
-        for (i2 = 0; i2 < s.length; i2++) {
-          var c = s.charAt(i2);
-          isGlob = isGlob || !quote && (c === "*" || c === "?");
-          if (esc) {
-            out += c;
-            esc = false;
-          } else if (quote) {
-            if (c === quote) {
-              quote = false;
-            } else if (quote == SQ) {
-              out += c;
-            } else {
-              if (c === BS) {
-                i2 += 1;
-                c = s.charAt(i2);
-                if (c === DQ || c === BS || c === DS) {
-                  out += c;
-                } else {
-                  out += BS + c;
-                }
-              } else if (c === DS) {
-                out += parseEnvVar();
-              } else {
-                out += c;
-              }
-            }
-          } else if (c === DQ || c === SQ) {
-            quote = c;
-          } else if (controlRE.test(c)) {
-            return { op: s };
-          } else if (hash.test(c)) {
-            commented = true;
-            var commentObj = { comment: string.slice(match.index + i2 + 1) };
-            if (out.length) {
-              return [out, commentObj];
-            }
-            return [commentObj];
-          } else if (c === BS) {
-            esc = true;
-          } else if (c === DS) {
-            out += parseEnvVar();
-          } else {
-            out += c;
-          }
-        }
-        if (isGlob) {
-          return { op: "glob", pattern: out };
-        }
-        return out;
-      }).reduce(function(prev, arg) {
-        return typeof arg === "undefined" ? prev : prev.concat(arg);
-      }, []);
-    }
-    module.exports = function parse(s, env, opts) {
-      var mapped = parseInternal(s, env, opts);
-      if (typeof env !== "function") {
-        return mapped;
-      }
-      return mapped.reduce(function(acc, s2) {
-        if (typeof s2 === "object") {
-          return acc.concat(s2);
-        }
-        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
-        if (xs.length === 1) {
-          return acc.concat(xs[0]);
-        }
-        return acc.concat(xs.filter(Boolean).map(function(x) {
-          if (startsWithToken.test(x)) {
-            return JSON.parse(x.split(TOKEN)[1]);
-          }
-          return x;
-        }));
-      }, []);
-    };
-  }
-});
-
-// ../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/index.js
-var require_shell_quote = __commonJS({
-  "../../node_modules/.bun/shell-quote@1.8.3/node_modules/shell-quote/index.js"(exports) {
+// ../core/src/shellQuote.ts
+import { createRequire as nodeCreateRequire } from "module";
+var requireShellQuote, impl, parse, quote;
+var init_shellQuote = __esm({
+  "../core/src/shellQuote.ts"() {
     "use strict";
     init_esm_shims();
-    exports.quote = require_quote();
-    exports.parse = require_parse();
+    requireShellQuote = nodeCreateRequire(import.meta.url);
+    impl = requireShellQuote("shell-quote/index.js");
+    parse = impl.parse;
+    quote = impl.quote;
   }
 });
 
@@ -2241,13 +2123,13 @@ var require_shell_quote = __commonJS({
 import { spawn } from "child_process";
 import { resolve as resolve3, relative as relative3, isAbsolute as isAbsolute3 } from "path";
 import { realpath } from "fs/promises";
-var import_shell_quote, RunCommandTool;
+var RunCommandTool;
 var init_RunCommandTool = __esm({
   "../core/src/tools/RunCommandTool.ts"() {
     "use strict";
     init_esm_shims();
     init_BaseTool();
-    import_shell_quote = __toESM(require_shell_quote(), 1);
+    init_shellQuote();
     RunCommandTool = class _RunCommandTool extends BaseTool {
       name = "run_command";
       description = "Execute a shell command and return its output.";
@@ -2290,7 +2172,7 @@ var init_RunCommandTool = __esm({
             isError: true
           };
         }
-        const parsed = (0, import_shell_quote.parse)(args2.command);
+        const parsed = parse(args2.command);
         const argv = parsed.filter((tok) => typeof tok === "string").map(String);
         if (argv.length === 0) {
           return {
@@ -2301,7 +2183,8 @@ var init_RunCommandTool = __esm({
         let cwd = projectRoot;
         if (args2.cwd && typeof args2.cwd === "string" && args2.cwd.trim()) {
           const rawCwd = args2.cwd.trim();
-          if (isAbsolute3(rawCwd)) {
+          const isWindowsStyleAbsolute = /^[a-zA-Z]:[\\/]/.test(rawCwd) || rawCwd.startsWith("\\");
+          if (isAbsolute3(rawCwd) || isWindowsStyleAbsolute) {
             return {
               content: `Error: invalid cwd "${args2.cwd}" \u2014 must be a relative path within the project root.`,
               isError: true
@@ -3340,7 +3223,7 @@ import { resolve as resolve6, normalize as normalize5, relative as relative6, is
 import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir4 } from "os";
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 var PatchFileTool;
 var init_PatchFileTool = __esm({
   "../core/src/tools/PatchFileTool.ts"() {
@@ -3448,7 +3331,7 @@ File preview (first 200 chars): ${JSON.stringify(preview)}`,
         try {
           const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes3(4).toString("hex");
+          const suffix = randomBytes4(4).toString("hex");
           const backupPath = join8(homedir4(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
           await mkdir2(join8(homedir4(), ".msapling", "backups"), { recursive: true });
           await writeFile2(backupPath, originalContent, "utf8");
@@ -4028,7 +3911,7 @@ Command: ${command}`,
           proc = spawn5(shellArgv[0], shellArgv.slice(1), {
             cwd,
             stdio: ["pipe", "pipe", "pipe"],
-            shell: true
+            shell: false
           });
         } catch (e) {
           return {
@@ -4309,7 +4192,7 @@ import { resolve as resolve9, normalize as normalize8, relative as relative9, is
 import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir5 } from "os";
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 function normaliseSource(source) {
   if (source === "") return [];
   const lines = source.split("\n");
@@ -4487,7 +4370,7 @@ var init_NotebookEditTool = __esm({
         try {
           const filename = absPath.split(/[\\/]/).pop() ?? "notebook.ipynb";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes4(4).toString("hex");
+          const suffix = randomBytes5(4).toString("hex");
           const backupPath = join10(
             homedir5(),
             ".msapling",
@@ -4568,7 +4451,7 @@ import { resolve as resolve10, normalize as normalize9, relative as relative10,
 import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
 import { homedir as homedir6 } from "os";
-import { randomBytes as randomBytes5 } from "crypto";
+import { randomBytes as randomBytes6 } from "crypto";
 var MAX_EDITS, MultiEditFileTool;
 var init_MultiEditFileTool = __esm({
   "../core/src/tools/MultiEditFileTool.ts"() {
@@ -4730,7 +4613,7 @@ No changes were written (atomic: all-or-nothing).`,
         try {
           const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes5(4).toString("hex");
+          const suffix = randomBytes6(4).toString("hex");
           const backupPath = join11(
             homedir6(),
             ".msapling",
@@ -4768,7 +4651,7 @@ Pre-edit content backed up to: ${backedUpTo}`;
 import { resolve as resolve11, normalize as normalize10, relative as relative11, isAbsolute as isAbsolute11, dirname as dirname2 } from "path";
 import { rename, mkdir as mkdir5, copyFile, rm, stat as stat2, readdir as readdir2 } from "fs/promises";
 import { existsSync as existsSync10, statSync as statSync3 } from "fs";
-import { randomBytes as randomBytes6 } from "crypto";
+import { randomBytes as randomBytes7 } from "crypto";
 function containedPath(p, root) {
   const abs = isAbsolute11(p) ? normalize10(p) : resolve11(root, p.trim());
   const rel = relative11(root, abs);
@@ -4797,7 +4680,7 @@ async function backupFile(absPath) {
     const { join: join39 } = await import("path");
     const filename = absPath.split(/[\\/]/).pop() ?? "file";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const suffix = randomBytes6(4).toString("hex");
+    const suffix = randomBytes7(4).toString("hex");
     const backupPath = join39(
       homedir22(),
       ".msapling",
@@ -4958,7 +4841,7 @@ Overwritten destination backed up to: ${backedUpTo}`;
 // ../core/src/tools/DeleteFileTool.ts
 import { resolve as resolve12, normalize as normalize11, relative as relative12, isAbsolute as isAbsolute12, join as join13 } from "path";
 import { rm as rm2, stat as stat3 } from "fs/promises";
-import { randomBytes as randomBytes7 } from "crypto";
+import { randomBytes as randomBytes8 } from "crypto";
 var DeleteFileTool;
 var init_DeleteFileTool = __esm({
   "../core/src/tools/DeleteFileTool.ts"() {
@@ -5036,7 +4919,7 @@ var init_DeleteFileTool = __esm({
             const existingContent = await readFile30(abs, "utf8");
             const filename = abs.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-            const suffix = randomBytes7(4).toString("hex");
+            const suffix = randomBytes8(4).toString("hex");
             const backupPath = join13(homedir22(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
             await mkdir10(join13(homedir22(), ".msapling", "backups"), { recursive: true });
             await writeFile19(backupPath, existingContent, "utf8");
@@ -5125,15 +5008,20 @@ import { resolve as resolve13, normalize as normalize12, relative as relative13,
 import { realpathSync } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-var import_shell_quote2, Sandbox;
+var Sandbox;
 var init_Sandbox = __esm({
   "../core/src/Sandbox.ts"() {
     "use strict";
     init_esm_shims();
-    import_shell_quote2 = __toESM(require_shell_quote(), 1);
+    init_shellQuote();
     Sandbox = class _Sandbox {
       projectRoot;
       permissions = { trustedCommands: [], trustedPaths: [] };
+      // CLI-TEST-MOCK-LEAK-01: injectable realpath resolver. Production uses the
+      // real fs.realpathSync; tests pass a stub here instead of `mock.module('fs')`,
+      // which under Bun pins the top-level `import { realpathSync }` binding for the
+      // ENTIRE process and silently breaks Sandbox in every later test file.
+      realpathSyncFn;
       static SAFE_BINARIES = /* @__PURE__ */ new Set([
         "git",
         "ls",
@@ -5174,8 +5062,9 @@ var init_Sandbox = __esm({
         "reg",
         "sc"
       ]);
-      constructor(projectRoot) {
+      constructor(projectRoot, opts) {
         this.projectRoot = resolve13(projectRoot);
+        this.realpathSyncFn = opts?.realpathSync ?? realpathSync;
       }
       setPermissions(state) {
         this.permissions = state;
@@ -5192,7 +5081,7 @@ var init_Sandbox = __esm({
         const normalizedTarget = isAbsolute13(targetPath) ? normalize12(targetPath) : resolve13(this.projectRoot, targetPath);
         let resolvedTarget = normalizedTarget;
         try {
-          resolvedTarget = realpathSync(normalizedTarget);
+          resolvedTarget = this.realpathSyncFn(normalizedTarget);
         } catch {
           resolvedTarget = normalizedTarget;
         }
@@ -5253,7 +5142,7 @@ var init_Sandbox = __esm({
         if (this.permissions.trustedCommands.includes(hash)) {
           return { status: "trusted", hash };
         }
-        const parsed = (0, import_shell_quote2.parse)(commandLine);
+        const parsed = parse(commandLine);
         const tokens = parsed.filter((t) => typeof t === "string");
         const normalize13 = (raw) => {
           let b = raw.toLowerCase();
@@ -5349,10 +5238,10 @@ var init_Sandbox = __esm({
        * to a minimal platform default so subprocess spawn never sees an empty PATH.
        */
       static curatePath(rawPath) {
-        const sep3 = process.platform === "win32" ? ";" : ":";
-        const entries = (rawPath ?? "").split(sep3);
+        const sep4 = process.platform === "win32" ? ";" : ":";
+        const entries = (rawPath ?? "").split(sep4);
         const kept = entries.filter((e) => _Sandbox.isSafePathEntry(e));
-        if (kept.length > 0) return kept.join(sep3);
+        if (kept.length > 0) return kept.join(sep4);
         return process.platform === "win32" ? "C:\\Windows\\System32;C:\\Windows" : "/usr/local/bin:/usr/bin:/bin";
       }
       getRestrictedEnv(pathOverride) {
@@ -5371,6 +5260,19 @@ var init_Sandbox = __esm({
 
 // ../core/src/Voice.ts
 import { spawn as spawn6 } from "child_process";
+function buildTtsInvocation(text, rate) {
+  const psCommand = `
+    Add-Type -AssemblyName System.Speech;
+    $synth = New-Object System.Speech.Synthesis.SpeechSynthesizer;
+    $synth.Rate = ${Math.trunc(rate)};
+    $synth.Speak($env:MSAPLING_TTS_TEXT);
+  `;
+  return {
+    command: "powershell",
+    args: ["-NoProfile", "-Command", psCommand],
+    env: { ...process.env, MSAPLING_TTS_TEXT: text }
+  };
+}
 var VoiceService;
 var init_Voice = __esm({
   "../core/src/Voice.ts"() {
@@ -5387,27 +5289,19 @@ var init_Voice = __esm({
        */
       async speak(text, identity = "natural") {
         if (!this.enabled) return;
-        let pitch = 0;
         let rate = 0;
         if (identity === "robotic") {
-          pitch = -5;
           rate = 2;
         }
         if (identity === "urgent") {
-          pitch = 5;
           rate = 5;
         }
-        const psCommand = `
-      Add-Type -AssemblyName System.Speech;
-      $synth = New-Object System.Speech.Synthesis.SpeechSynthesizer;
-      $synth.Rate = ${rate};
-      $synth.Speak("${text}");
-    `;
+        const { command, args: args2, env } = buildTtsInvocation(text, rate);
         try {
           if (process.platform === "win32") {
             await new Promise((resolve20, reject) => {
               try {
-                const proc = spawn6("powershell", ["-Command", psCommand]);
+                const proc = spawn6(command, args2, { env });
                 proc.on("exit", () => resolve20());
                 proc.on("error", reject);
               } catch (e) {
@@ -6103,15 +5997,15 @@ ${blocker.stderr || "(empty)"}`,
           }
         }
         if (args2.path) {
-          const check = await this.sandbox.isPathSafeAsync(args2.path);
-          if (!check.safe) {
+          const check2 = await this.sandbox.isPathSafeAsync(args2.path);
+          if (!check2.safe) {
             await this.voice.speak(`Security block detected`, "urgent");
             const staleKey = `${toolName}:${(args2.path || "").trim()}`;
             if (this.trustStore?.has(staleKey)) {
               this.trustStore.delete(staleKey).catch(() => {
               });
             }
-            return { content: `Security Block: ${check.reason}`, isError: true };
+            return { content: `Security Block: ${check2.reason}`, isError: true };
           }
         }
         if (toolName === "run_command" || toolName === "bash_command") {
@@ -6887,1626 +6781,43 @@ var init_Mutex = __esm({
        * unblock the next waiter.  Callers should always call `release` in a
        * `finally` block to prevent deadlocks on throw.
        */
-      acquire() {
-        let release3;
-        const next = new Promise((resolve20) => {
-          release3 = resolve20;
-        });
-        const entry = this._queue.then(() => release3);
-        this._queue = this._queue.then(() => next);
-        return entry;
-      }
-      /**
-       * Convenience wrapper: acquire the lock, run `fn`, then automatically
-       * release.  Returns whatever `fn` returns.
-       */
-      async run(fn) {
-        const release3 = await this.acquire();
-        try {
-          return await fn();
-        } finally {
-          release3();
-        }
-      }
-    };
-  }
-});
-
-// ../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
-var require_polyfills = __commonJS({
-  "../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var constants = __require("constants");
-    var origCwd = process.cwd;
-    var cwd = null;
-    var platform5 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
-    process.cwd = function() {
-      if (!cwd)
-        cwd = origCwd.call(process);
-      return cwd;
-    };
-    try {
-      process.cwd();
-    } catch (er) {
-    }
-    if (typeof process.chdir === "function") {
-      chdir = process.chdir;
-      process.chdir = function(d) {
-        cwd = null;
-        chdir.call(process, d);
-      };
-      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
-    }
-    var chdir;
-    module.exports = patch;
-    function patch(fs3) {
-      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs3);
-      }
-      if (!fs3.lutimes) {
-        patchLutimes(fs3);
-      }
-      fs3.chown = chownFix(fs3.chown);
-      fs3.fchown = chownFix(fs3.fchown);
-      fs3.lchown = chownFix(fs3.lchown);
-      fs3.chmod = chmodFix(fs3.chmod);
-      fs3.fchmod = chmodFix(fs3.fchmod);
-      fs3.lchmod = chmodFix(fs3.lchmod);
-      fs3.chownSync = chownFixSync(fs3.chownSync);
-      fs3.fchownSync = chownFixSync(fs3.fchownSync);
-      fs3.lchownSync = chownFixSync(fs3.lchownSync);
-      fs3.chmodSync = chmodFixSync(fs3.chmodSync);
-      fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
-      fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
-      fs3.stat = statFix(fs3.stat);
-      fs3.fstat = statFix(fs3.fstat);
-      fs3.lstat = statFix(fs3.lstat);
-      fs3.statSync = statFixSync(fs3.statSync);
-      fs3.fstatSync = statFixSync(fs3.fstatSync);
-      fs3.lstatSync = statFixSync(fs3.lstatSync);
-      if (fs3.chmod && !fs3.lchmod) {
-        fs3.lchmod = function(path2, mode, cb) {
-          if (cb) process.nextTick(cb);
-        };
-        fs3.lchmodSync = function() {
-        };
-      }
-      if (fs3.chown && !fs3.lchown) {
-        fs3.lchown = function(path2, uid, gid, cb) {
-          if (cb) process.nextTick(cb);
-        };
-        fs3.lchownSync = function() {
-        };
-      }
-      if (platform5 === "win32") {
-        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : (function(fs$rename) {
-          function rename4(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() {
-                  fs3.stat(to, function(stater, st) {
-                    if (stater && stater.code === "ENOENT")
-                      fs$rename(from, to, CB);
-                    else
-                      cb(er);
-                  });
-                }, backoff);
-                if (backoff < 100)
-                  backoff += 10;
-                return;
-              }
-              if (cb) cb(er);
-            });
-          }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename4, fs$rename);
-          return rename4;
-        })(fs3.rename);
-      }
-      fs3.read = typeof fs3.read !== "function" ? fs3.read : (function(fs$read) {
-        function read(fd, buffer, offset, length, position, callback_) {
-          var callback;
-          if (callback_ && typeof callback_ === "function") {
-            var eagCounter = 0;
-            callback = function(er, _, __) {
-              if (er && er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
-              }
-              callback_.apply(this, arguments);
-            };
-          }
-          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
-        }
-        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
-        return read;
-      })(fs3.read);
-      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ (function(fs$readSync) {
-        return function(fd, buffer, offset, length, position) {
-          var eagCounter = 0;
-          while (true) {
-            try {
-              return fs$readSync.call(fs3, fd, buffer, offset, length, position);
-            } catch (er) {
-              if (er.code === "EAGAIN" && eagCounter < 10) {
-                eagCounter++;
-                continue;
-              }
-              throw er;
-            }
-          }
-        };
-      })(fs3.readSync);
-      function patchLchmod(fs4) {
-        fs4.lchmod = function(path2, mode, callback) {
-          fs4.open(
-            path2,
-            constants.O_WRONLY | constants.O_SYMLINK,
-            mode,
-            function(err, fd) {
-              if (err) {
-                if (callback) callback(err);
-                return;
-              }
-              fs4.fchmod(fd, mode, function(err2) {
-                fs4.close(fd, function(err22) {
-                  if (callback) callback(err2 || err22);
-                });
-              });
-            }
-          );
-        };
-        fs4.lchmodSync = function(path2, mode) {
-          var fd = fs4.openSync(path2, constants.O_WRONLY | constants.O_SYMLINK, mode);
-          var threw = true;
-          var ret;
-          try {
-            ret = fs4.fchmodSync(fd, mode);
-            threw = false;
-          } finally {
-            if (threw) {
-              try {
-                fs4.closeSync(fd);
-              } catch (er) {
-              }
-            } else {
-              fs4.closeSync(fd);
-            }
-          }
-          return ret;
-        };
-      }
-      function patchLutimes(fs4) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
-          fs4.lutimes = function(path2, at, mt, cb) {
-            fs4.open(path2, constants.O_SYMLINK, function(er, fd) {
-              if (er) {
-                if (cb) cb(er);
-                return;
-              }
-              fs4.futimes(fd, at, mt, function(er2) {
-                fs4.close(fd, function(er22) {
-                  if (cb) cb(er2 || er22);
-                });
-              });
-            });
-          };
-          fs4.lutimesSync = function(path2, at, mt) {
-            var fd = fs4.openSync(path2, constants.O_SYMLINK);
-            var ret;
-            var threw = true;
-            try {
-              ret = fs4.futimesSync(fd, at, mt);
-              threw = false;
-            } finally {
-              if (threw) {
-                try {
-                  fs4.closeSync(fd);
-                } catch (er) {
-                }
-              } else {
-                fs4.closeSync(fd);
-              }
-            }
-            return ret;
-          };
-        } else if (fs4.futimes) {
-          fs4.lutimes = function(_a, _b, _c, cb) {
-            if (cb) process.nextTick(cb);
-          };
-          fs4.lutimesSync = function() {
-          };
-        }
-      }
-      function chmodFix(orig) {
-        if (!orig) return orig;
-        return function(target, mode, cb) {
-          return orig.call(fs3, target, mode, function(er) {
-            if (chownErOk(er)) er = null;
-            if (cb) cb.apply(this, arguments);
-          });
-        };
-      }
-      function chmodFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, mode) {
-          try {
-            return orig.call(fs3, target, mode);
-          } catch (er) {
-            if (!chownErOk(er)) throw er;
-          }
-        };
-      }
-      function chownFix(orig) {
-        if (!orig) return orig;
-        return function(target, uid, gid, cb) {
-          return orig.call(fs3, target, uid, gid, function(er) {
-            if (chownErOk(er)) er = null;
-            if (cb) cb.apply(this, arguments);
-          });
-        };
-      }
-      function chownFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, uid, gid) {
-          try {
-            return orig.call(fs3, target, uid, gid);
-          } catch (er) {
-            if (!chownErOk(er)) throw er;
-          }
-        };
-      }
-      function statFix(orig) {
-        if (!orig) return orig;
-        return function(target, options, cb) {
-          if (typeof options === "function") {
-            cb = options;
-            options = null;
-          }
-          function callback(er, stats) {
-            if (stats) {
-              if (stats.uid < 0) stats.uid += 4294967296;
-              if (stats.gid < 0) stats.gid += 4294967296;
-            }
-            if (cb) cb.apply(this, arguments);
-          }
-          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
-        };
-      }
-      function statFixSync(orig) {
-        if (!orig) return orig;
-        return function(target, options) {
-          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
-          if (stats) {
-            if (stats.uid < 0) stats.uid += 4294967296;
-            if (stats.gid < 0) stats.gid += 4294967296;
-          }
-          return stats;
-        };
-      }
-      function chownErOk(er) {
-        if (!er)
-          return true;
-        if (er.code === "ENOSYS")
-          return true;
-        var nonroot = !process.getuid || process.getuid() !== 0;
-        if (nonroot) {
-          if (er.code === "EINVAL" || er.code === "EPERM")
-            return true;
-        }
-        return false;
-      }
-    }
-  }
-});
-
-// ../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
-var require_legacy_streams = __commonJS({
-  "../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var Stream = __require("stream").Stream;
-    module.exports = legacy;
-    function legacy(fs3) {
-      return {
-        ReadStream,
-        WriteStream
-      };
-      function ReadStream(path2, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path2, options);
-        Stream.call(this);
-        var self = this;
-        this.path = path2;
-        this.fd = null;
-        this.readable = true;
-        this.paused = false;
-        this.flags = "r";
-        this.mode = 438;
-        this.bufferSize = 64 * 1024;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.encoding) this.setEncoding(this.encoding);
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.end === void 0) {
-            this.end = Infinity;
-          } else if ("number" !== typeof this.end) {
-            throw TypeError("end must be a Number");
-          }
-          if (this.start > this.end) {
-            throw new Error("start must be <= end");
-          }
-          this.pos = this.start;
-        }
-        if (this.fd !== null) {
-          process.nextTick(function() {
-            self._read();
-          });
-          return;
-        }
-        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
-          if (err) {
-            self.emit("error", err);
-            self.readable = false;
-            return;
-          }
-          self.fd = fd;
-          self.emit("open", fd);
-          self._read();
-        });
-      }
-      function WriteStream(path2, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path2, options);
-        Stream.call(this);
-        this.path = path2;
-        this.fd = null;
-        this.writable = true;
-        this.flags = "w";
-        this.encoding = "binary";
-        this.mode = 438;
-        this.bytesWritten = 0;
-        options = options || {};
-        var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
-          this[key] = options[key];
-        }
-        if (this.start !== void 0) {
-          if ("number" !== typeof this.start) {
-            throw TypeError("start must be a Number");
-          }
-          if (this.start < 0) {
-            throw new Error("start must be >= zero");
-          }
-          this.pos = this.start;
-        }
-        this.busy = false;
-        this._queue = [];
-        if (this.fd === null) {
-          this._open = fs3.open;
-          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
-          this.flush();
-        }
-      }
-    }
-  }
-});
-
-// ../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
-var require_clone = __commonJS({
-  "../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = clone;
-    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
-      return obj.__proto__;
-    };
-    function clone(obj) {
-      if (obj === null || typeof obj !== "object")
-        return obj;
-      if (obj instanceof Object)
-        var copy = { __proto__: getPrototypeOf(obj) };
-      else
-        var copy = /* @__PURE__ */ Object.create(null);
-      Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
-      });
-      return copy;
-    }
-  }
-});
-
-// ../../node_modules/.bun/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
-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 fs3 = __require("fs");
-    var polyfills = require_polyfills();
-    var legacy = require_legacy_streams();
-    var clone = require_clone();
-    var util = __require("util");
-    var gracefulQueue;
-    var previousSymbol;
-    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
-      gracefulQueue = /* @__PURE__ */ Symbol.for("graceful-fs.queue");
-      previousSymbol = /* @__PURE__ */ Symbol.for("graceful-fs.previous");
-    } else {
-      gracefulQueue = "___graceful-fs.queue";
-      previousSymbol = "___graceful-fs.previous";
-    }
-    function noop() {
-    }
-    function publishQueue(context, queue2) {
-      Object.defineProperty(context, gracefulQueue, {
-        get: function() {
-          return queue2;
-        }
-      });
-    }
-    var debug = noop;
-    if (util.debuglog)
-      debug = util.debuglog("gfs4");
-    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug = function() {
-        var m = util.format.apply(util, arguments);
-        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
-        console.error(m);
-      };
-    if (!fs3[gracefulQueue]) {
-      queue = global[gracefulQueue] || [];
-      publishQueue(fs3, queue);
-      fs3.close = (function(fs$close) {
-        function close(fd, cb) {
-          return fs$close.call(fs3, fd, function(err) {
-            if (!err) {
-              resetQueue();
-            }
-            if (typeof cb === "function")
-              cb.apply(this, arguments);
-          });
-        }
-        Object.defineProperty(close, previousSymbol, {
-          value: fs$close
-        });
-        return close;
-      })(fs3.close);
-      fs3.closeSync = (function(fs$closeSync) {
-        function closeSync(fd) {
-          fs$closeSync.apply(fs3, arguments);
-          resetQueue();
-        }
-        Object.defineProperty(closeSync, previousSymbol, {
-          value: fs$closeSync
-        });
-        return closeSync;
-      })(fs3.closeSync);
-      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
-        process.on("exit", function() {
-          debug(fs3[gracefulQueue]);
-          __require("assert").equal(fs3[gracefulQueue].length, 0);
-        });
-      }
-    }
-    var queue;
-    if (!global[gracefulQueue]) {
-      publishQueue(global, fs3[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs3));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
-      module.exports = patch(fs3);
-      fs3.__patched = true;
-    }
-    function patch(fs4) {
-      polyfills(fs4);
-      fs4.gracefulify = patch;
-      fs4.createReadStream = createReadStream;
-      fs4.createWriteStream = createWriteStream;
-      var fs$readFile = fs4.readFile;
-      fs4.readFile = readFile30;
-      function readFile30(path2, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$readFile(path2, options, cb);
-        function go$readFile(path3, options2, cb2, startTime) {
-          return fs$readFile(path3, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path3, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$writeFile = fs4.writeFile;
-      fs4.writeFile = writeFile19;
-      function writeFile19(path2, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$writeFile(path2, data, options, cb);
-        function go$writeFile(path3, data2, options2, cb2, startTime) {
-          return fs$writeFile(path3, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$appendFile = fs4.appendFile;
-      if (fs$appendFile)
-        fs4.appendFile = appendFile2;
-      function appendFile2(path2, data, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        return go$appendFile(path2, data, options, cb);
-        function go$appendFile(path3, data2, options2, cb2, startTime) {
-          return fs$appendFile(path3, data2, options2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path3, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$copyFile = fs4.copyFile;
-      if (fs$copyFile)
-        fs4.copyFile = copyFile2;
-      function copyFile2(src, dest, flags, cb) {
-        if (typeof flags === "function") {
-          cb = flags;
-          flags = 0;
-        }
-        return go$copyFile(src, dest, flags, cb);
-        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
-          return fs$copyFile(src2, dest2, flags2, function(err) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      var fs$readdir = fs4.readdir;
-      fs4.readdir = readdir5;
-      var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir5(path2, options, cb) {
-        if (typeof options === "function")
-          cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path3, options2, cb2, startTime) {
-          return fs$readdir(path3, fs$readdirCallback(
-            path3,
-            options2,
-            cb2,
-            startTime
-          ));
-        } : function go$readdir2(path3, options2, cb2, startTime) {
-          return fs$readdir(path3, options2, fs$readdirCallback(
-            path3,
-            options2,
-            cb2,
-            startTime
-          ));
-        };
-        return go$readdir(path2, options, cb);
-        function fs$readdirCallback(path3, options2, cb2, startTime) {
-          return function(err, files) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([
-                go$readdir,
-                [path3, options2, cb2],
-                err,
-                startTime || Date.now(),
-                Date.now()
-              ]);
-            else {
-              if (files && files.sort)
-                files.sort();
-              if (typeof cb2 === "function")
-                cb2.call(this, err, files);
-            }
-          };
-        }
-      }
-      if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs4);
-        ReadStream = legStreams.ReadStream;
-        WriteStream = legStreams.WriteStream;
-      }
-      var fs$ReadStream = fs4.ReadStream;
-      if (fs$ReadStream) {
-        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
-        ReadStream.prototype.open = ReadStream$open;
-      }
-      var fs$WriteStream = fs4.WriteStream;
-      if (fs$WriteStream) {
-        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
-        WriteStream.prototype.open = WriteStream$open;
-      }
-      Object.defineProperty(fs4, "ReadStream", {
-        get: function() {
-          return ReadStream;
-        },
-        set: function(val) {
-          ReadStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      Object.defineProperty(fs4, "WriteStream", {
-        get: function() {
-          return WriteStream;
-        },
-        set: function(val) {
-          WriteStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileReadStream = ReadStream;
-      Object.defineProperty(fs4, "FileReadStream", {
-        get: function() {
-          return FileReadStream;
-        },
-        set: function(val) {
-          FileReadStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      var FileWriteStream = WriteStream;
-      Object.defineProperty(fs4, "FileWriteStream", {
-        get: function() {
-          return FileWriteStream;
-        },
-        set: function(val) {
-          FileWriteStream = val;
-        },
-        enumerable: true,
-        configurable: true
-      });
-      function ReadStream(path2, options) {
-        if (this instanceof ReadStream)
-          return fs$ReadStream.apply(this, arguments), this;
-        else
-          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
-      }
-      function ReadStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            if (that.autoClose)
-              that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-            that.read();
-          }
-        });
-      }
-      function WriteStream(path2, options) {
-        if (this instanceof WriteStream)
-          return fs$WriteStream.apply(this, arguments), this;
-        else
-          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
-      }
-      function WriteStream$open() {
-        var that = this;
-        open(that.path, that.flags, that.mode, function(err, fd) {
-          if (err) {
-            that.destroy();
-            that.emit("error", err);
-          } else {
-            that.fd = fd;
-            that.emit("open", fd);
-          }
-        });
-      }
-      function createReadStream(path2, options) {
-        return new fs4.ReadStream(path2, options);
-      }
-      function createWriteStream(path2, options) {
-        return new fs4.WriteStream(path2, options);
-      }
-      var fs$open = fs4.open;
-      fs4.open = open;
-      function open(path2, flags, mode, cb) {
-        if (typeof mode === "function")
-          cb = mode, mode = null;
-        return go$open(path2, flags, mode, cb);
-        function go$open(path3, flags2, mode2, cb2, startTime) {
-          return fs$open(path3, flags2, mode2, function(err, fd) {
-            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path3, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
-            else {
-              if (typeof cb2 === "function")
-                cb2.apply(this, arguments);
-            }
-          });
-        }
-      }
-      return fs4;
-    }
-    function enqueue(elem) {
-      debug("ENQUEUE", elem[0].name, elem[1]);
-      fs3[gracefulQueue].push(elem);
-      retry();
-    }
-    var retryTimer;
-    function resetQueue() {
-      var now = Date.now();
-      for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
-        if (fs3[gracefulQueue][i].length > 2) {
-          fs3[gracefulQueue][i][3] = now;
-          fs3[gracefulQueue][i][4] = now;
-        }
-      }
-      retry();
-    }
-    function retry() {
-      clearTimeout(retryTimer);
-      retryTimer = void 0;
-      if (fs3[gracefulQueue].length === 0)
-        return;
-      var elem = fs3[gracefulQueue].shift();
-      var fn = elem[0];
-      var args2 = elem[1];
-      var err = elem[2];
-      var startTime = elem[3];
-      var lastTime = elem[4];
-      if (startTime === void 0) {
-        debug("RETRY", fn.name, args2);
-        fn.apply(null, args2);
-      } else if (Date.now() - startTime >= 6e4) {
-        debug("TIMEOUT", fn.name, args2);
-        var cb = args2.pop();
-        if (typeof cb === "function")
-          cb.call(null, err);
-      } else {
-        var sinceAttempt = Date.now() - lastTime;
-        var sinceStart = Math.max(lastTime - startTime, 1);
-        var desiredDelay = Math.min(sinceStart * 1.2, 100);
-        if (sinceAttempt >= desiredDelay) {
-          debug("RETRY", fn.name, args2);
-          fn.apply(null, args2.concat([startTime]));
-        } else {
-          fs3[gracefulQueue].push(elem);
-        }
-      }
-      if (retryTimer === void 0) {
-        retryTimer = setTimeout(retry, 0);
-      }
-    }
-  }
-});
-
-// ../../node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry_operation.js
-var require_retry_operation = __commonJS({
-  "../../node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry_operation.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    function RetryOperation(timeouts, options) {
-      if (typeof options === "boolean") {
-        options = { forever: options };
-      }
-      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
-      this._timeouts = timeouts;
-      this._options = options || {};
-      this._maxRetryTime = options && options.maxRetryTime || Infinity;
-      this._fn = null;
-      this._errors = [];
-      this._attempts = 1;
-      this._operationTimeout = null;
-      this._operationTimeoutCb = null;
-      this._timeout = null;
-      this._operationStart = null;
-      if (this._options.forever) {
-        this._cachedTimeouts = this._timeouts.slice(0);
-      }
-    }
-    module.exports = RetryOperation;
-    RetryOperation.prototype.reset = function() {
-      this._attempts = 1;
-      this._timeouts = this._originalTimeouts;
-    };
-    RetryOperation.prototype.stop = function() {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      this._timeouts = [];
-      this._cachedTimeouts = null;
-    };
-    RetryOperation.prototype.retry = function(err) {
-      if (this._timeout) {
-        clearTimeout(this._timeout);
-      }
-      if (!err) {
-        return false;
-      }
-      var currentTime = (/* @__PURE__ */ new Date()).getTime();
-      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
-        this._errors.unshift(new Error("RetryOperation timeout occurred"));
-        return false;
-      }
-      this._errors.push(err);
-      var timeout = this._timeouts.shift();
-      if (timeout === void 0) {
-        if (this._cachedTimeouts) {
-          this._errors.splice(this._errors.length - 1, this._errors.length);
-          this._timeouts = this._cachedTimeouts.slice(0);
-          timeout = this._timeouts.shift();
-        } else {
-          return false;
-        }
-      }
-      var self = this;
-      var timer = setTimeout(function() {
-        self._attempts++;
-        if (self._operationTimeoutCb) {
-          self._timeout = setTimeout(function() {
-            self._operationTimeoutCb(self._attempts);
-          }, self._operationTimeout);
-          if (self._options.unref) {
-            self._timeout.unref();
-          }
-        }
-        self._fn(self._attempts);
-      }, timeout);
-      if (this._options.unref) {
-        timer.unref();
-      }
-      return true;
-    };
-    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
-      this._fn = fn;
-      if (timeoutOps) {
-        if (timeoutOps.timeout) {
-          this._operationTimeout = timeoutOps.timeout;
-        }
-        if (timeoutOps.cb) {
-          this._operationTimeoutCb = timeoutOps.cb;
-        }
-      }
-      var self = this;
-      if (this._operationTimeoutCb) {
-        this._timeout = setTimeout(function() {
-          self._operationTimeoutCb();
-        }, self._operationTimeout);
-      }
-      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
-      this._fn(this._attempts);
-    };
-    RetryOperation.prototype.try = function(fn) {
-      console.log("Using RetryOperation.try() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = function(fn) {
-      console.log("Using RetryOperation.start() is deprecated");
-      this.attempt(fn);
-    };
-    RetryOperation.prototype.start = RetryOperation.prototype.try;
-    RetryOperation.prototype.errors = function() {
-      return this._errors;
-    };
-    RetryOperation.prototype.attempts = function() {
-      return this._attempts;
-    };
-    RetryOperation.prototype.mainError = function() {
-      if (this._errors.length === 0) {
-        return null;
-      }
-      var counts = {};
-      var mainError = null;
-      var mainErrorCount = 0;
-      for (var i = 0; i < this._errors.length; i++) {
-        var error = this._errors[i];
-        var message = error.message;
-        var count = (counts[message] || 0) + 1;
-        counts[message] = count;
-        if (count >= mainErrorCount) {
-          mainError = error;
-          mainErrorCount = count;
-        }
-      }
-      return mainError;
-    };
-  }
-});
-
-// ../../node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry.js
-var require_retry = __commonJS({
-  "../../node_modules/.bun/retry@0.12.0/node_modules/retry/lib/retry.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var RetryOperation = require_retry_operation();
-    exports.operation = function(options) {
-      var timeouts = exports.timeouts(options);
-      return new RetryOperation(timeouts, {
-        forever: options && options.forever,
-        unref: options && options.unref,
-        maxRetryTime: options && options.maxRetryTime
-      });
-    };
-    exports.timeouts = function(options) {
-      if (options instanceof Array) {
-        return [].concat(options);
-      }
-      var opts = {
-        retries: 10,
-        factor: 2,
-        minTimeout: 1 * 1e3,
-        maxTimeout: Infinity,
-        randomize: false
-      };
-      for (var key in options) {
-        opts[key] = options[key];
-      }
-      if (opts.minTimeout > opts.maxTimeout) {
-        throw new Error("minTimeout is greater than maxTimeout");
-      }
-      var timeouts = [];
-      for (var i = 0; i < opts.retries; i++) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      if (options && options.forever && !timeouts.length) {
-        timeouts.push(this.createTimeout(i, opts));
-      }
-      timeouts.sort(function(a, b) {
-        return a - b;
-      });
-      return timeouts;
-    };
-    exports.createTimeout = function(attempt, opts) {
-      var random = opts.randomize ? Math.random() + 1 : 1;
-      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
-      timeout = Math.min(timeout, opts.maxTimeout);
-      return timeout;
-    };
-    exports.wrap = function(obj, options, methods) {
-      if (options instanceof Array) {
-        methods = options;
-        options = null;
-      }
-      if (!methods) {
-        methods = [];
-        for (var key in obj) {
-          if (typeof obj[key] === "function") {
-            methods.push(key);
-          }
-        }
-      }
-      for (var i = 0; i < methods.length; i++) {
-        var method = methods[i];
-        var original = obj[method];
-        obj[method] = function retryWrapper(original2) {
-          var op = exports.operation(options);
-          var args2 = Array.prototype.slice.call(arguments, 1);
-          var callback = args2.pop();
-          args2.push(function(err) {
-            if (op.retry(err)) {
-              return;
-            }
-            if (err) {
-              arguments[0] = op.mainError();
-            }
-            callback.apply(this, arguments);
-          });
-          op.attempt(function() {
-            original2.apply(obj, args2);
-          });
-        }.bind(obj, original);
-        obj[method].options = options;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.bun/retry@0.12.0/node_modules/retry/index.js
-var require_retry2 = __commonJS({
-  "../../node_modules/.bun/retry@0.12.0/node_modules/retry/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = require_retry();
-  }
-});
-
-// ../../node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/signals.js
-var require_signals = __commonJS({
-  "../../node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/signals.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = [
-      "SIGABRT",
-      "SIGALRM",
-      "SIGHUP",
-      "SIGINT",
-      "SIGTERM"
-    ];
-    if (process.platform !== "win32") {
-      module.exports.push(
-        "SIGVTALRM",
-        "SIGXCPU",
-        "SIGXFSZ",
-        "SIGUSR2",
-        "SIGTRAP",
-        "SIGSYS",
-        "SIGQUIT",
-        "SIGIOT"
-        // should detect profiler and enable/disable accordingly.
-        // see #21
-        // 'SIGPROF'
-      );
-    }
-    if (process.platform === "linux") {
-      module.exports.push(
-        "SIGIO",
-        "SIGPOLL",
-        "SIGPWR",
-        "SIGSTKFLT",
-        "SIGUNUSED"
-      );
-    }
-  }
-});
-
-// ../../node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/index.js
-var require_signal_exit = __commonJS({
-  "../../node_modules/.bun/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var process2 = global.process;
-    var processOk = function(process3) {
-      return process3 && typeof process3 === "object" && typeof process3.removeListener === "function" && typeof process3.emit === "function" && typeof process3.reallyExit === "function" && typeof process3.listeners === "function" && typeof process3.kill === "function" && typeof process3.pid === "number" && typeof process3.on === "function";
-    };
-    if (!processOk(process2)) {
-      module.exports = function() {
-        return function() {
-        };
-      };
-    } else {
-      assert = __require("assert");
-      signals = require_signals();
-      isWin2 = /^win/i.test(process2.platform);
-      EE = __require("events");
-      if (typeof EE !== "function") {
-        EE = EE.EventEmitter;
-      }
-      if (process2.__signal_exit_emitter__) {
-        emitter = process2.__signal_exit_emitter__;
-      } else {
-        emitter = process2.__signal_exit_emitter__ = new EE();
-        emitter.count = 0;
-        emitter.emitted = {};
-      }
-      if (!emitter.infinite) {
-        emitter.setMaxListeners(Infinity);
-        emitter.infinite = true;
-      }
-      module.exports = function(cb, opts) {
-        if (!processOk(global.process)) {
-          return function() {
-          };
-        }
-        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
-        if (loaded === false) {
-          load();
-        }
-        var ev = "exit";
-        if (opts && opts.alwaysLast) {
-          ev = "afterexit";
-        }
-        var remove = function() {
-          emitter.removeListener(ev, cb);
-          if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
-            unload();
-          }
-        };
-        emitter.on(ev, cb);
-        return remove;
-      };
-      unload = function unload2() {
-        if (!loaded || !processOk(global.process)) {
-          return;
-        }
-        loaded = false;
-        signals.forEach(function(sig) {
-          try {
-            process2.removeListener(sig, sigListeners[sig]);
-          } catch (er) {
-          }
-        });
-        process2.emit = originalProcessEmit;
-        process2.reallyExit = originalProcessReallyExit;
-        emitter.count -= 1;
-      };
-      module.exports.unload = unload;
-      emit = function emit2(event, code, signal) {
-        if (emitter.emitted[event]) {
-          return;
-        }
-        emitter.emitted[event] = true;
-        emitter.emit(event, code, signal);
-      };
-      sigListeners = {};
-      signals.forEach(function(sig) {
-        sigListeners[sig] = function listener() {
-          if (!processOk(global.process)) {
-            return;
-          }
-          var listeners = process2.listeners(sig);
-          if (listeners.length === emitter.count) {
-            unload();
-            emit("exit", null, sig);
-            emit("afterexit", null, sig);
-            if (isWin2 && sig === "SIGHUP") {
-              sig = "SIGINT";
-            }
-            process2.kill(process2.pid, sig);
-          }
-        };
-      });
-      module.exports.signals = function() {
-        return signals;
-      };
-      loaded = false;
-      load = function load2() {
-        if (loaded || !processOk(global.process)) {
-          return;
-        }
-        loaded = true;
-        emitter.count += 1;
-        signals = signals.filter(function(sig) {
-          try {
-            process2.on(sig, sigListeners[sig]);
-            return true;
-          } catch (er) {
-            return false;
-          }
-        });
-        process2.emit = processEmit;
-        process2.reallyExit = processReallyExit;
-      };
-      module.exports.load = load;
-      originalProcessReallyExit = process2.reallyExit;
-      processReallyExit = function processReallyExit2(code) {
-        if (!processOk(global.process)) {
-          return;
-        }
-        process2.exitCode = code || /* istanbul ignore next */
-        0;
-        emit("exit", process2.exitCode, null);
-        emit("afterexit", process2.exitCode, null);
-        originalProcessReallyExit.call(process2, process2.exitCode);
-      };
-      originalProcessEmit = process2.emit;
-      processEmit = function processEmit2(ev, arg) {
-        if (ev === "exit" && processOk(global.process)) {
-          if (arg !== void 0) {
-            process2.exitCode = arg;
-          }
-          var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process2.exitCode, null);
-          emit("afterexit", process2.exitCode, null);
-          return ret;
-        } else {
-          return originalProcessEmit.apply(this, arguments);
-        }
-      };
-    }
-    var assert;
-    var signals;
-    var isWin2;
-    var EE;
-    var emitter;
-    var unload;
-    var emit;
-    var sigListeners;
-    var loaded;
-    var load;
-    var originalProcessReallyExit;
-    var processReallyExit;
-    var originalProcessEmit;
-    var processEmit;
-  }
-});
-
-// ../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js
-var require_mtime_precision = __commonJS({
-  "../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var cacheSymbol = /* @__PURE__ */ Symbol();
-    function probe(file, fs3, callback) {
-      const cachedPrecision = fs3[cacheSymbol];
-      if (cachedPrecision) {
-        return fs3.stat(file, (err, stat5) => {
-          if (err) {
-            return callback(err);
-          }
-          callback(null, stat5.mtime, cachedPrecision);
-        });
-      }
-      const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs3.utimes(file, mtime, mtime, (err) => {
-        if (err) {
-          return callback(err);
-        }
-        fs3.stat(file, (err2, stat5) => {
-          if (err2) {
-            return callback(err2);
-          }
-          const precision = stat5.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs3, cacheSymbol, { value: precision });
-          callback(null, stat5.mtime, precision);
-        });
-      });
-    }
-    function getMtime(precision) {
-      let now = Date.now();
-      if (precision === "s") {
-        now = Math.ceil(now / 1e3) * 1e3;
-      }
-      return new Date(now);
-    }
-    module.exports.probe = probe;
-    module.exports.getMtime = getMtime;
-  }
-});
-
-// ../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js
-var require_lockfile = __commonJS({
-  "../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var path2 = __require("path");
-    var fs3 = require_graceful_fs();
-    var retry = require_retry2();
-    var onExit = require_signal_exit();
-    var mtimePrecision = require_mtime_precision();
-    var locks = {};
-    function getLockFile(file, options) {
-      return options.lockfilePath || `${file}.lock`;
-    }
-    function resolveCanonicalPath(file, options, callback) {
-      if (!options.realpath) {
-        return callback(null, path2.resolve(file));
-      }
-      options.fs.realpath(file, callback);
-    }
-    function acquireLock(file, options, callback) {
-      const lockfilePath = getLockFile(file, options);
-      options.fs.mkdir(lockfilePath, (err) => {
-        if (!err) {
-          return mtimePrecision.probe(lockfilePath, options.fs, (err2, mtime, mtimePrecision2) => {
-            if (err2) {
-              options.fs.rmdir(lockfilePath, () => {
-              });
-              return callback(err2);
-            }
-            callback(null, mtime, mtimePrecision2);
-          });
-        }
-        if (err.code !== "EEXIST") {
-          return callback(err);
-        }
-        if (options.stale <= 0) {
-          return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
-        }
-        options.fs.stat(lockfilePath, (err2, stat5) => {
-          if (err2) {
-            if (err2.code === "ENOENT") {
-              return acquireLock(file, { ...options, stale: 0 }, callback);
-            }
-            return callback(err2);
-          }
-          if (!isLockStale(stat5, options)) {
-            return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
-          }
-          removeLock(file, options, (err3) => {
-            if (err3) {
-              return callback(err3);
-            }
-            acquireLock(file, { ...options, stale: 0 }, callback);
-          });
-        });
-      });
-    }
-    function isLockStale(stat5, options) {
-      return stat5.mtime.getTime() < Date.now() - options.stale;
-    }
-    function removeLock(file, options, callback) {
-      options.fs.rmdir(getLockFile(file, options), (err) => {
-        if (err && err.code !== "ENOENT") {
-          return callback(err);
-        }
-        callback();
-      });
-    }
-    function updateLock(file, options) {
-      const lock5 = locks[file];
-      if (lock5.updateTimeout) {
-        return;
-      }
-      lock5.updateDelay = lock5.updateDelay || options.update;
-      lock5.updateTimeout = setTimeout(() => {
-        lock5.updateTimeout = null;
-        options.fs.stat(lock5.lockfilePath, (err, stat5) => {
-          const isOverThreshold = lock5.lastUpdate + options.stale < Date.now();
-          if (err) {
-            if (err.code === "ENOENT" || isOverThreshold) {
-              return setLockAsCompromised(file, lock5, Object.assign(err, { code: "ECOMPROMISED" }));
-            }
-            lock5.updateDelay = 1e3;
-            return updateLock(file, options);
-          }
-          const isMtimeOurs = lock5.mtime.getTime() === stat5.mtime.getTime();
-          if (!isMtimeOurs) {
-            return setLockAsCompromised(
-              file,
-              lock5,
-              Object.assign(
-                new Error("Unable to update lock within the stale threshold"),
-                { code: "ECOMPROMISED" }
-              )
-            );
-          }
-          const mtime = mtimePrecision.getMtime(lock5.mtimePrecision);
-          options.fs.utimes(lock5.lockfilePath, mtime, mtime, (err2) => {
-            const isOverThreshold2 = lock5.lastUpdate + options.stale < Date.now();
-            if (lock5.released) {
-              return;
-            }
-            if (err2) {
-              if (err2.code === "ENOENT" || isOverThreshold2) {
-                return setLockAsCompromised(file, lock5, Object.assign(err2, { code: "ECOMPROMISED" }));
-              }
-              lock5.updateDelay = 1e3;
-              return updateLock(file, options);
-            }
-            lock5.mtime = mtime;
-            lock5.lastUpdate = Date.now();
-            lock5.updateDelay = null;
-            updateLock(file, options);
-          });
-        });
-      }, lock5.updateDelay);
-      if (lock5.updateTimeout.unref) {
-        lock5.updateTimeout.unref();
-      }
-    }
-    function setLockAsCompromised(file, lock5, err) {
-      lock5.released = true;
-      if (lock5.updateTimeout) {
-        clearTimeout(lock5.updateTimeout);
-      }
-      if (locks[file] === lock5) {
-        delete locks[file];
-      }
-      lock5.options.onCompromised(err);
-    }
-    function lock4(file, options, callback) {
-      options = {
-        stale: 1e4,
-        update: null,
-        realpath: true,
-        retries: 0,
-        fs: fs3,
-        onCompromised: (err) => {
-          throw err;
-        },
-        ...options
-      };
-      options.retries = options.retries || 0;
-      options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
-      options.stale = Math.max(options.stale || 0, 2e3);
-      options.update = options.update == null ? options.stale / 2 : options.update || 0;
-      options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
-      resolveCanonicalPath(file, options, (err, file2) => {
-        if (err) {
-          return callback(err);
-        }
-        const operation = retry.operation(options.retries);
-        operation.attempt(() => {
-          acquireLock(file2, options, (err2, mtime, mtimePrecision2) => {
-            if (operation.retry(err2)) {
-              return;
-            }
-            if (err2) {
-              return callback(operation.mainError());
-            }
-            const lock5 = locks[file2] = {
-              lockfilePath: getLockFile(file2, options),
-              mtime,
-              mtimePrecision: mtimePrecision2,
-              options,
-              lastUpdate: Date.now()
-            };
-            updateLock(file2, options);
-            callback(null, (releasedCallback) => {
-              if (lock5.released) {
-                return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
-              }
-              unlock4(file2, { ...options, realpath: false }, releasedCallback);
-            });
-          });
-        });
-      });
-    }
-    function unlock4(file, options, callback) {
-      options = {
-        fs: fs3,
-        realpath: true,
-        ...options
-      };
-      resolveCanonicalPath(file, options, (err, file2) => {
-        if (err) {
-          return callback(err);
-        }
-        const lock5 = locks[file2];
-        if (!lock5) {
-          return callback(Object.assign(new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
-        }
-        lock5.updateTimeout && clearTimeout(lock5.updateTimeout);
-        lock5.released = true;
-        delete locks[file2];
-        removeLock(file2, options, callback);
-      });
-    }
-    function check(file, options, callback) {
-      options = {
-        stale: 1e4,
-        realpath: true,
-        fs: fs3,
-        ...options
-      };
-      options.stale = Math.max(options.stale || 0, 2e3);
-      resolveCanonicalPath(file, options, (err, file2) => {
-        if (err) {
-          return callback(err);
-        }
-        options.fs.stat(getLockFile(file2, options), (err2, stat5) => {
-          if (err2) {
-            return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
-          }
-          return callback(null, !isLockStale(stat5, options));
-        });
-      });
-    }
-    function getLocks() {
-      return locks;
-    }
-    onExit(() => {
-      for (const file in locks) {
-        const options = locks[file].options;
-        try {
-          options.fs.rmdirSync(getLockFile(file, options));
-        } catch (e) {
-        }
-      }
-    });
-    module.exports.lock = lock4;
-    module.exports.unlock = unlock4;
-    module.exports.check = check;
-    module.exports.getLocks = getLocks;
-  }
-});
-
-// ../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js
-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 fs3 = require_graceful_fs();
-    function createSyncFs(fs4) {
-      const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs4 };
-      methods.forEach((method) => {
-        newFs[method] = (...args2) => {
-          const callback = args2.pop();
-          let ret;
-          try {
-            ret = fs4[`${method}Sync`](...args2);
-          } catch (err) {
-            return callback(err);
-          }
-          callback(null, ret);
-        };
-      });
-      return newFs;
-    }
-    function toPromise(method) {
-      return (...args2) => new Promise((resolve20, reject) => {
-        args2.push((err, result) => {
-          if (err) {
-            reject(err);
-          } else {
-            resolve20(result);
-          }
-        });
-        method(...args2);
-      });
-    }
-    function toSync(method) {
-      return (...args2) => {
-        let err;
-        let result;
-        args2.push((_err, _result) => {
-          err = _err;
-          result = _result;
+      acquire() {
+        let release3;
+        const next = new Promise((resolve20) => {
+          release3 = resolve20;
         });
-        method(...args2);
-        if (err) {
-          throw err;
+        const entry = this._queue.then(() => release3);
+        this._queue = this._queue.then(() => next);
+        return entry;
+      }
+      /**
+       * Convenience wrapper: acquire the lock, run `fn`, then automatically
+       * release.  Returns whatever `fn` returns.
+       */
+      async run(fn) {
+        const release3 = await this.acquire();
+        try {
+          return await fn();
+        } finally {
+          release3();
         }
-        return result;
-      };
-    }
-    function toSyncOptions(options) {
-      options = { ...options };
-      options.fs = createSyncFs(options.fs || fs3);
-      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" });
       }
-      return options;
-    }
-    module.exports = {
-      toPromise,
-      toSync,
-      toSyncOptions
     };
   }
 });
 
-// ../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js
-var require_proper_lockfile = __commonJS({
-  "../../node_modules/.bun/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js"(exports, module) {
+// ../core/src/lockfile.ts
+import { createRequire as nodeCreateRequire2 } from "module";
+var requireLockfile, impl2, lock, unlock, check;
+var init_lockfile = __esm({
+  "../core/src/lockfile.ts"() {
     "use strict";
     init_esm_shims();
-    var lockfile4 = require_lockfile();
-    var { toPromise, toSync, toSyncOptions } = require_adapter();
-    async function lock4(file, options) {
-      const release3 = await toPromise(lockfile4.lock)(file, options);
-      return toPromise(release3);
-    }
-    function lockSync(file, options) {
-      const release3 = toSync(lockfile4.lock)(file, toSyncOptions(options));
-      return toSync(release3);
-    }
-    function unlock4(file, options) {
-      return toPromise(lockfile4.unlock)(file, options);
-    }
-    function unlockSync(file, options) {
-      return toSync(lockfile4.unlock)(file, toSyncOptions(options));
-    }
-    function check(file, options) {
-      return toPromise(lockfile4.check)(file, options);
-    }
-    function checkSync(file, options) {
-      return toSync(lockfile4.check)(file, toSyncOptions(options));
-    }
-    module.exports = lock4;
-    module.exports.lock = lock4;
-    module.exports.unlock = unlock4;
-    module.exports.lockSync = lockSync;
-    module.exports.unlockSync = unlockSync;
-    module.exports.check = check;
-    module.exports.checkSync = checkSync;
+    requireLockfile = nodeCreateRequire2(import.meta.url);
+    impl2 = requireLockfile("proper-lockfile/index.js");
+    lock = impl2.lock;
+    unlock = impl2.unlock;
+    check = impl2.check;
   }
 });
 
@@ -8515,14 +6826,14 @@ import { join as join16, dirname as dirname4 } from "path";
 import { homedir as homedir9, platform as platform3 } from "os";
 import { existsSync as existsSync12, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFile12, writeFile as writeFile5, rename as rename2, chmod } from "fs/promises";
-import { randomBytes as randomBytes8 } from "crypto";
-var lockfile, USER_SETTINGS_PATH, TrustStore;
+import { randomBytes as randomBytes9 } from "crypto";
+var USER_SETTINGS_PATH, TrustStore;
 var init_TrustStore = __esm({
   "../core/src/TrustStore.ts"() {
     "use strict";
     init_esm_shims();
     init_Mutex();
-    lockfile = __toESM(require_proper_lockfile(), 1);
+    init_lockfile();
     USER_SETTINGS_PATH = join16(homedir9(), ".msapling", "settings.json");
     TrustStore = class {
       /** Current in-memory set of trusted `tool:command` keys. */
@@ -8563,7 +6874,7 @@ var init_TrustStore = __esm({
         const dir = dirname4(this.settingsPath);
         if (!existsSync12(dir)) mkdirSync2(dir, { recursive: true });
         const pid = process.pid;
-        const rand = randomBytes8(4).toString("hex");
+        const rand = randomBytes9(4).toString("hex");
         const tmpPath = `${this.settingsPath}.tmp.${pid}.${rand}`;
         await writeFile5(tmpPath, JSON.stringify(settings, null, 2), "utf8");
         await rename2(tmpPath, this.settingsPath);
@@ -8615,7 +6926,7 @@ var init_TrustStore = __esm({
           }
           let release3 = null;
           try {
-            release3 = await lockfile.lock(this.settingsPath, { retries: 5, retryWait: 50 });
+            release3 = await lock(this.settingsPath, { retries: 5, retryWait: 50 });
             this.trusted.add(key);
             const settings = await this.readSettings();
             const existing = Array.isArray(settings.trustedCommands) ? settings.trustedCommands : [];
@@ -8626,7 +6937,7 @@ var init_TrustStore = __esm({
           } finally {
             if (release3) {
               try {
-                await lockfile.unlock(this.settingsPath, { skipStale: true });
+                await unlock(this.settingsPath, { skipStale: true });
               } catch {
               }
             }
@@ -8649,7 +6960,7 @@ var init_TrustStore = __esm({
           }
           let release3 = null;
           try {
-            release3 = await lockfile.lock(this.settingsPath, { retries: 5, retryWait: 50 });
+            release3 = await lock(this.settingsPath, { retries: 5, retryWait: 50 });
             this.trusted.delete(key);
             const settings = await this.readSettings();
             if (Array.isArray(settings.trustedCommands)) {
@@ -8661,7 +6972,7 @@ var init_TrustStore = __esm({
           } finally {
             if (release3) {
               try {
-                await lockfile.unlock(this.settingsPath, { skipStale: true });
+                await unlock(this.settingsPath, { skipStale: true });
               } catch {
               }
             }
@@ -8688,7 +6999,7 @@ import { createHash as createHash4 } from "crypto";
 async function getKeytar() {
   if (_keytar !== "pending") return _keytar;
   try {
-    const mod = await import("keytar");
+    const mod = await import("@napi-rs/keyring/keytar.js");
     _keytar = mod && typeof mod.setPassword === "function" ? mod : mod?.default ?? mod;
   } catch {
     _keytar = null;
@@ -8699,33 +7010,43 @@ async function saveToken(baseDir, token) {
   const filePath = join17(baseDir, "vault", "token");
   try {
     const kt = await getKeytar();
-    if (!kt) throw new Error("keytar not loadable");
+    if (!kt) throw new Error("keyring not loadable");
     await kt.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, token);
-    try {
-      if (existsSync13(filePath)) unlinkSync(filePath);
-    } catch {
-    }
   } catch (e) {
-    console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)}), falling back to file storage`);
-    await writeFile6(filePath, token, "utf8");
-    if (process.platform !== "win32") {
-      chmodSync(filePath, 384);
-    }
+    throw new KeychainUnavailableError(e instanceof Error ? e.message : String(e));
+  }
+  try {
+    if (existsSync13(filePath)) unlinkSync(filePath);
+  } catch {
   }
 }
 async function loadToken(baseDir) {
   const filePath = join17(baseDir, "vault", "token");
+  let kt = null;
   try {
-    const kt = await getKeytar();
-    if (!kt) throw new Error("keytar not loadable");
+    kt = await getKeytar();
+    if (!kt) throw new Error("keyring not loadable");
     const keychainToken = await kt.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
     if (keychainToken) return keychainToken;
   } catch (e) {
-    console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)}), falling back to file storage`);
+    kt = null;
+    console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)})`);
   }
   if (existsSync13(filePath)) {
-    const text = await readFile13(filePath, "utf8");
-    return text.trim();
+    const legacyToken = (await readFile13(filePath, "utf8")).trim();
+    if (!legacyToken) return null;
+    if (kt) {
+      try {
+        await kt.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, legacyToken);
+        unlinkSync(filePath);
+        console.warn("[vault] Migrated legacy plaintext token into the OS keychain and deleted the plaintext file.");
+      } catch (e) {
+        console.warn(`[vault] WARNING: using legacy plaintext token file (keychain migration failed: ${e instanceof Error ? e.message : String(e)}). Re-run /login once the keychain is available to store the token securely.`);
+      }
+    } else {
+      console.warn("[vault] WARNING: using legacy plaintext token file because the OS keychain is unavailable. This token is stored insecurely; new logins require a working keychain.");
+    }
+    return legacyToken;
   }
   return null;
 }
@@ -8746,6 +7067,29 @@ async function clearToken(baseDir) {
     console.warn(`Failed to delete token file: ${e}`);
   }
 }
+async function getOrCreateJournalKey() {
+  let kt = null;
+  try {
+    kt = await getKeytar();
+    if (!kt) return null;
+  } catch {
+    return null;
+  }
+  try {
+    const existing = await kt.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_JOURNAL_ACCOUNT);
+    if (existing) {
+      const buf = Buffer.from(existing, "base64");
+      if (buf.length === 32) return buf;
+    }
+    const { randomBytes: randomBytes15 } = await import("crypto");
+    const key = randomBytes15(32);
+    await kt.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_JOURNAL_ACCOUNT, key.toString("base64"));
+    return key;
+  } catch (e) {
+    console.debug(`Journal key unavailable (${e instanceof Error ? e.message : String(e)})`);
+    return null;
+  }
+}
 async function writeVaultRef(baseDir, label, value) {
   const hash = createHash4("sha256").update(value, "utf8").digest("hex");
   const objectPath = join17(baseDir, "vault", "objects", hash);
@@ -8767,7 +7111,7 @@ async function readVaultRef(baseDir, label) {
   if (!existsSync13(objectPath)) return null;
   return readFile13(objectPath, "utf8");
 }
-var _keytar, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT;
+var _keytar, KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, KeychainUnavailableError, KEYCHAIN_JOURNAL_ACCOUNT;
 var init_vault = __esm({
   "../core/src/Storage/vault.ts"() {
     "use strict";
@@ -8775,6 +7119,15 @@ var init_vault = __esm({
     _keytar = "pending";
     KEYCHAIN_SERVICE = "msapling-cli";
     KEYCHAIN_ACCOUNT = "auth_token";
+    KeychainUnavailableError = class extends Error {
+      constructor(cause) {
+        super(
+          `Cannot save auth token: the OS keychain is unavailable (${cause}). Refusing to write the token to plain disk. Remediation: enable your platform keychain (Windows: Credential Manager/DPAPI, macOS: Keychain, Linux: libsecret/gnome-keyring) and retry login.`
+        );
+        this.name = "KeychainUnavailableError";
+      }
+    };
+    KEYCHAIN_JOURNAL_ACCOUNT = "journal_enc_key";
   }
 });
 
@@ -8834,10 +7187,10 @@ var init_recipes = __esm({
 });
 
 // ../core/src/Storage/history.ts
-import { join as join19 } from "path";
+import { join as join19, basename } from "path";
 import { existsSync as existsSync15, renameSync as renameSync4, writeFileSync as writeFileSync3 } from "fs";
 import { writeFile as writeFile8, readFile as readFile15, appendFile } from "fs/promises";
-import { createHash as createHash6, randomBytes as randomBytes9 } from "crypto";
+import { createHash as createHash6, randomBytes as randomBytes10 } from "crypto";
 function hashLine(line) {
   return createHash6("sha256").update(line, "utf8").digest("hex");
 }
@@ -8849,7 +7202,7 @@ async function appendHistoryEntry(baseDir, historyMutex, content) {
       if (!existsSync15(path2)) {
         await writeFile8(path2, "", "utf8");
       }
-      release3 = await lockfile2.lock(path2, { retries: 5, retryWait: 50 });
+      release3 = await lock(path2, { retries: 5, retryWait: 50 });
       let prevHash = null;
       let seq = 1;
       if (existsSync15(path2)) {
@@ -8877,7 +7230,7 @@ async function appendHistoryEntry(baseDir, historyMutex, content) {
     } finally {
       if (release3) {
         try {
-          await lockfile2.unlock(path2, { skipStale: true });
+          await unlock(path2, { skipStale: true });
         } catch {
         }
       }
@@ -8922,7 +7275,7 @@ async function saveHistory(baseDir, historyMutex, history) {
   let release3;
   try {
     if (!existsSync15(path2)) writeFileSync3(path2, "[]", "utf8");
-    release3 = await lockfile2.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+    release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     await historyMutex.run(async () => {
       const tmpPath = `${path2}.tmp`;
       const content = JSON.stringify(history, null, 2);
@@ -8943,7 +7296,7 @@ async function saveHistory(baseDir, historyMutex, history) {
   } finally {
     if (release3) {
       try {
-        await lockfile2.unlock(path2, { skipStale: true });
+        await unlock(path2, { skipStale: true });
       } catch (e) {
         console.warn(`Failed to unlock history file: ${e}`);
       }
@@ -8955,16 +7308,16 @@ async function loadHistory(baseDir, historyMutex) {
   if (!existsSync15(path2)) return [];
   let release3;
   try {
-    release3 = await lockfile2.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+    release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     return historyMutex.run(async () => {
       if (existsSync15(path2)) {
         const text = await readFile15(path2, "utf8");
         try {
           return JSON.parse(text);
         } catch (parseErr) {
-          const filename = path2.split("/").pop() || "shell_history.json";
+          const filename = basename(path2) || "shell_history.json";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes9(4).toString("hex");
+          const suffix = randomBytes10(4).toString("hex");
           const corruptBackupPath = join19(
             baseDir,
             "history",
@@ -8984,19 +7337,18 @@ async function loadHistory(baseDir, historyMutex) {
   } finally {
     if (release3) {
       try {
-        await lockfile2.unlock(path2, { skipStale: true });
+        await unlock(path2, { skipStale: true });
       } catch (e) {
         console.warn(`Failed to unlock history file: ${e}`);
       }
     }
   }
 }
-var lockfile2;
 var init_history = __esm({
   "../core/src/Storage/history.ts"() {
     "use strict";
     init_esm_shims();
-    lockfile2 = __toESM(require_proper_lockfile(), 1);
+    init_lockfile();
   }
 });
 
@@ -9004,13 +7356,13 @@ var init_history = __esm({
 import { join as join20 } from "path";
 import { existsSync as existsSync16, renameSync as renameSync5, writeFileSync as writeFileSync4 } from "fs";
 import { writeFile as writeFile9, readFile as readFile16 } from "fs/promises";
-import { randomBytes as randomBytes10 } from "crypto";
+import { randomBytes as randomBytes11 } from "crypto";
 async function savePermissions(baseDir, permissionsMutex, permissions) {
   const path2 = join20(baseDir, "vault", "permissions.json");
   let release3;
   try {
     if (!existsSync16(path2)) writeFileSync4(path2, "{}", "utf8");
-    release3 = await lockfile3.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+    release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     await permissionsMutex.run(async () => {
       const tmpPath = `${path2}.tmp`;
       const content = JSON.stringify(permissions, null, 2);
@@ -9031,7 +7383,7 @@ async function savePermissions(baseDir, permissionsMutex, permissions) {
   } finally {
     if (release3) {
       try {
-        await lockfile3.unlock(path2, { skipStale: true });
+        await unlock(path2, { skipStale: true });
       } catch (e) {
         console.warn(`Failed to unlock permissions file: ${e}`);
       }
@@ -9043,7 +7395,7 @@ async function loadPermissions(baseDir, permissionsMutex) {
   if (!existsSync16(path2)) return { trustedCommands: [], trustedPaths: [] };
   let release3;
   try {
-    release3 = await lockfile3.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+    release3 = await lock(path2, { realpath: false, retries: 5, retryWait: 50 });
     return permissionsMutex.run(async () => {
       if (existsSync16(path2)) {
         const text = await readFile16(path2, "utf8");
@@ -9052,7 +7404,7 @@ async function loadPermissions(baseDir, permissionsMutex) {
         } catch (parseErr) {
           const filename = path2.split("/").pop() || "permissions.json";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          const suffix = randomBytes10(4).toString("hex");
+          const suffix = randomBytes11(4).toString("hex");
           const corruptBackupPath = join20(
             baseDir,
             "vault",
@@ -9072,19 +7424,18 @@ async function loadPermissions(baseDir, permissionsMutex) {
   } finally {
     if (release3) {
       try {
-        await lockfile3.unlock(path2, { skipStale: true });
+        await unlock(path2, { skipStale: true });
       } catch (e) {
         console.warn(`Failed to unlock permissions file: ${e}`);
       }
     }
   }
 }
-var lockfile3;
 var init_permissions = __esm({
   "../core/src/Storage/permissions.ts"() {
     "use strict";
     init_esm_shims();
-    lockfile3 = __toESM(require_proper_lockfile(), 1);
+    init_lockfile();
   }
 });
 
@@ -9093,7 +7444,7 @@ import { join as join21 } from "path";
 import { homedir as homedir10 } from "os";
 import { chmodSync as chmodSync2 } from "fs";
 import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
-import { randomBytes as randomBytes11 } from "crypto";
+import { randomBytes as randomBytes12 } from "crypto";
 var StorageManager;
 var init_Storage = __esm({
   "../core/src/Storage.ts"() {
@@ -9101,6 +7452,8 @@ var init_Storage = __esm({
     init_esm_shims();
     init_Mutex();
     init_vault();
+    init_vault();
+    init_vault();
     init_recipes();
     init_history();
     init_permissions();
@@ -9212,7 +7565,7 @@ var init_Storage = __esm({
         await this._ready;
         const filename = filePath.split("/").pop() || "file";
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const suffix = randomBytes11(4).toString("hex");
+        const suffix = randomBytes12(4).toString("hex");
         const backupPath = join21(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
         await writeFile10(backupPath, content, "utf8");
         if (process.platform !== "win32") {
@@ -9224,23 +7577,48 @@ var init_Storage = __esm({
   }
 });
 
+// ../core/src/journalCrypto.ts
+async function initJournalEncryption() {
+  if (_initialized) return true;
+  const key = await getOrCreateJournalKey();
+  configureJournalCrypto(() => key);
+  _initialized = true;
+  return key !== null;
+}
+var _initialized;
+var init_journalCrypto = __esm({
+  "../core/src/journalCrypto.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src();
+    init_vault();
+    _initialized = false;
+  }
+});
+
 // ../core/src/Settings.ts
 import { homedir as homedir11 } from "os";
 import { join as join22 } from "path";
 import { existsSync as existsSync17 } from "fs";
 import * as fs from "fs";
 import { readFile as readFile17 } from "fs/promises";
-import { randomBytes as randomBytes12 } from "crypto";
+import { randomBytes as randomBytes13 } from "crypto";
+function backupStaleFile(p) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const suffix = randomBytes13(4).toString("hex");
+  fs.renameSync(p, `${p}.broken-${stamp}-${suffix}`);
+}
 function ensureConfigDir(p) {
+  if (fs.existsSync(p) && !fs.statSync(p).isDirectory()) {
+    backupStaleFile(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()) {
-        const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        const suffix = randomBytes12(4).toString("hex");
-        fs.renameSync(p, `${p}.broken-${stamp}-${suffix}`);
+        backupStaleFile(p);
         fs.mkdirSync(p, { recursive: true, mode: 448 });
       }
     } else {
@@ -9305,7 +7683,8 @@ function mergeSettings(base, override) {
 }
 async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
   const sources = [];
-  const userPath = join22(homedir11() || ".", ".msapling", "settings.json");
+  const home = env.HOME || env.USERPROFILE || process.env.HOME || process.env.USERPROFILE || homedir11() || ".";
+  const userPath = join22(home, ".msapling", "settings.json");
   const projectPath = join22(cwd, ".msapling", "settings.json");
   const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
   if (user) sources.push(userPath);
@@ -9664,6 +8043,7 @@ __export(src_exports2, {
   GlobFilesTool: () => GlobFilesTool,
   GrepSearchTool: () => GrepSearchTool,
   HookRunner: () => HookRunner,
+  KeychainUnavailableError: () => KeychainUnavailableError,
   ListDirectoryTool: () => ListDirectoryTool,
   MCPClient: () => MCPClient,
   MCPClientError: () => MCPClientError,
@@ -9688,6 +8068,8 @@ __export(src_exports2, {
   formatCell: () => formatCell,
   formatNotebookHeader: () => formatNotebookHeader,
   formatTodos: () => formatTodos,
+  getOrCreateJournalKey: () => getOrCreateJournalKey,
+  initJournalEncryption: () => initJournalEncryption,
   loadProjectConfig: () => loadProjectConfig,
   loadSettings: () => loadSettings,
   takeSnapshot: () => takeSnapshot
@@ -9702,6 +8084,8 @@ var init_src3 = __esm({
     init_TrustStore();
     init_ContextBudget();
     init_Storage();
+    init_Storage();
+    init_journalCrypto();
     init_Mutex();
     init_ProjectConfig();
     init_Settings();
@@ -9747,22 +8131,29 @@ async function promptPassword(prompt4) {
     const wasRaw = stdin.isRaw ?? false;
     setRawModeGuarded(stdin, true);
     let password = "";
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      setRawModeGuarded(stdin, wasRaw);
+      stdin.removeListener("data", onData);
+      stdout.write("\n");
+      resolve20(value);
+    };
     const onData = (chunk) => {
-      const char = chunk.toString();
-      if (char === "\n" || char === "\r") {
-        setRawModeGuarded(stdin, wasRaw);
-        stdin.removeListener("data", onData);
-        stdout.write("\n");
-        resolve20(password);
-      } else if (char === "") {
-        setRawModeGuarded(stdin, wasRaw);
-        stdin.removeListener("data", onData);
-        stdout.write("\n");
-        resolve20("");
-      } else if (char === "\x7F" || char === "\b") {
-        password = password.slice(0, -1);
-      } else if (char >= " " && char <= "~") {
-        password += char;
+      try {
+        const char = chunk.toString();
+        if (char === "\n" || char === "\r") {
+          settle(password);
+        } else if (char === "") {
+          settle("");
+        } else if (char === "\x7F" || char === "\b") {
+          password = password.slice(0, -1);
+        } else if (char >= " " && char <= "~") {
+          password += char;
+        }
+      } catch {
+        settle("");
       }
     };
     stdin.on("data", onData);
@@ -9971,10 +8362,11 @@ var init_login = __esm({
 async function getKeytar2() {
   if (_keytar2 !== "pending") return _keytar2;
   try {
-    _keytar2 = await import("keytar");
+    const mod = await import("@napi-rs/keyring/keytar.js");
+    _keytar2 = mod && typeof mod.setPassword === "function" ? mod : mod?.default ?? mod;
     return _keytar2;
   } catch (e) {
-    console.warn(`[secureStore] keytar unavailable, falling back to file token: ${e instanceof Error ? e.message : String(e)}`);
+    console.warn(`[secureStore] keyring unavailable, falling back to file token: ${e instanceof Error ? e.message : String(e)}`);
     _keytar2 = null;
     return null;
   }
@@ -10219,7 +8611,7 @@ var init_unlock = __esm({
 // src/commands/doctor.ts
 import { homedir as homedir12 } from "os";
 import { join as join23 } from "path";
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import { readFile as readFile18 } from "fs/promises";
 async function checkApiHealth(client) {
   try {
@@ -10247,7 +8639,7 @@ async function checkAuthStatus(client) {
 async function checkSettingsFile() {
   const settingsPath = join23(homedir12(), ".msapling", "settings.json");
   try {
-    if (!existsSync18(settingsPath)) {
+    if (!existsSync19(settingsPath)) {
       return { ok: false, message: `Not found: ${settingsPath}` };
     }
     const text = await readFile18(settingsPath, "utf8");
@@ -10815,6 +9207,43 @@ var init_ollama = __esm({
 });
 
 // src/commands/keys.ts
+function setRawModeGuarded2(stdin, mode) {
+  try {
+    if (typeof stdin.setRawMode === "function") {
+      stdin.setRawMode(mode);
+    }
+  } catch {
+  }
+}
+async function promptSecret(prompt4) {
+  return new Promise((resolve20) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdout.write(prompt4);
+    const wasRaw = stdin.isRaw ?? false;
+    setRawModeGuarded2(stdin, true);
+    let secret = "";
+    const onData = (chunk) => {
+      const char = chunk.toString();
+      if (char === "\n" || char === "\r") {
+        setRawModeGuarded2(stdin, wasRaw);
+        stdin.removeListener("data", onData);
+        stdout.write("\n");
+        resolve20(secret);
+      } else if (char === "") {
+        setRawModeGuarded2(stdin, wasRaw);
+        stdin.removeListener("data", onData);
+        stdout.write("\n");
+        resolve20("");
+      } else if (char === "\x7F" || char === "\b") {
+        secret = secret.slice(0, -1);
+      } else if (char >= " " && char <= "~") {
+        secret += char;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
 var keysCommand;
 var init_keys = __esm({
   "src/commands/keys.ts"() {
@@ -10848,12 +9277,42 @@ var init_keys = __esm({
           }
           if (sub === "add" || sub === "save") {
             const provider = rest[0];
-            const key = rest.slice(1).join(" ").trim();
-            if (!provider || !key) {
-              context.addMessage("system", "Usage: /keys add <provider> <key>  (e.g. /keys add openai sk-...)");
+            const inlineKey = rest.slice(1).join(" ").trim();
+            if (!provider) {
+              context.addMessage("system", "Usage: /keys add <provider>  (e.g. /keys add openai) \u2014 you will be prompted for the key");
+              return;
+            }
+            if (inlineKey) {
+              context.addMessage(
+                "error",
+                "Refusing to accept an API key on the command line \u2014 it would be saved in your REPL/shell history."
+              );
+              context.addMessage("system", `Re-run without the key:  /keys add ${provider}`);
+              context.addMessage("system", "You will be prompted for the key with hidden input. Then rotate the key you just typed, since it is now in history.");
+              return;
+            }
+            if (process.stdin.listenerCount("data") > 0) {
+              context.addMessage(
+                "error",
+                "Cannot prompt for the key inside the REPL \u2014 Ink owns stdin and would echo the key into chat."
+              );
+              context.addMessage("system", `Run it outside the REPL instead:  msapling --exec "/keys add ${provider}"`);
+              return;
+            }
+            let key = "";
+            try {
+              key = await promptSecret(`Enter API key for ${provider} (hidden): `);
+            } catch (err) {
+              context.addMessage("error", `Key prompt failed: ${err}`);
+              return;
+            }
+            key = key.trim();
+            if (!key) {
+              context.addMessage("system", "Cancelled \u2014 no key entered.");
               return;
             }
             const res = await context.client.saveProviderKey(provider, key);
+            key = "";
             context.addMessage("system", `Saved key for ${provider}: ${res.message ?? res.status}`);
             return;
           }
@@ -10935,14 +9394,28 @@ var init_memories = __esm({
 
 // src/commands/mdrive.ts
 import { readFile as readFile19, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import { basename, resolve as resolve14 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { basename as basename2, resolve as resolve14, relative as relative14, isAbsolute as isAbsolute14, sep as sep3 } from "path";
 function formatBytes(b) {
   if (!b) return "0";
   if (b < 1024) return `${b}`;
   if (b < 1024 * 1024) return `${(b / 1024).toFixed(1)}K`;
   return `${(b / 1024 / 1024).toFixed(1)}M`;
 }
+function containLocalPath(targetPath, root = process.cwd()) {
+  const resolvedRoot = resolve14(root);
+  const resolved = isAbsolute14(targetPath) ? resolve14(targetPath) : resolve14(resolvedRoot, targetPath);
+  const rel = relative14(resolvedRoot, resolved);
+  if (rel === ".." || rel.startsWith(`..${sep3}`) || rel.startsWith("../") || isAbsolute14(rel)) {
+    return null;
+  }
+  return resolved;
+}
+function isRemotePathSafe(remotePath) {
+  if (!remotePath || remotePath.includes("\0")) return false;
+  const segments = remotePath.replace(/\\/g, "/").split("/");
+  return !segments.some((seg) => seg === "..");
+}
 var mdriveCommand;
 var init_mdrive = __esm({
   "src/commands/mdrive.ts"() {
@@ -10969,6 +9442,10 @@ var init_mdrive = __esm({
         try {
           if (sub === "ls" || sub === "list") {
             const path2 = rest[0] || ".";
+            if (!isRemotePathSafe(path2)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${path2}`);
+              return;
+            }
             const res = await context.client.mdriveList(path2);
             const entries = res.entries ?? res.files ?? res.items ?? [];
             context.addMessage("system", `MDrive: ${path2}  (${entries.length} entries)`);
@@ -10986,19 +9463,31 @@ var init_mdrive = __esm({
               context.addMessage("system", "Usage: /mdrive cat <path>");
               return;
             }
+            if (!isRemotePathSafe(p)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${p}`);
+              return;
+            }
             const res = await context.client.mdriveRead(p);
             context.addMessage("system", res.content ?? res.body ?? "(no content)");
             return;
           }
           if (sub === "put" || sub === "upload" || sub === "write") {
             const local = rest[0];
-            const remote = rest[1] || (local ? basename(local) : "");
+            const remote = rest[1] || (local ? basename2(local) : "");
             if (!local || !remote) {
               context.addMessage("system", "Usage: /mdrive put <local> [<remote>]");
               return;
             }
-            const absLocal = resolve14(local);
-            if (!existsSync19(absLocal)) {
+            if (!isRemotePathSafe(remote)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${remote}`);
+              return;
+            }
+            const absLocal = containLocalPath(local);
+            if (!absLocal) {
+              context.addMessage("error", `Refusing to read local file outside the working directory: ${local}`);
+              return;
+            }
+            if (!existsSync20(absLocal)) {
               context.addMessage("error", `Local file not found: ${absLocal}`);
               return;
             }
@@ -11014,11 +9503,23 @@ var init_mdrive = __esm({
               context.addMessage("system", "Usage: /mdrive get <remote> [<local>]");
               return;
             }
+            if (!isRemotePathSafe(remote)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${remote}`);
+              return;
+            }
+            let absLocal = null;
+            if (local) {
+              absLocal = containLocalPath(local);
+              if (!absLocal) {
+                context.addMessage("error", `Refusing to write local file outside the working directory: ${local}`);
+                return;
+              }
+            }
             const res = await context.client.mdriveRead(remote);
             const content = res.content ?? res.body ?? "";
-            if (local) {
-              await writeFile11(resolve14(local), content, "utf8");
-              context.addMessage("system", `Wrote ${resolve14(local)}  (${formatBytes(content.length)})`);
+            if (absLocal) {
+              await writeFile11(absLocal, content, "utf8");
+              context.addMessage("system", `Wrote ${absLocal}  (${formatBytes(content.length)})`);
             } else {
               context.addMessage("system", content);
             }
@@ -11030,6 +9531,10 @@ var init_mdrive = __esm({
               context.addMessage("system", "Usage: /mdrive rm <path>");
               return;
             }
+            if (!isRemotePathSafe(p)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${p}`);
+              return;
+            }
             await context.client.mdriveDelete(p);
             context.addMessage("system", `Deleted mdrive:${p}`);
             return;
@@ -11041,6 +9546,10 @@ var init_mdrive = __esm({
               context.addMessage("system", "Usage: /mdrive mv <path> <new-name>");
               return;
             }
+            if (!isRemotePathSafe(p) || !isRemotePathSafe(newName)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${!isRemotePathSafe(p) ? p : newName}`);
+              return;
+            }
             await context.client.mdriveRename(p, newName);
             context.addMessage("system", `Renamed mdrive:${p} \u2192 ${newName}`);
             return;
@@ -11051,6 +9560,10 @@ var init_mdrive = __esm({
               context.addMessage("system", "Usage: /mdrive mkdir <path>");
               return;
             }
+            if (!isRemotePathSafe(p)) {
+              context.addMessage("error", `Rejected unsafe MDrive path (path traversal): ${p}`);
+              return;
+            }
             await context.client.mdriveMkdir(p);
             context.addMessage("system", `Created mdrive:${p}/`);
             return;
@@ -11061,7 +9574,7 @@ var init_mdrive = __esm({
           if (msg.includes("Invalid or revoked API key") || msg.includes("401")) {
             context.addMessage(
               "error",
-              'MDrive requires a paid account + MDrive API key. Generate one at https://msapling.com/settings \u2192 API Keys \u2192 "Create MDrive Key", then run /keys add mdrive <key>.'
+              'MDrive requires a paid account + MDrive API key. Generate one at https://msapling.com/settings \u2192 API Keys \u2192 "Create MDrive Key", then run /keys add mdrive (you will be prompted for the key).'
             );
           } else {
             context.addMessage("error", `MDrive: ${msg}`);
@@ -11097,12 +9610,12 @@ var init_clear = __esm({
 // src/commands/mode.ts
 import { homedir as homedir13 } from "os";
 import { join as join24 } from "path";
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { readFile as readFile20, writeFile as writeFile12, mkdir as mkdir7 } from "fs/promises";
 async function persistApprovalMode(mode, ttlMs) {
   try {
     let existing = {};
-    if (existsSync20(SETTINGS_PATH)) {
+    if (existsSync21(SETTINGS_PATH)) {
       const text = await readFile20(SETTINGS_PATH, "utf8");
       if (text.trim()) {
         existing = JSON.parse(text);
@@ -11115,7 +9628,7 @@ async function persistApprovalMode(mode, ttlMs) {
     };
     existing.approvalMode = entry;
     const settingsDir = join24(homedir13(), ".msapling");
-    if (!existsSync20(settingsDir)) {
+    if (!existsSync21(settingsDir)) {
       await mkdir7(settingsDir, { recursive: true });
     }
     await writeFile12(SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf8");
@@ -11550,7 +10063,7 @@ var init_compact = __esm({
 
 // src/commands/init.ts
 import { join as join25 } from "path";
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { writeFile as writeFile13 } from "fs/promises";
 var initCommand;
 var init_init = __esm({
@@ -11565,7 +10078,7 @@ var init_init = __esm({
         try {
           const cwd = process.cwd();
           const path2 = join25(cwd, "MSAPLING.md");
-          if (existsSync21(path2)) {
+          if (existsSync22(path2)) {
             context.addMessage("error", "MSAPLING.md already exists in current directory.");
             return;
           }
@@ -11591,7 +10104,7 @@ var init_init = __esm({
 });
 
 // src/commands/review.ts
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { readFile as readFile21 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
@@ -11611,7 +10124,7 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync22(target)) {
+          if (existsSync23(target)) {
             content = await readFile21(target, "utf8");
           } else {
             content = `Review target: ${target}`;
@@ -11705,7 +10218,7 @@ var init_swarm = __esm({
 
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { readFile as readFile22 } from "fs/promises";
 import { join as join26 } from "path";
 function findRecipe(name, cwd) {
@@ -11713,7 +10226,7 @@ function findRecipe(name, cwd) {
     for (const suffix of NAME_SUFFIXES) {
       for (const ext of FILE_EXTS) {
         const p = join26(cwd, dir, `${name}${suffix}${ext}`);
-        if (existsSync23(p)) return p;
+        if (existsSync24(p)) return p;
       }
     }
   }
@@ -11826,13 +10339,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync24, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
 import { readFile as readFile23 } from "fs/promises";
 import { join as join27, resolve as resolve15 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
     const full = resolve15(cwd, candidate);
-    if (existsSync24(full) && statSync5(full).isDirectory()) return full;
+    if (existsSync25(full) && statSync5(full).isDirectory()) return full;
   }
   return null;
 }
@@ -11968,7 +10481,7 @@ function parseArgs(args2) {
 }
 function formatTable(results) {
   const header = `${"Model".padEnd(40)} ${"TTFT(ms)".padStart(9)} ${"TPS".padStart(7)} ${"Tokens".padStart(8)} ${"Cost($)".padStart(9)}`;
-  const sep3 = "-".repeat(header.length);
+  const sep4 = "-".repeat(header.length);
   const rows = results.map((r) => {
     const model = r.model.slice(0, 39).padEnd(40);
     const ttft = r.ttft_ms != null ? r.ttft_ms.toFixed(0).padStart(9) : "    -    ";
@@ -11978,7 +10491,7 @@ function formatTable(results) {
     const err = r.error ? `  \u26A0 ${r.error}` : "";
     return `${model} ${ttft} ${tps} ${tok} ${cost}${err}`;
   });
-  return [sep3, header, sep3, ...rows, sep3].join("\n");
+  return [sep4, header, sep4, ...rows, sep4].join("\n");
 }
 var DEFAULT_PROMPTS, benchmarkCommand;
 var init_benchmark = __esm({
@@ -12322,13 +10835,13 @@ var init_theme = __esm({
 // src/commands/theme.ts
 import { join as join29 } from "path";
 import { homedir as homedir15 } from "os";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { readFile as readFile24, writeFile as writeFile14 } from "fs/promises";
 async function persistTheme(storage, themeName) {
   const settingsPath = join29(homedir15(), ".msapling", "settings.json");
   let existing = {};
   try {
-    if (existsSync25(settingsPath)) {
+    if (existsSync26(settingsPath)) {
       const text = await readFile24(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
@@ -12407,7 +10920,7 @@ var init_version = __esm({
       description: "Show version information for CLI and core packages",
       category: "debug",
       handler: async (_args, context) => {
-        const cliVersion = true ? "2.3.6-beta.43" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.45" : "(dev)";
         const coreVersion = true ? "2.3.6-beta.43" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -12416,7 +10929,7 @@ var init_version = __esm({
         context.addMessage("system", row2("Core (@msapling/core)", coreVersion));
         context.addMessage("system", row2("Runtime (Node/Bun)", runtime));
         try {
-          const ts = "2026-06-02T17:24:01.257Z";
+          const ts = "2026-06-20T07:16:00.342Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -12430,13 +10943,13 @@ var init_version = __esm({
 
 // src/commands/feedback.ts
 import { join as join30 } from "path";
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { readFile as readFile25 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
     const pkgPath = join30(baseDir, "..", "..", "package.json");
-    if (!existsSync26(pkgPath)) return "unknown";
+    if (!existsSync27(pkgPath)) return "unknown";
     const text = await readFile25(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
@@ -12740,14 +11253,14 @@ var init_plan = __esm({
 // src/commands/note.ts
 import { homedir as homedir17 } from "os";
 import { join as join32 } from "path";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { readFile as readFile26, writeFile as writeFile16 } from "fs/promises";
 function getNotesFilePath() {
   return join32(homedir17(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
-    if (!existsSync27(filePath)) return [];
+    if (!existsSync28(filePath)) return [];
     const raw = await readFile26(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
@@ -12904,10 +11417,13 @@ var init_todo = __esm({
 
 // src/commands/outputStyle.ts
 import { homedir as homedir18 } from "os";
-import { join as join33, basename as basename2, extname as extname3 } from "path";
-import { existsSync as existsSync28, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join33, basename as basename3, extname as extname3 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync5 } from "fs";
+function resolveHome() {
+  return process.env.HOME || process.env.USERPROFILE || homedir18();
+}
 function stylesDir() {
-  return join33(homedir18(), ".msapling", "output-styles");
+  return join33(resolveHome(), ".msapling", "output-styles");
 }
 function activeFile() {
   return join33(stylesDir(), ".active");
@@ -12931,7 +11447,7 @@ function parseStyleFile(text) {
 }
 function listUserStyles() {
   const dir = stylesDir();
-  if (!existsSync28(dir)) return [];
+  if (!existsSync29(dir)) return [];
   const out = [];
   for (const entry of readdirSync3(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
@@ -12940,7 +11456,7 @@ function listUserStyles() {
       const text = readFileSync2(full, "utf8");
       const { description, body } = parseStyleFile(text);
       out.push({
-        name: basename2(entry, ".md"),
+        name: basename3(entry, ".md"),
         description,
         body,
         source: "user",
@@ -12963,7 +11479,7 @@ function findStyle(name) {
 function getActiveStyleName() {
   try {
     const f = activeFile();
-    if (!existsSync28(f)) return "default";
+    if (!existsSync29(f)) return "default";
     return readFileSync2(f, "utf8").trim() || "default";
   } catch {
     return "default";
@@ -12971,7 +11487,7 @@ function getActiveStyleName() {
 }
 function setActiveStyleName(name) {
   const dir = stylesDir();
-  if (!existsSync28(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync29(dir)) mkdirSync5(dir, { recursive: true });
   writeFileSync5(activeFile(), `${name}
 `, "utf8");
 }
@@ -12984,7 +11500,7 @@ function createUserStyle(name, description, body) {
     throw new Error(`Invalid style name "${name}" \u2014 use letters, digits, _ and - only.`);
   }
   const dir = stylesDir();
-  if (!existsSync28(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync29(dir)) mkdirSync5(dir, { recursive: true });
   const target = join33(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
@@ -14351,7 +12867,7 @@ var exec_exports = {};
 __export(exec_exports, {
   runExec: () => runExec
 });
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { readFile as readFile29 } from "fs/promises";
 import { homedir as homedir20 } from "os";
 import { join as join35 } from "path";
@@ -14359,7 +12875,7 @@ async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
     const p = join35(homedir20(), ".msapling", "settings.json");
-    if (!existsSync31(p)) return out;
+    if (!existsSync32(p)) return out;
     const raw = JSON.parse(await readFile29(p, "utf8"));
     const parsed = parseApprovalMode(raw, Date.now());
     if (parsed.kind === "ok") out.mode = parsed.mode;
@@ -14725,8 +13241,7 @@ async function runSub(argv) {
     console.log(formatSubSummary(balance));
     console.log("");
   } catch (e) {
-    console.error(`Error fetching subscription status: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Error fetching subscription status: ${e.message}`, { cause: e });
   }
 }
 async function runSubUpgrade(flags) {
@@ -14779,8 +13294,7 @@ Payment confirmed. Your plan has been upgraded to ${formatTier(product)}.`);
 Checkout ${result.state}. No charges were made.`);
     }
   } catch (e) {
-    console.error(`Checkout error: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Checkout error: ${e.message}`, { cause: e });
   }
 }
 async function runSubManage() {
@@ -14818,8 +13332,7 @@ Current plan: ${formatTier(balance.tier)}`);
     await postSubscriptionCancel();
     console.log("\nSubscription cancelled. You retain access until the end of your billing period.");
   } catch (e) {
-    console.error(`Cancel failed: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Cancel failed: ${e.message}`, { cause: e });
   }
 }
 var init_sub = __esm({
@@ -14885,8 +13398,7 @@ Payment confirmed. New balance: ${formatCredits(balance.fuel_credits)} (${format
 Checkout ${result.state}. No charges were made.`);
     }
   } catch (e) {
-    console.error(`Checkout error: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Checkout error: ${e.message}`, { cause: e });
   }
 }
 async function runTopupAuto() {
@@ -14894,8 +13406,7 @@ async function runTopupAuto() {
   try {
     balance = await fetchBalance();
   } catch (e) {
-    console.error(`Error fetching settings: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Error fetching settings: ${e.message}`, { cause: e });
   }
   const at = balance.auto_topup;
   console.log("\n--- Auto-Topup Settings ---");
@@ -14920,8 +13431,7 @@ async function runTopupAuto() {
   const amount = parseFloat(amountStr);
   const cap = parseFloat(capStr);
   if (isNaN(threshold) || isNaN(amount) || isNaN(cap)) {
-    console.error("Invalid values \u2014 no changes made.");
-    process.exit(1);
+    throw new Error("Invalid values \u2014 no changes made.");
   }
   try {
     await patchAutoTopup({
@@ -14932,8 +13442,7 @@ async function runTopupAuto() {
     });
     console.log("Auto-topup settings updated.");
   } catch (e) {
-    console.error(`Update failed: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Update failed: ${e.message}`, { cause: e });
   }
 }
 var init_topup = __esm({
@@ -14954,8 +13463,7 @@ __export(redeem_exports, {
 async function runRedeem(argv) {
   const code = (argv[0] ?? "").trim().toUpperCase();
   if (!code) {
-    console.error("Usage: msapling gift redeem <code>  (e.g. MSAPL-GIFT-ABCD-EFGH)");
-    process.exit(1);
+    throw new Error("Usage: msapling gift redeem <code>  (e.g. MSAPL-GIFT-ABCD-EFGH)");
   }
   try {
     const result = await postGiftRedeem(code);
@@ -14965,8 +13473,7 @@ async function runRedeem(argv) {
       console.log(`Could not apply gift: ${result.message}`);
     }
   } catch (e) {
-    console.error(`Redeem failed: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Redeem failed: ${e.message}`, { cause: e });
   }
 }
 var init_redeem = __esm({
@@ -14987,20 +13494,18 @@ async function runGift(argv) {
   if (subCmd === "sub") return runGiftSub(argv.slice(1));
   if (subCmd === "credits") return runGiftCredits(argv.slice(1));
   if (subCmd === "redeem") return runRedeem(argv.slice(1));
-  console.error("Usage: msapling gift sub <user> | credits <user> <5|10> | redeem <code>");
-  process.exit(1);
+  throw new Error("Usage: msapling gift sub <user> | credits <user> <5|10> | redeem <code>");
 }
 async function _resolveRecipient(username) {
   const clean = username.replace(/^@/, "");
   try {
     const user = await fetchUserLookup(clean);
     if (user === null) {
-      console.error(`User @${clean} not found.`);
-      process.exit(1);
+      throw new Error(`User @${clean} not found.`);
     }
   } catch (e) {
-    console.error(`User lookup failed: ${e.message}`);
-    process.exit(1);
+    if (e.message?.startsWith("User @")) throw e;
+    throw new Error(`User lookup failed: ${e.message}`, { cause: e });
   }
   return clean;
 }
@@ -15013,14 +13518,12 @@ async function _giftMethodMenu() {
   rl.close();
   if (choice === "1") return "direct";
   if (choice === "2") return "code";
-  console.error("Invalid choice.");
-  process.exit(1);
+  throw new Error("Invalid choice.");
 }
 async function runGiftSub(argv) {
   const usernameRaw = argv[0] ?? "";
   if (!usernameRaw) {
-    console.error("Usage: msapling gift sub <username|@username>");
-    process.exit(1);
+    throw new Error("Usage: msapling gift sub <username|@username>");
   }
   const recipient = await _resolveRecipient(usernameRaw);
   console.log(`
@@ -15058,21 +13561,18 @@ Payment confirmed. Gift code will be emailed to you shortly.`);
 Checkout ${result.state}. No charges were made.`);
     }
   } catch (e) {
-    console.error(`Gift checkout error: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Gift checkout error: ${e.message}`, { cause: e });
   }
 }
 async function runGiftCredits(argv) {
   const usernameRaw = argv[0] ?? "";
   const countStr = argv[1] ?? "";
   if (!usernameRaw || !countStr) {
-    console.error("Usage: msapling gift credits <username|@username> <5|10>");
-    process.exit(1);
+    throw new Error("Usage: msapling gift credits <username|@username> <5|10>");
   }
   const count = parseInt(countStr, 10);
   if (count !== 5 && count !== 10) {
-    console.error("Credit amount must be 5 or 10.");
-    process.exit(1);
+    throw new Error("Credit amount must be 5 or 10.");
   }
   const recipient = await _resolveRecipient(usernameRaw);
   const product = `gift_fuel_${count}`;
@@ -15112,8 +13612,7 @@ Payment confirmed. Gift code will be emailed to you shortly.`);
 Checkout ${result.state}. No charges were made.`);
     }
   } catch (e) {
-    console.error(`Gift checkout error: ${e.message}`);
-    process.exit(1);
+    throw new Error(`Gift checkout error: ${e.message}`, { cause: e });
   }
 }
 var init_gift = __esm({
@@ -15142,8 +13641,7 @@ async function dispatchBillingCommand(cmd, argv) {
       return runGift(argv);
     default: {
       const _exhaustive = cmd;
-      console.error(`Unknown billing command: ${_exhaustive}`);
-      process.exit(1);
+      throw new Error(`Unknown billing command: ${_exhaustive}`);
     }
   }
 }
@@ -15237,7 +13735,7 @@ __export(doctor_exports, {
 });
 import { homedir as homedir21, platform as platform4, tmpdir } from "os";
 import { join as join36 } from "path";
-import { existsSync as existsSync32, statSync as statSync6 } from "fs";
+import { existsSync as existsSync33, statSync as statSync6 } from "fs";
 import { readdir as readdir3, mkdir as mkdir9, rm as rm3 } from "fs/promises";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -15261,7 +13759,7 @@ async function checkNodeVersion() {
 }
 async function checkConfigDir() {
   const configDir = join36(homedir21(), ".msapling");
-  if (!existsSync32(configDir)) {
+  if (!existsSync33(configDir)) {
     return {
       name: "Config directory",
       status: "WARN",
@@ -15298,28 +13796,29 @@ async function checkConfigDir() {
 }
 async function checkKeytar() {
   try {
-    const keytar = await import("keytar");
-    if (keytar && typeof keytar.getPassword === "function") {
+    const mod = await import("@napi-rs/keyring/keytar.js");
+    const keyring = mod && typeof mod.getPassword === "function" ? mod : mod?.default ?? mod;
+    if (keyring && typeof keyring.getPassword === "function") {
       return {
-        name: "Keytar native binary",
+        name: "Keyring native binary",
         status: "PASS",
-        message: "Keytar loadable and functional"
+        message: "@napi-rs/keyring loadable and functional"
       };
     }
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     return {
-      name: "Keytar native binary",
+      name: "Keyring native binary",
       status: "WARN",
-      message: `Keytar unavailable: ${msg}`,
-      remediation: `Token will be stored in plaintext. Run 'npm rebuild keytar' or 'bun install --force' to rebuild native bindings.`
+      message: `@napi-rs/keyring unavailable: ${msg}`,
+      remediation: `Token will be stored in plaintext. Run 'bun install' or 'npm install' to restore the @napi-rs/keyring prebuilt binary.`
     };
   }
   return {
-    name: "Keytar native binary",
+    name: "Keyring native binary",
     status: "WARN",
-    message: "Keytar check inconclusive",
-    remediation: `Run 'npm rebuild keytar' or 'bun install --force' to rebuild native bindings.`
+    message: "Keyring check inconclusive",
+    remediation: `Run 'bun install' or 'npm install' to restore the @napi-rs/keyring prebuilt binary.`
   };
 }
 async function checkPathConflicts() {
@@ -15329,7 +13828,7 @@ async function checkPathConflicts() {
   const timedOutDirs = [];
   const DIR_TIMEOUT_MS = 1500;
   for (const dir of paths) {
-    if (!dir || !existsSync32(dir)) continue;
+    if (!dir || !existsSync33(dir)) continue;
     try {
       const files = await Promise.race([
         readdir3(dir),
@@ -15422,7 +13921,8 @@ async function checkNetworkReach() {
 }
 async function checkTokenValidity() {
   try {
-    const keytar = await import("keytar");
+    const mod = await import("@napi-rs/keyring/keytar.js");
+    const keytar = mod && typeof mod.getPassword === "function" ? mod : mod?.default ?? mod;
     const KEYCHAIN_SERVICE3 = "msapling-cli";
     const KEYCHAIN_ACCOUNT3 = "auth_token";
     const token = await keytar.getPassword(KEYCHAIN_SERVICE3, KEYCHAIN_ACCOUNT3);
@@ -15517,11 +14017,11 @@ async function checkOsSpecific() {
   }
   if (platform4() === "linux") {
     try {
-      await import("keytar");
+      await import("@napi-rs/keyring/keytar.js");
       return {
         name: "OS-specific (Linux)",
         status: "PASS",
-        message: "libsecret/keytar dependencies available"
+        message: "libsecret/@napi-rs/keyring dependencies available"
       };
     } catch (e) {
       return {
@@ -15579,8 +14079,8 @@ async function runDoctor(debug = false) {
   checks.push(await checkTokenValidity());
   checks.push(await checkOsSpecific());
   const maxLabelWidth = Math.max(...checks.map((c) => c.name.length));
-  for (const check of checks) {
-    output.push(formatCheckResult(check, maxLabelWidth));
+  for (const check2 of checks) {
+    output.push(formatCheckResult(check2, maxLabelWidth));
   }
   output.push("");
   output.push("\u2500".repeat(60));
@@ -16004,10 +14504,10 @@ var init_local_tools = __esm({
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/diff/base.js
+// ../../node_modules/diff/libesm/diff/base.js
 var Diff;
 var init_base = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/diff/base.js"() {
+  "../../node_modules/diff/libesm/diff/base.js"() {
     "use strict";
     init_esm_shims();
     Diff = class {
@@ -16213,7 +14713,7 @@ var init_base = __esm({
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/util/string.js
+// ../../node_modules/diff/libesm/util/string.js
 function hasOnlyWinLineEndings(string) {
   return string.includes("\r\n") && !string.startsWith("\n") && !string.match(/[^\r]\n/);
 }
@@ -16221,13 +14721,13 @@ function hasOnlyUnixLineEndings(string) {
   return !string.includes("\r\n") && string.includes("\n");
 }
 var init_string = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/util/string.js"() {
+  "../../node_modules/diff/libesm/util/string.js"() {
     "use strict";
     init_esm_shims();
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/diff/line.js
+// ../../node_modules/diff/libesm/diff/line.js
 function diffLines(oldStr, newStr, options) {
   return lineDiff.diff(oldStr, newStr, options);
 }
@@ -16251,7 +14751,7 @@ function tokenize(value, options) {
 }
 var LineDiff, lineDiff;
 var init_line = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/diff/line.js"() {
+  "../../node_modules/diff/libesm/diff/line.js"() {
     "use strict";
     init_esm_shims();
     init_base();
@@ -16283,7 +14783,7 @@ var init_line = __esm({
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/line-endings.js
+// ../../node_modules/diff/libesm/patch/line-endings.js
 function unixToWin(patch) {
   if (Array.isArray(patch)) {
     return patch.map((p) => unixToWin(p));
@@ -16315,13 +14815,13 @@ function isWin(patch) {
   })));
 }
 var init_line_endings = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/line-endings.js"() {
+  "../../node_modules/diff/libesm/patch/line-endings.js"() {
     "use strict";
     init_esm_shims();
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/parse.js
+// ../../node_modules/diff/libesm/patch/parse.js
 function parsePatch(uniDiff) {
   const diffstr = uniDiff.split(/\n/), list2 = [];
   let i = 0;
@@ -16657,13 +15157,13 @@ function parsePatch(uniDiff) {
   return list2;
 }
 var init_parse = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/parse.js"() {
+  "../../node_modules/diff/libesm/patch/parse.js"() {
     "use strict";
     init_esm_shims();
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/util/distance-iterator.js
+// ../../node_modules/diff/libesm/util/distance-iterator.js
 function distance_iterator_default(start, minLine, maxLine) {
   let wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
   return function iterator() {
@@ -16692,13 +15192,13 @@ function distance_iterator_default(start, minLine, maxLine) {
   };
 }
 var init_distance_iterator = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/util/distance-iterator.js"() {
+  "../../node_modules/diff/libesm/util/distance-iterator.js"() {
     "use strict";
     init_esm_shims();
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/apply.js
+// ../../node_modules/diff/libesm/patch/apply.js
 function applyPatch(source, patch, options = {}) {
   let patches;
   if (typeof patch === "string") {
@@ -16847,7 +15347,7 @@ function applyStructuredPatch(source, patch, options = {}) {
   return resultLines.join("\n");
 }
 var init_apply = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/apply.js"() {
+  "../../node_modules/diff/libesm/patch/apply.js"() {
     "use strict";
     init_esm_shims();
     init_string();
@@ -16857,7 +15357,7 @@ var init_apply = __esm({
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/create.js
+// ../../node_modules/diff/libesm/patch/create.js
 function needsQuoting(s) {
   for (let i = 0; i < s.length; i++) {
     if (s[i] < " " || s[i] > "~" || s[i] === '"' || s[i] === "\\") {
@@ -17115,7 +15615,7 @@ function splitLines(text) {
 }
 var INCLUDE_HEADERS;
 var init_create = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/create.js"() {
+  "../../node_modules/diff/libesm/patch/create.js"() {
     "use strict";
     init_esm_shims();
     init_line();
@@ -17127,9 +15627,9 @@ var init_create = __esm({
   }
 });
 
-// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/index.js
+// ../../node_modules/diff/libesm/index.js
 var init_libesm = __esm({
-  "../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/index.js"() {
+  "../../node_modules/diff/libesm/index.js"() {
     "use strict";
     init_esm_shims();
     init_apply();
@@ -17139,7 +15639,7 @@ var init_libesm = __esm({
 
 // ../core/src/mcp/catalog.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync3, statSync as statSync7 } from "fs";
-import { join as join37, relative as relative14 } from "path";
+import { join as join37, relative as relative15 } from "path";
 function buildFileTree(root, maxFiles) {
   const SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "build", "dist", ".venv", "venv", ".next", "__pycache__", ".dart_tool", ".bun", "target"]);
   const SOURCE_EXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".kt", ".swift", ".dart", ".rb", ".cs", ".cpp", ".c", ".h", ".md", ".json", ".yaml", ".yml", ".toml", ".sh", ".sql"]);
@@ -17185,7 +15685,7 @@ function readFilesAsContext(root, files, maxKB) {
       continue;
     }
     if (body.length > cap) body = body.slice(0, cap) + "\n[...truncated]";
-    const rel = relative14(root, f).replace(/\\/g, "/");
+    const rel = relative15(root, f).replace(/\\/g, "/");
     parts.push(`### ${rel}
 
 \`\`\`
@@ -17595,8 +16095,38 @@ var server_exports = {};
 __export(server_exports, {
   MCPServer: () => MCPServer,
   runStdio: () => runStdio,
-  runStdioWithRegistry: () => runStdioWithRegistry
+  runStdioWithRegistry: () => runStdioWithRegistry,
+  safeStdoutWrite: () => safeStdoutWrite
 });
+function safeStdoutWrite(frame) {
+  if (stdoutBroken) return false;
+  try {
+    process.stdout.write(frame);
+    return true;
+  } catch (e) {
+    if (e?.code === "EPIPE") {
+      stdoutBroken = true;
+      process.stderr.write("[mcp-server] stdout pipe closed (EPIPE); shutting down.\n");
+      setImmediate(() => process.exit(0));
+      return false;
+    }
+    process.stderr.write(`[mcp-server] stdout write error: ${e?.message ?? e}
+`);
+    return false;
+  }
+}
+function installStdoutErrorHandler() {
+  process.stdout.on("error", (e) => {
+    if (e?.code === "EPIPE") {
+      stdoutBroken = true;
+      process.stderr.write("[mcp-server] stdout pipe closed (EPIPE, async); shutting down.\n");
+      process.exit(0);
+    } else {
+      process.stderr.write(`[mcp-server] stdout error: ${e?.message ?? e}
+`);
+    }
+  });
+}
 function installDrainHandlers(server) {
   const abort = new AbortController();
   let drainStarted = false;
@@ -17607,10 +16137,7 @@ function installDrainHandlers(server) {
 `);
     server.drain().then((forcedResponses) => {
       for (const resp of forcedResponses) {
-        try {
-          process.stdout.write(JSON.stringify(resp) + "\n");
-        } catch {
-        }
+        safeStdoutWrite(JSON.stringify(resp) + "\n");
       }
       process.stderr.write("[mcp-server] drain complete, exiting\n");
       abort.abort();
@@ -17635,7 +16162,7 @@ async function readStdinLoop(server, abort) {
       try {
         const req = JSON.parse(line);
         const resp = await server.handle(req);
-        if (resp) process.stdout.write(JSON.stringify(resp) + "\n");
+        if (resp) safeStdoutWrite(JSON.stringify(resp) + "\n");
       } catch (e) {
         process.stderr.write(`[mcp-server] frame error: ${e?.message}
 `);
@@ -17645,15 +16172,17 @@ async function readStdinLoop(server, abort) {
 }
 async function runStdio(client) {
   const server = new MCPServer(client);
+  installStdoutErrorHandler();
   const abort = installDrainHandlers(server);
   await readStdinLoop(server, abort);
 }
 async function runStdioWithRegistry(client, registryClient) {
   const server = new MCPServer(client, registryClient || client);
+  installStdoutErrorHandler();
   const abort = installDrainHandlers(server);
   await readStdinLoop(server, abort);
 }
-var MCPServer;
+var MCPServer, stdoutBroken;
 var init_server = __esm({
   "../core/src/mcp/server.ts"() {
     "use strict";
@@ -17903,6 +16432,7 @@ var init_server = __esm({
         return asResult2(JSON.stringify(result, null, 2));
       }
     };
+    stdoutBroken = false;
     if (typeof Bun !== "undefined" && import.meta.main) {
       const apiUrl = process.env.MSAPLING_API_URL;
       const token = process.env.MSAPLING_TOKEN;
@@ -17922,7 +16452,7 @@ import { render } from "ink";
 
 // src/App.tsx
 init_esm_shims();
-import { useState as useState3, useEffect as useEffect3, useCallback, useRef } from "react";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback2, useRef } from "react";
 import { Box as Box7, Text as Text8, useApp, useStdout } from "ink";
 
 // src/components/Header.tsx
@@ -17932,7 +16462,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 var Header = () => /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, marginBottom: 1, children: [
   /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
     "\u25CF MSapling CLI v",
-    "2.3.6-beta.43"
+    "2.3.6-beta.45"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -18328,6 +16858,7 @@ function createIdleAwarePoll(pollingIntervalRef, lastActivityRef, client, setUse
       const liveUser = await client.getLiveUsage();
       setUser(liveUser);
     } catch (e) {
+      console.debug(`[polling] live usage refresh failed: ${e instanceof Error ? e.message : String(e)}`);
     }
   }, POLL_INTERVAL_MS2);
 }
@@ -18342,13 +16873,13 @@ import { spawn as spawn9 } from "child_process";
 init_esm_shims();
 import { homedir as homedir19 } from "os";
 import { join as join34, dirname as dirname5 } from "path";
-import { existsSync as existsSync29, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync6 } from "fs";
 import { readFile as readFile27, writeFile as writeFile17, rename as rename3 } from "fs/promises";
-import { randomBytes as randomBytes13 } from "crypto";
+import { randomBytes as randomBytes14 } from "crypto";
 var STATE_PATH = join34(homedir19(), ".msapling", "state.json");
 async function loadPersistentState(statePath = STATE_PATH) {
   try {
-    if (!existsSync29(statePath)) return { version: 1 };
+    if (!existsSync30(statePath)) return { version: 1 };
     const text = await readFile27(statePath, "utf8");
     const parsed = JSON.parse(text);
     if (parsed.version !== 1) return { version: 1 };
@@ -18364,7 +16895,7 @@ async function loadPersistentState(statePath = STATE_PATH) {
 async function savePersistentState(state, statePath = STATE_PATH) {
   try {
     const dir = dirname5(statePath);
-    if (!existsSync29(dir)) mkdirSync6(dir, { recursive: true });
+    if (!existsSync30(dir)) mkdirSync6(dir, { recursive: true });
     const existing = await loadPersistentState(statePath);
     const merged = {
       version: 1,
@@ -18372,7 +16903,7 @@ async function savePersistentState(state, statePath = STATE_PATH) {
       lastChatId: state.lastChatId ?? existing.lastChatId
     };
     const pid = process.pid;
-    const rand = randomBytes13(4).toString("hex");
+    const rand = randomBytes14(4).toString("hex");
     const tmp = `${statePath}.tmp.${pid}.${rand}`;
     await writeFile17(tmp, JSON.stringify(merged, null, 2), "utf8");
     await rename3(tmp, statePath);
@@ -18511,9 +17042,9 @@ ${prompt4}` : prompt4;
         for (const mention of fileMentions) {
           const filePath = mention.slice(1);
           try {
-            const { existsSync: existsSync33 } = await import("fs");
+            const { existsSync: existsSync34 } = await import("fs");
             const { readFile: readFile30 } = await import("fs/promises");
-            if (existsSync33(filePath)) {
+            if (existsSync34(filePath)) {
               const content = await readFile30(filePath, "utf8");
               const MAX_LEN = 32768;
               const truncated = content.length > MAX_LEN ? content.slice(0, MAX_LEN) + "\n...[TRUNCATED]" : content;
@@ -18544,6 +17075,8 @@ ${finalCmd}`;
     } catch (e) {
       if (e.message.includes("423")) {
         ctx.addMessage("error", "Error: Chat is locked. Use /unlock to hijack.");
+      } else if (e?.status === 401 || e.message.includes("401") || /unauthor/i.test(e.message)) {
+        ctx.addMessage("error", "Session expired - run /login");
       } else {
         ctx.addMessage("error", `Error: ${e.message}`);
       }
@@ -18570,10 +17103,22 @@ ${finalCmd}`;
 // src/state/initSession.ts
 init_esm_shims();
 init_src3();
+init_src();
 init_parseApprovalMode();
 import { readFile as readFile28 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 async function initSession(ctx) {
+  try {
+    const journalEncrypted = await initJournalEncryption();
+    if (!journalEncrypted) {
+      ctx.addMessage(
+        "system",
+        "\u26A0 Offline journal encryption unavailable (OS keychain unreachable). Offline messages will NOT be persisted to disk to avoid storing chat content in plaintext."
+      );
+    }
+  } catch (e) {
+    ctx.addMessage("system", `\u26A0 Journal encryption init failed: ${e?.message ?? e}`);
+  }
   try {
     const { settings } = await loadSettings(
       process.cwd(),
@@ -18589,7 +17134,7 @@ async function initSession(ctx) {
       const { homedir: homedir22 } = await import("os");
       const { join: join39 } = await import("path");
       const userSettingsPath = join39(homedir22(), ".msapling", "settings.json");
-      if (existsSync30(userSettingsPath)) {
+      if (existsSync31(userSettingsPath)) {
         const userText = await readFile28(userSettingsPath, "utf8");
         let parsed;
         try {
@@ -18659,8 +17204,19 @@ async function initSession(ctx) {
   }
   const token = await ctx.storage.loadToken();
   if (token) {
-    ctx.client.setToken(token);
-    await ctx.refreshOverview();
+    const claims = decodeJwtClaims(token);
+    const expired = claims && typeof claims.exp === "number" && claims.exp * 1e3 <= Date.now();
+    if (expired) {
+      try {
+        await ctx.storage.clearToken();
+      } catch {
+      }
+      ctx.client.setToken("");
+      ctx.setStatus("Session expired - run /login");
+    } else {
+      ctx.client.setToken(token);
+      await ctx.refreshOverview();
+    }
   } else {
     ctx.setStatus("Login required: /login <token>");
   }
@@ -18676,30 +17232,60 @@ async function initSession(ctx) {
   }
 }
 
+// src/hooks/useTerminalResize.ts
+init_esm_shims();
+import { useState as useState3, useEffect as useEffect3, useCallback } from "react";
+function getCurrentDimensions() {
+  return {
+    columns: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  };
+}
+function useTerminalResize() {
+  const [dimensions, setDimensions] = useState3(
+    getCurrentDimensions
+  );
+  const handleResize = useCallback(() => {
+    setDimensions(getCurrentDimensions());
+  }, []);
+  useEffect3(() => {
+    process.stdout.on("resize", handleResize);
+    const onSigwinch = () => handleResize();
+    process.on("SIGWINCH", onSigwinch);
+    handleResize();
+    return () => {
+      process.stdout.off("resize", handleResize);
+      process.off("SIGWINCH", onSigwinch);
+    };
+  }, [handleResize]);
+  return dimensions;
+}
+
 // src/App.tsx
 import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
 var App = ({ compact: compact2 = false }) => {
-  const [user, setUser] = useState3(null);
-  const [input, setInput] = useState3("");
-  const [history, setHistory] = useState3([]);
-  const [isRunning, setIsRunning] = useState3(false);
-  const [status2, setStatus] = useState3("Initializing...");
-  const [activeChatId, setActiveChatId] = useState3(null);
-  const [activeProjectId, setActiveProjectId] = useState3(null);
-  const [mode, setModeState] = useState3("default");
-  const [activeModel, setActiveModel] = useState3("google/gemini-2.0-flash-001");
-  const [lastCost, setLastCost] = useState3(0);
-  const [sessionCost, setSessionCost] = useState3(0);
-  const [pendingApproval, setPendingApproval] = useState3(null);
-  const [swarmWorkers, setSwarmWorkers] = useState3(null);
-  const [activePlan, setActivePlan] = useState3(null);
-  const [contextBudgetSnap, setContextBudgetSnap] = useState3(null);
-  const [shellEscapeEnabled, setShellEscapeEnabled] = useState3(true);
+  const [user, setUser] = useState4(null);
+  const [input, setInput] = useState4("");
+  const [history, setHistory] = useState4([]);
+  const [isRunning, setIsRunning] = useState4(false);
+  const [status2, setStatus] = useState4("Initializing...");
+  const [activeChatId, setActiveChatId] = useState4(null);
+  const [activeProjectId, setActiveProjectId] = useState4(null);
+  const [mode, setModeState] = useState4("default");
+  const [activeModel, setActiveModel] = useState4("google/gemini-2.0-flash-001");
+  const [lastCost, setLastCost] = useState4(0);
+  const [sessionCost, setSessionCost] = useState4(0);
+  const [pendingApproval, setPendingApproval] = useState4(null);
+  const [swarmWorkers, setSwarmWorkers] = useState4(null);
+  const [activePlan, setActivePlan] = useState4(null);
+  const [contextBudgetSnap, setContextBudgetSnap] = useState4(null);
+  const [shellEscapeEnabled, setShellEscapeEnabled] = useState4(true);
   const { exit } = useApp();
   const { stdout: termStdout } = useStdout();
+  const { columns: termResizeCols, rows: termResizeRows } = useTerminalResize();
   const storage = useRef(new StorageManager()).current;
   const client = useRef(new MSaplingClient()).current;
-  const requestApproval = useCallback((request) => {
+  const requestApproval = useCallback2((request) => {
     return new Promise((resolve20) => {
       setPendingApproval({ request, resolve: resolve20 });
     });
@@ -18708,38 +17294,47 @@ var App = ({ compact: compact2 = false }) => {
   const trustStore = useRef(new TrustStore()).current;
   const lastActivityRef = useRef(Date.now());
   const pollingIntervalRef = useRef(null);
-  useEffect3(() => {
+  useEffect4(() => {
     agent.setApprovalCallback(requestApproval);
   }, [agent, requestApproval]);
-  const resolveApproval = useCallback((decision) => {
+  const resolveApproval = useCallback2((decision) => {
     setPendingApproval((current) => {
       current?.resolve(decision);
       return null;
     });
   }, []);
-  const addMessage = useCallback((role, content) => {
+  const addMessage = useCallback2((role, content) => {
     setHistory((prev) => [...prev, { role, content }]);
   }, []);
-  const clearHistory = useCallback(() => {
+  const clearHistory = useCallback2(() => {
     setHistory([]);
   }, []);
-  const setMode = useCallback((m) => {
+  const setMode = useCallback2((m) => {
     setModeState(m);
     agent.setMode(m);
   }, [agent]);
-  const getMode = useCallback(() => mode, [mode]);
-  const setModel = useCallback((m) => {
+  const getMode = useCallback2(() => mode, [mode]);
+  const setModel = useCallback2((m) => {
     setActiveModel(m);
   }, []);
-  const getModel = useCallback(() => activeModel, [activeModel]);
-  const setProjectId = useCallback((id) => {
+  const getModel = useCallback2(() => activeModel, [activeModel]);
+  const setProjectId = useCallback2((id) => {
     setActiveProjectId(id);
     agent.setProjectId(id);
   }, [agent]);
-  const getProjectId = useCallback(() => activeProjectId, [activeProjectId]);
-  const getPlan = useCallback(() => activePlan, [activePlan]);
-  const setPlan = useCallback((steps) => setActivePlan(steps), []);
-  const refreshOverview = useCallback(async () => {
+  const getProjectId = useCallback2(() => activeProjectId, [activeProjectId]);
+  const getPlan = useCallback2(() => activePlan, [activePlan]);
+  const setPlan = useCallback2((steps) => setActivePlan(steps), []);
+  const handle401 = useCallback2(async () => {
+    setUser(null);
+    try {
+      await storage.clearToken();
+    } catch {
+    }
+    client.setToken("");
+    setStatus("Session expired - run /login");
+  }, [client, storage]);
+  const refreshOverview = useCallback2(async () => {
     try {
       const overview = await client.me();
       setUser(overview.user);
@@ -18755,10 +17350,14 @@ var App = ({ compact: compact2 = false }) => {
         setStatus("No active chat. Use /chat <id> or send a message.");
       }
     } catch (e) {
+      if (e?.status === 401) {
+        await handle401();
+        return;
+      }
       setStatus(`Auth required: ${e.message}`);
     }
-  }, [client, activeChatId, activeProjectId, setProjectId]);
-  useEffect3(() => {
+  }, [client, activeChatId, activeProjectId, setProjectId, handle401]);
+  useEffect4(() => {
     initSession({
       agent,
       client,
@@ -18775,7 +17374,7 @@ var App = ({ compact: compact2 = false }) => {
       setActiveChatId
     });
   }, []);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!user) return;
     createIdleAwarePoll(pollingIntervalRef, lastActivityRef, client, setUser);
     return () => {
@@ -18830,8 +17429,8 @@ var App = ({ compact: compact2 = false }) => {
     updateAssistantMessage,
     shellEscapeEnabled
   });
-  const termHeight = termStdout?.rows ?? 24;
-  const termColumns = termStdout?.columns ?? 80;
+  const termHeight = termResizeRows ?? termStdout?.rows ?? 24;
+  const termColumns = termResizeCols ?? termStdout?.columns ?? 80;
   const visibleLines = Math.max(termHeight - 10, 5);
   return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", padding: 1, children: [
     /* @__PURE__ */ jsx8(Header, {}),
@@ -19020,6 +17619,30 @@ function handleCliArgs(args2) {
 // src/index.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
 var index_default = App;
+function restoreTerminalMode() {
+  try {
+    const stdin = process.stdin;
+    if (stdin?.isTTY && typeof stdin.setRawMode === "function") {
+      stdin.setRawMode(false);
+    }
+    if (process.stdout.isTTY) process.stdout.write("\x1B[?25h");
+  } catch {
+  }
+}
+var crashHandled = false;
+function handleFatal(label, err) {
+  if (crashHandled) return;
+  crashHandled = true;
+  restoreTerminalMode();
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`
+msapling: fatal ${label}: ${msg}`);
+  process.exit(1);
+}
+if (!process.env.NODE_ENV?.includes("test")) {
+  process.on("uncaughtException", (err) => handleFatal("uncaught exception", err));
+  process.on("unhandledRejection", (reason) => handleFatal("unhandled rejection", reason));
+}
 var args = process.argv.slice(2);
 var compact = args.includes("--compact");
 var shouldRenderRepl = handleCliArgs(args);