@mtreeai/msapling-cli 2.3.6-beta.28 → 2.3.6-beta.30

package/dist/index.js

@@ -53,11 +53,438 @@ var init_esm_shims = __esm({
   }
 });
 
+// ../api-client/src/localLlm.ts
+import { homedir } from "os";
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function probeDialect(baseUrl) {
+  const normalizedUrl = baseUrl.replace(/\/$/, "");
+  const timeout = 800;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(`${normalizedUrl}/api/tags`, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (response.ok) return "ollama";
+  } catch {
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(`${normalizedUrl}/v1/models`, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (response.ok) return "openai_compat";
+  } catch {
+  }
+  return null;
+}
+async function detectLocalLlm() {
+  const endpoints = [
+    process.env.MSAPLING_LOCAL_LLM_URL,
+    await readConfigLocalLlmUrl(),
+    "http://localhost:11434",
+    // Ollama
+    "http://localhost:8080",
+    // llama.cpp
+    "http://localhost:1234"
+    // LM Studio
+  ].filter((url) => !!url);
+  for (const baseUrl of endpoints) {
+    try {
+      const dialect = await probeDialect(baseUrl);
+      if (dialect) {
+        return new LocalLlmClient({
+          baseUrl,
+          model: process.env.MSAPLING_LOCAL_LLM_MODEL ?? "default",
+          dialect
+        });
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function readConfigLocalLlmUrl() {
+  try {
+    const configPath = join(homedir(), ".msapling", "config.json");
+    const content = await readFile(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.localLlm?.baseUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+var LocalLlmClient, OllamaClient;
+var init_localLlm = __esm({
+  "../api-client/src/localLlm.ts"() {
+    "use strict";
+    init_esm_shims();
+    LocalLlmClient = class {
+      baseUrl;
+      model;
+      apiKey;
+      dialect;
+      constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.model = config.model;
+        this.apiKey = config.apiKey;
+        this.dialect = config.dialect ?? "openai_compat";
+      }
+      /**
+       * Detect dialect from baseUrl if not explicitly provided
+       */
+      async detectDialect() {
+        if (this.dialect !== "openai_compat") return this.dialect;
+        const detected = await probeDialect(this.baseUrl);
+        if (detected) {
+          this.dialect = detected;
+        }
+        return this.dialect;
+      }
+      /**
+       * Check if local LLM server is reachable
+       */
+      async isAvailable() {
+        try {
+          const dialect = await this.detectDialect();
+          const endpoint = dialect === "ollama" ? "/api/tags" : "/v1/models";
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), 1e3);
+          const response = await fetch(`${this.baseUrl}${endpoint}`, { signal: controller.signal });
+          clearTimeout(timeout);
+          return response.ok;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * List available models
+       */
+      async listModels() {
+        const dialect = await this.detectDialect();
+        if (dialect === "ollama") {
+          const response = await fetch(`${this.baseUrl}/api/tags`);
+          if (!response.ok) throw new Error(`Ollama /api/tags failed: ${response.status}`);
+          const data = await response.json();
+          return (data.models ?? []).map((m) => ({ name: m.name, size: m.size }));
+        } else {
+          const response = await fetch(`${this.baseUrl}/v1/models`);
+          if (!response.ok) throw new Error(`OpenAI /v1/models failed: ${response.status}`);
+          const data = await response.json();
+          return (data.data ?? []).map((m) => ({ name: m.id, size: 0 }));
+        }
+      }
+      /**
+       * Stream chat messages
+       */
+      async *streamChat(model, messages) {
+        const dialect = await this.detectDialect();
+        if (dialect === "ollama") {
+          yield* this.streamChatOllama(model, messages);
+        } else {
+          yield* this.streamChatOpenAI(model, messages);
+        }
+      }
+      async *streamChatOllama(model, messages) {
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model, messages, stream: true })
+        });
+        if (!response.ok) throw new Error(`Ollama /api/chat failed: ${response.status}`);
+        if (!response.body) throw new Error("No response body");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let pending = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            pending += decoder.decode(value, { stream: true });
+            let nlIdx;
+            while ((nlIdx = pending.indexOf("\n")) !== -1) {
+              const line = pending.slice(0, nlIdx).trim();
+              pending = pending.slice(nlIdx + 1);
+              if (!line) continue;
+              try {
+                const obj = JSON.parse(line);
+                yield {
+                  delta: obj.message?.content ?? "",
+                  done: obj.done ?? false,
+                  prompt_tokens: obj.prompt_eval_count,
+                  completion_tokens: obj.eval_count
+                };
+              } catch {
+              }
+            }
+          }
+          pending += decoder.decode();
+          if (pending.trim()) {
+            try {
+              const obj = JSON.parse(pending);
+              yield {
+                delta: obj.message?.content ?? "",
+                done: obj.done ?? true,
+                prompt_tokens: obj.prompt_eval_count,
+                completion_tokens: obj.eval_count
+              };
+            } catch {
+            }
+          }
+        } finally {
+          reader.cancel();
+        }
+      }
+      async *streamChatOpenAI(model, messages) {
+        const headers = { "Content-Type": "application/json" };
+        if (this.apiKey) headers["Authorization"] = `Bearer ${this.apiKey}`;
+        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ model, messages, stream: true })
+        });
+        if (!response.ok) throw new Error(`OpenAI /v1/chat/completions failed: ${response.status}`);
+        if (!response.body) throw new Error("No response body");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let pending = "";
+        let promptTokens = 0;
+        let completionTokens = 0;
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            pending += decoder.decode(value, { stream: true });
+            let nlIdx;
+            while ((nlIdx = pending.indexOf("\n")) !== -1) {
+              const line = pending.slice(0, nlIdx).trim();
+              pending = pending.slice(nlIdx + 1);
+              if (!line || !line.startsWith("data:")) continue;
+              const data = line.slice(5).trim();
+              if (data === "[DONE]") continue;
+              try {
+                const obj = JSON.parse(data);
+                const delta = obj.choices?.[0]?.delta?.content ?? "";
+                const done2 = obj.choices?.[0]?.finish_reason !== null;
+                if (obj.usage) {
+                  promptTokens = obj.usage.prompt_tokens ?? 0;
+                  completionTokens = obj.usage.completion_tokens ?? 0;
+                }
+                yield {
+                  delta,
+                  done: done2 || obj.choices?.[0]?.finish_reason !== null && delta === "",
+                  prompt_tokens: promptTokens,
+                  completion_tokens: completionTokens
+                };
+              } catch {
+              }
+            }
+          }
+        } finally {
+          reader.cancel();
+        }
+      }
+    };
+    OllamaClient = class extends LocalLlmClient {
+      constructor(baseUrl = process.env.OLLAMA_HOST ?? "http://localhost:11434") {
+        super({ baseUrl, model: "default", dialect: "ollama" });
+      }
+    };
+  }
+});
+
+// ../api-client/src/journal.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function getJournal() {
+  if (!journalInstance) {
+    journalInstance = new Journal();
+  }
+  return journalInstance;
+}
+var DatabaseConnection, Journal, journalInstance;
+var init_journal = __esm({
+  "../api-client/src/journal.ts"() {
+    "use strict";
+    init_esm_shims();
+    try {
+      const sqlite = __require("sqlite");
+      DatabaseConnection = sqlite;
+    } catch {
+      DatabaseConnection = null;
+    }
+    Journal = class {
+      dbPath;
+      jsonlPath;
+      useJsonl = false;
+      db = null;
+      jsonlEntries = [];
+      constructor() {
+        const home = homedir2();
+        const msaplingDir = join2(home, ".msapling");
+        this.dbPath = join2(msaplingDir, "journal.sqlite");
+        this.jsonlPath = join2(msaplingDir, "journal.jsonl");
+        this.initialize();
+      }
+      initialize() {
+        if (DatabaseConnection) {
+          try {
+            const { DatabaseSync } = DatabaseConnection;
+            this.db = new DatabaseSync(this.dbPath);
+            this.initializeSchema();
+          } catch (e) {
+            console.warn("[Journal] SQLite init failed, falling back to JSONL", e);
+            this.useJsonl = true;
+            this.loadJsonl();
+          }
+        } else {
+          this.useJsonl = true;
+          this.loadJsonl();
+        }
+      }
+      initializeSchema() {
+        if (!this.db) return;
+        try {
+          this.db.exec(`
+        CREATE TABLE IF NOT EXISTS messages (
+          id TEXT PRIMARY KEY,
+          chat_id TEXT NOT NULL,
+          project_id TEXT,
+          role TEXT NOT NULL,
+          content TEXT NOT NULL,
+          ts INTEGER NOT NULL,
+          model TEXT,
+          token_count INTEGER,
+          source TEXT NOT NULL DEFAULT 'offline',
+          synced_at INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_synced ON messages(synced_at, ts);
+      `);
+        } catch (e) {
+          console.warn("[Journal] Schema creation failed", e);
+        }
+      }
+      loadJsonl() {
+      }
+      async journalAppend(entry) {
+        if (this.useJsonl) {
+          this.jsonlEntries.push(entry);
+        } else if (this.db) {
+          try {
+            const stmt = this.db.prepare(`
+          INSERT INTO messages (id, chat_id, project_id, role, content, ts, model, token_count, source)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+            stmt.run(
+              entry.id,
+              entry.chat_id,
+              entry.project_id || null,
+              entry.role,
+              entry.content,
+              entry.ts,
+              entry.model || null,
+              entry.token_count || null,
+              entry.source
+            );
+          } catch (e) {
+            console.warn("[Journal] Failed to append message", e);
+          }
+        }
+      }
+      async journalListPending() {
+        if (this.useJsonl) {
+          return this.jsonlEntries.filter((e) => !e.synced_at);
+        }
+        if (!this.db) return [];
+        try {
+          const stmt = this.db.prepare(`
+        SELECT id, chat_id, project_id, role, content, ts, model, token_count, source, synced_at
+        FROM messages
+        WHERE synced_at IS NULL
+        ORDER BY ts ASC
+      `);
+          const rows = stmt.all();
+          return rows.map((r) => ({
+            id: r.id,
+            chat_id: r.chat_id,
+            project_id: r.project_id,
+            role: r.role,
+            content: r.content,
+            ts: r.ts,
+            model: r.model,
+            token_count: r.token_count,
+            source: r.source,
+            synced_at: r.synced_at
+          }));
+        } catch (e) {
+          console.warn("[Journal] Failed to list pending messages", e);
+          return [];
+        }
+      }
+      async journalMarkSynced(ids) {
+        if (this.useJsonl) {
+          const now = Date.now();
+          this.jsonlEntries = this.jsonlEntries.map(
+            (e) => ids.includes(e.id) ? { ...e, synced_at: now } : e
+          );
+          return;
+        }
+        if (!this.db) return;
+        try {
+          const now = Date.now();
+          const placeholders = ids.map(() => "?").join(",");
+          const stmt = this.db.prepare(`
+        UPDATE messages SET synced_at = ? WHERE id IN (${placeholders})
+      `);
+          stmt.run(now, ...ids);
+        } catch (e) {
+          console.warn("[Journal] Failed to mark synced", e);
+        }
+      }
+      async journalCount() {
+        if (this.useJsonl) {
+          return {
+            pending: this.jsonlEntries.filter((e) => !e.synced_at).length,
+            total: this.jsonlEntries.length
+          };
+        }
+        if (!this.db) return { pending: 0, total: 0 };
+        try {
+          const pendingStmt = this.db.prepare("SELECT COUNT(*) as cnt FROM messages WHERE synced_at IS NULL");
+          const totalStmt = this.db.prepare("SELECT COUNT(*) as cnt FROM messages");
+          const pending = pendingStmt.get()?.cnt ?? 0;
+          const total = totalStmt.get()?.cnt ?? 0;
+          return { pending, total };
+        } catch (e) {
+          console.warn("[Journal] Failed to count messages", e);
+          return { pending: 0, total: 0 };
+        }
+      }
+      close() {
+        if (this.db) {
+          try {
+            this.db.close();
+          } catch (e) {
+            console.warn("[Journal] Failed to close", e);
+          }
+        }
+      }
+    };
+    journalInstance = null;
+  }
+});
+
 // ../api-client/src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Journal: () => Journal,
+  LocalLlmClient: () => LocalLlmClient,
   MSaplingClient: () => MSaplingClient,
-  MSaplingError: () => MSaplingError
+  MSaplingError: () => MSaplingError,
+  OllamaClient: () => OllamaClient,
+  detectLocalLlm: () => detectLocalLlm,
+  getJournal: () => getJournal,
+  probeDialect: () => probeDialect
 });
 function normalizeDetail(detail) {
   if (detail == null) return "";
@@ -86,6 +513,8 @@ var init_src = __esm({
   "../api-client/src/index.ts"() {
     "use strict";
     init_esm_shims();
+    init_localLlm();
+    init_journal();
     MSaplingError = class extends Error {
       constructor(message, status, code) {
         super(message);
@@ -956,6 +1385,23 @@ var init_src = __esm({
           clearTimeout(timeout);
         }
       }
+      /**
+       * CLI-OFFLINE-02: Import journaled messages from offline sessions
+       * POST /api/chat/import with batch of messages
+       */
+      async importChat(req) {
+        const response = await this.request("/api/chat/import", {
+          method: "POST",
+          body: JSON.stringify(req)
+        });
+        if (!response.ok) {
+          const err = await response.json().catch(() => ({ detail: response.statusText }));
+          throw new MSaplingError(
+            normalizeDetail(err.detail) || "Chat import failed",
+            response.status
+          );
+        }
+      }
     };
   }
 });
@@ -973,7 +1419,7 @@ var init_BaseTool = __esm({
 
 // ../core/src/tools/ReadFileTool.ts
 import { resolve, normalize, relative, isAbsolute } from "path";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync } from "fs";
 var ReadFileTool;
 var init_ReadFileTool = __esm({
@@ -1024,7 +1470,7 @@ var init_ReadFileTool = __esm({
           const limit = args2.limit ? parseInt(args2.limit) : 0;
           const MAX_BYTES = 32768;
           let content = "";
-          const fileContent = await readFile(fullPath, "utf8");
+          const fileContent = await readFile2(fullPath, "utf8");
           const lines = fileContent.split("\n");
           let currentLine = 1;
           let startLine = offset > 0 ? offset : 1;
@@ -1097,10 +1543,10 @@ var init_EditFileTool = __esm({
 });
 
 // ../core/src/tools/WriteFileTool.ts
-import { resolve as resolve2, normalize as normalize2, relative as relative2, isAbsolute as isAbsolute2, join as join2 } from "path";
-import { writeFile, readFile as readFile2, mkdir } from "fs/promises";
+import { resolve as resolve2, normalize as normalize2, relative as relative2, isAbsolute as isAbsolute2, join as join4 } from "path";
+import { writeFile, readFile as readFile3, mkdir } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import { homedir } from "os";
+import { homedir as homedir3 } from "os";
 import { randomBytes } from "crypto";
 var MAX_CONTENT_BYTES, WriteFileTool;
 var init_WriteFileTool = __esm({
@@ -1175,12 +1621,12 @@ var init_WriteFileTool = __esm({
         let backedUpTo = null;
         try {
           if (existsSync2(resolvedTarget)) {
-            const existingContent = await readFile2(resolvedTarget, "utf8");
+            const existingContent = await readFile3(resolvedTarget, "utf8");
             const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
             const suffix = randomBytes(4).toString("hex");
-            const backupPath = join2(homedir(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
-            await mkdir(join2(homedir(), ".msapling", "backups"), { recursive: true });
+            const backupPath = join4(homedir3(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+            await mkdir(join4(homedir3(), ".msapling", "backups"), { recursive: true });
             await writeFile(backupPath, existingContent, "utf8");
             backedUpTo = backupPath;
           }
@@ -1834,9 +2280,9 @@ var init_SubShellTool = __esm({
 
 // ../core/src/tools/SearchTools.ts
 import { spawn as spawn4 } from "child_process";
-import { readFile as readFile3, readdir, stat } from "fs/promises";
+import { readFile as readFile4, readdir, stat } from "fs/promises";
 import { existsSync as existsSync3, statSync } from "fs";
-import { join as join4, relative as relative4, sep, resolve as resolve4, normalize as normalize3, isAbsolute as isAbsolute4 } from "path";
+import { join as join6, relative as relative4, sep, resolve as resolve4, normalize as normalize3, isAbsolute as isAbsolute4 } from "path";
 function globToRegExp(pattern) {
   const normalised = pattern.replace(/\\/g, "/");
   let re = "^";
@@ -1889,7 +2335,7 @@ async function* walkFiles(root, current = root) {
     return;
   }
   for (const entry of entries) {
-    const full = join4(current, entry.name);
+    const full = join6(current, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       yield* walkFiles(root, full);
@@ -1941,12 +2387,12 @@ async function nodeGrepFallback(pattern, searchRoot, maxMatches, caseSensitive)
   const matches2 = [];
   for await (const relPath of walkFiles(searchRoot)) {
     if (matches2.length >= maxMatches) break;
-    const fullPath = join4(searchRoot, relPath);
+    const fullPath = join6(searchRoot, relPath);
     try {
       const s = await stat(fullPath);
       if (!s.isFile()) continue;
       if (s.size > 524288) continue;
-      const content = await readFile3(fullPath, "utf8");
+      const content = await readFile4(fullPath, "utf8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (regex.test(lines[i])) {
@@ -2031,7 +2477,7 @@ var init_SearchTools = __esm({
           const files = [];
           for await (const rel of walkFiles(scanRoot)) {
             if (!re.test(rel)) continue;
-            const full = scanRoot === projectRoot ? rel : join4(args2.path, rel).split(sep).join("/");
+            const full = scanRoot === projectRoot ? rel : join6(args2.path, rel).split(sep).join("/");
             files.push(full);
             if (files.length >= MAX_GLOB_RESULTS) {
               files.push(`... [capped at ${MAX_GLOB_RESULTS} results \u2014 refine your pattern]`);
@@ -2084,7 +2530,7 @@ var init_SearchTools = __esm({
             isError: true
           };
         }
-        const searchPath = args2?.path ? join4(projectRoot, String(args2.path)) : projectRoot;
+        const searchPath = args2?.path ? join6(projectRoot, String(args2.path)) : projectRoot;
         if (!existsSync3(searchPath)) {
           return {
             content: `Error: path "${args2.path}" does not exist.`,
@@ -2123,7 +2569,7 @@ var init_SearchTools = __esm({
           const isFile = statSync(searchPath).isFile();
           let matches2;
           if (isFile) {
-            const content = await readFile3(searchPath, "utf8");
+            const content = await readFile4(searchPath, "utf8");
             const regex = new RegExp(pattern, caseSensitive ? "" : "i");
             const lines = content.split("\n");
             const relPath = args2?.path ?? searchPath;
@@ -2144,7 +2590,7 @@ var init_SearchTools = __esm({
 });
 
 // ../core/src/tools/ListDirectoryTool.ts
-import { resolve as resolve5, normalize as normalize4, relative as relative5, isAbsolute as isAbsolute5, join as join5, sep as sep2 } from "path";
+import { resolve as resolve5, normalize as normalize4, relative as relative5, isAbsolute as isAbsolute5, join as join7, sep as sep2 } from "path";
 import { readdirSync, statSync as statSync2, existsSync as existsSync4 } from "fs";
 function humanSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -2163,7 +2609,7 @@ function scanDir(dir, relBase, recursive, showHidden, entries, cap) {
   const fileNames = [];
   for (const name of names) {
     if (!showHidden && name.startsWith(".")) continue;
-    const full = join5(dir, name);
+    const full = join7(dir, name);
     let st;
     try {
       st = statSync2(full);
@@ -2183,13 +2629,13 @@ function scanDir(dir, relBase, recursive, showHidden, entries, cap) {
     const rel = relBase ? `${relBase}${sep2}${name}` : name;
     entries.push({ kind: "dir", rel });
     if (recursive) {
-      scanDir(join5(dir, name), rel, recursive, showHidden, entries, cap);
+      scanDir(join7(dir, name), rel, recursive, showHidden, entries, cap);
     }
   }
   for (const name of fileNames) {
     if (entries.length >= cap) return;
     const rel = relBase ? `${relBase}${sep2}${name}` : name;
-    const full = join5(dir, name);
+    const full = join7(dir, name);
     let size;
     let mtime;
     try {
@@ -2480,10 +2926,10 @@ var init_TodoTools = __esm({
 });
 
 // ../core/src/tools/PatchFileTool.ts
-import { resolve as resolve6, normalize as normalize5, relative as relative6, isAbsolute as isAbsolute6, join as join6 } from "path";
-import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { resolve as resolve6, normalize as normalize5, relative as relative6, isAbsolute as isAbsolute6, join as join8 } from "path";
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir4 } from "os";
 import { randomBytes as randomBytes2 } from "crypto";
 var PatchFileTool;
 var init_PatchFileTool = __esm({
@@ -2545,7 +2991,7 @@ var init_PatchFileTool = __esm({
         }
         let originalContent;
         try {
-          originalContent = await readFile4(resolvedTarget, "utf8");
+          originalContent = await readFile5(resolvedTarget, "utf8");
         } catch (e) {
           return { content: `Error reading "${args2.path}": ${e.message}`, isError: true };
         }
@@ -2593,8 +3039,8 @@ File preview (first 200 chars): ${JSON.stringify(preview)}`,
           const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const suffix = randomBytes2(4).toString("hex");
-          const backupPath = join6(homedir2(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
-          await mkdir2(join6(homedir2(), ".msapling", "backups"), { recursive: true });
+          const backupPath = join8(homedir4(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+          await mkdir2(join8(homedir4(), ".msapling", "backups"), { recursive: true });
           await writeFile2(backupPath, originalContent, "utf8");
           backedUpTo = backupPath;
         } catch {
@@ -3225,7 +3671,7 @@ ${stderr}`;
 
 // ../core/src/tools/NotebookReadTool.ts
 import { resolve as resolve8, normalize as normalize7, relative as relative8, isAbsolute as isAbsolute8, extname } from "path";
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 function joinSource(source) {
   return Array.isArray(source) ? source.join("") : source ?? "";
@@ -3392,7 +3838,7 @@ var init_NotebookReadTool = __esm({
         }
         let raw;
         try {
-          raw = await readFile5(absPath, "utf8");
+          raw = await readFile6(absPath, "utf8");
         } catch (e) {
           return { content: `Error: could not read file: ${e.message}`, isError: true };
         }
@@ -3449,10 +3895,10 @@ _(Note: notebook has ${nb.cells.length} cells; only first ${MAX_CELLS} shown.)_`
 });
 
 // ../core/src/tools/NotebookEditTool.ts
-import { resolve as resolve9, normalize as normalize8, relative as relative9, isAbsolute as isAbsolute9, extname as extname2, join as join8 } from "path";
-import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve9, normalize as normalize8, relative as relative9, isAbsolute as isAbsolute9, extname as extname2, join as join10 } from "path";
+import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir5 } from "os";
 import { randomBytes as randomBytes3 } from "crypto";
 function normaliseSource(source) {
   if (source === "") return [];
@@ -3586,7 +4032,7 @@ var init_NotebookEditTool = __esm({
         }
         let rawJson;
         try {
-          rawJson = await readFile6(absPath, "utf8");
+          rawJson = await readFile7(absPath, "utf8");
         } catch (e) {
           return { content: `Error: could not read file: ${e.message}`, isError: true };
         }
@@ -3632,13 +4078,13 @@ var init_NotebookEditTool = __esm({
           const filename = absPath.split(/[\\/]/).pop() ?? "notebook.ipynb";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const suffix = randomBytes3(4).toString("hex");
-          const backupPath = join8(
-            homedir3(),
+          const backupPath = join10(
+            homedir5(),
             ".msapling",
             "backups",
             `${filename}.backup-${stamp}-${suffix}.bak`
           );
-          await mkdir3(join8(homedir3(), ".msapling", "backups"), { recursive: true });
+          await mkdir3(join10(homedir5(), ".msapling", "backups"), { recursive: true });
           await writeFile3(backupPath, rawJson, "utf8");
           backedUpTo = backupPath;
         } catch {
@@ -3708,10 +4154,10 @@ Backup: ${backedUpTo}`;
 });
 
 // ../core/src/tools/MultiEditFileTool.ts
-import { resolve as resolve10, normalize as normalize9, relative as relative10, isAbsolute as isAbsolute10, join as join9 } from "path";
-import { readFile as readFile7, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { resolve as resolve10, normalize as normalize9, relative as relative10, isAbsolute as isAbsolute10, join as join11 } from "path";
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir6 } from "os";
 import { randomBytes as randomBytes4 } from "crypto";
 var MAX_EDITS, MultiEditFileTool;
 var init_MultiEditFileTool = __esm({
@@ -3822,7 +4268,7 @@ var init_MultiEditFileTool = __esm({
         }
         let originalContent;
         try {
-          originalContent = await readFile7(resolvedTarget, "utf8");
+          originalContent = await readFile8(resolvedTarget, "utf8");
         } catch (e) {
           return {
             content: `Error reading "${args2.path}": ${e.message}`,
@@ -3875,13 +4321,13 @@ No changes were written (atomic: all-or-nothing).`,
           const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const suffix = randomBytes4(4).toString("hex");
-          const backupPath = join9(
-            homedir4(),
+          const backupPath = join11(
+            homedir6(),
             ".msapling",
             "backups",
             `${filename}.backup-${stamp}-${suffix}.bak`
           );
-          await mkdir4(join9(homedir4(), ".msapling", "backups"), { recursive: true });
+          await mkdir4(join11(homedir6(), ".msapling", "backups"), { recursive: true });
           await writeFile4(backupPath, originalContent, "utf8");
           backedUpTo = backupPath;
         } catch {
@@ -3936,20 +4382,20 @@ async function copyDir(src, dst) {
 }
 async function backupFile(absPath) {
   try {
-    const { readFile: readFile24, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
-    const { homedir: homedir18 } = await import("os");
-    const { join: join31 } = await import("path");
+    const { readFile: readFile26, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
+    const { homedir: homedir21 } = await import("os");
+    const { join: join34 } = await import("path");
     const filename = absPath.split(/[\\/]/).pop() ?? "file";
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const suffix = randomBytes5(4).toString("hex");
-    const backupPath = join31(
-      homedir18(),
+    const backupPath = join34(
+      homedir21(),
       ".msapling",
       "backups",
       `${filename}.backup-${stamp}-${suffix}.bak`
     );
-    await mkdir9(join31(homedir18(), ".msapling", "backups"), { recursive: true });
-    const content = await readFile24(absPath, "utf8");
+    await mkdir9(join34(homedir21(), ".msapling", "backups"), { recursive: true });
+    const content = await readFile26(absPath, "utf8");
     await writeFile13(backupPath, content, "utf8");
     return backupPath;
   } catch {
@@ -4100,7 +4546,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 join11 } from "path";
+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 randomBytes6 } from "crypto";
 var DeleteFileTool;
@@ -4175,14 +4621,14 @@ var init_DeleteFileTool = __esm({
         let backedUpTo = null;
         if (isFile) {
           try {
-            const { readFile: readFile24, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
-            const { homedir: homedir18 } = await import("os");
-            const existingContent = await readFile24(abs, "utf8");
+            const { readFile: readFile26, writeFile: writeFile13, mkdir: mkdir9 } = await import("fs/promises");
+            const { homedir: homedir21 } = await import("os");
+            const existingContent = await readFile26(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 });
+            const backupPath = join13(homedir21(), ".msapling", "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+            await mkdir9(join13(homedir21(), ".msapling", "backups"), { recursive: true });
             await writeFile13(backupPath, existingContent, "utf8");
             backedUpTo = backupPath;
           } catch {
@@ -4731,7 +5177,7 @@ var init_Hooks = __esm({
 });
 
 // ../core/src/agent/ToolExecutor.ts
-import { readFile as readFile8 } from "fs/promises";
+import { readFile as readFile9 } from "fs/promises";
 var APPROVAL_GATED, ToolExecutor;
 var init_ToolExecutor = __esm({
   "../core/src/agent/ToolExecutor.ts"() {
@@ -4982,7 +5428,7 @@ ${blocker.stderr || "(empty)"}`,
         }
         await this.voice.speak(`Executing ${toolName}`, "natural");
         if (toolName === "edit_file") {
-          const content = await readFile8(args2.path, "utf-8");
+          const content = await readFile9(args2.path, "utf-8");
           const parentHash = await this.mdrive.getHash(content);
           const block = await this.mdrive.proposeRemoteEdit(
             args2.path,
@@ -5069,14 +5515,14 @@ var init_Safety = __esm({
 });
 
 // ../core/src/ProjectConfig.ts
-import { homedir as homedir5 } from "os";
-import { join as join12, dirname as dirname2, parse as parsePath } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join14, dirname as dirname2, parse as parsePath } from "path";
 import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 async function readIfExists(path2) {
   try {
     if (!existsSync10(path2)) return null;
-    const text = await readFile9(path2, "utf8");
+    const text = await readFile10(path2, "utf8");
     return text.length > TRUNCATE_AT ? text.slice(0, TRUNCATE_AT) + "\n[...truncated]" : text;
   } catch {
     return null;
@@ -5084,7 +5530,7 @@ async function readIfExists(path2) {
 }
 async function findInDir(dir) {
   for (const filename of FILENAMES) {
-    const path2 = join12(dir, filename);
+    const path2 = join14(dir, filename);
     const content = await readIfExists(path2);
     if (content !== null) {
       return { path: path2, filename, content };
@@ -5107,9 +5553,9 @@ async function findProjectConfig(start) {
   return null;
 }
 async function findUserConfig() {
-  const home = homedir5();
+  const home = homedir7();
   if (!home) return null;
-  const userDir = join12(home, ".msapling");
+  const userDir = join14(home, ".msapling");
   return findInDir(userDir);
 }
 function buildCombined(user, project) {
@@ -5237,6 +5683,7 @@ var init_Agent = __esm({
   "../core/src/agent/Agent.ts"() {
     "use strict";
     init_esm_shims();
+    init_src();
     init_Safety();
     init_ProjectConfig();
     init_Hooks();
@@ -5400,15 +5847,19 @@ ${next}`;
           }
           const currentPrompt = queue.shift();
           rounds++;
-          const stream = this.client.streamChat({
-            chat_id: chatId,
-            prompt: currentPrompt,
-            model,
-            tools: this.executor.getToolSchemas(),
-            project_root: this.projectRoot,
-            mode: this.executor.getMode(),
-            ...config.combined ? { project_context: config.combined } : {}
-          });
+          const stream = this.chatWithFallback(
+            {
+              chat_id: chatId,
+              prompt: currentPrompt,
+              model,
+              tools: this.executor.getToolSchemas(),
+              project_root: this.projectRoot,
+              mode: this.executor.getMode(),
+              ...config.combined ? { project_context: config.combined } : {}
+            },
+            chatId,
+            currentPrompt
+          );
           for await (const chunk of stream) {
             if (chunk.content) {
               onContent(chunk.content);
@@ -5449,6 +5900,156 @@ ${next}`;
         }
         return fullResponse;
       }
+      /**
+       * CLI-OFFLINE-01: Fallback to Ollama when backend is unreachable.
+       * On network error / 5xx / ECONNREFUSED, try local Ollama.
+       * If Ollama unavailable, show offline message and journal the user message only.
+       */
+      async *chatWithFallback(params, chatId, userMessage) {
+        const journal = getJournal();
+        let backendReachable = false;
+        let connectionTimeout = null;
+        try {
+          const controller = new AbortController();
+          connectionTimeout = setTimeout(() => controller.abort(), 3e3);
+          const backendStream = this.client.streamChat(params);
+          for await (const chunk of backendStream) {
+            if (connectionTimeout) {
+              clearTimeout(connectionTimeout);
+              connectionTimeout = null;
+            }
+            backendReachable = true;
+            yield chunk;
+          }
+        } catch (error) {
+          if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+          }
+          const isNetworkError = error?.code === "ECONNREFUSED" || error?.code === "ECONNRESET" || error?.code === "ETIMEDOUT" || error?.status >= 500 || error?.message?.includes("timeout");
+          if (!isNetworkError) {
+            throw error;
+          }
+          const localLlm = await detectLocalLlm();
+          if (!localLlm) {
+            const userEntry2 = {
+              id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+              chat_id: chatId,
+              project_id: void 0,
+              role: "user",
+              content: userMessage,
+              ts: Date.now(),
+              source: "offline"
+            };
+            await journal.journalAppend(userEntry2);
+            yield {
+              content: "Offline \u2014 no local model available. Install Ollama (ollama.ai) or llama.cpp and pull a model.\n"
+            };
+            return;
+          }
+          const userEntry = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+            chat_id: chatId,
+            project_id: void 0,
+            role: "user",
+            content: userMessage,
+            ts: Date.now(),
+            source: "offline"
+          };
+          await journal.journalAppend(userEntry);
+          const dialect = await localLlm.detectDialect();
+          let models = await localLlm.listModels();
+          let selectedModel = process.env.MSAPLING_LOCAL_LLM_MODEL || "default";
+          if (models.length === 0) {
+            const assistantEntry2 = {
+              id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+              chat_id: chatId,
+              project_id: void 0,
+              role: "assistant",
+              content: `No models available. Pull one for your local LLM server.`,
+              ts: Date.now(),
+              model: selectedModel,
+              source: `offline_${dialect}`
+            };
+            await journal.journalAppend(assistantEntry2);
+            yield {
+              content: `No models available. Pull one for your local LLM server.`
+            };
+            return;
+          }
+          if (!models.find((m) => m.name === selectedModel)) {
+            selectedModel = models[0].name;
+          }
+          const messages = params.messages || [{ role: "user", content: userMessage }];
+          let assistantContent = "";
+          let promptTokens = 0;
+          let completionTokens = 0;
+          for await (const delta of localLlm.streamChat(selectedModel, messages)) {
+            assistantContent += delta.delta;
+            if (delta.done) {
+              promptTokens = delta.prompt_tokens ?? 0;
+              completionTokens = delta.completion_tokens ?? 0;
+            }
+            if (delta.delta) {
+              yield { content: delta.delta };
+            }
+          }
+          const assistantEntry = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+            chat_id: chatId,
+            project_id: void 0,
+            role: "assistant",
+            content: assistantContent,
+            ts: Date.now(),
+            model: selectedModel,
+            token_count: completionTokens,
+            source: `offline_${dialect}`
+          };
+          await journal.journalAppend(assistantEntry);
+        }
+        if (backendReachable) {
+          const pending = await journal.journalListPending();
+          if (pending.length > 0) {
+            this.syncPendingMessages().catch(
+              (e) => console.warn("[Offline] Background sync failed:", e)
+            );
+          }
+        }
+      }
+      /**
+       * Sync pending journal entries to backend in batches of 50
+       */
+      async syncPendingMessages() {
+        const journal = getJournal();
+        const pending = await journal.journalListPending();
+        if (pending.length === 0) return;
+        const byChat = /* @__PURE__ */ new Map();
+        for (const entry of pending) {
+          if (!byChat.has(entry.chat_id)) {
+            byChat.set(entry.chat_id, []);
+          }
+          byChat.get(entry.chat_id).push(entry);
+        }
+        for (const [chatId, entries] of byChat.entries()) {
+          for (let i = 0; i < entries.length; i += 50) {
+            const batch = entries.slice(i, i + 50);
+            try {
+              await this.client.importChat({
+                chat_id: chatId,
+                messages: batch.map((e) => ({
+                  role: e.role,
+                  content: e.content,
+                  model: e.model
+                }))
+              });
+              await journal.journalMarkSynced(batch.map((e) => e.id));
+            } catch (e) {
+              console.warn("[Offline] Sync batch failed, will retry on next connection:", e);
+              break;
+            }
+          }
+        }
+      }
     };
   }
 });
@@ -5518,11 +6119,11 @@ var init_Mutex = __esm({
        * `finally` block to prevent deadlocks on throw.
        */
       acquire() {
-        let release2;
+        let release3;
         const next = new Promise((resolve19) => {
-          release2 = resolve19;
+          release3 = resolve19;
         });
-        const entry = this._queue.then(() => release2);
+        const entry = this._queue.then(() => release3);
         this._queue = this._queue.then(() => next);
         return entry;
       }
@@ -5531,11 +6132,11 @@ var init_Mutex = __esm({
        * release.  Returns whatever `fn` returns.
        */
       async run(fn) {
-        const release2 = await this.acquire();
+        const release3 = await this.acquire();
         try {
           return await fn();
         } finally {
-          release2();
+          release3();
         }
       }
     };
@@ -5543,17 +6144,17 @@ var init_Mutex = __esm({
 });
 
 // ../core/src/TrustStore.ts
-import { join as join13 } from "path";
-import { homedir as homedir6, platform as platform2 } from "os";
+import { join as join15 } from "path";
+import { homedir as homedir8, platform as platform2 } from "os";
 import { existsSync as existsSync11, mkdirSync } from "fs";
-import { readFile as readFile10, writeFile as writeFile5, chmod } from "fs/promises";
+import { readFile as readFile11, writeFile as writeFile5, chmod } from "fs/promises";
 var USER_SETTINGS_PATH, TrustStore;
 var init_TrustStore = __esm({
   "../core/src/TrustStore.ts"() {
     "use strict";
     init_esm_shims();
     init_Mutex();
-    USER_SETTINGS_PATH = join13(homedir6(), ".msapling", "settings.json");
+    USER_SETTINGS_PATH = join15(homedir8(), ".msapling", "settings.json");
     TrustStore = class {
       /** Current in-memory set of trusted `tool:command` keys. */
       trusted = /* @__PURE__ */ new Set();
@@ -5571,7 +6172,7 @@ var init_TrustStore = __esm({
       async readSettings() {
         try {
           if (!existsSync11(this.settingsPath)) return {};
-          const text = await readFile10(this.settingsPath, "utf8");
+          const text = await readFile11(this.settingsPath, "utf8");
           if (!text.trim()) return {};
           return JSON.parse(text);
         } catch {
@@ -5583,7 +6184,7 @@ var init_TrustStore = __esm({
        * updating `trustedCommands`.
        */
       async writeSettings(settings) {
-        const dir = join13(homedir6(), ".msapling");
+        const dir = join15(homedir8(), ".msapling");
         if (!existsSync11(dir)) mkdirSync(dir, { recursive: true });
         await writeFile5(this.settingsPath, JSON.stringify(settings, null, 2), "utf8");
         if (platform2() !== "win32") {
@@ -5669,7 +6270,7 @@ var require_polyfills = __commonJS({
     var constants = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform4 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform5 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -5728,7 +6329,7 @@ var require_polyfills = __commonJS({
         fs3.lchownSync = function() {
         };
       }
-      if (platform4 === "win32") {
+      if (platform5 === "win32") {
         fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : (function(fs$rename) {
           function rename2(from, to, cb) {
             var start = Date.now();
@@ -6160,8 +6761,8 @@ var require_graceful_fs = __commonJS({
       fs4.createReadStream = createReadStream;
       fs4.createWriteStream = createWriteStream;
       var fs$readFile = fs4.readFile;
-      fs4.readFile = readFile24;
-      function readFile24(path2, options, cb) {
+      fs4.readFile = readFile26;
+      function readFile26(path2, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path2, options, cb);
@@ -7230,12 +7831,12 @@ var require_proper_lockfile = __commonJS({
     var lockfile2 = require_lockfile();
     var { toPromise, toSync, toSyncOptions } = require_adapter();
     async function lock2(file, options) {
-      const release2 = await toPromise(lockfile2.lock)(file, options);
-      return toPromise(release2);
+      const release3 = await toPromise(lockfile2.lock)(file, options);
+      return toPromise(release3);
     }
     function lockSync(file, options) {
-      const release2 = toSync(lockfile2.lock)(file, toSyncOptions(options));
-      return toSync(release2);
+      const release3 = toSync(lockfile2.lock)(file, toSyncOptions(options));
+      return toSync(release3);
     }
     function unlock2(file, options) {
       return toPromise(lockfile2.unlock)(file, options);
@@ -7321,10 +7922,10 @@ var require_keytar2 = __commonJS({
 });
 
 // ../core/src/Storage.ts
-import { join as join14 } from "path";
-import { homedir as homedir7 } from "os";
+import { join as join16 } from "path";
+import { homedir as homedir9 } from "os";
 import { chmodSync, existsSync as existsSync12, renameSync, unlinkSync, writeFileSync } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile6, readFile as readFile11, appendFile } from "fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile6, readFile as readFile12, appendFile } from "fs/promises";
 import { randomBytes as randomBytes7, createHash as createHash3 } from "crypto";
 function hashLine(line) {
   return createHash3("sha256").update(line, "utf8").digest("hex");
@@ -7355,7 +7956,7 @@ var init_Storage = __esm({
        */
       _ready;
       constructor() {
-        this.baseDir = join14(homedir7(), ".msapling");
+        this.baseDir = join16(homedir9(), ".msapling");
         this._ready = this.ensureDirs();
       }
       async ensureDirs() {
@@ -7374,7 +7975,7 @@ var init_Storage = __esm({
             "cache/recipes/objects"
           ];
           for (const sub of subdirs) {
-            const path2 = join14(this.baseDir, sub);
+            const path2 = join16(this.baseDir, sub);
             await mkdir6(path2, { recursive: true });
           }
           if (process.platform !== "win32") {
@@ -7392,7 +7993,7 @@ var init_Storage = __esm({
         await this._ready;
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join14(this.baseDir, "vault", "token");
+        const filePath = join16(this.baseDir, "vault", "token");
         try {
           await keytar.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, token);
           try {
@@ -7412,7 +8013,7 @@ var init_Storage = __esm({
       async loadToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join14(this.baseDir, "vault", "token");
+        const filePath = join16(this.baseDir, "vault", "token");
         try {
           const keychainToken = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
           if (keychainToken) {
@@ -7422,7 +8023,7 @@ var init_Storage = __esm({
           console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)}), falling back to file storage`);
         }
         if (existsSync12(filePath)) {
-          const text = await readFile11(filePath, "utf8");
+          const text = await readFile12(filePath, "utf8");
           return text.trim();
         }
         return null;
@@ -7433,7 +8034,7 @@ var init_Storage = __esm({
       async clearToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join14(this.baseDir, "vault", "token");
+        const filePath = join16(this.baseDir, "vault", "token");
         try {
           await keytar.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
         } catch (e) {
@@ -7472,8 +8073,8 @@ var init_Storage = __esm({
       async writeVaultRef(label, value) {
         await this._ready;
         const hash = createHash3("sha256").update(value, "utf8").digest("hex");
-        const objectPath = join14(this.baseDir, "vault", "objects", hash);
-        const refPath = join14(this.baseDir, "vault", "refs", label);
+        const objectPath = join16(this.baseDir, "vault", "objects", hash);
+        const refPath = join16(this.baseDir, "vault", "refs", label);
         const refTmp = `${refPath}.tmp`;
         await writeFile6(objectPath, value, "utf8");
         if (process.platform !== "win32") {
@@ -7489,12 +8090,12 @@ var init_Storage = __esm({
        */
       async readVaultRef(label) {
         await this._ready;
-        const refPath = join14(this.baseDir, "vault", "refs", label);
+        const refPath = join16(this.baseDir, "vault", "refs", label);
         if (!existsSync12(refPath)) return null;
-        const hash = (await readFile11(refPath, "utf8")).trim();
-        const objectPath = join14(this.baseDir, "vault", "objects", hash);
+        const hash = (await readFile12(refPath, "utf8")).trim();
+        const objectPath = join16(this.baseDir, "vault", "objects", hash);
         if (!existsSync12(objectPath)) return null;
-        return readFile11(objectPath, "utf8");
+        return readFile12(objectPath, "utf8");
       }
       // ─────────────────────────────────────────────────────────────────────────
       // CLI-ARCH-RECIPE-AT-HASH-URI-01 — recipe hash registry helpers
@@ -7517,8 +8118,8 @@ var init_Storage = __esm({
       async registerRecipe(name, content) {
         await this._ready;
         const hash = createHash3("sha256").update(content, "utf8").digest("hex");
-        const objectPath = join14(this.baseDir, "cache", "recipes", "objects", hash);
-        const indexPath = join14(this.baseDir, "cache", "recipes", "index.json");
+        const objectPath = join16(this.baseDir, "cache", "recipes", "objects", hash);
+        const indexPath = join16(this.baseDir, "cache", "recipes", "index.json");
         const indexTmp = `${indexPath}.tmp`;
         if (!existsSync12(objectPath)) {
           await writeFile6(objectPath, content, "utf8");
@@ -7526,7 +8127,7 @@ var init_Storage = __esm({
         let index = {};
         if (existsSync12(indexPath)) {
           try {
-            index = JSON.parse(await readFile11(indexPath, "utf8"));
+            index = JSON.parse(await readFile12(indexPath, "utf8"));
           } catch {
             index = {};
           }
@@ -7542,26 +8143,26 @@ var init_Storage = __esm({
        */
       async resolveRecipe(nameOrRef) {
         await this._ready;
-        const indexPath = join14(this.baseDir, "cache", "recipes", "index.json");
+        const indexPath = join16(this.baseDir, "cache", "recipes", "index.json");
         const atIdx = nameOrRef.indexOf("@");
         if (atIdx !== -1) {
           const hash2 = nameOrRef.slice(atIdx + 1);
-          const objectPath2 = join14(this.baseDir, "cache", "recipes", "objects", hash2);
+          const objectPath2 = join16(this.baseDir, "cache", "recipes", "objects", hash2);
           if (!existsSync12(objectPath2)) return null;
-          return { hash: hash2, content: await readFile11(objectPath2, "utf8") };
+          return { hash: hash2, content: await readFile12(objectPath2, "utf8") };
         }
         if (!existsSync12(indexPath)) return null;
         let index;
         try {
-          index = JSON.parse(await readFile11(indexPath, "utf8"));
+          index = JSON.parse(await readFile12(indexPath, "utf8"));
         } catch {
           return null;
         }
         const hash = index[nameOrRef];
         if (!hash) return null;
-        const objectPath = join14(this.baseDir, "cache", "recipes", "objects", hash);
+        const objectPath = join16(this.baseDir, "cache", "recipes", "objects", hash);
         if (!existsSync12(objectPath)) return null;
-        return { hash, content: await readFile11(objectPath, "utf8") };
+        return { hash, content: await readFile12(objectPath, "utf8") };
       }
       // ─────────────────────────────────────────────────────────────────────────
       // CLI-ARCH-HASH-CHAIN-HISTORY-01 — append-only NDJSON history with hash chain
@@ -7583,18 +8184,18 @@ var init_Storage = __esm({
        */
       async appendHistoryEntry(content) {
         await this._ready;
-        const path2 = join14(this.baseDir, "history", "shell_history.jsonl");
+        const path2 = join16(this.baseDir, "history", "shell_history.jsonl");
         return this.historyMutex.run(async () => {
-          let release2 = null;
+          let release3 = null;
           try {
             if (!existsSync12(path2)) {
               await writeFile6(path2, "", "utf8");
             }
-            release2 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
+            release3 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
             let prevHash = null;
             let seq = 1;
             if (existsSync12(path2)) {
-              const raw = (await readFile11(path2, "utf8")).trimEnd();
+              const raw = (await readFile12(path2, "utf8")).trimEnd();
               if (raw.length > 0) {
                 const lines = raw.split("\n");
                 const lastLine = lines[lines.length - 1];
@@ -7616,7 +8217,7 @@ var init_Storage = __esm({
             await appendFile(path2, line + "\n", "utf8");
             return entry;
           } finally {
-            if (release2) {
+            if (release3) {
               try {
                 await lockfile.unlock(path2, { skipStale: true });
               } catch {
@@ -7633,9 +8234,9 @@ var init_Storage = __esm({
        */
       async loadHistoryEntries() {
         await this._ready;
-        const path2 = join14(this.baseDir, "history", "shell_history.jsonl");
+        const path2 = join16(this.baseDir, "history", "shell_history.jsonl");
         if (!existsSync12(path2)) return [];
-        const raw = await readFile11(path2, "utf8");
+        const raw = await readFile12(path2, "utf8");
         const entries = [];
         for (const line of raw.split("\n")) {
           if (!line.trim()) continue;
@@ -7683,11 +8284,11 @@ var init_Storage = __esm({
        */
       async saveHistory(history) {
         await this._ready;
-        const path2 = join14(this.baseDir, "history", "shell_history.json");
-        let release2;
+        const path2 = join16(this.baseDir, "history", "shell_history.json");
+        let release3;
         try {
           if (!existsSync12(path2)) writeFileSync(path2, "[]", "utf8");
-          release2 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+          release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           await this.historyMutex.run(async () => {
             const tmpPath = `${path2}.tmp`;
             const content = JSON.stringify(history, null, 2);
@@ -7706,7 +8307,7 @@ var init_Storage = __esm({
             }
           });
         } finally {
-          if (release2) {
+          if (release3) {
             try {
               await lockfile.unlock(path2, { skipStale: true });
             } catch (e) {
@@ -7724,21 +8325,21 @@ var init_Storage = __esm({
        */
       async loadHistory() {
         await this._ready;
-        const path2 = join14(this.baseDir, "history", "shell_history.json");
+        const path2 = join16(this.baseDir, "history", "shell_history.json");
         if (!existsSync12(path2)) return [];
-        let release2;
+        let release3;
         try {
-          release2 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+          release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           return this.historyMutex.run(async () => {
             if (existsSync12(path2)) {
-              const text = await readFile11(path2, "utf8");
+              const text = await readFile12(path2, "utf8");
               try {
                 return JSON.parse(text);
               } catch (parseErr) {
                 const filename = path2.split("/").pop() || "shell_history.json";
                 const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
                 const suffix = randomBytes7(4).toString("hex");
-                const corruptBackupPath = join14(
+                const corruptBackupPath = join16(
                   this.baseDir,
                   "history",
                   `${filename}.corrupt.${stamp}-${suffix}.bak`
@@ -7755,7 +8356,7 @@ var init_Storage = __esm({
             return [];
           });
         } finally {
-          if (release2) {
+          if (release3) {
             try {
               await lockfile.unlock(path2, { skipStale: true });
             } catch (e) {
@@ -7769,11 +8370,11 @@ var init_Storage = __esm({
        * R20-CLI-2: Typed with PermissionState from Sandbox.ts.
        */
       async savePermissions(permissions) {
-        const path2 = join14(this.baseDir, "vault", "permissions.json");
-        let release2;
+        const path2 = join16(this.baseDir, "vault", "permissions.json");
+        let release3;
         try {
           if (!existsSync12(path2)) writeFileSync(path2, "{}", "utf8");
-          release2 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+          release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           await this.permissionsMutex.run(async () => {
             const tmpPath = `${path2}.tmp`;
             const content = JSON.stringify(permissions, null, 2);
@@ -7792,7 +8393,7 @@ var init_Storage = __esm({
             }
           });
         } finally {
-          if (release2) {
+          if (release3) {
             try {
               await lockfile.unlock(path2, { skipStale: true });
             } catch (e) {
@@ -7806,21 +8407,21 @@ var init_Storage = __esm({
        * R20-CLI-2: Typed with PermissionState from Sandbox.ts.
        */
       async loadPermissions() {
-        const path2 = join14(this.baseDir, "vault", "permissions.json");
+        const path2 = join16(this.baseDir, "vault", "permissions.json");
         if (!existsSync12(path2)) return { trustedCommands: [], trustedPaths: [] };
-        let release2;
+        let release3;
         try {
-          release2 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
+          release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           return this.permissionsMutex.run(async () => {
             if (existsSync12(path2)) {
-              const text = await readFile11(path2, "utf8");
+              const text = await readFile12(path2, "utf8");
               try {
                 return JSON.parse(text);
               } catch (parseErr) {
                 const filename = path2.split("/").pop() || "permissions.json";
                 const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
                 const suffix = randomBytes7(4).toString("hex");
-                const corruptBackupPath = join14(
+                const corruptBackupPath = join16(
                   this.baseDir,
                   "vault",
                   `${filename}.corrupt.${stamp}-${suffix}.bak`
@@ -7837,7 +8438,7 @@ var init_Storage = __esm({
             return { trustedCommands: [], trustedPaths: [] };
           });
         } finally {
-          if (release2) {
+          if (release3) {
             try {
               await lockfile.unlock(path2, { skipStale: true });
             } catch (e) {
@@ -7857,7 +8458,7 @@ var init_Storage = __esm({
         const filename = filePath.split("/").pop() || "file";
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         const suffix = randomBytes7(4).toString("hex");
-        const backupPath = join14(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+        const backupPath = join16(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
         await writeFile6(backupPath, content, "utf8");
         if (process.platform !== "win32") {
           chmodSync(backupPath, 384);
@@ -7869,11 +8470,11 @@ var init_Storage = __esm({
 });
 
 // ../core/src/Settings.ts
-import { homedir as homedir8 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join17 } from "path";
 import { existsSync as existsSync13 } from "fs";
 import * as fs from "fs";
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile13 } from "fs/promises";
 import { randomBytes as randomBytes8 } from "crypto";
 function ensureConfigDir(p) {
   try {
@@ -7895,7 +8496,7 @@ function ensureConfigDir(p) {
 async function readJson(path2) {
   try {
     if (!existsSync13(path2)) return null;
-    const text = await readFile12(path2, "utf8");
+    const text = await readFile13(path2, "utf8");
     if (!text.trim()) return null;
     return JSON.parse(text);
   } catch {
@@ -7949,8 +8550,8 @@ function mergeSettings(base, override) {
 }
 async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
   const sources = [];
-  const userPath = join15(homedir8() || ".", ".msapling", "settings.json");
-  const projectPath = join15(cwd, ".msapling", "settings.json");
+  const userPath = join17(homedir10() || ".", ".msapling", "settings.json");
+  const projectPath = join17(cwd, ".msapling", "settings.json");
   const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
   if (user) sources.push(userPath);
   if (project) sources.push(projectPath);
@@ -8617,10 +9218,10 @@ var init_unlock = __esm({
 });
 
 // src/commands/doctor.ts
-import { homedir as homedir9 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join18 } from "path";
 import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 async function checkApiHealth(client) {
   try {
     if (typeof client.request !== "function") {
@@ -8645,12 +9246,12 @@ async function checkAuthStatus(client) {
   }
 }
 async function checkSettingsFile() {
-  const settingsPath = join16(homedir9(), ".msapling", "settings.json");
+  const settingsPath = join18(homedir11(), ".msapling", "settings.json");
   try {
     if (!existsSync14(settingsPath)) {
       return { ok: false, message: `Not found: ${settingsPath}` };
     }
-    const text = await readFile13(settingsPath, "utf8");
+    const text = await readFile14(settingsPath, "utf8");
     const parsed = JSON.parse(text);
     return { ok: true, message: `Valid JSON (${settingsPath})`, settings: parsed };
   } catch (e) {
@@ -9334,7 +9935,7 @@ var init_memories = __esm({
 });
 
 // src/commands/mdrive.ts
-import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
+import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
 import { basename, resolve as resolve14 } from "path";
 function formatBytes(b) {
@@ -9392,7 +9993,7 @@ var init_mdrive = __esm({
               context.addMessage("error", `Local file not found: ${absLocal}`);
               return;
             }
-            const content = await readFile14(absLocal, "utf8");
+            const content = await readFile15(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;
@@ -9485,15 +10086,15 @@ var init_clear = __esm({
 });
 
 // src/commands/mode.ts
-import { homedir as homedir10 } from "os";
-import { join as join17 } from "path";
+import { homedir as homedir12 } from "os";
+import { join as join19 } from "path";
 import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile15, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
+import { readFile as readFile16, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
 async function persistApprovalMode(mode, ttlMs) {
   try {
     let existing = {};
     if (existsSync16(SETTINGS_PATH)) {
-      const text = await readFile15(SETTINGS_PATH, "utf8");
+      const text = await readFile16(SETTINGS_PATH, "utf8");
       if (text.trim()) {
         existing = JSON.parse(text);
       }
@@ -9504,7 +10105,7 @@ async function persistApprovalMode(mode, ttlMs) {
       ...ttlMs && { ttlMs }
     };
     existing.approvalMode = entry;
-    const settingsDir = join17(homedir10(), ".msapling");
+    const settingsDir = join19(homedir12(), ".msapling");
     if (!existsSync16(settingsDir)) {
       await mkdir7(settingsDir, { recursive: true });
     }
@@ -9517,7 +10118,7 @@ var init_mode = __esm({
   "src/commands/mode.ts"() {
     "use strict";
     init_esm_shims();
-    SETTINGS_PATH = join17(homedir10(), ".msapling", "settings.json");
+    SETTINGS_PATH = join19(homedir12(), ".msapling", "settings.json");
     modeCommand = {
       name: "mode",
       args: "[default|plan|acceptEdits|bypassPermissions] [...options]",
@@ -9919,7 +10520,7 @@ var init_compact = __esm({
 });
 
 // src/commands/init.ts
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 import { existsSync as existsSync17 } from "fs";
 import { writeFile as writeFile9 } from "fs/promises";
 var initCommand;
@@ -9934,7 +10535,7 @@ var init_init = __esm({
       handler: async (args2, context) => {
         try {
           const cwd = process.cwd();
-          const path2 = join18(cwd, "MSAPLING.md");
+          const path2 = join20(cwd, "MSAPLING.md");
           if (existsSync17(path2)) {
             context.addMessage("error", "MSAPLING.md already exists in current directory.");
             return;
@@ -9962,7 +10563,7 @@ var init_init = __esm({
 
 // src/commands/review.ts
 import { existsSync as existsSync18 } from "fs";
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
   "src/commands/review.ts"() {
@@ -9982,7 +10583,7 @@ var init_review = __esm({
         let content = "";
         try {
           if (existsSync18(target)) {
-            content = await readFile16(target, "utf8");
+            content = await readFile17(target, "utf8");
           } else {
             content = `Review target: ${target}`;
           }
@@ -10076,13 +10677,13 @@ var init_swarm = __esm({
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
 import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join21 } 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}`);
+        const p = join21(cwd, dir, `${name}${suffix}${ext}`);
         if (existsSync19(p)) return p;
       }
     }
@@ -10142,7 +10743,7 @@ var init_recipe = __esm({
         let text;
         let recipe;
         try {
-          text = await readFile17(path2, "utf8");
+          text = await readFile18(path2, "utf8");
           recipe = parseYaml(text);
         } catch (e) {
           context.addMessage("error", `Failed to load ${path2}: ${e.message}`);
@@ -10197,8 +10798,8 @@ ${rendered}` : rendered;
 
 // src/commands/skill.ts
 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";
+import { readFile as readFile19 } from "fs/promises";
+import { join as join22, resolve as resolve15 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
     const full = resolve15(cwd, candidate);
@@ -10215,7 +10816,7 @@ function listAllSkills(root) {
     return out;
   }
   for (const domain of domains) {
-    const dir = join20(root, domain);
+    const dir = join22(root, domain);
     let s;
     try {
       s = statSync5(dir);
@@ -10231,7 +10832,7 @@ function listAllSkills(root) {
     }
     for (const f of files) {
       if (!f.endsWith(".md")) continue;
-      out.push({ domain, name: f.slice(0, -3), path: join20(dir, f) });
+      out.push({ domain, name: f.slice(0, -3), path: join22(dir, f) });
     }
   }
   return out.sort(
@@ -10296,7 +10897,7 @@ var init_skill = __esm({
         }
         let body;
         try {
-          body = await readFile18(skill.path, "utf8");
+          body = await readFile19(skill.path, "utf8");
         } catch (e) {
           context.addMessage("error", `Failed to load skill ${skill.path}: ${e.message}`);
           return;
@@ -10320,8 +10921,8 @@ ${prompt4}`;
 });
 
 // src/commands/benchmark.ts
-import { homedir as homedir11 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join23 } from "path";
 import { mkdirSync as mkdirSync4 } from "fs";
 import * as fs2 from "fs";
 function parseArgs(args2) {
@@ -10441,10 +11042,10 @@ HW at start: ${hw.cores}-core ${hw.platform} | CPU ${hw.cpuPct}% | RAM ${hw.ramP
           `[HW at run time: CPU ${hwAtEnd.cpuPct}% / RAM ${hwAtEnd.ramPct}% | ${hw.ramGiB} GiB RAM, ${hw.cores} cores]`
         );
         try {
-          const dir = join21(homedir11(), ".msapling", "benchmarks");
+          const dir = join23(homedir13(), ".msapling", "benchmarks");
           mkdirSync4(dir, { recursive: true });
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-          const file = join21(dir, `${ts}.json`);
+          const file = join23(dir, `${ts}.json`);
           const run = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             rounds,
@@ -10690,22 +11291,22 @@ var init_theme = __esm({
 });
 
 // src/commands/theme.ts
-import { join as join22 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join24 } from "path";
+import { homedir as homedir14 } from "os";
 import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
+import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
 async function persistTheme(storage, themeName) {
-  const settingsPath = join22(homedir12(), ".msapling", "settings.json");
+  const settingsPath = join24(homedir14(), ".msapling", "settings.json");
   let existing = {};
   try {
     if (existsSync21(settingsPath)) {
-      const text = await readFile19(settingsPath, "utf8");
+      const text = await readFile20(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
   } catch {
   }
   existing["theme"] = themeName;
-  ensureConfigDir(join22(homedir12(), ".msapling"));
+  ensureConfigDir(join24(homedir14(), ".msapling"));
   await writeFile10(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
@@ -10777,7 +11378,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.28" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.30" : "(dev)";
         const coreVersion = true ? "2.3.2" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -10786,7 +11387,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-29T17:03:26.902Z";
+          const ts = "2026-05-29T20:13:59.523Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -10799,15 +11400,15 @@ var init_version = __esm({
 });
 
 // src/commands/feedback.ts
-import { join as join23 } from "path";
+import { join as join25 } from "path";
 import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile20 } from "fs/promises";
+import { readFile as readFile21 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    const pkgPath = join23(baseDir, "..", "..", "package.json");
+    const pkgPath = join25(baseDir, "..", "..", "package.json");
     if (!existsSync22(pkgPath)) return "unknown";
-    const text = await readFile20(pkgPath, "utf8");
+    const text = await readFile21(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
   } catch {
@@ -10847,8 +11448,8 @@ var init_feedback = __esm({
 });
 
 // src/commands/export.ts
-import { homedir as homedir13 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join26 } from "path";
 import { writeFile as writeFile11, mkdir as mkdir8 } from "fs/promises";
 function formatTimestamp(date) {
   return date.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
@@ -10898,10 +11499,10 @@ var init_export = __esm({
         let outputPath;
         let content;
         if (arg === "" || arg === "json") {
-          outputPath = join24(homedir13(), `msapling-export-${timestamp}.json`);
+          outputPath = join26(homedir15(), `msapling-export-${timestamp}.json`);
           content = buildJsonExport(history);
         } else if (arg === "markdown" || arg === "md") {
-          outputPath = join24(homedir13(), `msapling-export-${timestamp}.md`);
+          outputPath = join26(homedir15(), `msapling-export-${timestamp}.md`);
           content = buildMarkdownExport(history);
         } else {
           outputPath = arg;
@@ -10913,7 +11514,7 @@ var init_export = __esm({
           }
         }
         try {
-          const dir = join24(outputPath, "..");
+          const dir = join26(outputPath, "..");
           await mkdir8(dir, { recursive: true });
           await writeFile11(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
@@ -11108,17 +11709,17 @@ var init_plan = __esm({
 });
 
 // src/commands/note.ts
-import { homedir as homedir14 } from "os";
-import { join as join25 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join27 } from "path";
 import { existsSync as existsSync23 } from "fs";
-import { readFile as readFile21, writeFile as writeFile12 } from "fs/promises";
+import { readFile as readFile22, writeFile as writeFile12 } from "fs/promises";
 function getNotesFilePath() {
-  return join25(homedir14(), ".msapling", "notes.json");
+  return join27(homedir16(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
     if (!existsSync23(filePath)) return [];
-    const raw = await readFile21(filePath, "utf8");
+    const raw = await readFile22(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -11127,7 +11728,7 @@ async function readNotes(filePath = getNotesFilePath()) {
   }
 }
 async function writeNotes(notes, filePath = getNotesFilePath()) {
-  const dir = join25(homedir14(), ".msapling");
+  const dir = join27(homedir16(), ".msapling");
   ensureConfigDir(dir);
   await writeFile12(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
@@ -11273,14 +11874,14 @@ var init_todo = __esm({
 });
 
 // src/commands/outputStyle.ts
-import { homedir as homedir15 } from "os";
-import { join as join26, basename as basename2, extname as extname3 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join28, 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");
+  return join28(homedir17(), ".msapling", "output-styles");
 }
 function activeFile() {
-  return join26(stylesDir(), ".active");
+  return join28(stylesDir(), ".active");
 }
 function parseStyleFile(text) {
   const fm = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
@@ -11305,7 +11906,7 @@ function listUserStyles() {
   const out = [];
   for (const entry of readdirSync3(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
-    const full = join26(dir, entry);
+    const full = join28(dir, entry);
     try {
       const text = readFileSync(full, "utf8");
       const { description, body } = parseStyleFile(text);
@@ -11355,7 +11956,7 @@ function createUserStyle(name, description, body) {
   }
   const dir = stylesDir();
   if (!existsSync24(dir)) mkdirSync5(dir, { recursive: true });
-  const target = join26(dir, `${name}.md`);
+  const target = join28(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
 ---
@@ -12027,6 +12628,442 @@ var init_webhook = __esm({
   }
 });
 
+// src/commands/sync.ts
+var syncCommand;
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_src();
+    syncCommand = {
+      name: "sync",
+      description: "Manage offline message sync (status|push)",
+      args: "[status|push]",
+      category: "config",
+      handler: async (args2, context) => {
+        const subcommand = (args2[0] || "status").toLowerCase();
+        const journal = getJournal();
+        switch (subcommand) {
+          case "status": {
+            const { pending, total } = await journal.journalCount();
+            context.addMessage("assistant", [
+              `Offline messages journal:`,
+              `  Total: ${total}`,
+              `  Pending sync: ${pending}`,
+              `  Synced: ${total - pending}`,
+              ...pending > 0 ? [``, `Run /sync push to sync pending messages to the backend.`] : []
+            ].join("\n"));
+            break;
+          }
+          case "push": {
+            const pending = await journal.journalListPending();
+            if (pending.length === 0) {
+              context.addMessage("assistant", "No pending messages to sync.");
+              break;
+            }
+            context.addMessage("assistant", `Syncing ${pending.length} message(s)...`);
+            const byChat = /* @__PURE__ */ new Map();
+            for (const entry of pending) {
+              if (!byChat.has(entry.chat_id)) {
+                byChat.set(entry.chat_id, []);
+              }
+              byChat.get(entry.chat_id).push(entry);
+            }
+            let synced = 0;
+            let failed = 0;
+            for (const [chatId, entries] of byChat.entries()) {
+              for (let i = 0; i < entries.length; i += 50) {
+                const batch = entries.slice(i, i + 50);
+                try {
+                  await context.client.importChat({
+                    chat_id: chatId,
+                    messages: batch.map((e) => ({
+                      role: e.role,
+                      content: e.content,
+                      model: e.model
+                    }))
+                  });
+                  await journal.journalMarkSynced(batch.map((e) => e.id));
+                  synced += batch.length;
+                } catch (e) {
+                  context.addMessage(
+                    "error",
+                    `Error syncing batch from chat ${chatId}: ${String(e).slice(0, 100)}`
+                  );
+                  failed += batch.length;
+                }
+              }
+            }
+            context.addMessage("assistant", `Sync complete: ${synced} synced, ${failed} failed`);
+            break;
+          }
+          default:
+            context.addMessage("error", `Unknown sync subcommand: ${subcommand}
+Usage: /sync [status|push]`);
+        }
+      }
+    };
+  }
+});
+
+// ../core/src/diagnostics/specs.ts
+import { cpus as cpus2, totalmem as totalmem2, freemem as freemem2, platform as platform3, arch as arch2 } from "os";
+import { execSync } from "child_process";
+async function collectSpecs() {
+  const cpuList = cpus2();
+  const totalMemBytes = totalmem2();
+  const freeMemBytes = freemem2();
+  const specs = {
+    cpu: {
+      cores: cpuList.length,
+      model: cpuList[0]?.model ?? "Unknown",
+      speed: cpuList[0]?.speed ?? 0
+      // MHz -> convert below
+    },
+    memory: {
+      totalGB: Math.round(totalMemBytes / 1024 ** 3 * 10) / 10,
+      freeGB: Math.round(freeMemBytes / 1024 ** 3 * 10) / 10
+    },
+    gpu: [],
+    disk: {
+      freeGB: 0,
+      totalGB: 0
+    },
+    platform: platform3(),
+    arch: arch2(),
+    nodeVersion: process.version.slice(1)
+    // Remove 'v' prefix
+  };
+  specs.cpu.speed = Math.round(specs.cpu.speed / 1e3 * 10) / 10;
+  try {
+    const { statfs } = await import("fs/promises");
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "/";
+    const stat5 = await statfs(homeDir);
+    specs.disk.freeGB = Math.round(stat5.bavail * stat5.bsize / 1024 ** 3 * 10) / 10;
+    specs.disk.totalGB = Math.round(stat5.blocks * stat5.bsize / 1024 ** 3 * 10) / 10;
+  } catch {
+    specs.disk.freeGB = -1;
+    specs.disk.totalGB = -1;
+  }
+  specs.gpu = await detectGpu();
+  return specs;
+}
+async function detectGpu() {
+  const currentPlatform = platform3();
+  if (currentPlatform === "win32") {
+    return detectGpuWindows();
+  } else if (currentPlatform === "darwin") {
+    return detectGpuMacOS();
+  } else {
+    return detectGpuLinux();
+  }
+}
+function detectGpuWindows() {
+  try {
+    const output = execSync(
+      'powershell -Command "Get-CimInstance Win32_VideoController | Select-Object Name, AdapterRAM"',
+      { timeout: 2e3, encoding: "utf-8" }
+    );
+    const gpus = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+      const parts = line.trim().split(/\s{2,}/);
+      if (parts[0] && parts[0] !== "Name") {
+        const memBytes = parseInt(parts[1] || "0");
+        gpus.push({
+          name: parts[0],
+          memoryGB: memBytes > 0 ? Math.round(memBytes / 1024 ** 3 * 10) / 10 : void 0
+        });
+      }
+    }
+    return gpus;
+  } catch {
+    return [];
+  }
+}
+function detectGpuMacOS() {
+  try {
+    const output = execSync("system_profiler SPDisplaysDataType -json", {
+      timeout: 2e3,
+      encoding: "utf-8"
+    });
+    const data = JSON.parse(output);
+    const gpus = [];
+    const displays = data.SPDisplaysDataType || [];
+    for (const display of displays) {
+      const chips = display["sppci_model_name"];
+      if (chips) {
+        gpus.push({ name: chips });
+      }
+    }
+    return gpus;
+  } catch {
+    return [];
+  }
+}
+function detectGpuLinux() {
+  const gpus = [];
+  try {
+    const output = execSync(
+      "nvidia-smi --query-gpu=name,memory.total --format=csv,noheader",
+      { timeout: 2e3, encoding: "utf-8" }
+    );
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+      const [name, mem] = line.split(",");
+      const memGB = mem ? Math.round(parseInt(mem) / 1024 * 10) / 10 : void 0;
+      gpus.push({ name: name.trim(), memoryGB: memGB });
+    }
+    return gpus;
+  } catch {
+  }
+  try {
+    const output = execSync("rocm-smi --showproductname", {
+      timeout: 2e3,
+      encoding: "utf-8"
+    });
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+      if (line.includes("GPU")) {
+        const match = line.match(/:\s*(.+)/);
+        if (match) gpus.push({ name: match[1].trim() });
+      }
+    }
+    return gpus;
+  } catch {
+  }
+  try {
+    const output = execSync("lspci | grep -i vga", {
+      timeout: 2e3,
+      encoding: "utf-8"
+    });
+    const lines = output.trim().split("\n");
+    for (const line of lines) {
+      const match = line.match(/:\s*(.+)/);
+      if (match) gpus.push({ name: match[1].trim() });
+    }
+    return gpus;
+  } catch {
+    return [];
+  }
+}
+var init_specs = __esm({
+  "../core/src/diagnostics/specs.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// ../core/src/governor/ResourceGovernor.ts
+import { freemem as freemem3 } from "os";
+import { homedir as homedir18 } from "os";
+import { readFile as readFile23 } from "fs/promises";
+import { join as join29 } from "path";
+function determineTier(specs) {
+  const memGB = specs.memory.totalGB;
+  const cores = specs.cpu.cores;
+  if (memGB < 8 || cores < 4) return "T1";
+  if (memGB < 16 || cores < 8) return "T2";
+  if (memGB < 32 || cores < 16) return "T3";
+  return "T4";
+}
+function recommendLimits(specs) {
+  const tier = determineTier(specs);
+  return tierTable[tier];
+}
+async function readConfigOverrides() {
+  try {
+    const configPath = join29(homedir18(), ".msapling", "config.json");
+    const content = await readFile23(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.limits ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createResourceGovernor(specs) {
+  const recommended = recommendLimits(specs);
+  const overrides = await readConfigOverrides();
+  return new ResourceGovernor(recommended, overrides ?? void 0);
+}
+var tierTable, ResourceGovernor;
+var init_ResourceGovernor = __esm({
+  "../core/src/governor/ResourceGovernor.ts"() {
+    "use strict";
+    init_esm_shims();
+    tierTable = {
+      T1: { maxAgents: 1, maxParallelTools: 1, maxFileWatchers: 50, localLlmTier: "3B" },
+      T2: { maxAgents: 2, maxParallelTools: 4, maxFileWatchers: 200, localLlmTier: "7B" },
+      T3: { maxAgents: 4, maxParallelTools: 8, maxFileWatchers: 500, localLlmTier: "13B" },
+      T4: { maxAgents: 8, maxParallelTools: 16, maxFileWatchers: 2e3, localLlmTier: "32B+" }
+    };
+    ResourceGovernor = class {
+      activeAgents = 0;
+      maxAgents;
+      activeTool = 0;
+      maxParallelTools;
+      maxFileWatchers;
+      memoryWarningShown = false;
+      memoryCheckInterval = null;
+      minFreeMemGB = 1.5;
+      constructor(limits, overrides) {
+        this.maxAgents = overrides?.maxAgents ?? limits.maxAgents;
+        this.maxParallelTools = overrides?.maxParallelTools ?? limits.maxParallelTools;
+        this.maxFileWatchers = overrides?.maxFileWatchers ?? limits.maxFileWatchers;
+        this.startMemoryMonitor();
+      }
+      /**
+       * Monitor free memory every 5s; block new acquires if below threshold
+       */
+      startMemoryMonitor() {
+        this.memoryCheckInterval = setInterval(() => {
+          const freeMemBytes = freemem3();
+          const freeMemGB = freeMemBytes / 1024 ** 3;
+          if (freeMemGB < this.minFreeMemGB && !this.memoryWarningShown) {
+            console.warn(
+              `[ResourceGovernor] Low memory: ${freeMemGB.toFixed(2)}GB free (threshold: ${this.minFreeMemGB}GB)`
+            );
+            this.memoryWarningShown = true;
+          } else if (freeMemGB >= this.minFreeMemGB) {
+            this.memoryWarningShown = false;
+          }
+        }, 5e3);
+      }
+      /**
+       * Attempt to acquire an agent slot
+       */
+      acquireAgent() {
+        const freeMemGB = freemem3() / 1024 ** 3;
+        if (freeMemGB < this.minFreeMemGB) return false;
+        if (this.activeAgents >= this.maxAgents) return false;
+        this.activeAgents++;
+        return true;
+      }
+      /**
+       * Release an agent slot
+       */
+      releaseAgent() {
+        this.activeAgents = Math.max(0, this.activeAgents - 1);
+      }
+      /**
+       * Attempt to acquire a tool execution slot
+       */
+      acquireTool() {
+        const freeMemGB = freemem3() / 1024 ** 3;
+        if (freeMemGB < this.minFreeMemGB) return false;
+        if (this.activeTool >= this.maxParallelTools) return false;
+        this.activeTool++;
+        return true;
+      }
+      /**
+       * Release a tool execution slot
+       */
+      releaseTool() {
+        this.activeTool = Math.max(0, this.activeTool - 1);
+      }
+      /**
+       * Get current active counts
+       */
+      getStatus() {
+        return {
+          activeAgents: this.activeAgents,
+          activeTool: this.activeTool,
+          maxAgents: this.maxAgents,
+          maxParallelTools: this.maxParallelTools
+        };
+      }
+      /**
+       * Clean up monitor interval
+       */
+      destroy() {
+        if (this.memoryCheckInterval) {
+          clearInterval(this.memoryCheckInterval);
+          this.memoryCheckInterval = null;
+        }
+      }
+    };
+  }
+});
+
+// src/commands/diag.ts
+async function handler(args2, ctx) {
+  const jsonMode = args2.includes("json");
+  try {
+    const specs = await collectSpecs();
+    const recommended = recommendLimits(specs);
+    const tier = determineTier(specs);
+    const governor = await createResourceGovernor(specs);
+    const status = governor.getStatus();
+    governor.destroy();
+    if (jsonMode) {
+      const output = {
+        specs,
+        recommended,
+        tier,
+        status
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log("\n=== System Diagnostics ===\n");
+      console.log("CPU:");
+      console.log(`  Cores: ${specs.cpu.cores}`);
+      console.log(`  Model: ${specs.cpu.model}`);
+      console.log(`  Speed: ${specs.cpu.speed} GHz`);
+      console.log("\nMemory:");
+      console.log(`  Total: ${specs.memory.totalGB} GB`);
+      console.log(`  Free: ${specs.memory.freeGB} GB`);
+      console.log("\nGPU:");
+      if (specs.gpu.length === 0) {
+        console.log("  None detected");
+      } else {
+        for (const gpu of specs.gpu) {
+          console.log(`  ${gpu.name}${gpu.memoryGB ? ` (${gpu.memoryGB} GB)` : ""}`);
+        }
+      }
+      console.log("\nDisk:");
+      if (specs.disk.totalGB > 0) {
+        console.log(`  Total: ${specs.disk.totalGB} GB`);
+        console.log(`  Free: ${specs.disk.freeGB} GB`);
+      } else {
+        console.log("  Unavailable");
+      }
+      console.log("\nPlatform:");
+      console.log(`  OS: ${specs.platform}`);
+      console.log(`  Arch: ${specs.arch}`);
+      console.log(`  Node: ${specs.nodeVersion}`);
+      console.log("\n=== Resource Recommendations ===\n");
+      console.log(`Tier: ${tier}`);
+      console.log(`  Max Agents: ${recommended.maxAgents}`);
+      console.log(`  Max Parallel Tools: ${recommended.maxParallelTools}`);
+      console.log(`  Max File Watchers: ${recommended.maxFileWatchers}`);
+      console.log(`  Local LLM Tier: ${recommended.localLlmTier}`);
+      console.log("\n=== Current Active ===\n");
+      console.log(`Active Agents: ${status.activeAgents}/${status.maxAgents}`);
+      console.log(`Active Tools: ${status.activeTool}/${status.maxParallelTools}`);
+      console.log("\n");
+    }
+  } catch (error) {
+    ctx.addMessage("error", `[diag] Error: ${error instanceof Error ? error.message : error}`);
+  }
+}
+var diagCommand;
+var init_diag = __esm({
+  "src/commands/diag.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_specs();
+    init_ResourceGovernor();
+    diagCommand = {
+      name: "diag",
+      aliases: ["diagnostics"],
+      description: "Display system specs and resource limits",
+      category: "debug",
+      args: "[json]",
+      handler
+    };
+  }
+});
+
 // src/commands/index.ts
 var commands_exports = {};
 __export(commands_exports, {
@@ -12090,6 +13127,8 @@ var init_commands = __esm({
     init_mfa();
     init_mcp();
     init_webhook();
+    init_sync();
+    init_diag();
     commands = [
       loginCommand,
       unlockCommand,
@@ -12139,7 +13178,9 @@ var init_commands = __esm({
       mlineageCommand,
       mfaCommand,
       mcpCommand,
-      webhookCommand
+      webhookCommand,
+      syncCommand,
+      diagCommand
     ];
   }
 });
@@ -12210,15 +13251,15 @@ __export(exec_exports, {
   runExec: () => runExec
 });
 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";
+import { readFile as readFile25 } from "fs/promises";
+import { homedir as homedir19 } from "os";
+import { join as join30 } from "path";
 async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
-    const p = join27(homedir16(), ".msapling", "settings.json");
+    const p = join30(homedir19(), ".msapling", "settings.json");
     if (!existsSync26(p)) return out;
-    const raw = JSON.parse(await readFile23(p, "utf8"));
+    const raw = JSON.parse(await readFile25(p, "utf8"));
     const parsed = parseApprovalMode(raw, Date.now());
     if (parsed.kind === "ok") out.mode = parsed.mode;
     const themeRaw = raw?.theme;
@@ -12455,13 +13496,13 @@ var init_format = __esm({
 // src/commands/billing/open-browser.ts
 import { spawn as spawn10 } from "child_process";
 async function openBrowser(url) {
-  const platform4 = process.platform;
+  const platform5 = process.platform;
   let cmd;
   let args2;
-  if (platform4 === "win32") {
+  if (platform5 === "win32") {
     cmd = "cmd";
     args2 = ["/c", "start", "", url];
-  } else if (platform4 === "darwin") {
+  } else if (platform5 === "darwin") {
     cmd = "open";
     args2 = [url];
   } else {
@@ -13093,8 +14134,8 @@ var doctor_exports = {};
 __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
-import { homedir as homedir17, platform as platform3 } from "os";
-import { join as join28 } from "path";
+import { homedir as homedir20, platform as platform4 } from "os";
+import { join as join31 } from "path";
 import { existsSync as existsSync27, statSync as statSync6, accessSync } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { exec } from "child_process";
@@ -13118,7 +14159,7 @@ async function checkNodeVersion() {
   };
 }
 async function checkConfigDir() {
-  const configDir = join28(homedir17(), ".msapling");
+  const configDir = join31(homedir20(), ".msapling");
   if (!existsSync27(configDir)) {
     return {
       name: "Config directory",
@@ -13136,7 +14177,7 @@ async function checkConfigDir() {
       remediation: `rm "${configDir}" && mkdir -p "${configDir}"`
     };
   }
-  if (platform3() !== "win32") {
+  if (platform4() !== "win32") {
     const mode = stats.mode & 511;
     const safe = (mode & 63) === 0;
     if (!safe) {
@@ -13182,7 +14223,7 @@ async function checkKeytar() {
 }
 async function checkPathConflicts() {
   const pathEnv = process.env.PATH || "";
-  const paths = pathEnv.split(platform3() === "win32" ? ";" : ":");
+  const paths = pathEnv.split(platform4() === "win32" ? ";" : ":");
   const conflicts = [];
   for (const dir of paths) {
     if (!dir || !existsSync27(dir)) continue;
@@ -13190,7 +14231,7 @@ async function checkPathConflicts() {
       const files = await readdir3(dir);
       for (const file of files) {
         if (file === "msapling" || file === "msapling.exe" || file === "msapling.py") {
-          const fullPath = join28(dir, file);
+          const fullPath = join31(dir, file);
           conflicts.push(fullPath);
         }
       }
@@ -13290,11 +14331,11 @@ async function checkTokenValidity() {
   }
 }
 async function checkOsSpecific() {
-  if (platform3() === "win32") {
+  if (platform4() === "win32") {
     try {
-      const configDir = join28(homedir17(), ".msapling");
+      const configDir = join31(homedir20(), ".msapling");
       const longPath = "A".repeat(260);
-      const testPath = join28(configDir, longPath);
+      const testPath = join31(configDir, longPath);
       try {
         accessSync(configDir);
       } catch {
@@ -13319,14 +14360,14 @@ async function checkOsSpecific() {
       };
     }
   }
-  if (platform3() === "darwin") {
+  if (platform4() === "darwin") {
     return {
       name: "OS-specific (macOS)",
       status: "PASS",
       message: "macOS detected"
     };
   }
-  if (platform3() === "linux") {
+  if (platform4() === "linux") {
     try {
       await import("keytar");
       return {
@@ -13346,7 +14387,7 @@ async function checkOsSpecific() {
   return {
     name: "OS-specific",
     status: "PASS",
-    message: `${platform3()} detected`
+    message: `${platform4()} detected`
   };
 }
 function formatCheckResult(result, maxLabelWidth) {
@@ -14956,7 +15997,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 resolve18 } from "path";
+import { join as join32, relative as relative14, resolve as resolve18 } from "path";
 function asResult2(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
 }
@@ -14976,7 +16017,7 @@ function buildFileTree(root, maxFiles) {
     for (const name of entries) {
       if (out.length >= maxFiles) break;
       if (SKIP_DIRS2.has(name)) continue;
-      const full = join29(dir, name);
+      const full = join32(dir, name);
       let s;
       try {
         s = statSync7(full);
@@ -15742,7 +16783,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.28"
+    "2.3.6-beta.30"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -16266,9 +17307,9 @@ ${prompt4}` : prompt4;
           const filePath = mention.slice(1);
           try {
             const { existsSync: existsSync28 } = await import("fs");
-            const { readFile: readFile24 } = await import("fs/promises");
+            const { readFile: readFile26 } = await import("fs/promises");
             if (existsSync28(filePath)) {
-              const content = await readFile24(filePath, "utf8");
+              const content = await readFile26(filePath, "utf8");
               const MAX_LEN = 32768;
               const truncated = content.length > MAX_LEN ? content.slice(0, MAX_LEN) + "\n...[TRUNCATED]" : content;
               finalCmd += `
@@ -16320,7 +17361,7 @@ ${finalCmd}`;
 init_esm_shims();
 init_src3();
 init_parseApprovalMode();
-import { readFile as readFile22 } from "fs/promises";
+import { readFile as readFile24 } from "fs/promises";
 import { existsSync as existsSync25 } from "fs";
 async function initSession(ctx) {
   try {
@@ -16335,11 +17376,11 @@ async function initSession(ctx) {
       ctx.setShellEscapeEnabled(settings.shellEscapeEnabled !== false);
     }
     try {
-      const { homedir: homedir18 } = await import("os");
-      const { join: join31 } = await import("path");
-      const userSettingsPath = join31(homedir18(), ".msapling", "settings.json");
+      const { homedir: homedir21 } = await import("os");
+      const { join: join34 } = await import("path");
+      const userSettingsPath = join34(homedir21(), ".msapling", "settings.json");
       if (existsSync25(userSettingsPath)) {
-        const userText = await readFile22(userSettingsPath, "utf8");
+        const userText = await readFile24(userSettingsPath, "utf8");
         let parsed;
         try {
           parsed = JSON.parse(userText);
@@ -16644,12 +17685,12 @@ var App = ({ compact: compact2 = false }) => {
 init_esm_shims();
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join30 } from "path";
+import { dirname as dirname3, join as join33 } from "path";
 function readCliVersion2() {
   const here = dirname3(fileURLToPath2(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync3(join30(here, rel), "utf8"));
+      const pkg = JSON.parse(readFileSync3(join33(here, rel), "utf8"));
       if (pkg.name && pkg.version) {
         return { name: pkg.name, version: pkg.version };
       }
@@ -16735,11 +17776,11 @@ function handleCliArgs(args2) {
   }
   if (args2[0] === "mcp" && args2[1] === "serve") {
     (async () => {
-      const { MSaplingClient: MSaplingClient2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const { MSaplingClient: MSaplingClient3 } = await Promise.resolve().then(() => (init_src(), src_exports));
       const { runStdio: runStdio2 } = await Promise.resolve().then(() => (init_server(), server_exports));
       const apiUrl = process.env.MSAPLING_API_URL;
       const token = process.env.MSAPLING_TOKEN;
-      const client = new MSaplingClient2({ apiUrl, token });
+      const client = new MSaplingClient3({ apiUrl, token });
       await runStdio2(client);
     })().catch((e) => {
       process.stderr.write(`[msapling-mcp] fatal: ${e?.message ?? e}