@wipcomputer/memory-crystal 0.7.34-alpha.2 → 0.7.34-alpha.4

package/dist/doctor.js

@@ -1,20 +1,485 @@
-import {
-  detectRole
-} from "./chunk-437F27T6.js";
-import {
-  isBridgeInstalled,
-  isBridgeRegistered
-} from "./chunk-AEWLSYPH.js";
-import {
-  ldmPaths,
-  resolveStatePath
-} from "./chunk-DFQ72B7M.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mlx-setup.ts
+var mlx_setup_exports = {};
+__export(mlx_setup_exports, {
+  MLX_CONFIG: () => MLX_CONFIG,
+  canRunMlx: () => canRunMlx,
+  createLaunchAgent: () => createLaunchAgent,
+  detectPlatform: () => detectPlatform,
+  doctorCheck: () => doctorCheck,
+  installMlxLm: () => installMlxLm,
+  isMlxLmInstalled: () => isMlxLmInstalled,
+  isServerRunning: () => isServerRunning,
+  setupMlx: () => setupMlx,
+  startServer: () => startServer,
+  stopServer: () => stopServer,
+  verifyServer: () => verifyServer
+});
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { join as join3 } from "path";
+import { homedir } from "os";
+function detectPlatform() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    return arch === "arm64" ? "apple-silicon" : "intel-mac";
+  }
+  if (platform === "linux") return "linux";
+  return "other";
+}
+function canRunMlx() {
+  return detectPlatform() === "apple-silicon";
+}
+function findPython() {
+  const candidates = ["python3", "/opt/homebrew/bin/python3", "/usr/local/bin/python3"];
+  for (const cmd of candidates) {
+    try {
+      const version = execSync3(`${cmd} --version 2>&1`, { encoding: "utf-8", timeout: 5e3 }).trim();
+      const match = version.match(/Python (\d+)\.(\d+)/);
+      if (match && parseInt(match[1]) >= 3 && parseInt(match[2]) >= 10) {
+        const realPath = execSync3(`which ${cmd} 2>/dev/null`, { encoding: "utf-8", timeout: 3e3 }).trim();
+        return realPath || cmd;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function findInstaller() {
+  try {
+    execSync3("uv --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
+    return "uv";
+  } catch {
+  }
+  try {
+    execSync3("pip3 --version 2>/dev/null", { encoding: "utf-8", timeout: 3e3 });
+    return "pip3";
+  } catch {
+  }
+  return null;
+}
+function isMlxLmInstalled() {
+  try {
+    execSync3('python3 -c "import mlx_lm" 2>/dev/null', { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installMlxLm(steps) {
+  const installer = findInstaller();
+  if (!installer) {
+    steps.push("No pip3 or uv found. Cannot install mlx-lm.");
+    return false;
+  }
+  const cmd = installer === "uv" ? "uv pip install mlx-lm" : "pip3 install mlx-lm";
+  steps.push(`Installing mlx-lm via ${installer}...`);
+  try {
+    execSync3(cmd, { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
+    steps.push("mlx-lm installed successfully.");
+    return true;
+  } catch (err) {
+    if (installer === "pip3") {
+      try {
+        execSync3("pip3 install --user mlx-lm", { encoding: "utf-8", timeout: 12e4, stdio: "pipe" });
+        steps.push("mlx-lm installed (--user) successfully.");
+        return true;
+      } catch {
+      }
+    }
+    steps.push(`mlx-lm install failed: ${err.message.slice(0, 200)}`);
+    return false;
+  }
+}
+function isServerRunning() {
+  try {
+    const state = loadState();
+    const port = state?.port || MLX_PORT;
+    execSync3(`curl -s -o /dev/null -w "%{http_code}" http://localhost:${port}/v1/models`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createLaunchAgent(pythonPath, steps) {
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${MLX_PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${pythonPath}</string>
+    <string>-m</string>
+    <string>mlx_lm.server</string>
+    <string>--model</string>
+    <string>${MLX_MODEL}</string>
+    <string>--port</string>
+    <string>${MLX_PORT}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${MLX_LOG_PATH}</string>
+  <key>StandardErrorPath</key>
+  <string>${MLX_LOG_PATH}</string>
+</dict>
+</plist>`;
+  try {
+    writeFileSync4(MLX_PLIST_PATH, plist);
+    execSync3(`launchctl load "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
+    steps.push(`LaunchAgent installed at ${MLX_PLIST_PATH}`);
+    steps.push(`MLX server will start on port ${MLX_PORT}`);
+    return true;
+  } catch (err) {
+    steps.push(`LaunchAgent install failed: ${err.message}`);
+    return false;
+  }
+}
+function startServer(steps) {
+  try {
+    execSync3(`launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL} 2>/dev/null`, { timeout: 1e4 });
+    steps.push("MLX server started.");
+    return true;
+  } catch {
+    steps.push("MLX server start failed. Check /tmp/mlx-server.log");
+    return false;
+  }
+}
+function stopServer() {
+  try {
+    execSync3(`launchctl unload "${MLX_PLIST_PATH}" 2>/dev/null`, { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function loadState() {
+  try {
+    if (existsSync4(MLX_STATE_FILE)) {
+      return JSON.parse(readFileSync4(MLX_STATE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveState(state) {
+  const dir = join3(HOME3, ".ldm", "state");
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync4(MLX_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+async function verifyServer(steps) {
+  const state = loadState();
+  const port = state?.port || MLX_PORT;
+  for (let i = 0; i < 15; i++) {
+    try {
+      const resp = await fetch(`http://localhost:${port}/v1/models`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        const model = data?.data?.[0]?.id || "unknown";
+        steps.push(`MLX server verified: ${model} on port ${port}`);
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  steps.push("MLX server did not respond within 30 seconds. Check /tmp/mlx-server.log");
+  return false;
+}
+async function setupMlx(options) {
+  const steps = [];
+  const platform = detectPlatform();
+  if (platform !== "apple-silicon") {
+    steps.push(`Platform: ${platform}. MLX requires Apple Silicon. Skipping.`);
+    return { ok: false, steps };
+  }
+  steps.push("Platform: Apple Silicon detected.");
+  const pythonPath = findPython();
+  if (!pythonPath) {
+    steps.push("Python 3.10+ not found. Install via: brew install python3");
+    return { ok: false, steps };
+  }
+  steps.push(`Python: ${pythonPath}`);
+  if (!isMlxLmInstalled()) {
+    if (!options?.yes) {
+      steps.push("mlx-lm not installed. Run with --yes to auto-install, or: pip3 install mlx-lm");
+      return { ok: false, steps };
+    }
+    const installed = installMlxLm(steps);
+    if (!installed) return { ok: false, steps };
+  } else {
+    steps.push("mlx-lm: already installed.");
+  }
+  if (!existsSync4(MLX_PLIST_PATH)) {
+    const created = createLaunchAgent(pythonPath, steps);
+    if (!created) return { ok: false, steps };
+  } else {
+    steps.push("LaunchAgent: already installed.");
+  }
+  saveState({
+    installed: true,
+    port: MLX_PORT,
+    model: MLX_MODEL,
+    pythonPath,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (!isServerRunning()) {
+    startServer(steps);
+    steps.push(`Waiting for model to load (~1.5 GB on first run)...`);
+    const verified = await verifyServer(steps);
+    if (!verified) {
+      steps.push("Server started but not yet responding. It may still be downloading the model.");
+      steps.push(`Check: tail -f ${MLX_LOG_PATH}`);
+    }
+  } else {
+    steps.push(`MLX server: already running on port ${MLX_PORT}`);
+  }
+  return { ok: true, steps };
+}
+function doctorCheck() {
+  const platform = detectPlatform();
+  if (platform !== "apple-silicon") {
+    return { status: "skip", detail: `${platform} (MLX requires Apple Silicon)` };
+  }
+  const state = loadState();
+  if (!state || !state.installed) {
+    return {
+      status: "warn",
+      detail: "not installed",
+      fix: "crystal init (will offer MLX setup)"
+    };
+  }
+  if (isServerRunning()) {
+    return { status: "ok", detail: `running on port ${state.port} (${state.model})` };
+  }
+  if (existsSync4(MLX_PLIST_PATH)) {
+    return {
+      status: "warn",
+      detail: "installed but not running",
+      fix: `launchctl kickstart -kp gui/$(id -u)/${MLX_PLIST_LABEL}`
+    };
+  }
+  return {
+    status: "warn",
+    detail: "installed but LaunchAgent missing",
+    fix: "crystal init (will recreate LaunchAgent)"
+  };
+}
+var HOME3, MLX_PORT, MLX_MODEL, MLX_STATE_FILE, MLX_PLIST_LABEL, MLX_PLIST_PATH, MLX_LOG_PATH, MLX_CONFIG;
+var init_mlx_setup = __esm({
+  "src/mlx-setup.ts"() {
+    "use strict";
+    HOME3 = homedir();
+    MLX_PORT = 18791;
+    MLX_MODEL = "mlx-community/Qwen2.5-3B-Instruct-4bit";
+    MLX_STATE_FILE = join3(HOME3, ".ldm", "state", "mlx-server.json");
+    MLX_PLIST_LABEL = "ai.ldm.mlx-server";
+    MLX_PLIST_PATH = join3(HOME3, "Library", "LaunchAgents", `${MLX_PLIST_LABEL}.plist`);
+    MLX_LOG_PATH = "/tmp/mlx-server.log";
+    MLX_CONFIG = {
+      port: MLX_PORT,
+      model: MLX_MODEL,
+      plistPath: MLX_PLIST_PATH,
+      logPath: MLX_LOG_PATH,
+      stateFile: MLX_STATE_FILE
+    };
+  }
+});
 
 // src/doctor.ts
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import { join as join4 } from "path";
+
+// src/role.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync, readdirSync } from "fs";
+import { join, dirname } from "path";
 import { execSync } from "child_process";
-import { join } from "path";
+import { fileURLToPath } from "url";
 var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function loadAgentConfig(id) {
+  const cfgPath = join(LDM_ROOT, "agents", id, "config.json");
+  try {
+    if (existsSync(cfgPath)) return JSON.parse(readFileSync(cfgPath, "utf-8"));
+  } catch {
+  }
+  return null;
+}
+function getAgentId(harnessHint) {
+  if (process.env.CRYSTAL_AGENT_ID) return process.env.CRYSTAL_AGENT_ID;
+  const agentsDir = join(LDM_ROOT, "agents");
+  if (existsSync(agentsDir)) {
+    try {
+      for (const d of readdirSync(agentsDir)) {
+        const cfg = loadAgentConfig(d);
+        if (!cfg || !cfg.agentId) continue;
+        if (!harnessHint) return cfg.agentId;
+        if (harnessHint === "claude-code" && cfg.harness === "claude-code-cli") return cfg.agentId;
+        if (harnessHint === "openclaw" && cfg.harness === "openclaw") return cfg.agentId;
+      }
+    } catch {
+    }
+  }
+  return harnessHint === "openclaw" ? "oc-lesa-mini" : "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals"),
+    workspace: join(agentRoot, "memory", "workspace")
+  };
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function resolveStatePath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.state, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "memory", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function resolveSecretPath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.secrets, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "secrets", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+
+// src/role.ts
+var STATE_FILE = "crystal-role.json";
+function loadRoleState() {
+  try {
+    const path = resolveStatePath(STATE_FILE);
+    if (existsSync2(path)) {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function hasLocalEmbeddingProvider() {
+  if (process.env.OPENAI_API_KEY) return true;
+  if (process.env.GOOGLE_API_KEY && process.env.CRYSTAL_EMBEDDING_PROVIDER === "google") return true;
+  if (process.env.CRYSTAL_EMBEDDING_PROVIDER === "ollama") return true;
+  return false;
+}
+function hasRelayKey() {
+  const keyPath = resolveSecretPath("crystal-relay-key");
+  return existsSync2(keyPath);
+}
+function detectRole() {
+  const agentId = getAgentId();
+  const paths = ldmPaths(agentId);
+  const relayUrl = process.env.CRYSTAL_RELAY_URL || null;
+  const relayToken = !!process.env.CRYSTAL_RELAY_TOKEN;
+  const relayKeyExists = hasRelayKey();
+  const localEmbeddings = hasLocalEmbeddingProvider();
+  const localDb = existsSync2(paths.crystalDb);
+  const state = loadRoleState();
+  if (state && state.override) {
+    return {
+      role: state.role,
+      source: "state-file",
+      relayUrl,
+      relayToken,
+      relayKeyExists,
+      agentId,
+      hasLocalEmbeddings: localEmbeddings,
+      hasLocalDb: localDb
+    };
+  }
+  let role = "core";
+  if ((relayUrl || relayKeyExists) && !localEmbeddings) {
+    role = "node";
+  } else if ((relayUrl || relayKeyExists) && localEmbeddings) {
+    role = "core";
+  }
+  return {
+    role,
+    source: "auto-detected",
+    relayUrl,
+    relayToken,
+    relayKeyExists,
+    agentId,
+    hasLocalEmbeddings: localEmbeddings,
+    hasLocalDb: localDb
+  };
+}
+
+// src/bridge.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join2 } from "path";
+var HOME2 = process.env.HOME || "";
+function _checkLocalBridge() {
+  if (existsSync3(join2(HOME2, ".openclaw", "extensions", "lesa-bridge", "dist", "index.js"))) return true;
+  if (existsSync3(join2(HOME2, ".ldm", "extensions", "lesa-bridge", "dist", "index.js"))) return true;
+  return false;
+}
+function isBridgeInstalled() {
+  try {
+    execSync2("which lesa 2>/dev/null", { encoding: "utf-8" });
+    return true;
+  } catch {
+    return _checkLocalBridge();
+  }
+}
+function isBridgeRegistered() {
+  const mcpPath = join2(HOME2, ".claude", ".mcp.json");
+  try {
+    if (existsSync3(mcpPath)) {
+      const config = JSON.parse(readFileSync3(mcpPath, "utf-8"));
+      if (config.mcpServers && config.mcpServers["lesa-bridge"]) return true;
+    }
+  } catch {
+  }
+  try {
+    const r = execSync2("claude mcp get lesa-bridge 2>&1", { encoding: "utf-8", timeout: 5e3 });
+    if (!r.includes("not found") && !r.includes("error")) return true;
+  } catch {
+  }
+  return false;
+}
+
+// src/doctor.ts
+var HOME4 = process.env.HOME || "";
 async function runDoctor() {
   const checks = [];
   const role = detectRole();
@@ -36,8 +501,8 @@ async function runDoctor() {
   checks.push(checkLdmDirectory(paths));
   checks.push(checkPrivateMode());
   try {
-    const { doctorCheck } = await import("./mlx-setup-XKU67WCT.js");
-    const mlx = doctorCheck();
+    const { doctorCheck: doctorCheck2 } = await Promise.resolve().then(() => (init_mlx_setup(), mlx_setup_exports));
+    const mlx = doctorCheck2();
     if (mlx.status !== "skip") {
       checks.push({ name: "MLX LLM", status: mlx.status, detail: mlx.detail, fix: mlx.fix });
     }
@@ -46,13 +511,13 @@ async function runDoctor() {
   return checks;
 }
 function checkOpEmbeddings() {
-  const saTokenLdm = join(HOME, ".ldm", "secrets", "op-sa-token");
-  const saTokenOc = join(HOME, ".openclaw", "secrets", "op-sa-token");
-  if (!existsSync(saTokenLdm) && !existsSync(saTokenOc)) return null;
-  const saTokenPath = existsSync(saTokenLdm) ? saTokenLdm : saTokenOc;
+  const saTokenLdm = join4(HOME4, ".ldm", "secrets", "op-sa-token");
+  const saTokenOc = join4(HOME4, ".openclaw", "secrets", "op-sa-token");
+  if (!existsSync5(saTokenLdm) && !existsSync5(saTokenOc)) return null;
+  const saTokenPath = existsSync5(saTokenLdm) ? saTokenLdm : saTokenOc;
   try {
-    const saToken = readFileSync(saTokenPath, "utf-8").trim();
-    const result = execSync('op read "op://Agent Secrets/OpenAI API/api key" 2>/dev/null', {
+    const saToken = readFileSync5(saTokenPath, "utf-8").trim();
+    const result = execSync4('op read "op://Agent Secrets/OpenAI API/api key" 2>/dev/null', {
       encoding: "utf-8",
       env: { ...process.env, OP_SERVICE_ACCOUNT_TOKEN: saToken },
       timeout: 1e4
@@ -71,12 +536,12 @@ function checkOpEmbeddings() {
   return null;
 }
 function checkVersion() {
-  const ldmExtPkg = join(HOME, ".ldm", "extensions", "memory-crystal", "package.json");
-  const ocExtPkg = join(HOME, ".openclaw", "extensions", "memory-crystal", "package.json");
+  const ldmExtPkg = join4(HOME4, ".ldm", "extensions", "memory-crystal", "package.json");
+  const ocExtPkg = join4(HOME4, ".openclaw", "extensions", "memory-crystal", "package.json");
   let installedVersion = null;
   try {
-    if (existsSync(ldmExtPkg)) {
-      const pkg = JSON.parse(readFileSync(ldmExtPkg, "utf-8"));
+    if (existsSync5(ldmExtPkg)) {
+      const pkg = JSON.parse(readFileSync5(ldmExtPkg, "utf-8"));
       installedVersion = pkg.version;
     }
   } catch {
@@ -91,8 +556,8 @@ function checkVersion() {
   }
   let ocVersion = null;
   try {
-    if (existsSync(ocExtPkg)) {
-      const pkg = JSON.parse(readFileSync(ocExtPkg, "utf-8"));
+    if (existsSync5(ocExtPkg)) {
+      const pkg = JSON.parse(readFileSync5(ocExtPkg, "utf-8"));
       ocVersion = pkg.version;
     }
   } catch {
@@ -114,10 +579,10 @@ function checkVersion() {
   };
 }
 function checkCCHook() {
-  const settingsPath = join(HOME, ".claude", "settings.json");
+  const settingsPath = join4(HOME4, ".claude", "settings.json");
   try {
-    if (existsSync(settingsPath)) {
-      const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (existsSync5(settingsPath)) {
+      const settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
       const stopHooks = settings?.hooks?.Stop;
       if (Array.isArray(stopHooks)) {
         const found = stopHooks.some((entry) => {
@@ -140,7 +605,7 @@ function checkCCHook() {
   };
 }
 async function checkDatabase(dbPath) {
-  if (!existsSync(dbPath)) {
+  if (!existsSync5(dbPath)) {
     return {
       name: "Database",
       status: "fail",
@@ -196,7 +661,7 @@ function checkEmbeddingProvider(role) {
 }
 function checkCaptureCron() {
   try {
-    const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    const crontab = execSync4("crontab -l 2>/dev/null", { encoding: "utf-8" });
     if (crontab.includes("crystal-capture")) {
       return { name: "Capture", status: "ok", detail: "cron installed" };
     }
@@ -232,26 +697,26 @@ function checkRelayConfig(role) {
 }
 function checkMcpServer() {
   const candidates = [
-    join(HOME, ".claude", ".mcp.json"),
+    join4(HOME4, ".claude", ".mcp.json"),
     // user-level (legacy)
-    join(HOME, ".openclaw", ".mcp.json"),
+    join4(HOME4, ".openclaw", ".mcp.json"),
     // OpenClaw project-level
-    join(process.cwd(), ".mcp.json")
+    join4(process.cwd(), ".mcp.json")
     // current project
   ];
   for (const mcpPath of candidates) {
     try {
-      if (existsSync(mcpPath)) {
-        const config = JSON.parse(readFileSync(mcpPath, "utf-8"));
+      if (existsSync5(mcpPath)) {
+        const config = JSON.parse(readFileSync5(mcpPath, "utf-8"));
         if (config.mcpServers && config.mcpServers["memory-crystal"]) {
-          return { name: "MCP Server", status: "ok", detail: `memory-crystal registered (${mcpPath.replace(HOME, "~")})` };
+          return { name: "MCP Server", status: "ok", detail: `memory-crystal registered (${mcpPath.replace(HOME4, "~")})` };
         }
       }
     } catch {
     }
   }
   try {
-    const result = execSync("claude mcp get memory-crystal 2>&1", { encoding: "utf-8", timeout: 5e3 });
+    const result = execSync4("claude mcp get memory-crystal 2>&1", { encoding: "utf-8", timeout: 5e3 });
     if (!result.includes("not found") && !result.includes("error")) {
       return { name: "MCP Server", status: "ok", detail: "memory-crystal registered (user scope)" };
     }
@@ -265,21 +730,21 @@ function checkMcpServer() {
   };
 }
 function checkBackup() {
-  const plistPath = join(HOME, "Library", "LaunchAgents", "ai.openclaw.ldm-backup.plist");
-  if (existsSync(plistPath)) {
+  const plistPath = join4(HOME4, "Library", "LaunchAgents", "ai.openclaw.ldm-backup.plist");
+  if (existsSync5(plistPath)) {
     return { name: "Backup", status: "ok", detail: "LaunchAgent installed" };
   }
   try {
-    const crontab = execSync("crontab -l 2>/dev/null", { encoding: "utf-8" });
+    const crontab = execSync4("crontab -l 2>/dev/null", { encoding: "utf-8" });
     if (crontab.includes("ldm-backup") || crontab.includes("LDMDevTools") && crontab.includes("backup")) {
       return { name: "Backup", status: "ok", detail: "cron installed" };
     }
   } catch {
   }
-  const backupsDir = join(HOME, ".ldm", "backups");
-  if (existsSync(backupsDir)) {
+  const backupsDir = join4(HOME4, ".ldm", "backups");
+  if (existsSync5(backupsDir)) {
     try {
-      const entries = readdirSync(backupsDir).filter((e) => !e.startsWith("."));
+      const entries = readdirSync2(backupsDir).filter((e) => !e.startsWith("."));
       if (entries.length > 0) return { name: "Backup", status: "ok", detail: `${entries.length} backup(s) in ~/.ldm/backups/` };
     } catch {
     }
@@ -309,11 +774,11 @@ function checkBridge() {
 }
 function checkLdmDirectory(paths) {
   const missing = [];
-  if (!existsSync(paths.root)) missing.push("~/.ldm");
-  if (!existsSync(join(paths.root, "memory"))) missing.push("memory/");
-  if (!existsSync(paths.state)) missing.push("state/");
-  if (!existsSync(paths.bin)) missing.push("bin/");
-  if (!existsSync(paths.transcripts)) missing.push("transcripts/");
+  if (!existsSync5(paths.root)) missing.push("~/.ldm");
+  if (!existsSync5(join4(paths.root, "memory"))) missing.push("memory/");
+  if (!existsSync5(paths.state)) missing.push("state/");
+  if (!existsSync5(paths.bin)) missing.push("bin/");
+  if (!existsSync5(paths.transcripts)) missing.push("transcripts/");
   if (missing.length === 0) {
     return { name: "LDM Directory", status: "ok", detail: "intact" };
   }
@@ -327,8 +792,8 @@ function checkLdmDirectory(paths) {
 function checkPrivateMode() {
   const statePath = resolveStatePath("memory-capture-state.json");
   try {
-    if (existsSync(statePath)) {
-      const state = JSON.parse(readFileSync(statePath, "utf-8"));
+    if (existsSync5(statePath)) {
+      const state = JSON.parse(readFileSync5(statePath, "utf-8"));
       if (state.enabled === false) {
         return { name: "Private Mode", status: "warn", detail: "capture disabled (private mode ON)" };
       }