@mtreeai/msapling-cli 2.3.6-beta.23 → 2.3.6-beta.25

package/dist/index.js

@@ -266,6 +266,125 @@ var init_src = __esm({
           body: JSON.stringify(symbol)
         });
       }
+      // CLI-MDRIVE-COMMANDS-01 (Iter 36): MDrive user-facing file CRUD. Per LAB
+      // routers/mdrive_files.py — all paths under /api/mdrive/ (assembled by
+      // mdrive_product.py).
+      async mdriveList(path2 = ".", limit = 1e3, offset = 0) {
+        const qs = new URLSearchParams({ path: path2, limit: String(limit), offset: String(offset) });
+        return await this.request(`/api/mdrive/list?${qs.toString()}`);
+      }
+      async mdriveRead(path2) {
+        return await this.request("/api/mdrive/read", {
+          method: "POST",
+          body: JSON.stringify({ path: path2 })
+        });
+      }
+      async mdriveWrite(path2, content) {
+        return await this.request("/api/mdrive/write", {
+          method: "POST",
+          body: JSON.stringify({ path: path2, content })
+        });
+      }
+      async mdriveDelete(path2) {
+        return await this.request("/api/mdrive/delete", {
+          method: "POST",
+          body: JSON.stringify({ path: path2 })
+        });
+      }
+      async mdriveRename(path2, newName) {
+        return await this.request("/api/mdrive/rename", {
+          method: "POST",
+          body: JSON.stringify({ path: path2, new_name: newName })
+        });
+      }
+      async mdriveMkdir(path2) {
+        return await this.request("/api/mdrive/mkdir", {
+          method: "POST",
+          body: JSON.stringify({ path: path2 })
+        });
+      }
+      // CLI-OLLAMA-COMMANDS-01 (Iter 35): Ollama BYOK helpers. Per LAB ollama.py
+      // routes are GET/POST/DELETE under /api/ollama. The CLI uses these to wire
+      // up the user's local Ollama instance as a free-tier model provider.
+      async getOllamaStatus() {
+        return await this.request("/api/ollama/status");
+      }
+      async configureOllama(opts) {
+        return await this.request("/api/ollama/configure", {
+          method: "POST",
+          body: JSON.stringify({
+            base_url: opts.baseUrl,
+            enabled: opts.enabled,
+            action: opts.action,
+            model: opts.model
+          })
+        });
+      }
+      async testOllama(baseUrl) {
+        return await this.request("/api/ollama/test", {
+          method: "POST",
+          body: JSON.stringify({ base_url: baseUrl })
+        });
+      }
+      async deleteOllamaModel(modelName) {
+        return await this.request(`/api/ollama/models/${encodeURIComponent(modelName)}`, {
+          method: "DELETE"
+        });
+      }
+      async disableOllama() {
+        return await this.request("/api/ollama/disable", { method: "POST" });
+      }
+      // CLI-KEYS-BYOK-01 (Iter 35): BYOK provider-key management. Per LAB
+      // routers/keys.py — /api/keys/{status,save,{provider}}.
+      async getProviderKeys() {
+        return await this.request("/api/keys/status");
+      }
+      async saveProviderKey(provider, apiKey) {
+        return await this.request("/api/keys/save", {
+          method: "POST",
+          body: JSON.stringify({ provider, api_key: apiKey })
+        });
+      }
+      async deleteProviderKey(provider) {
+        return await this.request(`/api/keys/${encodeURIComponent(provider)}`, { method: "DELETE" });
+      }
+      // CLI-CHAT-LIFECYCLE-01 (Iter 35): rename/delete/fork/pin. Per LAB
+      // projects.py:404 (PATCH), 879 (DELETE), 534 (POST fork), 726 (PATCH pin).
+      async renameChat(chatId, title) {
+        return await this.request(`/api/projects/chat/${encodeURIComponent(chatId)}`, {
+          method: "PATCH",
+          body: JSON.stringify({ title })
+        });
+      }
+      async deleteChat(chatId) {
+        return await this.request(`/api/projects/chat/${encodeURIComponent(chatId)}`, { method: "DELETE" });
+      }
+      async forkChat(chatId, body) {
+        return await this.request(`/api/projects/chat/${encodeURIComponent(chatId)}/fork`, {
+          method: "POST",
+          body: JSON.stringify(body ?? {})
+        });
+      }
+      async pinChat(chatId, pinned) {
+        return await this.request(`/api/projects/chat/${encodeURIComponent(chatId)}/pin`, {
+          method: "PATCH",
+          body: JSON.stringify({ pinned })
+        });
+      }
+      // CLI-MEMORIES-01 (Iter 35): backend-managed memories (vs the local notes
+      // /memory currently surfaces). Per LAB memories.py — list / create / delete.
+      async listMemories() {
+        return await this.request("/api/memories");
+      }
+      async createMemory(content) {
+        return await this.request("/api/memories", {
+          method: "POST",
+          body: JSON.stringify({ content })
+        });
+      }
+      async deleteMemory(memoryId) {
+        return await this.request(`/api/memories/${encodeURIComponent(memoryId)}`, { method: "DELETE" });
+      }
       // CLI-PROJECT-CREATE-01 (Iter 34): create a new project. Per LAB
       // projects.py:239 — POST /api/projects/ with {project_name}.
       async createProject(name) {
@@ -1213,7 +1332,7 @@ var init_RunCommandTool = __esm({
           this.activeCommands++;
           return;
         }
-        return new Promise((resolve18) => this.queue.push(resolve18));
+        return new Promise((resolve19) => this.queue.push(resolve19));
       }
       static releaseLock() {
         if (this.queue.length > 0) {
@@ -1292,9 +1411,9 @@ var init_RunCommandTool = __esm({
           const chunks = { stdout: [], stderr: [] };
           proc.stdout?.on("data", (chunk) => chunks.stdout.push(chunk));
           proc.stderr?.on("data", (chunk) => chunks.stderr.push(chunk));
-          const exitCode = await new Promise((resolve18) => {
-            proc.on("exit", (code) => resolve18(code ?? 1));
-            proc.on("error", () => resolve18(1));
+          const exitCode = await new Promise((resolve19) => {
+            proc.on("exit", (code) => resolve19(code ?? 1));
+            proc.on("error", () => resolve19(1));
           });
           const stdout = Buffer.concat(chunks.stdout).toString("utf-8");
           const stderr = Buffer.concat(chunks.stderr).toString("utf-8");
@@ -1405,9 +1524,9 @@ var init_src2 = __esm({
           const messages = this.parser.parse(value);
           for (const msg of messages) {
             if (msg.id !== void 0 && this.pendingRequests.has(Number(msg.id))) {
-              const resolve18 = this.pendingRequests.get(Number(msg.id));
-              if (resolve18) {
-                resolve18(msg.result || msg.error);
+              const resolve19 = this.pendingRequests.get(Number(msg.id));
+              if (resolve19) {
+                resolve19(msg.result || msg.error);
                 this.pendingRequests.delete(Number(msg.id));
               }
             }
@@ -1422,8 +1541,8 @@ var init_src2 = __esm({
         const message = `Content-Length: ${Buffer.byteLength(content, "utf8")}\r
 \r
 ${content}`;
-        return new Promise((resolve18) => {
-          this.pendingRequests.set(id, resolve18);
+        return new Promise((resolve19) => {
+          this.pendingRequests.set(id, resolve19);
           this.process.stdin.write(message);
           this.process.stdin.flush();
         });
@@ -1555,9 +1674,9 @@ var init_SubShellTool = __esm({
               }
               throw e;
             }
-            await new Promise((resolve18) => {
-              proc.on("exit", () => resolve18());
-              proc.on("error", () => resolve18());
+            await new Promise((resolve19) => {
+              proc.on("exit", () => resolve19());
+              proc.on("error", () => resolve19());
             });
             return { content: `Successfully launched separate window for ${args2.worker_id}` };
           }
@@ -1640,13 +1759,13 @@ async function findRg() {
   const candidates = ["rg", "C:\\Program Files\\ripgrep\\rg.exe"];
   for (const bin of candidates) {
     try {
-      const exited = await new Promise((resolve18) => {
+      const exited = await new Promise((resolve19) => {
         try {
           const p = spawn4(bin, ["--version"], { stdio: ["ignore", "pipe", "pipe"] });
-          p.on("error", () => resolve18(null));
-          p.on("exit", (code) => resolve18(code));
+          p.on("error", () => resolve19(null));
+          p.on("exit", (code) => resolve19(code));
         } catch {
-          resolve18(null);
+          resolve19(null);
         }
       });
       if (exited === 0) return bin;
@@ -1656,7 +1775,7 @@ async function findRg() {
   return null;
 }
 function runRg(bin, args2) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const p = spawn4(bin, args2, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -1667,10 +1786,10 @@ function runRg(bin, args2) {
       stderr += d.toString("utf8");
     });
     p.on("error", (e) => {
-      resolve18({ stdout, stderr: stderr + (e?.message ?? ""), exitCode: -1 });
+      resolve19({ stdout, stderr: stderr + (e?.message ?? ""), exitCode: -1 });
     });
     p.on("exit", (code) => {
-      resolve18({ stdout, stderr, exitCode: code });
+      resolve19({ stdout, stderr, exitCode: code });
     });
   });
 }
@@ -2922,12 +3041,12 @@ Command: ${command}`,
         proc.stdout?.on("data", (chunk) => chunks.stdout.push(chunk));
         proc.stderr?.on("data", (chunk) => chunks.stderr.push(chunk));
         const timeoutPromise = new Promise(
-          (resolve18) => setTimeout(() => resolve18("timeout"), timeoutMs)
+          (resolve19) => setTimeout(() => resolve19("timeout"), timeoutMs)
         );
         const processPromise = (async () => {
-          const exitCode2 = await new Promise((resolve18) => {
-            proc.on("exit", (code) => resolve18(code ?? 1));
-            proc.on("error", () => resolve18(1));
+          const exitCode2 = await new Promise((resolve19) => {
+            proc.on("exit", (code) => resolve19(code ?? 1));
+            proc.on("error", () => resolve19(1));
           });
           const stdout2 = Buffer.concat(chunks.stdout).toString("utf-8");
           const stderr2 = Buffer.concat(chunks.stderr).toString("utf-8");
@@ -3674,7 +3793,7 @@ async function copyDir(src, dst) {
 }
 async function backupFile(absPath) {
   try {
-    const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir9 } = await import("fs/promises");
+    const { readFile: readFile24, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
     const { homedir: homedir18 } = await import("os");
     const { join: join31 } = await import("path");
     const filename = absPath.split(/[\\/]/).pop() ?? "file";
@@ -3687,8 +3806,8 @@ async function backupFile(absPath) {
       `${filename}.backup-${stamp}-${suffix}.bak`
     );
     await mkdir9(join31(homedir18(), ".msapling", "backups"), { recursive: true });
-    const content = await readFile23(absPath, "utf8");
-    await writeFile12(backupPath, content, "utf8");
+    const content = await readFile24(absPath, "utf8");
+    await writeFile13(backupPath, content, "utf8");
     return backupPath;
   } catch {
     return null;
@@ -3913,15 +4032,15 @@ var init_DeleteFileTool = __esm({
         let backedUpTo = null;
         if (isFile) {
           try {
-            const { readFile: readFile23, writeFile: writeFile12, mkdir: mkdir9 } = await import("fs/promises");
+            const { readFile: readFile24, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
             const { homedir: homedir18 } = await import("os");
-            const existingContent = await readFile23(abs, "utf8");
+            const existingContent = await readFile24(abs, "utf8");
             const filename = abs.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
             const suffix = randomBytes6(4).toString("hex");
             const backupPath = join11(homedir18(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
             await mkdir9(join11(homedir18(), ".msapling", "backups"), { recursive: true });
-            await writeFile12(backupPath, existingContent, "utf8");
+            await writeFile13(backupPath, existingContent, "utf8");
             backedUpTo = backupPath;
           } catch {
           }
@@ -4260,10 +4379,10 @@ var init_Voice = __esm({
     `;
         try {
           if (process.platform === "win32") {
-            await new Promise((resolve18, reject) => {
+            await new Promise((resolve19, reject) => {
               try {
                 const proc = spawn6("powershell", ["-Command", psCommand]);
-                proc.on("exit", () => resolve18());
+                proc.on("exit", () => resolve19());
                 proc.on("error", reject);
               } catch (e) {
                 reject(e);
@@ -4377,7 +4496,7 @@ function matches(entry, ctx) {
 async function runOne(entry, ctx) {
   const timeoutMs = entry.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
   const command = entry.command;
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const isWindows = process.platform === "win32";
     const child = spawn7(isWindows ? "cmd.exe" : "sh", isWindows ? ["/c", command] : ["-c", command], {
       cwd: ctx.cwd ?? process.cwd(),
@@ -4392,7 +4511,7 @@ async function runOne(entry, ctx) {
       settled = true;
       clearTimeout(killer);
       const blocked = !!entry.blocking && (exitCode === null || exitCode !== 0);
-      resolve18({ command, exitCode, stdout, stderr, timedOut, blocked });
+      resolve19({ command, exitCode, stdout, stderr, timedOut, blocked });
     };
     const killer = setTimeout(() => {
       timedOut = true;
@@ -5257,8 +5376,8 @@ var init_Mutex = __esm({
        */
       acquire() {
         let release2;
-        const next = new Promise((resolve18) => {
-          release2 = resolve18;
+        const next = new Promise((resolve19) => {
+          release2 = resolve19;
         });
         const entry = this._queue.then(() => release2);
         this._queue = this._queue.then(() => next);
@@ -5898,8 +6017,8 @@ var require_graceful_fs = __commonJS({
       fs4.createReadStream = createReadStream;
       fs4.createWriteStream = createWriteStream;
       var fs$readFile = fs4.readFile;
-      fs4.readFile = readFile23;
-      function readFile23(path2, options, cb) {
+      fs4.readFile = readFile24;
+      function readFile24(path2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path2, options, cb);
@@ -5915,8 +6034,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs4.writeFile;
-      fs4.writeFile = writeFile12;
-      function writeFile12(path2, data, options, cb) {
+      fs4.writeFile = writeFile13;
+      function writeFile13(path2, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path2, data, options, cb);
@@ -6918,12 +7037,12 @@ var require_adapter = __commonJS({
       return newFs;
     }
     function toPromise(method) {
-      return (...args2) => new Promise((resolve18, reject) => {
+      return (...args2) => new Promise((resolve19, reject) => {
         args2.push((err, result) => {
           if (err) {
             reject(err);
           } else {
-            resolve18(result);
+            resolve19(result);
           }
         });
         method(...args2);
@@ -7851,7 +7970,7 @@ var init_client = __esm({
         if (!this.proc) throw new MCPClientError(`MCP server "${this.name}" not started`);
         const id = this.nextId++;
         const frame = { jsonrpc: "2.0", id, method, params };
-        return new Promise((resolve18, reject) => {
+        return new Promise((resolve19, reject) => {
           const timer = setTimeout(() => {
             this.pending.delete(id);
             reject(new MCPClientError(`MCP request ${method} timed out after ${timeoutMs}ms`));
@@ -7859,7 +7978,7 @@ var init_client = __esm({
           this.pending.set(id, {
             resolve: (v) => {
               clearTimeout(timer);
-              resolve18(v);
+              resolve19(v);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -7886,7 +8005,7 @@ var init_client = __esm({
         if (!this.proc?.stdout) return;
         const stdout = this.proc.stdout;
         const decoder = new TextDecoder();
-        return new Promise((resolve18) => {
+        return new Promise((resolve19) => {
           stdout.on("data", (chunk) => {
             this.buffer += decoder.decode(chunk, { stream: true });
             let idx;
@@ -7897,8 +8016,8 @@ var init_client = __esm({
               this.handleFrame(line);
             }
           });
-          stdout.on("end", () => resolve18());
-          stdout.on("error", () => resolve18());
+          stdout.on("end", () => resolve19());
+          stdout.on("error", () => resolve19());
         });
       }
       handleFrame(line) {
@@ -8122,7 +8241,7 @@ function setRawModeGuarded(stdin, mode) {
   }
 }
 async function promptPassword(prompt4) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const stdin = process.stdin;
     const stdout = process.stdout;
     stdout.write(prompt4);
@@ -8135,12 +8254,12 @@ async function promptPassword(prompt4) {
         setRawModeGuarded(stdin, wasRaw);
         stdin.removeListener("data", onData);
         stdout.write("\n");
-        resolve18(password);
+        resolve19(password);
       } else if (char === "") {
         setRawModeGuarded(stdin, wasRaw);
         stdin.removeListener("data", onData);
         stdout.write("\n");
-        resolve18("");
+        resolve19("");
       } else if (char === "\x7F" || char === "\b") {
         password = password.slice(0, -1);
       } else if (char >= " " && char <= "~") {
@@ -8219,7 +8338,7 @@ async function loginWithGithubDevice(context) {
   const deadline = Date.now() + expires_in * 1e3;
   let githubToken = null;
   while (Date.now() < deadline) {
-    await new Promise((resolve18) => setTimeout(resolve18, pollMs));
+    await new Promise((resolve19) => setTimeout(resolve19, pollMs));
     let tokenResp;
     try {
       tokenResp = await fetch(GITHUB_TOKEN_URL, {
@@ -8243,7 +8362,7 @@ async function loginWithGithubDevice(context) {
     if (tokenData.error === "authorization_pending") continue;
     if (tokenData.error === "slow_down") {
       pollMs += 5e3;
-      await new Promise((resolve18) => setTimeout(resolve18, 5e3));
+      await new Promise((resolve19) => setTimeout(resolve19, 5e3));
       continue;
     }
     context.addMessage("system", `GitHub auth error: ${tokenData.error_description || tokenData.error}`);
@@ -8656,10 +8775,79 @@ async function createChat(args2, context) {
     context.addMessage("error", `Failed to create chat: ${e.message}`);
   }
 }
+async function resolveChatId(rest, context) {
+  const candidate = rest[0]?.trim();
+  if (candidate && /^[0-9a-fA-F-]{32,}$/.test(candidate)) return candidate;
+  return context.activeChatId ?? null;
+}
+async function lifecycleSub(args2, context) {
+  const sub = args2[0]?.toLowerCase();
+  const rest = args2.slice(1);
+  try {
+    if (sub === "rename") {
+      const newTitle = rest.slice(1).join(" ").trim() || rest[0]?.trim();
+      const chatId = await resolveChatId(rest, context);
+      if (!chatId || !newTitle) {
+        context.addMessage("system", "Usage: /chat rename [<chat_id>] <new title>");
+        return;
+      }
+      const r = await context.client.renameChat(chatId, newTitle);
+      context.addMessage("system", `Renamed to "${r.title}"`);
+      return;
+    }
+    if (sub === "delete" || sub === "rm") {
+      const chatId = await resolveChatId(rest, context);
+      if (!chatId) {
+        context.addMessage("system", "Usage: /chat delete [<chat_id>]");
+        return;
+      }
+      await context.client.deleteChat(chatId);
+      context.addMessage("system", `Deleted chat ${chatId}`);
+      if (chatId === context.activeChatId) context.setActiveChatId(null);
+      return;
+    }
+    if (sub === "fork") {
+      const chatId = await resolveChatId(rest, context);
+      if (!chatId) {
+        context.addMessage("system", "Usage: /chat fork [<chat_id>]");
+        return;
+      }
+      const r = await context.client.forkChat(chatId);
+      context.addMessage("system", `Forked \u2192 ${r.chat_id ?? r.title ?? "(ok)"}`);
+      if (r.chat_id) context.setActiveChatId(r.chat_id);
+      return;
+    }
+    if (sub === "pin") {
+      const chatId = await resolveChatId(rest, context);
+      if (!chatId) {
+        context.addMessage("system", "Usage: /chat pin [<chat_id>]");
+        return;
+      }
+      await context.client.pinChat(chatId, true);
+      context.addMessage("system", `Pinned ${chatId}`);
+      return;
+    }
+    if (sub === "unpin") {
+      const chatId = await resolveChatId(rest, context);
+      if (!chatId) {
+        context.addMessage("system", "Usage: /chat unpin [<chat_id>]");
+        return;
+      }
+      await context.client.pinChat(chatId, false);
+      context.addMessage("system", `Unpinned ${chatId}`);
+      return;
+    }
+  } catch (e) {
+    context.addMessage("error", `Chat ${sub}: ${e.message}`);
+  }
+}
 async function listChats(args2, context) {
   if (args2[0] === "new" || args2[0] === "create") {
     return createChat(args2.slice(1), context);
   }
+  if (["rename", "delete", "rm", "fork", "pin", "unpin"].includes(args2[0])) {
+    return lifecycleSub(args2, context);
+  }
   const arg = args2.join(" ").trim();
   const result = await fetchChatsForCurrentProject(context);
   if ("error" in result) {
@@ -8782,6 +8970,344 @@ var init_broadcast = __esm({
   }
 });
 
+// src/commands/ollama.ts
+function formatSize(bytes) {
+  if (!bytes) return "?";
+  const gb = bytes / 1e9;
+  if (gb >= 1) return `${gb.toFixed(1)} GB`;
+  const mb = bytes / 1e6;
+  return `${mb.toFixed(0)} MB`;
+}
+var DEFAULT_BASE_URL, ollamaCommand;
+var init_ollama = __esm({
+  "src/commands/ollama.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_BASE_URL = "http://localhost:11434";
+    ollamaCommand = {
+      name: "ollama",
+      args: "[status|configure|enable|disable|test|models|pull|delete] [...args]",
+      description: "Configure local Ollama integration (BYOK free tier) and manage local models.",
+      category: "config",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "status").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "status" || sub === "models") {
+            const s = await context.client.getOllamaStatus();
+            context.addMessage("system", "=== Ollama Status ===");
+            context.addMessage("system", `  Enabled:    ${s.enabled ? "yes" : "no"}`);
+            context.addMessage("system", `  Base URL:   ${s.base_url}`);
+            context.addMessage("system", `  Connected:  ${s.connected ? "yes" : "no"}${s.connection_message ? " \u2014 " + s.connection_message : ""}`);
+            if (s.models?.length) {
+              context.addMessage("system", `  Models (${s.models.length}):`);
+              for (const m of s.models) {
+                context.addMessage("system", `    - ${m.id}  (${formatSize(m.size)})`);
+              }
+            } else if (s.enabled) {
+              context.addMessage("system", "  Models:     (none pulled \u2014 try /ollama pull <name>, e.g. llama3.2)");
+            } else {
+              context.addMessage("system", "");
+              context.addMessage("system", "  Run '/ollama configure' to enable.");
+            }
+            return;
+          }
+          if (sub === "configure" || sub === "enable") {
+            const url = rest[0] || DEFAULT_BASE_URL;
+            const res = await context.client.configureOllama({ baseUrl: url, enabled: true });
+            context.addMessage("system", `Ollama enabled at ${url}: ${res.message ?? res.status}`);
+            return;
+          }
+          if (sub === "disable") {
+            const res = await context.client.disableOllama();
+            context.addMessage("system", `Ollama disabled: ${res.message ?? res.status}`);
+            return;
+          }
+          if (sub === "test") {
+            const url = rest[0] || DEFAULT_BASE_URL;
+            const res = await context.client.testOllama(url);
+            context.addMessage("system", `Connection to ${url}: ${res.connected ? "OK" : "FAILED"} \u2014 ${res.message}`);
+            if (res.models?.length) {
+              context.addMessage("system", `  Found ${res.models.length} model(s):`);
+              for (const m of res.models.slice(0, 12)) {
+                context.addMessage("system", `    - ${m.id}`);
+              }
+              if (res.models.length > 12) context.addMessage("system", `    \u2026and ${res.models.length - 12} more.`);
+            }
+            return;
+          }
+          if (sub === "pull") {
+            const model = rest[0];
+            if (!model) {
+              context.addMessage("system", "Usage: /ollama pull <model>  (e.g. /ollama pull llama3.2)");
+              return;
+            }
+            const status = await context.client.getOllamaStatus();
+            const res = await context.client.configureOllama({
+              baseUrl: status.base_url || DEFAULT_BASE_URL,
+              enabled: status.enabled !== false,
+              action: "pull",
+              model
+            });
+            context.addMessage("system", res.message ?? res.status);
+            return;
+          }
+          if (sub === "delete" || sub === "remove" || sub === "rm") {
+            const model = rest[0];
+            if (!model) {
+              context.addMessage("system", "Usage: /ollama delete <model>");
+              return;
+            }
+            const res = await context.client.deleteOllamaModel(model);
+            context.addMessage("system", res.message ?? res.status);
+            return;
+          }
+          context.addMessage("error", `Unknown /ollama subcommand '${sub}'. Try: status, configure, disable, test, pull, delete.`);
+        } catch (e) {
+          context.addMessage("error", `Ollama: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/keys.ts
+var keysCommand;
+var init_keys = __esm({
+  "src/commands/keys.ts"() {
+    "use strict";
+    init_esm_shims();
+    keysCommand = {
+      name: "keys",
+      args: "[list|add|delete] [...args]",
+      description: "Manage BYOK provider API keys (openai, anthropic, google, openrouter, \u2026).",
+      category: "config",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list" || sub === "status") {
+            const s = await context.client.getProviderKeys();
+            const providers = s.providers ?? [];
+            context.addMessage("system", `Provider Keys (${providers.length}):`);
+            for (const p of providers) {
+              const tag = p.configured ? "\u2713" : " ";
+              const prefix = p.key_prefix ? ` (${p.key_prefix}\u2026)` : "";
+              context.addMessage("system", `  [${tag}] ${p.provider}${prefix}`);
+            }
+            if (providers.length === 0) {
+              context.addMessage("system", "  (none \u2014 add via /keys add <provider> <key>)");
+            }
+            return;
+          }
+          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-...)");
+              return;
+            }
+            const res = await context.client.saveProviderKey(provider, key);
+            context.addMessage("system", `Saved key for ${provider}: ${res.message ?? res.status}`);
+            return;
+          }
+          if (sub === "delete" || sub === "rm" || sub === "remove") {
+            const provider = rest[0];
+            if (!provider) {
+              context.addMessage("system", "Usage: /keys delete <provider>");
+              return;
+            }
+            const res = await context.client.deleteProviderKey(provider);
+            context.addMessage("system", `Removed key for ${provider}: ${res.message ?? res.status}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /keys subcommand '${sub}'. Try: list, add, delete.`);
+        } catch (e) {
+          context.addMessage("error", `Keys: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/memories.ts
+var memoriesCommand;
+var init_memories = __esm({
+  "src/commands/memories.ts"() {
+    "use strict";
+    init_esm_shims();
+    memoriesCommand = {
+      name: "memories",
+      args: "[list|add|delete] [...args]",
+      description: "Manage the user-scoped memory bank (used across all chats).",
+      category: "project",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list" || sub === "show") {
+            const items = await context.client.listMemories();
+            if (!items || items.length === 0) {
+              context.addMessage("system", "No memories yet. Add one via /memories add <text>.");
+              return;
+            }
+            context.addMessage("system", `Memories (${items.length}):`);
+            for (const m of items) {
+              const when = m.created_at ? new Date(m.created_at).toISOString().slice(0, 10) : "";
+              context.addMessage("system", `  ${m.id?.slice(0, 8)} \xB7 ${when}  ${m.content}`);
+            }
+            return;
+          }
+          if (sub === "add" || sub === "save") {
+            const content = rest.join(" ").trim();
+            if (!content) {
+              context.addMessage("system", "Usage: /memories add <content>");
+              return;
+            }
+            const m = await context.client.createMemory(content);
+            context.addMessage("system", `Saved (${m.id?.slice(0, 8)}).`);
+            return;
+          }
+          if (sub === "delete" || sub === "rm" || sub === "remove") {
+            const id = rest[0]?.trim();
+            if (!id) {
+              context.addMessage("system", "Usage: /memories delete <id>");
+              return;
+            }
+            await context.client.deleteMemory(id);
+            context.addMessage("system", `Deleted ${id.slice(0, 8)}.`);
+            return;
+          }
+          context.addMessage("error", `Unknown /memories subcommand '${sub}'. Try: list, add, delete.`);
+        } catch (e) {
+          context.addMessage("error", `Memories: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/mdrive.ts
+import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { basename, resolve as resolve14 } 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`;
+}
+var mdriveCommand;
+var init_mdrive = __esm({
+  "src/commands/mdrive.ts"() {
+    "use strict";
+    init_esm_shims();
+    mdriveCommand = {
+      name: "mdrive",
+      args: "[ls|cat|put|get|rm|mv|mkdir] [...args]",
+      description: "Browse and manage files on MSapling Drive (your AI-native context storage).",
+      category: "project",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "ls").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "ls" || sub === "list") {
+            const path2 = rest[0] || ".";
+            const res = await context.client.mdriveList(path2);
+            const entries = res.entries ?? res.files ?? res.items ?? [];
+            context.addMessage("system", `MDrive: ${path2}  (${entries.length} entries)`);
+            for (const e of entries) {
+              const type = e.is_dir || e.type === "dir" ? "d" : "-";
+              const size = e.size != null ? formatBytes(e.size).padStart(6) : "     -";
+              const name = e.name ?? e.path ?? "?";
+              context.addMessage("system", `  ${type} ${size}  ${name}`);
+            }
+            return;
+          }
+          if (sub === "cat" || sub === "read") {
+            const p = rest[0];
+            if (!p) {
+              context.addMessage("system", "Usage: /mdrive cat <path>");
+              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) : "");
+            if (!local || !remote) {
+              context.addMessage("system", "Usage: /mdrive put <local> [<remote>]");
+              return;
+            }
+            const absLocal = resolve14(local);
+            if (!existsSync15(absLocal)) {
+              context.addMessage("error", `Local file not found: ${absLocal}`);
+              return;
+            }
+            const content = await readFile14(absLocal, "utf8");
+            const res = await context.client.mdriveWrite(remote, content);
+            context.addMessage("system", `Uploaded ${absLocal} \u2192 mdrive:${remote}  (${formatBytes(content.length)}, hash=${res?.hash?.slice(0, 12) ?? "?"})`);
+            return;
+          }
+          if (sub === "get" || sub === "download" || sub === "pull") {
+            const remote = rest[0];
+            const local = rest[1];
+            if (!remote) {
+              context.addMessage("system", "Usage: /mdrive get <remote> [<local>]");
+              return;
+            }
+            const res = await context.client.mdriveRead(remote);
+            const content = res.content ?? res.body ?? "";
+            if (local) {
+              await writeFile7(resolve14(local), content, "utf8");
+              context.addMessage("system", `Wrote ${resolve14(local)}  (${formatBytes(content.length)})`);
+            } else {
+              context.addMessage("system", content);
+            }
+            return;
+          }
+          if (sub === "rm" || sub === "delete" || sub === "del") {
+            const p = rest[0];
+            if (!p) {
+              context.addMessage("system", "Usage: /mdrive rm <path>");
+              return;
+            }
+            await context.client.mdriveDelete(p);
+            context.addMessage("system", `Deleted mdrive:${p}`);
+            return;
+          }
+          if (sub === "mv" || sub === "rename") {
+            const p = rest[0];
+            const newName = rest[1];
+            if (!p || !newName) {
+              context.addMessage("system", "Usage: /mdrive mv <path> <new-name>");
+              return;
+            }
+            await context.client.mdriveRename(p, newName);
+            context.addMessage("system", `Renamed mdrive:${p} \u2192 ${newName}`);
+            return;
+          }
+          if (sub === "mkdir") {
+            const p = rest[0];
+            if (!p) {
+              context.addMessage("system", "Usage: /mdrive mkdir <path>");
+              return;
+            }
+            await context.client.mdriveMkdir(p);
+            context.addMessage("system", `Created mdrive:${p}/`);
+            return;
+          }
+          context.addMessage("error", `Unknown /mdrive subcommand '${sub}'. Try: ls, cat, put, get, rm, mv, mkdir.`);
+        } catch (e) {
+          context.addMessage("error", `MDrive: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
 // src/commands/clear.ts
 var clearCommand;
 var init_clear = __esm({
@@ -8807,13 +9333,13 @@ var init_clear = __esm({
 // src/commands/mode.ts
 import { homedir as homedir10 } from "os";
 import { join as join17 } from "path";
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile14, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile15, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
 async function persistApprovalMode(mode, ttlMs) {
   try {
     let existing = {};
-    if (existsSync15(SETTINGS_PATH)) {
-      const text = await readFile14(SETTINGS_PATH, "utf8");
+    if (existsSync16(SETTINGS_PATH)) {
+      const text = await readFile15(SETTINGS_PATH, "utf8");
       if (text.trim()) {
         existing = JSON.parse(text);
       }
@@ -8825,10 +9351,10 @@ async function persistApprovalMode(mode, ttlMs) {
     };
     existing.approvalMode = entry;
     const settingsDir = join17(homedir10(), ".msapling");
-    if (!existsSync15(settingsDir)) {
+    if (!existsSync16(settingsDir)) {
       await mkdir7(settingsDir, { recursive: true });
     }
-    await writeFile7(SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf8");
+    await writeFile8(SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf8");
   } catch {
   }
 }
@@ -9213,8 +9739,8 @@ var init_compact = __esm({
 
 // src/commands/init.ts
 import { join as join18 } from "path";
-import { existsSync as existsSync16 } from "fs";
-import { writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import { writeFile as writeFile9 } from "fs/promises";
 var initCommand;
 var init_init = __esm({
   "src/commands/init.ts"() {
@@ -9228,7 +9754,7 @@ var init_init = __esm({
         try {
           const cwd = process.cwd();
           const path2 = join18(cwd, "MSAPLING.md");
-          if (existsSync16(path2)) {
+          if (existsSync17(path2)) {
             context.addMessage("error", "MSAPLING.md already exists in current directory.");
             return;
           }
@@ -9243,7 +9769,7 @@ var init_init = __esm({
 ## Guidelines
 - Follow existing code style.
 `;
-          await writeFile8(path2, content, "utf8");
+          await writeFile9(path2, content, "utf8");
           context.addMessage("system", `Created MSAPLING.md at ${path2}`);
         } catch (e) {
           context.addMessage("error", `Failed to initialize project: ${e.message}`);
@@ -9254,8 +9780,8 @@ var init_init = __esm({
 });
 
 // src/commands/review.ts
-import { existsSync as existsSync17 } from "fs";
-import { readFile as readFile15 } from "fs/promises";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile16 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
   "src/commands/review.ts"() {
@@ -9274,8 +9800,8 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync17(target)) {
-            content = await readFile15(target, "utf8");
+          if (existsSync18(target)) {
+            content = await readFile16(target, "utf8");
           } else {
             content = `Review target: ${target}`;
           }
@@ -9368,15 +9894,15 @@ var init_swarm = __esm({
 
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
-import { existsSync as existsSync18 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
 import { join as join19 } from "path";
 function findRecipe(name, cwd) {
   for (const dir of RECIPE_DIRS) {
     for (const suffix of NAME_SUFFIXES) {
       for (const ext of FILE_EXTS) {
         const p = join19(cwd, dir, `${name}${suffix}${ext}`);
-        if (existsSync18(p)) return p;
+        if (existsSync19(p)) return p;
       }
     }
   }
@@ -9435,7 +9961,7 @@ var init_recipe = __esm({
         let text;
         let recipe;
         try {
-          text = await readFile16(path2, "utf8");
+          text = await readFile17(path2, "utf8");
           recipe = parseYaml(text);
         } catch (e) {
           context.addMessage("error", `Failed to load ${path2}: ${e.message}`);
@@ -9489,13 +10015,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync19, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
-import { join as join20, resolve as resolve14 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join20, resolve as resolve15 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
-    const full = resolve14(cwd, candidate);
-    if (existsSync19(full) && statSync5(full).isDirectory()) return full;
+    const full = resolve15(cwd, candidate);
+    if (existsSync20(full) && statSync5(full).isDirectory()) return full;
   }
   return null;
 }
@@ -9589,7 +10115,7 @@ var init_skill = __esm({
         }
         let body;
         try {
-          body = await readFile17(skill.path, "utf8");
+          body = await readFile18(skill.path, "utf8");
         } catch (e) {
           context.addMessage("error", `Failed to load skill ${skill.path}: ${e.message}`);
           return;
@@ -9985,21 +10511,21 @@ var init_theme = __esm({
 // src/commands/theme.ts
 import { join as join22 } from "path";
 import { homedir as homedir12 } from "os";
-import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile18, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import { readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
 async function persistTheme(storage, themeName) {
   const settingsPath = join22(homedir12(), ".msapling", "settings.json");
   let existing = {};
   try {
-    if (existsSync20(settingsPath)) {
-      const text = await readFile18(settingsPath, "utf8");
+    if (existsSync21(settingsPath)) {
+      const text = await readFile19(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
   } catch {
   }
   existing["theme"] = themeName;
   ensureConfigDir(join22(homedir12(), ".msapling"));
-  await writeFile9(settingsPath, JSON.stringify(existing, null, 2), "utf8");
+  await writeFile10(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
 var init_theme2 = __esm({
@@ -10070,7 +10596,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.23" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.25" : "(dev)";
         const coreVersion = true ? "2.3.2" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -10079,7 +10605,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-05-28T19:20:38.494Z";
+          const ts = "2026-05-28T19:45:02.204Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -10093,14 +10619,14 @@ var init_version = __esm({
 
 // src/commands/feedback.ts
 import { join as join23 } from "path";
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile19 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
+import { readFile as readFile20 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
     const pkgPath = join23(baseDir, "..", "..", "package.json");
-    if (!existsSync21(pkgPath)) return "unknown";
-    const text = await readFile19(pkgPath, "utf8");
+    if (!existsSync22(pkgPath)) return "unknown";
+    const text = await readFile20(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
   } catch {
@@ -10142,7 +10668,7 @@ var init_feedback = __esm({
 // src/commands/export.ts
 import { homedir as homedir13 } from "os";
 import { join as join24 } from "path";
-import { writeFile as writeFile10, mkdir as mkdir8 } from "fs/promises";
+import { writeFile as writeFile11, mkdir as mkdir8 } from "fs/promises";
 function formatTimestamp(date) {
   return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
 }
@@ -10208,7 +10734,7 @@ var init_export = __esm({
         try {
           const dir = join24(outputPath, "..");
           await mkdir8(dir, { recursive: true });
-          await writeFile10(outputPath, content, "utf8");
+          await writeFile11(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
         } catch (e) {
           context.addMessage("error", `Failed to export: ${e.message}`);
@@ -10403,15 +10929,15 @@ var init_plan = __esm({
 // src/commands/note.ts
 import { homedir as homedir14 } from "os";
 import { join as join25 } from "path";
-import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile20, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import { readFile as readFile21, writeFile as writeFile12 } from "fs/promises";
 function getNotesFilePath() {
   return join25(homedir14(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
-    if (!existsSync22(filePath)) return [];
-    const raw = await readFile20(filePath, "utf8");
+    if (!existsSync23(filePath)) return [];
+    const raw = await readFile21(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -10422,7 +10948,7 @@ async function readNotes(filePath = getNotesFilePath()) {
 async function writeNotes(notes, filePath = getNotesFilePath()) {
   const dir = join25(homedir14(), ".msapling");
   ensureConfigDir(dir);
-  await writeFile11(filePath, JSON.stringify(notes, null, 2), "utf8");
+  await writeFile12(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
 function formatTimestamp2(iso) {
   const d = new Date(iso);
@@ -10567,8 +11093,8 @@ var init_todo = __esm({
 
 // src/commands/outputStyle.ts
 import { homedir as homedir15 } from "os";
-import { join as join26, basename, extname as extname3 } from "path";
-import { existsSync as existsSync23, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join26, basename as basename2, extname as extname3 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 function stylesDir() {
   return join26(homedir15(), ".msapling", "output-styles");
 }
@@ -10594,7 +11120,7 @@ function parseStyleFile(text) {
 }
 function listUserStyles() {
   const dir = stylesDir();
-  if (!existsSync23(dir)) return [];
+  if (!existsSync24(dir)) return [];
   const out = [];
   for (const entry of readdirSync3(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
@@ -10603,7 +11129,7 @@ function listUserStyles() {
       const text = readFileSync(full, "utf8");
       const { description, body } = parseStyleFile(text);
       out.push({
-        name: basename(entry, ".md"),
+        name: basename2(entry, ".md"),
         description,
         body,
         source: "user",
@@ -10626,7 +11152,7 @@ function findStyle(name) {
 function getActiveStyleName() {
   try {
     const f = activeFile();
-    if (!existsSync23(f)) return "default";
+    if (!existsSync24(f)) return "default";
     return readFileSync(f, "utf8").trim() || "default";
   } catch {
     return "default";
@@ -10634,7 +11160,7 @@ function getActiveStyleName() {
 }
 function setActiveStyleName(name) {
   const dir = stylesDir();
-  if (!existsSync23(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync24(dir)) mkdirSync5(dir, { recursive: true });
   writeFileSync2(activeFile(), `${name}
 `, "utf8");
 }
@@ -10647,7 +11173,7 @@ function createUserStyle(name, description, body) {
     throw new Error(`Invalid style name "${name}" \u2014 use letters, digits, _ and - only.`);
   }
   const dir = stylesDir();
-  if (!existsSync23(dir)) mkdirSync5(dir, { recursive: true });
+  if (!existsSync24(dir)) mkdirSync5(dir, { recursive: true });
   const target = join26(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
@@ -10819,6 +11345,10 @@ var init_commands = __esm({
     init_help();
     init_chat();
     init_broadcast();
+    init_ollama();
+    init_keys();
+    init_memories();
+    init_mdrive();
     init_clear();
     init_mode();
     init_model();
@@ -10855,6 +11385,10 @@ var init_commands = __esm({
       chatCommand,
       chatsCommand,
       broadcastCommand,
+      ollamaCommand,
+      keysCommand,
+      memoriesCommand,
+      mdriveCommand,
       clearCommand,
       modeCommand,
       modelCommand,
@@ -10951,16 +11485,16 @@ var exec_exports = {};
 __export(exec_exports, {
   runExec: () => runExec
 });
-import { existsSync as existsSync25 } from "fs";
-import { readFile as readFile22 } from "fs/promises";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile23 } from "fs/promises";
 import { homedir as homedir16 } from "os";
 import { join as join27 } from "path";
 async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
     const p = join27(homedir16(), ".msapling", "settings.json");
-    if (!existsSync25(p)) return out;
-    const raw = JSON.parse(await readFile22(p, "utf8"));
+    if (!existsSync26(p)) return out;
+    const raw = JSON.parse(await readFile23(p, "utf8"));
     const parsed = parseApprovalMode(raw, Date.now());
     if (parsed.kind === "ok") out.mode = parsed.mode;
     const themeRaw = raw?.theme;
@@ -11210,13 +11744,13 @@ async function openBrowser(url) {
     cmd = "xdg-open";
     args2 = [url];
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     try {
       const child = spawn10(cmd, args2, { stdio: "ignore", detached: true });
       child.unref();
     } catch {
     }
-    resolve18();
+    resolve19();
   });
 }
 var init_open_browser = __esm({
@@ -11306,7 +11840,7 @@ var init_checkout = __esm({
 // src/commands/billing/sub.ts
 import * as readline from "readline";
 function prompt(rl, question) {
-  return new Promise((resolve18) => rl.question(question, resolve18));
+  return new Promise((resolve19) => rl.question(question, resolve19));
 }
 async function runSub(argv) {
   const subCmd = argv[0] ?? "";
@@ -11435,11 +11969,11 @@ var init_sub = __esm({
 // src/commands/billing/topup.ts
 import * as readline2 from "readline";
 function prompt2(rl, question) {
-  return new Promise((resolve18) => rl.question(question, resolve18));
+  return new Promise((resolve19) => rl.question(question, resolve19));
 }
 function promptDefault(rl, question, defaultVal) {
   return new Promise(
-    (resolve18) => rl.question(`${question} [${defaultVal}]: `, (ans) => resolve18(ans.trim() || defaultVal))
+    (resolve19) => rl.question(`${question} [${defaultVal}]: `, (ans) => resolve19(ans.trim() || defaultVal))
   );
 }
 async function runTopup(argv) {
@@ -11580,7 +12114,7 @@ var init_redeem = __esm({
 // src/commands/billing/gift.ts
 import * as readline3 from "readline";
 function prompt3(rl, question) {
-  return new Promise((resolve18) => rl.question(question, resolve18));
+  return new Promise((resolve19) => rl.question(question, resolve19));
 }
 async function runGift(argv) {
   const subCmd = argv[0] ?? "";
@@ -11837,7 +12371,7 @@ __export(doctor_exports, {
 });
 import { homedir as homedir17, platform as platform3 } from "os";
 import { join as join28 } from "path";
-import { existsSync as existsSync26, statSync as statSync6, accessSync } from "fs";
+import { existsSync as existsSync27, statSync as statSync6, accessSync } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -11861,7 +12395,7 @@ async function checkNodeVersion() {
 }
 async function checkConfigDir() {
   const configDir = join28(homedir17(), ".msapling");
-  if (!existsSync26(configDir)) {
+  if (!existsSync27(configDir)) {
     return {
       name: "Config directory",
       status: "WARN",
@@ -11927,7 +12461,7 @@ async function checkPathConflicts() {
   const paths = pathEnv.split(platform3() === "win32" ? ";" : ":");
   const conflicts = [];
   for (const dir of paths) {
-    if (!dir || !existsSync26(dir)) continue;
+    if (!dir || !existsSync27(dir)) continue;
     try {
       const files = await readdir3(dir);
       for (const file of files) {
@@ -13349,16 +13883,16 @@ var init_registry_merger = __esm({
 // ../core/src/mcp/local_tools.ts
 import { spawn as spawn11 } from "child_process";
 import { readdir as readdir4, stat as stat4, realpath as realpath2 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 function asResult(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
 }
 async function runCommand(command, cwd) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     let p;
     const timeout = setTimeout(() => {
       if (p) p.kill();
-      resolve18({ stdout: "", stderr: "Command timed out after 30s", exit_code: -1 });
+      resolve19({ stdout: "", stderr: "Command timed out after 30s", exit_code: -1 });
     }, 3e4);
     try {
       p = spawn11("sh", ["-c", command], {
@@ -13376,15 +13910,15 @@ async function runCommand(command, cwd) {
       });
       p.on("error", (e) => {
         clearTimeout(timeout);
-        resolve18({ stdout, stderr: stderr + (e?.message ?? ""), exit_code: -1 });
+        resolve19({ stdout, stderr: stderr + (e?.message ?? ""), exit_code: -1 });
       });
       p.on("exit", (code) => {
         clearTimeout(timeout);
-        resolve18({ stdout, stderr, exit_code: code });
+        resolve19({ stdout, stderr, exit_code: code });
       });
     } catch (e) {
       clearTimeout(timeout);
-      resolve18({
+      resolve19({
         stdout: "",
         stderr: e?.message ?? "Failed to spawn process",
         exit_code: -1
@@ -13451,7 +13985,7 @@ async function callLocalTool(name, args2, projectRoot) {
       const command = String(args2.command ?? "");
       let cwd = projectRoot;
       if (args2.cwd) {
-        cwd = resolve16(projectRoot, String(args2.cwd));
+        cwd = resolve17(projectRoot, String(args2.cwd));
         try {
           const resolvedCwd = await realpath2(cwd);
           const resolvedRoot = await realpath2(projectRoot);
@@ -13488,7 +14022,7 @@ ${res.stderr}`
         return asResult("path is required", true);
       }
       try {
-        const resolvedPath = await realpath2(resolve16(projectRoot, pathArg));
+        const resolvedPath = await realpath2(resolve17(projectRoot, pathArg));
         const resolvedRoot = await realpath2(projectRoot);
         if (!resolvedPath.startsWith(resolvedRoot)) {
           return asResult("Error: path attempts to escape project root", true);
@@ -13507,7 +14041,7 @@ ${res.stderr}`
     }
     case "local_glob": {
       const pattern = String(args2.pattern ?? "");
-      let cwd = args2.cwd ? resolve16(projectRoot, String(args2.cwd)) : projectRoot;
+      let cwd = args2.cwd ? resolve17(projectRoot, String(args2.cwd)) : projectRoot;
       if (!pattern) {
         return asResult("pattern is required", true);
       }
@@ -13536,7 +14070,7 @@ ${res.stderr}`
       }
       if (path2) {
         try {
-          const resolvedPath = await realpath2(resolve16(projectRoot, path2));
+          const resolvedPath = await realpath2(resolve17(projectRoot, path2));
           const resolvedRoot = await realpath2(projectRoot);
           if (!resolvedPath.startsWith(resolvedRoot)) {
             return asResult("Error: path attempts to escape project root", true);
@@ -13556,7 +14090,7 @@ ${res.stderr}`
         return asResult("cwd is required", true);
       }
       try {
-        const resolvedCwd = await realpath2(resolve16(projectRoot, cwdArg));
+        const resolvedCwd = await realpath2(resolve17(projectRoot, cwdArg));
         const resolvedRoot = await realpath2(projectRoot);
         if (!resolvedCwd.startsWith(resolvedRoot)) {
           return asResult("Error: cwd attempts to escape project root", true);
@@ -13582,7 +14116,7 @@ ${status.porcelain || "(clean)"}`
         return asResult("cwd is required", true);
       }
       try {
-        const resolvedCwd = await realpath2(resolve16(projectRoot, cwdArg));
+        const resolvedCwd = await realpath2(resolve17(projectRoot, cwdArg));
         const resolvedRoot = await realpath2(projectRoot);
         if (!resolvedCwd.startsWith(resolvedRoot)) {
           return asResult("Error: cwd attempts to escape project root", true);
@@ -13698,7 +14232,7 @@ __export(server_exports, {
   runStdioWithRegistry: () => runStdioWithRegistry
 });
 import { readdirSync as readdirSync4, readFileSync as readFileSync2, statSync as statSync7 } from "fs";
-import { join as join29, relative as relative14, resolve as resolve17 } from "path";
+import { join as join29, relative as relative14, resolve as resolve18 } from "path";
 function asResult2(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
 }
@@ -14056,13 +14590,13 @@ var init_server = __esm({
         if (inflight === 0) {
           return [];
         }
-        const forcedResponses = await new Promise((resolve18) => {
-          this._drainResolve = () => resolve18([]);
+        const forcedResponses = await new Promise((resolve19) => {
+          this._drainResolve = () => resolve19([]);
           setTimeout(() => {
             this._drainResolve = null;
             const remaining = Array.from(this._inflightCalls.values());
             if (remaining.length === 0) {
-              resolve18([]);
+              resolve19([]);
               return;
             }
             process.stderr.write(
@@ -14078,7 +14612,7 @@ var init_server = __esm({
               }
             }));
             this._inflightCalls.clear();
-            resolve18(errorResponses);
+            resolve19(errorResponses);
           }, DRAIN_TIMEOUT_MS);
         });
         return forcedResponses;
@@ -14356,7 +14890,7 @@ ${r.response ?? ""}`;
             return asResult2(JSON.stringify(result));
           }
           case "msapling_project_context": {
-            const root = resolve17(String(args2.path ?? "."));
+            const root = resolve18(String(args2.path ?? "."));
             const maxFiles = Number.isFinite(args2.max_files) ? Number(args2.max_files) : 30;
             const maxKB = Number.isFinite(args2.max_file_size_kb) ? Number(args2.max_file_size_kb) : 50;
             const files = buildFileTree(root, maxFiles);
@@ -14484,7 +15018,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.23"
+    "2.3.6-beta.25"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -14978,9 +15512,9 @@ ${prompt4}` : prompt4;
         if (proc.stderr) proc.stderr.on("data", (chunk) => {
           stderr += chunk.toString();
         });
-        await new Promise((resolve18, reject) => {
+        await new Promise((resolve19, reject) => {
           proc.on("close", (code) => {
-            if (code === 0 || code === null) resolve18();
+            if (code === 0 || code === null) resolve19();
             else reject(new Error(`Process exited with code ${code}`));
           });
           proc.on("error", reject);
@@ -15007,10 +15541,10 @@ ${prompt4}` : prompt4;
         for (const mention of fileMentions) {
           const filePath = mention.slice(1);
           try {
-            const { existsSync: existsSync27 } = await import("fs");
-            const { readFile: readFile23 } = await import("fs/promises");
-            if (existsSync27(filePath)) {
-              const content = await readFile23(filePath, "utf8");
+            const { existsSync: existsSync28 } = await import("fs");
+            const { readFile: readFile24 } = await import("fs/promises");
+            if (existsSync28(filePath)) {
+              const content = await readFile24(filePath, "utf8");
               const MAX_LEN = 32768;
               const truncated = content.length > MAX_LEN ? content.slice(0, MAX_LEN) + "\n...[TRUNCATED]" : content;
               finalCmd += `
@@ -15062,8 +15596,8 @@ ${finalCmd}`;
 init_esm_shims();
 init_src3();
 init_parseApprovalMode();
-import { readFile as readFile21 } from "fs/promises";
-import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile22 } from "fs/promises";
+import { existsSync as existsSync25 } from "fs";
 async function initSession(ctx) {
   try {
     const { settings } = await loadSettings(
@@ -15080,8 +15614,8 @@ async function initSession(ctx) {
       const { homedir: homedir18 } = await import("os");
       const { join: join31 } = await import("path");
       const userSettingsPath = join31(homedir18(), ".msapling", "settings.json");
-      if (existsSync24(userSettingsPath)) {
-        const userText = await readFile21(userSettingsPath, "utf8");
+      if (existsSync25(userSettingsPath)) {
+        const userText = await readFile22(userSettingsPath, "utf8");
         let parsed;
         try {
           parsed = JSON.parse(userText);
@@ -15181,8 +15715,8 @@ var App = ({ compact: compact2 = false }) => {
   const storage = useRef(new StorageManager()).current;
   const client = useRef(new MSaplingClient()).current;
   const requestApproval = useCallback((request) => {
-    return new Promise((resolve18) => {
-      setPendingApproval({ request, resolve: resolve18 });
+    return new Promise((resolve19) => {
+      setPendingApproval({ request, resolve: resolve19 });
     });
   }, []);
   const agent = useRef(new Agent(client, process.cwd(), requestApproval)).current;