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

package/dist/index.js

@@ -295,7 +295,15 @@ var init_localLlm = __esm({
 
 // ../api-client/src/journal.ts
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join2, dirname } from "path";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync
+} from "fs";
 function getJournal() {
   if (!journalInstance) {
     journalInstance = new Journal();
@@ -365,10 +373,39 @@ var init_journal = __esm({
         }
       }
       loadJsonl() {
+        try {
+          mkdirSync(dirname(this.jsonlPath), { recursive: true });
+        } catch (e) {
+          console.warn("[Journal] Failed to ensure journal dir", e);
+        }
+        if (!existsSync(this.jsonlPath)) return;
+        try {
+          const content = readFileSync(this.jsonlPath, "utf-8");
+          let malformed = 0;
+          for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+              this.jsonlEntries.push(JSON.parse(trimmed));
+            } catch {
+              malformed++;
+            }
+          }
+          if (malformed > 0) {
+            console.warn(`[Journal] Skipped ${malformed} malformed JSONL line(s)`);
+          }
+        } catch (e) {
+          console.warn("[Journal] Failed to load JSONL fallback", e);
+        }
       }
       async journalAppend(entry) {
         if (this.useJsonl) {
           this.jsonlEntries.push(entry);
+          try {
+            appendFileSync(this.jsonlPath, JSON.stringify(entry) + "\n", "utf8");
+          } catch (e) {
+            console.warn("[Journal] Failed to append JSONL entry", e);
+          }
         } else if (this.db) {
           try {
             const stmt = this.db.prepare(`
@@ -424,9 +461,18 @@ var init_journal = __esm({
       async journalMarkSynced(ids) {
         if (this.useJsonl) {
           const now = Date.now();
+          const idSet = new Set(ids);
           this.jsonlEntries = this.jsonlEntries.map(
-            (e) => ids.includes(e.id) ? { ...e, synced_at: now } : e
+            (e) => idSet.has(e.id) ? { ...e, synced_at: now } : e
           );
+          try {
+            const tmpPath = this.jsonlPath + ".tmp";
+            const body = this.jsonlEntries.map((e) => JSON.stringify(e)).join("\n") + (this.jsonlEntries.length > 0 ? "\n" : "");
+            writeFileSync(tmpPath, body, "utf8");
+            renameSync(tmpPath, this.jsonlPath);
+          } catch (e) {
+            console.warn("[Journal] Failed to persist mark-synced", e);
+          }
           return;
         }
         if (!this.db) return;
@@ -1309,11 +1355,16 @@ var init_src = __esm({
           body: JSON.stringify(params)
         });
       }
-      async *streamChat(params) {
+      async *streamChat(params, externalSignal) {
         if (!params.frame_id) {
           params = { ...params, frame_id: "earth_surface" };
         }
         const controller = new AbortController();
+        const externalAbortHandler = () => controller.abort();
+        if (externalSignal) {
+          if (externalSignal.aborted) controller.abort();
+          else externalSignal.addEventListener("abort", externalAbortHandler);
+        }
         const timeout = setTimeout(() => controller.abort(), 3e4);
         try {
           const headers = {
@@ -1378,11 +1429,15 @@ var init_src = __esm({
           }
         } catch (e) {
           if (e.name === "AbortError") {
+            if (externalSignal?.aborted) throw e;
             throw new MSaplingError("Request timed out after 30s.", 408, "timeout");
           }
           throw e;
         } finally {
           clearTimeout(timeout);
+          if (externalSignal) {
+            externalSignal.removeEventListener("abort", externalAbortHandler);
+          }
         }
       }
       /**
@@ -1420,7 +1475,7 @@ var init_BaseTool = __esm({
 // ../core/src/tools/ReadFileTool.ts
 import { resolve, normalize, relative, isAbsolute } from "path";
 import { readFile as readFile2 } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 var ReadFileTool;
 var init_ReadFileTool = __esm({
   "../core/src/tools/ReadFileTool.ts"() {
@@ -1463,7 +1518,7 @@ var init_ReadFileTool = __esm({
             };
           }
           const fullPath = normalizedTarget;
-          if (!existsSync(fullPath)) {
+          if (!existsSync2(fullPath)) {
             return { content: `Error: file not found: ${args2.path}`, isError: true };
           }
           const offset = args2.offset ? parseInt(args2.offset) : 0;
@@ -1545,7 +1600,7 @@ var init_EditFileTool = __esm({
 // ../core/src/tools/WriteFileTool.ts
 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 { existsSync as existsSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { randomBytes } from "crypto";
 var MAX_CONTENT_BYTES, WriteFileTool;
@@ -1620,7 +1675,7 @@ var init_WriteFileTool = __esm({
         }
         let backedUpTo = null;
         try {
-          if (existsSync2(resolvedTarget)) {
+          if (existsSync3(resolvedTarget)) {
             const existingContent = await readFile3(resolvedTarget, "utf8");
             const filename = resolvedTarget.split(/[\\/]/).pop() ?? "file";
             const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -2281,7 +2336,7 @@ var init_SubShellTool = __esm({
 // ../core/src/tools/SearchTools.ts
 import { spawn as spawn4 } from "child_process";
 import { readFile as readFile4, readdir, stat } from "fs/promises";
-import { existsSync as existsSync3, statSync } from "fs";
+import { existsSync as existsSync4, statSync } from "fs";
 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, "/");
@@ -2463,7 +2518,7 @@ var init_SearchTools = __esm({
             };
           }
           const candidate = normalizedTarget;
-          if (existsSync3(candidate) && statSync(candidate).isDirectory()) {
+          if (existsSync4(candidate) && statSync(candidate).isDirectory()) {
             scanRoot = candidate;
           } else {
             return {
@@ -2531,7 +2586,7 @@ var init_SearchTools = __esm({
           };
         }
         const searchPath = args2?.path ? join6(projectRoot, String(args2.path)) : projectRoot;
-        if (!existsSync3(searchPath)) {
+        if (!existsSync4(searchPath)) {
           return {
             content: `Error: path "${args2.path}" does not exist.`,
             isError: true
@@ -2591,7 +2646,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 join7, sep as sep2 } from "path";
-import { readdirSync, statSync as statSync2, existsSync as existsSync4 } from "fs";
+import { readdirSync, statSync as statSync2, existsSync as existsSync5 } from "fs";
 function humanSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -2686,7 +2741,7 @@ var init_ListDirectoryTool = __esm({
             isError: true
           };
         }
-        if (!existsSync4(normalizedTarget)) {
+        if (!existsSync5(normalizedTarget)) {
           return {
             content: `Error: path "${rawPath}" does not exist.`,
             isError: true
@@ -2928,7 +2983,7 @@ var init_TodoTools = __esm({
 // ../core/src/tools/PatchFileTool.ts
 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 { existsSync as existsSync6 } from "fs";
 import { homedir as homedir4 } from "os";
 import { randomBytes as randomBytes2 } from "crypto";
 var PatchFileTool;
@@ -2983,7 +3038,7 @@ var init_PatchFileTool = __esm({
           };
         }
         const resolvedTarget = normalizedTarget;
-        if (!existsSync5(resolvedTarget)) {
+        if (!existsSync6(resolvedTarget)) {
           return {
             content: `Error: file not found: ${args2.path}. Use write_file to create it first.`,
             isError: true
@@ -3672,7 +3727,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 readFile6 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 function joinSource(source) {
   return Array.isArray(source) ? source.join("") : source ?? "";
 }
@@ -3833,7 +3888,7 @@ var init_NotebookReadTool = __esm({
             isError: true
           };
         }
-        if (!existsSync6(absPath)) {
+        if (!existsSync7(absPath)) {
           return { content: `Error: file not found: ${absPath}`, isError: true };
         }
         let raw;
@@ -3897,7 +3952,7 @@ _(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 join10 } from "path";
 import { readFile as readFile7, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir5 } from "os";
 import { randomBytes as randomBytes3 } from "crypto";
 function normaliseSource(source) {
@@ -4027,7 +4082,7 @@ var init_NotebookEditTool = __esm({
             isError: true
           };
         }
-        if (!existsSync7(absPath)) {
+        if (!existsSync8(absPath)) {
           return { content: `Error: file not found: ${absPath}`, isError: true };
         }
         let rawJson;
@@ -4156,7 +4211,7 @@ Backup: ${backedUpTo}`;
 // ../core/src/tools/MultiEditFileTool.ts
 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 { existsSync as existsSync9 } from "fs";
 import { homedir as homedir6 } from "os";
 import { randomBytes as randomBytes4 } from "crypto";
 var MAX_EDITS, MultiEditFileTool;
@@ -4260,7 +4315,7 @@ var init_MultiEditFileTool = __esm({
           };
         }
         const resolvedTarget = normalizedTarget;
-        if (!existsSync8(resolvedTarget)) {
+        if (!existsSync9(resolvedTarget)) {
           return {
             content: `Error: file not found: ${args2.path}. Use write_file to create it first.`,
             isError: true
@@ -4355,9 +4410,9 @@ Pre-edit content backed up to: ${backedUpTo}`;
 });
 
 // ../core/src/tools/MoveFileTool.ts
-import { resolve as resolve11, normalize as normalize10, relative as relative11, isAbsolute as isAbsolute11, dirname } from "path";
+import { resolve as resolve11, normalize as normalize10, relative as relative11, isAbsolute as isAbsolute11, dirname as dirname2 } from "path";
 import { rename, mkdir as mkdir5, copyFile, rm, stat as stat2, readdir as readdir2 } from "fs/promises";
-import { existsSync as existsSync9, statSync as statSync3 } from "fs";
+import { existsSync as existsSync10, statSync as statSync3 } from "fs";
 import { randomBytes as randomBytes5 } from "crypto";
 function containedPath(p, root) {
   const abs = isAbsolute11(p) ? normalize10(p) : resolve11(root, p.trim());
@@ -4448,7 +4503,7 @@ var init_MoveFileTool = __esm({
           return { content: `Security Block: ${srcCheck.reason}.`, isError: true };
         }
         const absSrc = srcCheck.abs;
-        if (!existsSync9(absSrc)) {
+        if (!existsSync10(absSrc)) {
           return {
             content: `Error: source path "${args2.source}" does not exist.`,
             isError: true
@@ -4462,7 +4517,7 @@ var init_MoveFileTool = __esm({
           return { content: `Security Block: ${dstPrelimCheck.reason}.`, isError: true };
         }
         let absDst = dstPrelimCheck.abs;
-        if (existsSync9(absDst) && statSync3(absDst).isDirectory() && !srcIsDir) {
+        if (existsSync10(absDst) && statSync3(absDst).isDirectory() && !srcIsDir) {
           const srcName = absSrc.split(/[\\/]/).pop();
           absDst = resolve11(absDst, srcName);
           const rel2 = relative11(projectRoot, absDst);
@@ -4480,7 +4535,7 @@ var init_MoveFileTool = __esm({
           };
         }
         let backedUpTo = null;
-        if (existsSync9(absDst)) {
+        if (existsSync10(absDst)) {
           if (!overwrite) {
             return {
               content: `Error: destination "${args2.destination}" already exists. Pass \`overwrite: true\` to replace it.`,
@@ -4492,7 +4547,7 @@ var init_MoveFileTool = __esm({
           }
         }
         try {
-          await mkdir5(dirname(absDst), { recursive: true });
+          await mkdir5(dirname2(absDst), { recursive: true });
         } catch (e) {
           return {
             content: `Error: failed to create destination parent directory: ${e.message}`,
@@ -5176,119 +5231,428 @@ var init_Hooks = __esm({
   }
 });
 
-// ../core/src/agent/ToolExecutor.ts
-import { readFile as readFile9 } from "fs/promises";
-var APPROVAL_GATED, ToolExecutor;
-var init_ToolExecutor = __esm({
-  "../core/src/agent/ToolExecutor.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_ReadFileTool();
-    init_EditFileTool();
-    init_WriteFileTool();
-    init_RunCommandTool();
-    init_LSPTool();
-    init_SubShellTool();
-    init_SearchTools();
-    init_ListDirectoryTool();
-    init_TodoTools();
-    init_PatchFileTool();
-    init_DispatchAgentTool();
-    init_WebFetchTool();
-    init_BashTool();
-    init_NotebookReadTool();
-    init_NotebookEditTool();
-    init_MultiEditFileTool();
-    init_MoveFileTool();
-    init_DeleteFileTool();
-    init_MDrive();
-    init_Sandbox();
-    init_Voice();
-    init_ShadowService();
-    init_Hooks();
-    APPROVAL_GATED = /* @__PURE__ */ new Set(["run_command", "bash_command", "edit_file", "write_file", "patch_file", "multi_edit_file", "notebook_edit_cell", "move_file", "delete_file", "open_sub_shell"]);
-    ToolExecutor = class {
-      tools = /* @__PURE__ */ new Map();
-      sandbox;
-      mdrive;
-      voice;
-      shadow;
-      // CLI-TOOLS-ENABLED-DEFAULT-ON-01 (Iter 30): default to true so the CLI's
-      // 19 client-side tools are actually advertised to the backend in
-      // ChatMessagePayload.tools. Previously false, and nothing in the CLI ever
-      // called setToolsEnabled(true), so getToolSchemas() always returned [] and
-      // the LLM had no idea tools existed — which is why every chat refused
-      // file/shell access. Side effects are still gated by the permission mode
-      // (default prompts before each call) and the persistent trust store.
-      // Opt out via MSAPLING_TOOLS_ENABLED=false.
-      toolsEnabled = process.env.MSAPLING_TOOLS_ENABLED !== "false";
-      mode = "default";
-      approvalCallback = null;
-      /**
-       * CLI-PARITY-37: Two-tier trust set.
-       * `trustStore`    — optional persistent store loaded from ~/.msapling/settings.json;
-       *                   provides cross-session memory for "always" decisions.
-       * `sessionTrust`  — in-memory fallback for the current session when no
-       *                   TrustStore is wired (preserves old behaviour exactly).
-       */
-      trustStore = null;
-      sessionTrust = /* @__PURE__ */ new Set();
-      mcpRegistry = null;
-      hooks = null;
-      constructor(client, projectRoot) {
-        this.sandbox = new Sandbox(projectRoot);
-        this.mdrive = new MDriveService(client);
-        this.voice = new VoiceService();
-        this.shadow = new ShadowService(client);
-        this.registerTool(new ReadFileTool());
-        this.registerTool(new EditFileTool());
-        this.registerTool(new WriteFileTool());
-        this.registerTool(new RunCommandTool());
-        this.registerTool(new LSPTool());
-        this.registerTool(new SubShellTool());
-        this.registerTool(new GlobFilesTool());
-        this.registerTool(new GrepSearchTool());
-        this.registerTool(new ListDirectoryTool());
-        this.registerTool(new TodoWriteTool());
-        this.registerTool(new TodoReadTool());
-        this.registerTool(new PatchFileTool());
-        this.registerTool(new DispatchAgentTool({
-          client,
-          projectRoot
-        }));
-        this.registerTool(new WebFetchTool());
-        this.registerTool(new BashTool());
-        this.registerTool(new NotebookReadTool());
-        this.registerTool(new NotebookEditTool());
-        this.registerTool(new MultiEditFileTool());
-        this.registerTool(new MoveFileTool());
-        this.registerTool(new DeleteFileTool());
-      }
-      setToolsEnabled(enabled) {
-        this.toolsEnabled = enabled;
-      }
-      setMode(mode) {
-        this.mode = mode;
-      }
-      getMode() {
-        return this.mode;
-      }
-      setApprovalCallback(cb) {
-        this.approvalCallback = cb;
+// ../core/src/diagnostics/specs.ts
+var specs_exports = {};
+__export(specs_exports, {
+  collectSpecs: () => collectSpecs
+});
+import { cpus, totalmem, freemem, platform, arch } from "os";
+import { execSync } from "child_process";
+async function collectSpecs() {
+  const cpuList = cpus();
+  const totalMemBytes = totalmem();
+  const freeMemBytes = freemem();
+  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: platform(),
+    arch: arch(),
+    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 = platform();
+  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
+        });
       }
-      setMCPRegistry(registry) {
-        this.mcpRegistry = registry;
+    }
+    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 });
       }
-      setHookRunner(runner) {
-        this.hooks = runner;
+    }
+    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() });
       }
-      /**
-       * CLI-PARITY-37: Wire in a pre-loaded TrustStore so that "always" approval
-       * decisions survive CLI restarts.  Call this once at startup after `load()`
-       * has been awaited.
-       */
-      setTrustStore(store2) {
-        this.trustStore = store2;
+    }
+    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 freemem2 } from "os";
+import { homedir as homedir7 } from "os";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join14 } 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 = join14(homedir7(), ".msapling", "config.json");
+    const content = await readFile9(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);
+}
+async function getGlobalGovernor() {
+  if (globalGovernor) return globalGovernor;
+  if (!globalGovernorPromise) {
+    globalGovernorPromise = (async () => {
+      const { collectSpecs: collectSpecs2 } = await Promise.resolve().then(() => (init_specs(), specs_exports));
+      const specs = await collectSpecs2();
+      const g = await createResourceGovernor(specs);
+      globalGovernor = g;
+      return g;
+    })();
+  }
+  return globalGovernorPromise;
+}
+var tierTable, ResourceGovernor, globalGovernor, globalGovernorPromise;
+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;
+      agentWaiters = [];
+      toolWaiters = [];
+      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 = freemem2();
+          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);
+      }
+      /**
+       * Acquire an agent slot, awaiting if the cap is currently full.
+       * Low-memory state is logged via the monitor but does not block — the
+       * single-warning behavior is intentional (see startMemoryMonitor).
+       */
+      async acquireAgent() {
+        if (this.activeAgents < this.maxAgents) {
+          this.activeAgents++;
+          return;
+        }
+        await new Promise((resolve19) => this.agentWaiters.push(resolve19));
+        this.activeAgents++;
+      }
+      /**
+       * Release an agent slot
+       */
+      releaseAgent() {
+        this.activeAgents = Math.max(0, this.activeAgents - 1);
+        const next = this.agentWaiters.shift();
+        if (next) next();
+      }
+      /**
+       * Acquire a tool execution slot, awaiting if the cap is currently full.
+       */
+      async acquireTool() {
+        if (this.activeTool < this.maxParallelTools) {
+          this.activeTool++;
+          return;
+        }
+        await new Promise((resolve19) => this.toolWaiters.push(resolve19));
+        this.activeTool++;
+      }
+      /**
+       * Release a tool execution slot
+       */
+      releaseTool() {
+        this.activeTool = Math.max(0, this.activeTool - 1);
+        const next = this.toolWaiters.shift();
+        if (next) next();
+      }
+      /**
+       * 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;
+        }
+      }
+    };
+    globalGovernor = null;
+    globalGovernorPromise = null;
+  }
+});
+
+// ../core/src/agent/ToolExecutor.ts
+import { readFile as readFile10 } from "fs/promises";
+var APPROVAL_GATED, ToolExecutor;
+var init_ToolExecutor = __esm({
+  "../core/src/agent/ToolExecutor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ReadFileTool();
+    init_EditFileTool();
+    init_WriteFileTool();
+    init_RunCommandTool();
+    init_LSPTool();
+    init_SubShellTool();
+    init_SearchTools();
+    init_ListDirectoryTool();
+    init_TodoTools();
+    init_PatchFileTool();
+    init_DispatchAgentTool();
+    init_WebFetchTool();
+    init_BashTool();
+    init_NotebookReadTool();
+    init_NotebookEditTool();
+    init_MultiEditFileTool();
+    init_MoveFileTool();
+    init_DeleteFileTool();
+    init_MDrive();
+    init_Sandbox();
+    init_Voice();
+    init_ShadowService();
+    init_Hooks();
+    init_ResourceGovernor();
+    APPROVAL_GATED = /* @__PURE__ */ new Set(["run_command", "bash_command", "edit_file", "write_file", "patch_file", "multi_edit_file", "notebook_edit_cell", "move_file", "delete_file", "open_sub_shell"]);
+    ToolExecutor = class {
+      tools = /* @__PURE__ */ new Map();
+      sandbox;
+      mdrive;
+      voice;
+      shadow;
+      // CLI-TOOLS-ENABLED-DEFAULT-ON-01 (Iter 30): default to true so the CLI's
+      // 19 client-side tools are actually advertised to the backend in
+      // ChatMessagePayload.tools. Previously false, and nothing in the CLI ever
+      // called setToolsEnabled(true), so getToolSchemas() always returned [] and
+      // the LLM had no idea tools existed — which is why every chat refused
+      // file/shell access. Side effects are still gated by the permission mode
+      // (default prompts before each call) and the persistent trust store.
+      // Opt out via MSAPLING_TOOLS_ENABLED=false.
+      toolsEnabled = process.env.MSAPLING_TOOLS_ENABLED !== "false";
+      mode = "default";
+      approvalCallback = null;
+      /**
+       * CLI-PARITY-37: Two-tier trust set.
+       * `trustStore`    — optional persistent store loaded from ~/.msapling/settings.json;
+       *                   provides cross-session memory for "always" decisions.
+       * `sessionTrust`  — in-memory fallback for the current session when no
+       *                   TrustStore is wired (preserves old behaviour exactly).
+       */
+      trustStore = null;
+      sessionTrust = /* @__PURE__ */ new Set();
+      mcpRegistry = null;
+      hooks = null;
+      constructor(client, projectRoot) {
+        this.sandbox = new Sandbox(projectRoot);
+        this.mdrive = new MDriveService(client);
+        this.voice = new VoiceService();
+        this.shadow = new ShadowService(client);
+        this.registerTool(new ReadFileTool());
+        this.registerTool(new EditFileTool());
+        this.registerTool(new WriteFileTool());
+        this.registerTool(new RunCommandTool());
+        this.registerTool(new LSPTool());
+        this.registerTool(new SubShellTool());
+        this.registerTool(new GlobFilesTool());
+        this.registerTool(new GrepSearchTool());
+        this.registerTool(new ListDirectoryTool());
+        this.registerTool(new TodoWriteTool());
+        this.registerTool(new TodoReadTool());
+        this.registerTool(new PatchFileTool());
+        this.registerTool(new DispatchAgentTool({
+          client,
+          projectRoot
+        }));
+        this.registerTool(new WebFetchTool());
+        this.registerTool(new BashTool());
+        this.registerTool(new NotebookReadTool());
+        this.registerTool(new NotebookEditTool());
+        this.registerTool(new MultiEditFileTool());
+        this.registerTool(new MoveFileTool());
+        this.registerTool(new DeleteFileTool());
+      }
+      setToolsEnabled(enabled) {
+        this.toolsEnabled = enabled;
+      }
+      setMode(mode) {
+        this.mode = mode;
+      }
+      getMode() {
+        return this.mode;
+      }
+      setApprovalCallback(cb) {
+        this.approvalCallback = cb;
+      }
+      setMCPRegistry(registry) {
+        this.mcpRegistry = registry;
+      }
+      setHookRunner(runner) {
+        this.hooks = runner;
+      }
+      /**
+       * CLI-PARITY-37: Wire in a pre-loaded TrustStore so that "always" approval
+       * decisions survive CLI restarts.  Call this once at startup after `load()`
+       * has been awaited.
+       */
+      setTrustStore(store2) {
+        this.trustStore = store2;
         if (store2) {
           for (const key of this.sessionTrust) {
             store2.add(key).catch(() => {
@@ -5428,7 +5792,7 @@ ${blocker.stderr || "(empty)"}`,
         }
         await this.voice.speak(`Executing ${toolName}`, "natural");
         if (toolName === "edit_file") {
-          const content = await readFile9(args2.path, "utf-8");
+          const content = await readFile10(args2.path, "utf-8");
           const parentHash = await this.mdrive.getHash(content);
           const block = await this.mdrive.proposeRemoteEdit(
             args2.path,
@@ -5442,7 +5806,14 @@ ${blocker.stderr || "(empty)"}`,
 Please approve the diff in the UI to sync this change locally.`
           };
         }
-        const result = await tool.execute(args2, projectRoot);
+        const governor = await getGlobalGovernor();
+        await governor.acquireTool();
+        let result;
+        try {
+          result = await tool.execute(args2, projectRoot);
+        } finally {
+          governor.releaseTool();
+        }
         if (this.hooks) {
           this.hooks.fire({
             event: "post-tool-use",
@@ -5515,14 +5886,14 @@ var init_Safety = __esm({
 });
 
 // ../core/src/ProjectConfig.ts
-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 readFile10 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join15, dirname as dirname3, parse as parsePath } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile11 } from "fs/promises";
 async function readIfExists(path2) {
   try {
-    if (!existsSync10(path2)) return null;
-    const text = await readFile10(path2, "utf8");
+    if (!existsSync11(path2)) return null;
+    const text = await readFile11(path2, "utf8");
     return text.length > TRUNCATE_AT ? text.slice(0, TRUNCATE_AT) + "\n[...truncated]" : text;
   } catch {
     return null;
@@ -5530,7 +5901,7 @@ async function readIfExists(path2) {
 }
 async function findInDir(dir) {
   for (const filename of FILENAMES) {
-    const path2 = join14(dir, filename);
+    const path2 = join15(dir, filename);
     const content = await readIfExists(path2);
     if (content !== null) {
       return { path: path2, filename, content };
@@ -5543,7 +5914,7 @@ async function findProjectConfig(start) {
   for (let i = 0; i < 64; i++) {
     const hit = await findInDir(dir);
     if (hit) return hit;
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir || parent === parsePath(dir).root) {
       const rootHit = await findInDir(parent);
       return rootHit;
@@ -5553,9 +5924,9 @@ async function findProjectConfig(start) {
   return null;
 }
 async function findUserConfig() {
-  const home = homedir7();
+  const home = homedir8();
   if (!home) return null;
-  const userDir = join14(home, ".msapling");
+  const userDir = join15(home, ".msapling");
   return findInDir(userDir);
 }
 function buildCombined(user, project) {
@@ -5689,6 +6060,7 @@ var init_Agent = __esm({
     init_Hooks();
     init_ContextBudget();
     init_ToolExecutor();
+    init_ResourceGovernor();
     Agent = class {
       client;
       executor;
@@ -5784,6 +6156,15 @@ var init_Agent = __esm({
        * old backend versions or local/offline models that omit billing data).
        */
       async runWorkerTurn(chatId, prompt4, model, onContent) {
+        const governor = await getGlobalGovernor();
+        await governor.acquireAgent();
+        try {
+          return await this._runWorkerTurnInner(chatId, prompt4, model, onContent);
+        } finally {
+          governor.releaseAgent();
+        }
+      }
+      async _runWorkerTurnInner(chatId, prompt4, model, onContent) {
         if (this.hooks) {
           const outcomes = await this.hooks.fire({
             event: "user-prompt-submit",
@@ -5909,10 +6290,14 @@ ${next}`;
         const journal = getJournal();
         let backendReachable = false;
         let connectionTimeout = null;
+        const controller = new AbortController();
+        let timedOut = false;
         try {
-          const controller = new AbortController();
-          connectionTimeout = setTimeout(() => controller.abort(), 3e3);
-          const backendStream = this.client.streamChat(params);
+          connectionTimeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+          }, 3e3);
+          const backendStream = this.client.streamChat(params, controller.signal);
           for await (const chunk of backendStream) {
             if (connectionTimeout) {
               clearTimeout(connectionTimeout);
@@ -5922,11 +6307,8 @@ ${next}`;
             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");
+          const isAbortTimeout = timedOut || error?.name === "AbortError" && controller.signal.aborted;
+          const isNetworkError = isAbortTimeout || error?.code === "ECONNREFUSED" || error?.code === "ECONNRESET" || error?.code === "ETIMEDOUT" || error?.status >= 500;
           if (!isNetworkError) {
             throw error;
           }
@@ -6006,6 +6388,11 @@ ${next}`;
             source: `offline_${dialect}`
           };
           await journal.journalAppend(assistantEntry);
+        } finally {
+          if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+          }
         }
         if (backendReachable) {
           const pending = await journal.journalListPending();
@@ -6055,9 +6442,9 @@ ${next}`;
 });
 
 // ../core/src/HardwareMonitor.ts
-import { cpus, totalmem, freemem, platform, arch, release } from "os";
+import { cpus as cpus2, totalmem as totalmem2, freemem as freemem3, platform as platform2, arch as arch2, release as release2 } from "os";
 function cpuPercent() {
-  const all = cpus();
+  const all = cpus2();
   let idle = 0;
   let total = 0;
   for (const c of all) {
@@ -6069,12 +6456,12 @@ function cpuPercent() {
   return Math.round((1 - idle / total) * 100);
 }
 function takeSnapshot() {
-  const total = totalmem();
-  const free = freemem();
-  const cpuList = cpus();
+  const total = totalmem2();
+  const free = freemem3();
+  const cpuList = cpus2();
   return {
-    platform: platform(),
-    arch: arch(),
+    platform: platform2(),
+    arch: arch2(),
     cores: cpuList.length,
     cpuModel: cpuList[0]?.model ?? "unknown",
     ramGiB: Math.round(total / 1073741824 * 10) / 10,
@@ -6084,18 +6471,18 @@ function takeSnapshot() {
   };
 }
 function buildHwContext() {
-  const cpuList = cpus();
-  const totalMemBytes = totalmem();
+  const cpuList = cpus2();
+  const totalMemBytes = totalmem2();
   const totalMemGb = Math.round(totalMemBytes / 1073741824 * 100) / 100;
   return {
-    platform: platform(),
-    arch: arch(),
+    platform: platform2(),
+    arch: arch2(),
     cpu_model: cpuList[0]?.model ?? "unknown",
     cpu_count: cpuList.length,
     total_mem_gb: totalMemGb,
     node_version: process.version,
     bun_version: process.versions.bun,
-    os_release: release()
+    os_release: release2()
   };
 }
 var init_HardwareMonitor = __esm({
@@ -6144,17 +6531,17 @@ var init_Mutex = __esm({
 });
 
 // ../core/src/TrustStore.ts
-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 readFile11, writeFile as writeFile5, chmod } from "fs/promises";
+import { join as join16 } from "path";
+import { homedir as homedir9, platform as platform3 } from "os";
+import { existsSync as existsSync12, mkdirSync as mkdirSync2 } from "fs";
+import { readFile as readFile12, 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 = join15(homedir8(), ".msapling", "settings.json");
+    USER_SETTINGS_PATH = join16(homedir9(), ".msapling", "settings.json");
     TrustStore = class {
       /** Current in-memory set of trusted `tool:command` keys. */
       trusted = /* @__PURE__ */ new Set();
@@ -6171,8 +6558,8 @@ var init_TrustStore = __esm({
        */
       async readSettings() {
         try {
-          if (!existsSync11(this.settingsPath)) return {};
-          const text = await readFile11(this.settingsPath, "utf8");
+          if (!existsSync12(this.settingsPath)) return {};
+          const text = await readFile12(this.settingsPath, "utf8");
           if (!text.trim()) return {};
           return JSON.parse(text);
         } catch {
@@ -6184,10 +6571,10 @@ var init_TrustStore = __esm({
        * updating `trustedCommands`.
        */
       async writeSettings(settings) {
-        const dir = join15(homedir8(), ".msapling");
-        if (!existsSync11(dir)) mkdirSync(dir, { recursive: true });
+        const dir = join16(homedir9(), ".msapling");
+        if (!existsSync12(dir)) mkdirSync2(dir, { recursive: true });
         await writeFile5(this.settingsPath, JSON.stringify(settings, null, 2), "utf8");
-        if (platform2() !== "win32") {
+        if (platform3() !== "win32") {
           try {
             await chmod(this.settingsPath, 384);
           } catch {
@@ -7922,10 +8309,10 @@ var require_keytar2 = __commonJS({
 });
 
 // ../core/src/Storage.ts
-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 readFile12, appendFile } from "fs/promises";
+import { join as join17 } from "path";
+import { homedir as homedir10 } from "os";
+import { chmodSync, existsSync as existsSync13, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { mkdir as mkdir6, writeFile as writeFile6, readFile as readFile13, appendFile } from "fs/promises";
 import { randomBytes as randomBytes7, createHash as createHash3 } from "crypto";
 function hashLine(line) {
   return createHash3("sha256").update(line, "utf8").digest("hex");
@@ -7956,7 +8343,7 @@ var init_Storage = __esm({
        */
       _ready;
       constructor() {
-        this.baseDir = join16(homedir9(), ".msapling");
+        this.baseDir = join17(homedir10(), ".msapling");
         this._ready = this.ensureDirs();
       }
       async ensureDirs() {
@@ -7975,7 +8362,7 @@ var init_Storage = __esm({
             "cache/recipes/objects"
           ];
           for (const sub of subdirs) {
-            const path2 = join16(this.baseDir, sub);
+            const path2 = join17(this.baseDir, sub);
             await mkdir6(path2, { recursive: true });
           }
           if (process.platform !== "win32") {
@@ -7993,11 +8380,11 @@ var init_Storage = __esm({
         await this._ready;
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join16(this.baseDir, "vault", "token");
+        const filePath = join17(this.baseDir, "vault", "token");
         try {
           await keytar.setPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, token);
           try {
-            if (existsSync12(filePath)) {
+            if (existsSync13(filePath)) {
               unlinkSync(filePath);
             }
           } catch {
@@ -8013,7 +8400,7 @@ var init_Storage = __esm({
       async loadToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join16(this.baseDir, "vault", "token");
+        const filePath = join17(this.baseDir, "vault", "token");
         try {
           const keychainToken = await keytar.getPassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
           if (keychainToken) {
@@ -8022,8 +8409,8 @@ var init_Storage = __esm({
         } catch (e) {
           console.debug(`Keychain unavailable (${e instanceof Error ? e.message : String(e)}), falling back to file storage`);
         }
-        if (existsSync12(filePath)) {
-          const text = await readFile12(filePath, "utf8");
+        if (existsSync13(filePath)) {
+          const text = await readFile13(filePath, "utf8");
           return text.trim();
         }
         return null;
@@ -8034,14 +8421,14 @@ var init_Storage = __esm({
       async clearToken() {
         const KEYCHAIN_SERVICE = "msapling-cli";
         const KEYCHAIN_ACCOUNT = "auth_token";
-        const filePath = join16(this.baseDir, "vault", "token");
+        const filePath = join17(this.baseDir, "vault", "token");
         try {
           await keytar.deletePassword(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
         } catch (e) {
           console.debug(`Keychain unavailable for deletion (${e instanceof Error ? e.message : String(e)})`);
         }
         try {
-          if (existsSync12(filePath)) {
+          if (existsSync13(filePath)) {
             const fs3 = await import("fs/promises");
             await fs3.unlink(filePath);
           }
@@ -8073,15 +8460,15 @@ var init_Storage = __esm({
       async writeVaultRef(label, value) {
         await this._ready;
         const hash = createHash3("sha256").update(value, "utf8").digest("hex");
-        const objectPath = join16(this.baseDir, "vault", "objects", hash);
-        const refPath = join16(this.baseDir, "vault", "refs", label);
+        const objectPath = join17(this.baseDir, "vault", "objects", hash);
+        const refPath = join17(this.baseDir, "vault", "refs", label);
         const refTmp = `${refPath}.tmp`;
         await writeFile6(objectPath, value, "utf8");
         if (process.platform !== "win32") {
           chmodSync(objectPath, 384);
         }
         await writeFile6(refTmp, hash, "utf8");
-        renameSync(refTmp, refPath);
+        renameSync2(refTmp, refPath);
         return hash;
       }
       /**
@@ -8090,12 +8477,12 @@ var init_Storage = __esm({
        */
       async readVaultRef(label) {
         await this._ready;
-        const refPath = join16(this.baseDir, "vault", "refs", label);
-        if (!existsSync12(refPath)) return null;
-        const hash = (await readFile12(refPath, "utf8")).trim();
-        const objectPath = join16(this.baseDir, "vault", "objects", hash);
-        if (!existsSync12(objectPath)) return null;
-        return readFile12(objectPath, "utf8");
+        const refPath = join17(this.baseDir, "vault", "refs", label);
+        if (!existsSync13(refPath)) return null;
+        const hash = (await readFile13(refPath, "utf8")).trim();
+        const objectPath = join17(this.baseDir, "vault", "objects", hash);
+        if (!existsSync13(objectPath)) return null;
+        return readFile13(objectPath, "utf8");
       }
       // ─────────────────────────────────────────────────────────────────────────
       // CLI-ARCH-RECIPE-AT-HASH-URI-01 — recipe hash registry helpers
@@ -8118,23 +8505,23 @@ var init_Storage = __esm({
       async registerRecipe(name, content) {
         await this._ready;
         const hash = createHash3("sha256").update(content, "utf8").digest("hex");
-        const objectPath = join16(this.baseDir, "cache", "recipes", "objects", hash);
-        const indexPath = join16(this.baseDir, "cache", "recipes", "index.json");
+        const objectPath = join17(this.baseDir, "cache", "recipes", "objects", hash);
+        const indexPath = join17(this.baseDir, "cache", "recipes", "index.json");
         const indexTmp = `${indexPath}.tmp`;
-        if (!existsSync12(objectPath)) {
+        if (!existsSync13(objectPath)) {
           await writeFile6(objectPath, content, "utf8");
         }
         let index = {};
-        if (existsSync12(indexPath)) {
+        if (existsSync13(indexPath)) {
           try {
-            index = JSON.parse(await readFile12(indexPath, "utf8"));
+            index = JSON.parse(await readFile13(indexPath, "utf8"));
           } catch {
             index = {};
           }
         }
         index[name] = hash;
         await writeFile6(indexTmp, JSON.stringify(index, null, 2), "utf8");
-        renameSync(indexTmp, indexPath);
+        renameSync2(indexTmp, indexPath);
         return hash;
       }
       /**
@@ -8143,26 +8530,26 @@ var init_Storage = __esm({
        */
       async resolveRecipe(nameOrRef) {
         await this._ready;
-        const indexPath = join16(this.baseDir, "cache", "recipes", "index.json");
+        const indexPath = join17(this.baseDir, "cache", "recipes", "index.json");
         const atIdx = nameOrRef.indexOf("@");
         if (atIdx !== -1) {
           const hash2 = nameOrRef.slice(atIdx + 1);
-          const objectPath2 = join16(this.baseDir, "cache", "recipes", "objects", hash2);
-          if (!existsSync12(objectPath2)) return null;
-          return { hash: hash2, content: await readFile12(objectPath2, "utf8") };
+          const objectPath2 = join17(this.baseDir, "cache", "recipes", "objects", hash2);
+          if (!existsSync13(objectPath2)) return null;
+          return { hash: hash2, content: await readFile13(objectPath2, "utf8") };
         }
-        if (!existsSync12(indexPath)) return null;
+        if (!existsSync13(indexPath)) return null;
         let index;
         try {
-          index = JSON.parse(await readFile12(indexPath, "utf8"));
+          index = JSON.parse(await readFile13(indexPath, "utf8"));
         } catch {
           return null;
         }
         const hash = index[nameOrRef];
         if (!hash) return null;
-        const objectPath = join16(this.baseDir, "cache", "recipes", "objects", hash);
-        if (!existsSync12(objectPath)) return null;
-        return { hash, content: await readFile12(objectPath, "utf8") };
+        const objectPath = join17(this.baseDir, "cache", "recipes", "objects", hash);
+        if (!existsSync13(objectPath)) return null;
+        return { hash, content: await readFile13(objectPath, "utf8") };
       }
       // ─────────────────────────────────────────────────────────────────────────
       // CLI-ARCH-HASH-CHAIN-HISTORY-01 — append-only NDJSON history with hash chain
@@ -8184,18 +8571,18 @@ var init_Storage = __esm({
        */
       async appendHistoryEntry(content) {
         await this._ready;
-        const path2 = join16(this.baseDir, "history", "shell_history.jsonl");
+        const path2 = join17(this.baseDir, "history", "shell_history.jsonl");
         return this.historyMutex.run(async () => {
           let release3 = null;
           try {
-            if (!existsSync12(path2)) {
+            if (!existsSync13(path2)) {
               await writeFile6(path2, "", "utf8");
             }
             release3 = await lockfile.lock(path2, { retries: 5, retryWait: 50 });
             let prevHash = null;
             let seq = 1;
-            if (existsSync12(path2)) {
-              const raw = (await readFile12(path2, "utf8")).trimEnd();
+            if (existsSync13(path2)) {
+              const raw = (await readFile13(path2, "utf8")).trimEnd();
               if (raw.length > 0) {
                 const lines = raw.split("\n");
                 const lastLine = lines[lines.length - 1];
@@ -8234,9 +8621,9 @@ var init_Storage = __esm({
        */
       async loadHistoryEntries() {
         await this._ready;
-        const path2 = join16(this.baseDir, "history", "shell_history.jsonl");
-        if (!existsSync12(path2)) return [];
-        const raw = await readFile12(path2, "utf8");
+        const path2 = join17(this.baseDir, "history", "shell_history.jsonl");
+        if (!existsSync13(path2)) return [];
+        const raw = await readFile13(path2, "utf8");
         const entries = [];
         for (const line of raw.split("\n")) {
           if (!line.trim()) continue;
@@ -8284,20 +8671,20 @@ var init_Storage = __esm({
        */
       async saveHistory(history) {
         await this._ready;
-        const path2 = join16(this.baseDir, "history", "shell_history.json");
+        const path2 = join17(this.baseDir, "history", "shell_history.json");
         let release3;
         try {
-          if (!existsSync12(path2)) writeFileSync(path2, "[]", "utf8");
+          if (!existsSync13(path2)) writeFileSync2(path2, "[]", "utf8");
           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);
             await writeFile6(tmpPath, content, "utf8");
             try {
-              renameSync(tmpPath, path2);
+              renameSync2(tmpPath, path2);
             } catch (e) {
               try {
-                if (existsSync12(tmpPath)) {
+                if (existsSync13(tmpPath)) {
                   const fs3 = await import("fs/promises");
                   await fs3.unlink(tmpPath);
                 }
@@ -8325,27 +8712,27 @@ var init_Storage = __esm({
        */
       async loadHistory() {
         await this._ready;
-        const path2 = join16(this.baseDir, "history", "shell_history.json");
-        if (!existsSync12(path2)) return [];
+        const path2 = join17(this.baseDir, "history", "shell_history.json");
+        if (!existsSync13(path2)) return [];
         let release3;
         try {
           release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           return this.historyMutex.run(async () => {
-            if (existsSync12(path2)) {
-              const text = await readFile12(path2, "utf8");
+            if (existsSync13(path2)) {
+              const text = await readFile13(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 = join16(
+                const corruptBackupPath = join17(
                   this.baseDir,
                   "history",
                   `${filename}.corrupt.${stamp}-${suffix}.bak`
                 );
                 try {
-                  renameSync(path2, corruptBackupPath);
+                  renameSync2(path2, corruptBackupPath);
                   console.warn(`History file was corrupt; backed up to ${corruptBackupPath}`);
                 } catch (backupErr) {
                   console.error(`Failed to backup corrupt history file: ${backupErr}`);
@@ -8370,20 +8757,20 @@ var init_Storage = __esm({
        * R20-CLI-2: Typed with PermissionState from Sandbox.ts.
        */
       async savePermissions(permissions) {
-        const path2 = join16(this.baseDir, "vault", "permissions.json");
+        const path2 = join17(this.baseDir, "vault", "permissions.json");
         let release3;
         try {
-          if (!existsSync12(path2)) writeFileSync(path2, "{}", "utf8");
+          if (!existsSync13(path2)) writeFileSync2(path2, "{}", "utf8");
           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);
             await writeFile6(tmpPath, content, "utf8");
             try {
-              renameSync(tmpPath, path2);
+              renameSync2(tmpPath, path2);
             } catch (e) {
               try {
-                if (existsSync12(tmpPath)) {
+                if (existsSync13(tmpPath)) {
                   const fs3 = await import("fs/promises");
                   await fs3.unlink(tmpPath);
                 }
@@ -8407,27 +8794,27 @@ var init_Storage = __esm({
        * R20-CLI-2: Typed with PermissionState from Sandbox.ts.
        */
       async loadPermissions() {
-        const path2 = join16(this.baseDir, "vault", "permissions.json");
-        if (!existsSync12(path2)) return { trustedCommands: [], trustedPaths: [] };
+        const path2 = join17(this.baseDir, "vault", "permissions.json");
+        if (!existsSync13(path2)) return { trustedCommands: [], trustedPaths: [] };
         let release3;
         try {
           release3 = await lockfile.lock(path2, { realpath: false, retries: 5, retryWait: 50 });
           return this.permissionsMutex.run(async () => {
-            if (existsSync12(path2)) {
-              const text = await readFile12(path2, "utf8");
+            if (existsSync13(path2)) {
+              const text = await readFile13(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 = join16(
+                const corruptBackupPath = join17(
                   this.baseDir,
                   "vault",
                   `${filename}.corrupt.${stamp}-${suffix}.bak`
                 );
                 try {
-                  renameSync(path2, corruptBackupPath);
+                  renameSync2(path2, corruptBackupPath);
                   console.warn(`Permissions file was corrupt; backed up to ${corruptBackupPath}`);
                 } catch (backupErr) {
                   console.error(`Failed to backup corrupt permissions file: ${backupErr}`);
@@ -8458,7 +8845,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 = join16(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
+        const backupPath = join17(this.baseDir, "backups", `${filename}.backup-${stamp}-${suffix}.bak`);
         await writeFile6(backupPath, content, "utf8");
         if (process.platform !== "win32") {
           chmodSync(backupPath, 384);
@@ -8470,11 +8857,11 @@ var init_Storage = __esm({
 });
 
 // ../core/src/Settings.ts
-import { homedir as homedir10 } from "os";
-import { join as join17 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join18 } from "path";
+import { existsSync as existsSync14 } from "fs";
 import * as fs from "fs";
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 import { randomBytes as randomBytes8 } from "crypto";
 function ensureConfigDir(p) {
   try {
@@ -8495,8 +8882,8 @@ function ensureConfigDir(p) {
 }
 async function readJson(path2) {
   try {
-    if (!existsSync13(path2)) return null;
-    const text = await readFile13(path2, "utf8");
+    if (!existsSync14(path2)) return null;
+    const text = await readFile14(path2, "utf8");
     if (!text.trim()) return null;
     return JSON.parse(text);
   } catch {
@@ -8550,8 +8937,8 @@ function mergeSettings(base, override) {
 }
 async function loadSettings(cwd = process.cwd(), env = process.env, warn) {
   const sources = [];
-  const userPath = join17(homedir10() || ".", ".msapling", "settings.json");
-  const projectPath = join17(cwd, ".msapling", "settings.json");
+  const userPath = join18(homedir11() || ".", ".msapling", "settings.json");
+  const projectPath = join18(cwd, ".msapling", "settings.json");
   const [user, project] = await Promise.all([readJson(userPath), readJson(projectPath)]);
   if (user) sources.push(userPath);
   if (project) sources.push(projectPath);
@@ -9218,10 +9605,10 @@ var init_unlock = __esm({
 });
 
 // src/commands/doctor.ts
-import { homedir as homedir11 } from "os";
-import { join as join18 } from "path";
-import { existsSync as existsSync14 } from "fs";
-import { readFile as readFile14 } from "fs/promises";
+import { homedir as homedir12 } from "os";
+import { join as join19 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { readFile as readFile15 } from "fs/promises";
 async function checkApiHealth(client) {
   try {
     if (typeof client.request !== "function") {
@@ -9246,12 +9633,12 @@ async function checkAuthStatus(client) {
   }
 }
 async function checkSettingsFile() {
-  const settingsPath = join18(homedir11(), ".msapling", "settings.json");
+  const settingsPath = join19(homedir12(), ".msapling", "settings.json");
   try {
-    if (!existsSync14(settingsPath)) {
+    if (!existsSync15(settingsPath)) {
       return { ok: false, message: `Not found: ${settingsPath}` };
     }
-    const text = await readFile14(settingsPath, "utf8");
+    const text = await readFile15(settingsPath, "utf8");
     const parsed = JSON.parse(text);
     return { ok: true, message: `Valid JSON (${settingsPath})`, settings: parsed };
   } catch (e) {
@@ -9935,8 +10322,8 @@ var init_memories = __esm({
 });
 
 // src/commands/mdrive.ts
-import { readFile as readFile15, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { readFile as readFile16, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
 import { basename, resolve as resolve14 } from "path";
 function formatBytes(b) {
   if (!b) return "0";
@@ -9989,11 +10376,11 @@ var init_mdrive = __esm({
               return;
             }
             const absLocal = resolve14(local);
-            if (!existsSync15(absLocal)) {
+            if (!existsSync16(absLocal)) {
               context.addMessage("error", `Local file not found: ${absLocal}`);
               return;
             }
-            const content = await readFile15(absLocal, "utf8");
+            const content = await readFile16(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;
@@ -10086,15 +10473,15 @@ var init_clear = __esm({
 });
 
 // src/commands/mode.ts
-import { homedir as homedir12 } from "os";
-import { join as join19 } from "path";
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile16, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
+import { homedir as homedir13 } from "os";
+import { join as join20 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile17, writeFile as writeFile8, mkdir as mkdir7 } from "fs/promises";
 async function persistApprovalMode(mode, ttlMs) {
   try {
     let existing = {};
-    if (existsSync16(SETTINGS_PATH)) {
-      const text = await readFile16(SETTINGS_PATH, "utf8");
+    if (existsSync17(SETTINGS_PATH)) {
+      const text = await readFile17(SETTINGS_PATH, "utf8");
       if (text.trim()) {
         existing = JSON.parse(text);
       }
@@ -10105,8 +10492,8 @@ async function persistApprovalMode(mode, ttlMs) {
       ...ttlMs && { ttlMs }
     };
     existing.approvalMode = entry;
-    const settingsDir = join19(homedir12(), ".msapling");
-    if (!existsSync16(settingsDir)) {
+    const settingsDir = join20(homedir13(), ".msapling");
+    if (!existsSync17(settingsDir)) {
       await mkdir7(settingsDir, { recursive: true });
     }
     await writeFile8(SETTINGS_PATH, JSON.stringify(existing, null, 2), "utf8");
@@ -10118,7 +10505,7 @@ var init_mode = __esm({
   "src/commands/mode.ts"() {
     "use strict";
     init_esm_shims();
-    SETTINGS_PATH = join19(homedir12(), ".msapling", "settings.json");
+    SETTINGS_PATH = join20(homedir13(), ".msapling", "settings.json");
     modeCommand = {
       name: "mode",
       args: "[default|plan|acceptEdits|bypassPermissions] [...options]",
@@ -10520,8 +10907,8 @@ var init_compact = __esm({
 });
 
 // src/commands/init.ts
-import { join as join20 } from "path";
-import { existsSync as existsSync17 } from "fs";
+import { join as join21 } from "path";
+import { existsSync as existsSync18 } from "fs";
 import { writeFile as writeFile9 } from "fs/promises";
 var initCommand;
 var init_init = __esm({
@@ -10535,8 +10922,8 @@ var init_init = __esm({
       handler: async (args2, context) => {
         try {
           const cwd = process.cwd();
-          const path2 = join20(cwd, "MSAPLING.md");
-          if (existsSync17(path2)) {
+          const path2 = join21(cwd, "MSAPLING.md");
+          if (existsSync18(path2)) {
             context.addMessage("error", "MSAPLING.md already exists in current directory.");
             return;
           }
@@ -10562,8 +10949,8 @@ var init_init = __esm({
 });
 
 // src/commands/review.ts
-import { existsSync as existsSync18 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import { readFile as readFile18 } from "fs/promises";
 var reviewCommand;
 var init_review = __esm({
   "src/commands/review.ts"() {
@@ -10582,8 +10969,8 @@ var init_review = __esm({
         }
         let content = "";
         try {
-          if (existsSync18(target)) {
-            content = await readFile17(target, "utf8");
+          if (existsSync19(target)) {
+            content = await readFile18(target, "utf8");
           } else {
             content = `Review target: ${target}`;
           }
@@ -10676,15 +11063,15 @@ var init_swarm = __esm({
 
 // src/commands/recipe.ts
 import { parse as parseYaml } from "yaml";
-import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile18 } from "fs/promises";
-import { join as join21 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile19 } from "fs/promises";
+import { join as join22 } 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 = join21(cwd, dir, `${name}${suffix}${ext}`);
-        if (existsSync19(p)) return p;
+        const p = join22(cwd, dir, `${name}${suffix}${ext}`);
+        if (existsSync20(p)) return p;
       }
     }
   }
@@ -10743,7 +11130,7 @@ var init_recipe = __esm({
         let text;
         let recipe;
         try {
-          text = await readFile18(path2, "utf8");
+          text = await readFile19(path2, "utf8");
           recipe = parseYaml(text);
         } catch (e) {
           context.addMessage("error", `Failed to load ${path2}: ${e.message}`);
@@ -10797,13 +11184,13 @@ ${rendered}` : rendered;
 });
 
 // src/commands/skill.ts
-import { existsSync as existsSync20, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
-import { readFile as readFile19 } from "fs/promises";
-import { join as join22, resolve as resolve15 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync2, statSync as statSync5 } from "fs";
+import { readFile as readFile20 } from "fs/promises";
+import { join as join23, resolve as resolve15 } from "path";
 function findSkillsRoot(cwd) {
   for (const candidate of SKILLS_DIRS) {
     const full = resolve15(cwd, candidate);
-    if (existsSync20(full) && statSync5(full).isDirectory()) return full;
+    if (existsSync21(full) && statSync5(full).isDirectory()) return full;
   }
   return null;
 }
@@ -10816,7 +11203,7 @@ function listAllSkills(root) {
     return out;
   }
   for (const domain of domains) {
-    const dir = join22(root, domain);
+    const dir = join23(root, domain);
     let s;
     try {
       s = statSync5(dir);
@@ -10832,7 +11219,7 @@ function listAllSkills(root) {
     }
     for (const f of files) {
       if (!f.endsWith(".md")) continue;
-      out.push({ domain, name: f.slice(0, -3), path: join22(dir, f) });
+      out.push({ domain, name: f.slice(0, -3), path: join23(dir, f) });
     }
   }
   return out.sort(
@@ -10897,7 +11284,7 @@ var init_skill = __esm({
         }
         let body;
         try {
-          body = await readFile19(skill.path, "utf8");
+          body = await readFile20(skill.path, "utf8");
         } catch (e) {
           context.addMessage("error", `Failed to load skill ${skill.path}: ${e.message}`);
           return;
@@ -10921,9 +11308,9 @@ ${prompt4}`;
 });
 
 // src/commands/benchmark.ts
-import { homedir as homedir13 } from "os";
-import { join as join23 } from "path";
-import { mkdirSync as mkdirSync4 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join24 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
 import * as fs2 from "fs";
 function parseArgs(args2) {
   let models = null;
@@ -11042,10 +11429,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 = join23(homedir13(), ".msapling", "benchmarks");
-          mkdirSync4(dir, { recursive: true });
+          const dir = join24(homedir14(), ".msapling", "benchmarks");
+          mkdirSync5(dir, { recursive: true });
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-          const file = join23(dir, `${ts}.json`);
+          const file = join24(dir, `${ts}.json`);
           const run = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             rounds,
@@ -11291,22 +11678,22 @@ var init_theme = __esm({
 });
 
 // src/commands/theme.ts
-import { join as join24 } from "path";
-import { homedir as homedir14 } from "os";
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
+import { join as join25 } from "path";
+import { homedir as homedir15 } from "os";
+import { existsSync as existsSync22 } from "fs";
+import { readFile as readFile21, writeFile as writeFile10 } from "fs/promises";
 async function persistTheme(storage, themeName) {
-  const settingsPath = join24(homedir14(), ".msapling", "settings.json");
+  const settingsPath = join25(homedir15(), ".msapling", "settings.json");
   let existing = {};
   try {
-    if (existsSync21(settingsPath)) {
-      const text = await readFile20(settingsPath, "utf8");
+    if (existsSync22(settingsPath)) {
+      const text = await readFile21(settingsPath, "utf8");
       if (text.trim()) existing = JSON.parse(text);
     }
   } catch {
   }
   existing["theme"] = themeName;
-  ensureConfigDir(join24(homedir14(), ".msapling"));
+  ensureConfigDir(join25(homedir15(), ".msapling"));
   await writeFile10(settingsPath, JSON.stringify(existing, null, 2), "utf8");
 }
 var VALID_THEMES, themeCommand;
@@ -11378,7 +11765,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.30" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.31" : "(dev)";
         const coreVersion = true ? "2.3.2" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -11387,7 +11774,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-29T20:13:59.523Z";
+          const ts = "2026-05-30T19:14:27.313Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -11400,15 +11787,15 @@ var init_version = __esm({
 });
 
 // src/commands/feedback.ts
-import { join as join25 } from "path";
-import { existsSync as existsSync22 } from "fs";
-import { readFile as readFile21 } from "fs/promises";
+import { join as join26 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { readFile as readFile22 } from "fs/promises";
 async function readCliVersion() {
   try {
     const baseDir = typeof __dirname !== "undefined" ? __dirname : process.cwd();
-    const pkgPath = join25(baseDir, "..", "..", "package.json");
-    if (!existsSync22(pkgPath)) return "unknown";
-    const text = await readFile21(pkgPath, "utf8");
+    const pkgPath = join26(baseDir, "..", "..", "package.json");
+    if (!existsSync23(pkgPath)) return "unknown";
+    const text = await readFile22(pkgPath, "utf8");
     const json = JSON.parse(text);
     return json.version ?? "unknown";
   } catch {
@@ -11448,8 +11835,8 @@ var init_feedback = __esm({
 });
 
 // src/commands/export.ts
-import { homedir as homedir15 } from "os";
-import { join as join26 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join27 } 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);
@@ -11499,10 +11886,10 @@ var init_export = __esm({
         let outputPath;
         let content;
         if (arg === "" || arg === "json") {
-          outputPath = join26(homedir15(), `msapling-export-${timestamp}.json`);
+          outputPath = join27(homedir16(), `msapling-export-${timestamp}.json`);
           content = buildJsonExport(history);
         } else if (arg === "markdown" || arg === "md") {
-          outputPath = join26(homedir15(), `msapling-export-${timestamp}.md`);
+          outputPath = join27(homedir16(), `msapling-export-${timestamp}.md`);
           content = buildMarkdownExport(history);
         } else {
           outputPath = arg;
@@ -11514,7 +11901,7 @@ var init_export = __esm({
           }
         }
         try {
-          const dir = join26(outputPath, "..");
+          const dir = join27(outputPath, "..");
           await mkdir8(dir, { recursive: true });
           await writeFile11(outputPath, content, "utf8");
           context.addMessage("system", `Exported to: ${outputPath}`);
@@ -11709,17 +12096,17 @@ var init_plan = __esm({
 });
 
 // src/commands/note.ts
-import { homedir as homedir16 } from "os";
-import { join as join27 } from "path";
-import { existsSync as existsSync23 } from "fs";
-import { readFile as readFile22, writeFile as writeFile12 } from "fs/promises";
+import { homedir as homedir17 } from "os";
+import { join as join28 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile23, writeFile as writeFile12 } from "fs/promises";
 function getNotesFilePath() {
-  return join27(homedir16(), ".msapling", "notes.json");
+  return join28(homedir17(), ".msapling", "notes.json");
 }
 async function readNotes(filePath = getNotesFilePath()) {
   try {
-    if (!existsSync23(filePath)) return [];
-    const raw = await readFile22(filePath, "utf8");
+    if (!existsSync24(filePath)) return [];
+    const raw = await readFile23(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -11728,7 +12115,7 @@ async function readNotes(filePath = getNotesFilePath()) {
   }
 }
 async function writeNotes(notes, filePath = getNotesFilePath()) {
-  const dir = join27(homedir16(), ".msapling");
+  const dir = join28(homedir17(), ".msapling");
   ensureConfigDir(dir);
   await writeFile12(filePath, JSON.stringify(notes, null, 2), "utf8");
 }
@@ -11874,14 +12261,14 @@ var init_todo = __esm({
 });
 
 // src/commands/outputStyle.ts
-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";
+import { homedir as homedir18 } from "os";
+import { join as join29, basename as basename2, extname as extname3 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 function stylesDir() {
-  return join28(homedir17(), ".msapling", "output-styles");
+  return join29(homedir18(), ".msapling", "output-styles");
 }
 function activeFile() {
-  return join28(stylesDir(), ".active");
+  return join29(stylesDir(), ".active");
 }
 function parseStyleFile(text) {
   const fm = text.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
@@ -11902,13 +12289,13 @@ function parseStyleFile(text) {
 }
 function listUserStyles() {
   const dir = stylesDir();
-  if (!existsSync24(dir)) return [];
+  if (!existsSync25(dir)) return [];
   const out = [];
   for (const entry of readdirSync3(dir)) {
     if (extname3(entry).toLowerCase() !== ".md") continue;
-    const full = join28(dir, entry);
+    const full = join29(dir, entry);
     try {
-      const text = readFileSync(full, "utf8");
+      const text = readFileSync2(full, "utf8");
       const { description, body } = parseStyleFile(text);
       out.push({
         name: basename2(entry, ".md"),
@@ -11934,16 +12321,16 @@ function findStyle(name) {
 function getActiveStyleName() {
   try {
     const f = activeFile();
-    if (!existsSync24(f)) return "default";
-    return readFileSync(f, "utf8").trim() || "default";
+    if (!existsSync25(f)) return "default";
+    return readFileSync2(f, "utf8").trim() || "default";
   } catch {
     return "default";
   }
 }
 function setActiveStyleName(name) {
   const dir = stylesDir();
-  if (!existsSync24(dir)) mkdirSync5(dir, { recursive: true });
-  writeFileSync2(activeFile(), `${name}
+  if (!existsSync25(dir)) mkdirSync6(dir, { recursive: true });
+  writeFileSync3(activeFile(), `${name}
 `, "utf8");
 }
 function getActiveStyle() {
@@ -11955,14 +12342,14 @@ function createUserStyle(name, description, body) {
     throw new Error(`Invalid style name "${name}" \u2014 use letters, digits, _ and - only.`);
   }
   const dir = stylesDir();
-  if (!existsSync24(dir)) mkdirSync5(dir, { recursive: true });
-  const target = join28(dir, `${name}.md`);
+  if (!existsSync25(dir)) mkdirSync6(dir, { recursive: true });
+  const target = join29(dir, `${name}.md`);
   const frontmatter = `---
 description: ${description.replace(/\n/g, " ")}
 ---
 
 `;
-  writeFileSync2(target, frontmatter + body.trim() + "\n", "utf8");
+  writeFileSync3(target, frontmatter + body.trim() + "\n", "utf8");
   return target;
 }
 var BUILTIN_STYLES, outputStyleCommand;
@@ -12470,515 +12857,236 @@ var init_mfa = __esm({
       }
     };
   }
-});
-
-// src/commands/mcp.ts
-var mcpCommand;
-var init_mcp = __esm({
-  "src/commands/mcp.ts"() {
-    "use strict";
-    init_esm_shims();
-    mcpCommand = {
-      name: "mcp",
-      args: "[connect|invoke|tools|disconnect] [...args]",
-      description: "MCP client surface: connect, invoke, list tools, disconnect",
-      category: "config",
-      handler: async (args2, context) => {
-        const sub = (args2[0] ?? "tools").toLowerCase();
-        const rest = args2.slice(1);
-        try {
-          if (sub === "connect") {
-            const url = rest[0];
-            if (!url) {
-              context.addMessage("system", "Usage: /mcp connect <server-url>");
-              return;
-            }
-            const result = await context.client.mcpConnect(url);
-            context.addMessage("system", `MCP Connected: ${result.status ?? "ok"}`);
-            return;
-          }
-          if (sub === "tools") {
-            const tools = await context.client.mcpTools();
-            context.addMessage("system", "Available MCP Tools:");
-            if (Array.isArray(tools)) {
-              for (const tool of tools) {
-                context.addMessage("system", `  - ${tool.name}: ${tool.description ?? ""}`);
-              }
-            } else if (typeof tools === "object") {
-              context.addMessage("system", JSON.stringify(tools, null, 2));
-            }
-            return;
-          }
-          if (sub === "invoke") {
-            const method = rest[0];
-            if (!method) {
-              context.addMessage("system", "Usage: /mcp invoke <method> [args...]");
-              return;
-            }
-            const argsStr = rest.slice(1).join(" ");
-            let argsObj;
-            try {
-              argsObj = argsStr ? JSON.parse(argsStr) : void 0;
-            } catch {
-              argsObj = { raw: argsStr };
-            }
-            const result = await context.client.mcpInvoke(method, argsObj);
-            context.addMessage("system", `MCP Result: ${JSON.stringify(result)}`);
-            return;
-          }
-          if (sub === "disconnect") {
-            const result = await context.client.mcpDisconnect();
-            context.addMessage("system", `MCP Disconnected: ${result.status ?? "ok"}`);
-            return;
-          }
-          context.addMessage("error", `Unknown /mcp subcommand '${sub}'. Try: connect, tools, invoke, disconnect.`);
-        } catch (e) {
-          context.addMessage("error", `MCP: ${e.message}`);
-        }
-      }
-    };
-  }
-});
-
-// src/commands/webhook.ts
-var webhookCommand;
-var init_webhook = __esm({
-  "src/commands/webhook.ts"() {
-    "use strict";
-    init_esm_shims();
-    webhookCommand = {
-      name: "webhook",
-      args: "[list|add|rm|deliveries|retry] [...args]",
-      description: "Manage webhooks: create, list, delete, and view delivery logs",
-      category: "project",
-      handler: async (args2, context) => {
-        const sub = (args2[0] ?? "list").toLowerCase();
-        const rest = args2.slice(1);
-        try {
-          if (sub === "list") {
-            const webhooks = await context.client.listWebhooks();
-            context.addMessage("system", "Webhooks:");
-            if (Array.isArray(webhooks) && webhooks.length > 0) {
-              for (const wh of webhooks) {
-                const id = wh.id ?? wh.webhook_id ?? "?";
-                const url = wh.url ?? "?";
-                const events = wh.events ? wh.events.join(", ") : "";
-                context.addMessage("system", `  - ${id}: ${url} (${events})`);
-              }
-            } else {
-              context.addMessage("system", "  (no webhooks)");
-            }
-            return;
-          }
-          if (sub === "add") {
-            const url = rest[0];
-            const events = rest.slice(1);
-            if (!url || events.length === 0) {
-              context.addMessage("system", "Usage: /webhook add <url> <event1> [event2] ...");
-              return;
-            }
-            const result = await context.client.createWebhook(url, events);
-            const id = result.id ?? result.webhook_id ?? "?";
-            context.addMessage("system", `Webhook created: ${id} \u2192 ${url}`);
-            return;
-          }
-          if (sub === "rm" || sub === "delete") {
-            const id = rest[0];
-            if (!id) {
-              context.addMessage("system", "Usage: /webhook rm <id>");
-              return;
-            }
-            await context.client.deleteWebhook(id);
-            context.addMessage("system", `Deleted webhook: ${id}`);
-            return;
-          }
-          if (sub === "deliveries") {
-            const webhookId = rest[0] || void 0;
-            const deliveries = await context.client.listWebhookDeliveries(webhookId);
-            const title = webhookId ? `Deliveries for webhook ${webhookId}:` : "Recent deliveries:";
-            context.addMessage("system", title);
-            if (Array.isArray(deliveries) && deliveries.length > 0) {
-              for (const d of deliveries) {
-                const id = d.id ?? d.delivery_id ?? "?";
-                const status = d.status ?? "?";
-                const at = d.delivered_at ?? d.created_at ?? "?";
-                context.addMessage("system", `  - ${id}: ${status} (${at})`);
-              }
-            } else {
-              context.addMessage("system", "  (no deliveries)");
-            }
-            return;
-          }
-          if (sub === "retry") {
-            const deliveryId = rest[0];
-            if (!deliveryId) {
-              context.addMessage("system", "Usage: /webhook retry <delivery-id>");
-              return;
-            }
-            const result = await context.client.retryWebhookDelivery(deliveryId);
-            context.addMessage("system", `Retrying delivery: ${deliveryId} (${result.status ?? "queued"})`);
-            return;
-          }
-          context.addMessage("error", `Unknown /webhook subcommand '${sub}'. Try: list, add, rm, deliveries, retry.`);
-        } catch (e) {
-          context.addMessage("error", `Webhook: ${e.message}`);
-        }
-      }
-    };
-  }
-});
-
-// src/commands/sync.ts
-var syncCommand;
-var init_sync = __esm({
-  "src/commands/sync.ts"() {
+});
+
+// src/commands/mcp.ts
+var mcpCommand;
+var init_mcp = __esm({
+  "src/commands/mcp.ts"() {
     "use strict";
     init_esm_shims();
-    init_src();
-    syncCommand = {
-      name: "sync",
-      description: "Manage offline message sync (status|push)",
-      args: "[status|push]",
+    mcpCommand = {
+      name: "mcp",
+      args: "[connect|invoke|tools|disconnect] [...args]",
+      description: "MCP client surface: connect, invoke, list tools, disconnect",
       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;
+        const sub = (args2[0] ?? "tools").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "connect") {
+            const url = rest[0];
+            if (!url) {
+              context.addMessage("system", "Usage: /mcp connect <server-url>");
+              return;
             }
-            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, []);
+            const result = await context.client.mcpConnect(url);
+            context.addMessage("system", `MCP Connected: ${result.status ?? "ok"}`);
+            return;
+          }
+          if (sub === "tools") {
+            const tools = await context.client.mcpTools();
+            context.addMessage("system", "Available MCP Tools:");
+            if (Array.isArray(tools)) {
+              for (const tool of tools) {
+                context.addMessage("system", `  - ${tool.name}: ${tool.description ?? ""}`);
               }
-              byChat.get(entry.chat_id).push(entry);
+            } else if (typeof tools === "object") {
+              context.addMessage("system", JSON.stringify(tools, null, 2));
             }
-            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;
-                }
-              }
+            return;
+          }
+          if (sub === "invoke") {
+            const method = rest[0];
+            if (!method) {
+              context.addMessage("system", "Usage: /mcp invoke <method> [args...]");
+              return;
             }
-            context.addMessage("assistant", `Sync complete: ${synced} synced, ${failed} failed`);
-            break;
+            const argsStr = rest.slice(1).join(" ");
+            let argsObj;
+            try {
+              argsObj = argsStr ? JSON.parse(argsStr) : void 0;
+            } catch {
+              argsObj = { raw: argsStr };
+            }
+            const result = await context.client.mcpInvoke(method, argsObj);
+            context.addMessage("system", `MCP Result: ${JSON.stringify(result)}`);
+            return;
           }
-          default:
-            context.addMessage("error", `Unknown sync subcommand: ${subcommand}
-Usage: /sync [status|push]`);
+          if (sub === "disconnect") {
+            const result = await context.client.mcpDisconnect();
+            context.addMessage("system", `MCP Disconnected: ${result.status ?? "ok"}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /mcp subcommand '${sub}'. Try: connect, tools, invoke, disconnect.`);
+        } catch (e) {
+          context.addMessage("error", `MCP: ${e.message}`);
         }
       }
     };
   }
 });
 
-// ../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"() {
+// src/commands/webhook.ts
+var webhookCommand;
+var init_webhook = __esm({
+  "src/commands/webhook.ts"() {
     "use strict";
     init_esm_shims();
+    webhookCommand = {
+      name: "webhook",
+      args: "[list|add|rm|deliveries|retry] [...args]",
+      description: "Manage webhooks: create, list, delete, and view delivery logs",
+      category: "project",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list") {
+            const webhooks = await context.client.listWebhooks();
+            context.addMessage("system", "Webhooks:");
+            if (Array.isArray(webhooks) && webhooks.length > 0) {
+              for (const wh of webhooks) {
+                const id = wh.id ?? wh.webhook_id ?? "?";
+                const url = wh.url ?? "?";
+                const events = wh.events ? wh.events.join(", ") : "";
+                context.addMessage("system", `  - ${id}: ${url} (${events})`);
+              }
+            } else {
+              context.addMessage("system", "  (no webhooks)");
+            }
+            return;
+          }
+          if (sub === "add") {
+            const url = rest[0];
+            const events = rest.slice(1);
+            if (!url || events.length === 0) {
+              context.addMessage("system", "Usage: /webhook add <url> <event1> [event2] ...");
+              return;
+            }
+            const result = await context.client.createWebhook(url, events);
+            const id = result.id ?? result.webhook_id ?? "?";
+            context.addMessage("system", `Webhook created: ${id} \u2192 ${url}`);
+            return;
+          }
+          if (sub === "rm" || sub === "delete") {
+            const id = rest[0];
+            if (!id) {
+              context.addMessage("system", "Usage: /webhook rm <id>");
+              return;
+            }
+            await context.client.deleteWebhook(id);
+            context.addMessage("system", `Deleted webhook: ${id}`);
+            return;
+          }
+          if (sub === "deliveries") {
+            const webhookId = rest[0] || void 0;
+            const deliveries = await context.client.listWebhookDeliveries(webhookId);
+            const title = webhookId ? `Deliveries for webhook ${webhookId}:` : "Recent deliveries:";
+            context.addMessage("system", title);
+            if (Array.isArray(deliveries) && deliveries.length > 0) {
+              for (const d of deliveries) {
+                const id = d.id ?? d.delivery_id ?? "?";
+                const status = d.status ?? "?";
+                const at = d.delivered_at ?? d.created_at ?? "?";
+                context.addMessage("system", `  - ${id}: ${status} (${at})`);
+              }
+            } else {
+              context.addMessage("system", "  (no deliveries)");
+            }
+            return;
+          }
+          if (sub === "retry") {
+            const deliveryId = rest[0];
+            if (!deliveryId) {
+              context.addMessage("system", "Usage: /webhook retry <delivery-id>");
+              return;
+            }
+            const result = await context.client.retryWebhookDelivery(deliveryId);
+            context.addMessage("system", `Retrying delivery: ${deliveryId} (${result.status ?? "queued"})`);
+            return;
+          }
+          context.addMessage("error", `Unknown /webhook subcommand '${sub}'. Try: list, add, rm, deliveries, retry.`);
+        } catch (e) {
+          context.addMessage("error", `Webhook: ${e.message}`);
+        }
+      }
+    };
   }
 });
 
-// ../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"() {
+// src/commands/sync.ts
+var syncCommand;
+var init_sync = __esm({
+  "src/commands/sync.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;
+    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;
           }
-        }, 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;
+          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]`);
         }
       }
     };
@@ -12992,9 +13100,8 @@ async function handler(args2, ctx) {
     const specs = await collectSpecs();
     const recommended = recommendLimits(specs);
     const tier = determineTier(specs);
-    const governor = await createResourceGovernor(specs);
+    const governor = await getGlobalGovernor();
     const status = governor.getStatus();
-    governor.destroy();
     if (jsonMode) {
       const output = {
         specs,
@@ -13250,7 +13357,7 @@ var exec_exports = {};
 __export(exec_exports, {
   runExec: () => runExec
 });
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { readFile as readFile25 } from "fs/promises";
 import { homedir as homedir19 } from "os";
 import { join as join30 } from "path";
@@ -13258,7 +13365,7 @@ async function loadPersistedSettings() {
   const out = { mode: "default", theme: null };
   try {
     const p = join30(homedir19(), ".msapling", "settings.json");
-    if (!existsSync26(p)) return out;
+    if (!existsSync27(p)) return out;
     const raw = JSON.parse(await readFile25(p, "utf8"));
     const parsed = parseApprovalMode(raw, Date.now());
     if (parsed.kind === "ok") out.mode = parsed.mode;
@@ -14136,7 +14243,7 @@ __export(doctor_exports, {
 });
 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 { existsSync as existsSync28, statSync as statSync6, accessSync } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -14160,7 +14267,7 @@ async function checkNodeVersion() {
 }
 async function checkConfigDir() {
   const configDir = join31(homedir20(), ".msapling");
-  if (!existsSync27(configDir)) {
+  if (!existsSync28(configDir)) {
     return {
       name: "Config directory",
       status: "WARN",
@@ -14226,7 +14333,7 @@ async function checkPathConflicts() {
   const paths = pathEnv.split(platform4() === "win32" ? ";" : ":");
   const conflicts = [];
   for (const dir of paths) {
-    if (!dir || !existsSync27(dir)) continue;
+    if (!dir || !existsSync28(dir)) continue;
     try {
       const files = await readdir3(dir);
       for (const file of files) {
@@ -15996,7 +16103,7 @@ __export(server_exports, {
   runStdio: () => runStdio,
   runStdioWithRegistry: () => runStdioWithRegistry
 });
-import { readdirSync as readdirSync4, readFileSync as readFileSync2, statSync as statSync7 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync3, statSync as statSync7 } from "fs";
 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 } : {} };
@@ -16041,7 +16148,7 @@ function readFilesAsContext(root, files, maxKB) {
   for (const f of files) {
     let body;
     try {
-      body = readFileSync2(f, "utf8");
+      body = readFileSync3(f, "utf8");
     } catch {
       continue;
     }
@@ -16783,7 +16890,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.30"
+    "2.3.6-beta.31"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });
@@ -17306,9 +17413,9 @@ ${prompt4}` : prompt4;
         for (const mention of fileMentions) {
           const filePath = mention.slice(1);
           try {
-            const { existsSync: existsSync28 } = await import("fs");
+            const { existsSync: existsSync29 } = await import("fs");
             const { readFile: readFile26 } = await import("fs/promises");
-            if (existsSync28(filePath)) {
+            if (existsSync29(filePath)) {
               const content = await readFile26(filePath, "utf8");
               const MAX_LEN = 32768;
               const truncated = content.length > MAX_LEN ? content.slice(0, MAX_LEN) + "\n...[TRUNCATED]" : content;
@@ -17362,7 +17469,7 @@ init_esm_shims();
 init_src3();
 init_parseApprovalMode();
 import { readFile as readFile24 } from "fs/promises";
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 async function initSession(ctx) {
   try {
     const { settings } = await loadSettings(
@@ -17379,7 +17486,7 @@ async function initSession(ctx) {
       const { homedir: homedir21 } = await import("os");
       const { join: join34 } = await import("path");
       const userSettingsPath = join34(homedir21(), ".msapling", "settings.json");
-      if (existsSync25(userSettingsPath)) {
+      if (existsSync26(userSettingsPath)) {
         const userText = await readFile24(userSettingsPath, "utf8");
         let parsed;
         try {
@@ -17683,14 +17790,14 @@ var App = ({ compact: compact2 = false }) => {
 
 // src/runtime/bootstrap.ts
 init_esm_shims();
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join33 } from "path";
+import { dirname as dirname4, join as join33 } from "path";
 function readCliVersion2() {
-  const here = dirname3(fileURLToPath2(import.meta.url));
+  const here = dirname4(fileURLToPath2(import.meta.url));
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const pkg = JSON.parse(readFileSync3(join33(here, rel), "utf8"));
+      const pkg = JSON.parse(readFileSync4(join33(here, rel), "utf8"));
       if (pkg.name && pkg.version) {
         return { name: pkg.name, version: pkg.version };
       }