@askexenow/exe-os 0.9.279 → 0.9.281

package/dist/chunk-DIAOAGZ6.js

@@ -0,0 +1,38 @@
+import {
+  listReminders
+} from "./chunk-YWN6DKZJ.js";
+
+// src/mcp/tools/list-reminders.ts
+import { z } from "zod";
+function registerListReminders(server) {
+  server.registerTool(
+    "list_reminders",
+    {
+      title: "List Reminders",
+      description: "List active reminders. Pass include_completed=true to see all.",
+      inputSchema: {
+        include_completed: z.boolean().optional().default(false).describe("Include completed reminders")
+      }
+    },
+    async ({ include_completed }) => {
+      const reminders = await listReminders(include_completed);
+      if (reminders.length === 0) {
+        return {
+          content: [{ type: "text", text: "No active reminders." }]
+        };
+      }
+      const lines = reminders.map((r) => {
+        const due = r.dueDate ? ` (due: ${r.dueDate})` : "";
+        const done = r.completedAt ? " [DONE]" : "";
+        return `\u2022 ${r.text}${due}${done}  [id: ${r.id.slice(0, 8)}]`;
+      });
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+export {
+  registerListReminders
+};

package/dist/chunk-DJ2MBAAF.js

@@ -0,0 +1,280 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-X46O77S4.js";
+
+// src/lib/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+function getGitRoot(dir) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return realpath(root);
+  } catch {
+    return null;
+  }
+}
+function getMainRepoRoot(dir) {
+  try {
+    const commonDir = execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return realpath(path.dirname(commonDir));
+  } catch {
+    return null;
+  }
+}
+function worktreePath(repoRoot, employeeName, instance) {
+  const label = instanceLabel(employeeName, instance);
+  return path.join(repoRoot, ".worktrees", label);
+}
+function worktreeBranch(employeeName, instance, taskSlug) {
+  const label = instanceLabel(employeeName, instance);
+  if (taskSlug) {
+    const slug = taskSlug.slice(0, 40).replace(/[^a-z0-9-]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+    return `${label}-${slug}`;
+  }
+  return `${label}-work`;
+}
+function instanceLabel(name, instance) {
+  return instance != null && instance > 0 ? `${name}${instance}` : name;
+}
+function ensureWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getGitRoot(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  mkdirSync(worktreesDir, { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  const branchExists = branchExistsLocally(repoRoot, branch);
+  try {
+    if (branchExists) {
+      execSync(`git worktree add "${wtPath}" "${branch}"`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } else {
+      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function isWorktreeDirty(wtPath) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: wtPath,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return true;
+  }
+}
+function cleanupWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getMainRepoRoot(projectDir);
+  if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (!existsSync(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree does not exist", branch }
+    });
+    return { cleaned: false, reason: "worktree does not exist" };
+  }
+  if (isWorktreeDirty(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree has uncommitted changes", branch }
+    });
+    return { cleaned: false, reason: "worktree has uncommitted changes" };
+  }
+  const mainBranch = detectMainBranch(repoRoot);
+  if (!mainBranch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "could not determine main branch", branch }
+    });
+    return { cleaned: false, reason: "could not determine main branch" };
+  }
+  if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "branch not merged", branch, mainBranch }
+    });
+    return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
+  }
+  try {
+    execSync(`git worktree remove "${wtPath}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.cleanupWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_remove_failed",
+      payload: { branch, mainBranch }
+    });
+    return {
+      cleaned: false,
+      reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    execSync(`git branch -d "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "worktree.pruned",
+    source: "worktree.cleanupWorktree",
+    agentId: employeeName,
+    instanceId: instance != null ? String(instance) : null,
+    payload: { branch, mainBranch }
+  });
+  return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
+}
+function branchExistsLocally(repoRoot, branch) {
+  try {
+    execSync(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    if (branchExistsLocally(repoRoot, candidate)) return candidate;
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function ensureGitignoreEntry(repoRoot, entry) {
+  try {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `
+# Agent worktrees (exe-os)
+${entry}
+`);
+    } else {
+    }
+  } catch {
+  }
+}
+
+export {
+  getGitRoot,
+  getMainRepoRoot,
+  worktreePath,
+  worktreeBranch,
+  ensureWorktree,
+  isWorktreeDirty,
+  cleanupWorktree
+};

package/dist/chunk-DKH2VU3V.js

@@ -0,0 +1,97 @@
+import {
+  loadEmployeesSync
+} from "./chunk-ZJP3ZONM.js";
+
+// src/adapters/mcp-http-config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
+import { execFileSync } from "child_process";
+import path from "path";
+import os from "os";
+var DEFAULT_MCP_HTTP_PORT = "48739";
+function resolveDefaultAgentId() {
+  if (process.env.AGENT_ID && process.env.AGENT_ID !== "default") return process.env.AGENT_ID;
+  try {
+    const coo = loadEmployeesSync().find((e) => e.role === "COO");
+    if (coo) return coo.name;
+  } catch {
+  }
+  return "exe";
+}
+var DEFAULT_MCP_HTTP_AGENT_ID = resolveDefaultAgentId();
+var DEFAULT_MCP_HTTP_AGENT_ROLE = "COO";
+function mcpHttpPort() {
+  const raw = process.env.EXE_MCP_PORT?.trim();
+  if (!raw) return DEFAULT_MCP_HTTP_PORT;
+  if (!/^\d+$/.test(raw)) return DEFAULT_MCP_HTTP_PORT;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return DEFAULT_MCP_HTTP_PORT;
+  return raw;
+}
+function mcpHttpUrl() {
+  return `http://127.0.0.1:${mcpHttpPort()}/mcp`;
+}
+function readOrCreateDaemonToken(homeDir = os.homedir()) {
+  const exeDir = path.join(homeDir, ".exe-os");
+  const tokenPath = path.join(exeDir, "exed.token");
+  if (existsSync(tokenPath)) {
+    try {
+      const token2 = readFileSync(tokenPath, "utf-8").trim();
+      if (/^[a-f0-9]{64}$/i.test(token2)) return token2;
+    } catch {
+    }
+  }
+  const token = randomBytes(32).toString("hex");
+  mkdirSync(exeDir, { recursive: true });
+  writeFileSync(tokenPath, `${token}
+`, "utf-8");
+  try {
+    chmodSync(tokenPath, 384);
+  } catch {
+  }
+  return token;
+}
+function buildMcpHttpHeaders(homeDir = os.homedir(), opts = {}) {
+  const agentId = opts.useShellPlaceholders ? "${AGENT_ID:-exe}" : opts.agentId ?? DEFAULT_MCP_HTTP_AGENT_ID;
+  const agentRole = opts.useShellPlaceholders ? "${AGENT_ROLE:-COO}" : opts.agentRole ?? DEFAULT_MCP_HTTP_AGENT_ROLE;
+  let sessionName = process.env.EXE_SESSION_NAME ?? "";
+  if (!sessionName && !opts.useShellPlaceholders) {
+    try {
+      const sock = process.env.EXE_TMUX_SOCKET;
+      const tmuxArgs = sock ? ["-L", sock, "display-message", "-p", "#{session_name}"] : ["display-message", "-p", "#{session_name}"];
+      const tmuxSession = execFileSync("tmux", tmuxArgs, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      if (tmuxSession) sessionName = tmuxSession;
+    } catch {
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${readOrCreateDaemonToken(homeDir)}`,
+    "X-Agent-Id": agentId,
+    "X-Agent-Role": agentRole
+  };
+  if (sessionName && !opts.useShellPlaceholders) headers["X-Exe-Session"] = sessionName;
+  return headers;
+}
+function buildClaudeHttpMcpEntry(homeDir = os.homedir()) {
+  const entry = {
+    type: "http",
+    url: mcpHttpUrl(),
+    headers: buildMcpHttpHeaders(homeDir, { useShellPlaceholders: true })
+  };
+  delete entry.headers["X-Exe-Session"];
+  return entry;
+}
+
+export {
+  DEFAULT_MCP_HTTP_PORT,
+  DEFAULT_MCP_HTTP_AGENT_ID,
+  DEFAULT_MCP_HTTP_AGENT_ROLE,
+  mcpHttpPort,
+  mcpHttpUrl,
+  readOrCreateDaemonToken,
+  buildMcpHttpHeaders,
+  buildClaudeHttpMcpEntry
+};

package/dist/chunk-DNTCYFJ6.js

@@ -0,0 +1,76 @@
+import {
+  fastDbInit
+} from "./chunk-EMXYUAVP.js";
+import {
+  sessionScopeFilter
+} from "./chunk-PC635OAG.js";
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux
+} from "./chunk-SSTLTIF3.js";
+import {
+  getClient,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-52UDAVZE.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};

package/dist/chunk-DOTMUSXW.js

@@ -0,0 +1,81 @@
+// src/bin/fast-db-init.ts
+async function fastDbInit() {
+  const { isInitialized, getClient, setExternalClient } = await import("./lib/database.js");
+  if (isInitialized()) {
+    return getClient();
+  }
+  const forceDirect = process.env.EXE_DB_DIRECT === "1" || process.env.EXE_DB_READONLY === "1" || process.env.EXE_SKIP_DAEMON === "1";
+  if (!forceDirect) {
+    try {
+      const { connectEmbedDaemon, sendDaemonRequest, isClientConnected, disconnectClient } = await import("./lib/exe-daemon-client.js");
+      const { deserializeResultSet } = await import("./daemon-protocol-XW2OLNBS.js");
+      await Promise.race([
+        connectEmbedDaemon(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Daemon socket timeout (2s)")), 2e3))
+      ]);
+      if (isClientConnected()) {
+        const daemonClient = {
+          async execute(stmt) {
+            const sql = typeof stmt === "string" ? stmt : stmt.sql;
+            const args = typeof stmt === "string" ? [] : Array.isArray(stmt.args) ? stmt.args : [];
+            const resp = await sendDaemonRequest({ type: "db-execute", sql, args });
+            if (resp.error) throw new Error(String(resp.error));
+            if (resp.db) return deserializeResultSet(resp.db);
+            throw new Error("Unexpected daemon response");
+          },
+          async batch(stmts, mode) {
+            const statements = stmts.map((s) => {
+              const sql = typeof s === "string" ? s : s.sql;
+              const args = typeof s === "string" ? [] : Array.isArray(s.args) ? s.args : [];
+              return { sql, args };
+            });
+            const resp = await sendDaemonRequest({ type: "db-batch", statements, mode: mode ?? "deferred" });
+            if (resp.error) throw new Error(String(resp.error));
+            const batchResults = resp["db-batch"];
+            if (batchResults) return batchResults.map(deserializeResultSet);
+            throw new Error("Unexpected daemon batch response");
+          },
+          async transaction(_mode) {
+            throw new Error("Transactions not supported via daemon socket");
+          },
+          async executeMultiple(_sql) {
+            throw new Error("executeMultiple not supported via daemon socket");
+          },
+          async migrate(_stmts) {
+            throw new Error("migrate not supported via daemon socket");
+          },
+          sync() {
+            return Promise.resolve(void 0);
+          },
+          close() {
+          },
+          get closed() {
+            return false;
+          },
+          get protocol() {
+            return "file";
+          }
+        };
+        try {
+          await daemonClient.execute("SELECT 1");
+        } catch {
+          try {
+            disconnectClient();
+          } catch {
+          }
+          throw new Error("Daemon socket validation failed");
+        }
+        setExternalClient(daemonClient);
+        return daemonClient;
+      }
+    } catch {
+    }
+  }
+  const { initStore } = await import("./lib/store.js");
+  await initStore({ lightweight: true });
+  return getClient();
+}
+
+export {
+  fastDbInit
+};

package/dist/chunk-DPDRRS7T.js

@@ -0,0 +1,103 @@
+// src/lib/retrieval-health.ts
+async function getRetrievalHealth() {
+  let embedDaemon = "unavailable";
+  try {
+    const { isDaemonAlive } = await import("./mcp-health-VULNT722.js");
+    const { alive } = isDaemonAlive();
+    if (alive) {
+      try {
+        const { pingDaemon } = await import("./lib/exe-daemon-client.js");
+        const health = await pingDaemon();
+        if (health) {
+          const embeddingField = health.embedding;
+          if (embeddingField === "ok") {
+            embedDaemon = "running";
+          } else if (embeddingField === "disabled") {
+            embedDaemon = "disabled";
+          } else {
+            embedDaemon = "stopped";
+          }
+        } else {
+          embedDaemon = "stopped";
+        }
+      } catch {
+        embedDaemon = "stopped";
+      }
+    } else {
+      embedDaemon = "unavailable";
+    }
+  } catch {
+    embedDaemon = "unavailable";
+  }
+  let configuredSearchMode = "hybrid";
+  let selfQueryRouterEnabled = true;
+  try {
+    const { loadConfigSync } = await import("./lib/config.js");
+    const cfg = loadConfigSync();
+    configuredSearchMode = cfg.searchMode ?? "hybrid";
+    selfQueryRouterEnabled = cfg.selfQueryRouter ?? true;
+  } catch {
+  }
+  let actualSearchMode;
+  if (configuredSearchMode === "fts") {
+    actualSearchMode = "fts+graph";
+  } else if (embedDaemon === "running") {
+    actualSearchMode = "hybrid (vector+fts+graph)";
+  } else {
+    actualSearchMode = "fts+graph (degraded from hybrid)";
+  }
+  let queryRouter;
+  if (!selfQueryRouterEnabled) {
+    queryRouter = "disabled";
+  } else if (embedDaemon === "running" || embedDaemon === "disabled") {
+    queryRouter = process.env.ANTHROPIC_API_KEY ? "active" : "fallback";
+  } else {
+    queryRouter = "fallback";
+  }
+  let totalMemories = 0;
+  let memoriesWithVectors = 0;
+  let entities = 0;
+  let relationships = 0;
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const [totalRes, vectorRes] = await Promise.all([
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE status IS NULL OR status != 'deleted'"),
+      client.execute("SELECT COUNT(*) as cnt FROM memories WHERE vector IS NOT NULL AND (status IS NULL OR status != 'deleted')")
+    ]);
+    totalMemories = Number(totalRes.rows[0]?.cnt ?? 0);
+    memoriesWithVectors = Number(vectorRes.rows[0]?.cnt ?? 0);
+    try {
+      const { getGraphStats } = await import("./graph-query-XEDHA2PQ.js");
+      const stats = await getGraphStats(client);
+      entities = stats.entities;
+      relationships = stats.relationships;
+    } catch {
+    }
+  } catch {
+  }
+  const staleCount = totalMemories - memoriesWithVectors;
+  const coveragePct = totalMemories > 0 ? Math.round(memoriesWithVectors / totalMemories * 100) : null;
+  return {
+    embedDaemon,
+    searchMode: {
+      configured: configuredSearchMode,
+      actual: actualSearchMode
+    },
+    queryRouter,
+    vectorBackfill: {
+      totalMemories,
+      memoriesWithVectors,
+      staleCount,
+      coveragePct
+    },
+    graph: {
+      entities,
+      relationships
+    }
+  };
+}
+
+export {
+  getRetrievalHealth
+};