@a-company/paradigm 5.8.2 → 5.9.0

package/dist/chunk-NQKQG45G.js

@@ -0,0 +1,688 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/symphony-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
+var LEGACY_MAIL_DIR = path.join(os.homedir(), ".paradigm", "mail");
+var AGENTS_DIR = path.join(SCORE_DIR, "agents");
+var THREADS_DIR = path.join(SCORE_DIR, "threads");
+var FILE_REQUESTS_DIR = path.join(SCORE_DIR, "file-requests");
+var TRUST_CONFIG_PATH = path.join(SCORE_DIR, "trust.yaml");
+var FILE_REQUEST_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_TRUST = {
+  users: {},
+  defaults: {
+    level: "restricted",
+    autoApprove: [],
+    neverApprove: [
+      ".env*",
+      "**/*.key",
+      "**/*.pem",
+      "**/credentials*",
+      "**/secrets/**"
+    ]
+  }
+};
+function migrateFromLegacyMail() {
+  if (fs.existsSync(LEGACY_MAIL_DIR) && !fs.existsSync(SCORE_DIR)) {
+    try {
+      fs.renameSync(LEGACY_MAIL_DIR, SCORE_DIR);
+    } catch {
+    }
+  }
+}
+function ensureScoreDirs() {
+  migrateFromLegacyMail();
+  for (const dir of [AGENTS_DIR, THREADS_DIR, FILE_REQUESTS_DIR]) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+var ensureMailDirs = ensureScoreDirs;
+function getAgentDir(agentId) {
+  return path.join(AGENTS_DIR, agentId);
+}
+function ensureAgentDir(agentId) {
+  const dir = getAgentDir(agentId);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function readJsonlFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const items = [];
+  for (const line of lines) {
+    try {
+      items.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return items;
+}
+function appendJsonlLine(filePath, item) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
+}
+function sanitizeId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "unknown";
+}
+function resolveProjectName(projectDir) {
+  try {
+    const configPath = path.join(projectDir, ".paradigm", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const match = content.match(/^project:\s*(.+)$/m);
+      if (match) return sanitizeId(match[1].trim().replace(/["']/g, ""));
+    }
+  } catch {
+  }
+  return sanitizeId(path.basename(projectDir));
+}
+function resolveAgentIdentity(projectDir, role) {
+  const project = resolveProjectName(projectDir);
+  const agentRole = role || "core";
+  return `${project}/${agentRole}`;
+}
+function registerAgent(projectDir, role, label) {
+  ensureScoreDirs();
+  const agentId = resolveAgentIdentity(projectDir, role);
+  const agentDir = ensureAgentDir(agentId);
+  const project = resolveProjectName(projectDir);
+  const identity = {
+    id: agentId,
+    name: label || `${project} (${role || "core"})`,
+    type: "agent",
+    project,
+    role: role || "core",
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    label
+  };
+  fs.writeFileSync(
+    path.join(agentDir, "identity.json"),
+    JSON.stringify(identity, null, 2),
+    "utf-8"
+  );
+  return identity;
+}
+function unregisterAgent(agentId) {
+  const agentDir = getAgentDir(agentId);
+  if (!fs.existsSync(agentDir)) return false;
+  try {
+    fs.rmSync(agentDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listAgents() {
+  ensureScoreDirs();
+  if (!fs.existsSync(AGENTS_DIR)) return [];
+  const agents = [];
+  const projectDirs = fs.readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDir of projectDirs) {
+    const projectPath = path.join(AGENTS_DIR, projectDir.name);
+    const roleDirs = fs.readdirSync(projectPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const roleDir of roleDirs) {
+      const identityPath = path.join(projectPath, roleDir.name, "identity.json");
+      if (!fs.existsSync(identityPath)) continue;
+      try {
+        const content = fs.readFileSync(identityPath, "utf-8");
+        const identity = JSON.parse(content);
+        agents.push(identity);
+      } catch {
+      }
+    }
+  }
+  return agents;
+}
+function cleanStaleAgents() {
+  const agents = listAgents();
+  let cleaned = 0;
+  for (const agent of agents) {
+    if (!isProcessAlive(agent.pid)) {
+      unregisterAgent(agent.id);
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
+function getMyIdentity(projectDir) {
+  const agentId = resolveAgentIdentity(projectDir);
+  const identityPath = path.join(getAgentDir(agentId), "identity.json");
+  if (!fs.existsSync(identityPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(identityPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function markAgentPollTime(agentId, statusBlurb) {
+  const identityPath = path.join(getAgentDir(agentId), "identity.json");
+  if (!fs.existsSync(identityPath)) return;
+  try {
+    const identity = JSON.parse(fs.readFileSync(identityPath, "utf-8"));
+    identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    if (statusBlurb !== void 0) {
+      identity.statusBlurb = statusBlurb || void 0;
+    }
+    fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
+  } catch {
+  }
+}
+function updateAgentStatus(agentId, statusBlurb) {
+  const identityPath = path.join(getAgentDir(agentId), "identity.json");
+  if (!fs.existsSync(identityPath)) return;
+  try {
+    const identity = JSON.parse(fs.readFileSync(identityPath, "utf-8"));
+    identity.statusBlurb = statusBlurb || void 0;
+    fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isAgentAsleep(identity, thresholdMs = 6e4) {
+  if (!identity.lastPoll) return true;
+  const lastPoll = new Date(identity.lastPoll).getTime();
+  return Date.now() - lastPoll > thresholdMs;
+}
+function discoverClaudeCodeSessions() {
+  const agents = listAgents();
+  const alive = agents.filter((a) => isProcessAlive(a.pid));
+  try {
+    const conductorSessionsDir = path.join(os.homedir(), ".conductor", "sessions");
+    if (fs.existsSync(conductorSessionsDir)) {
+      const files = fs.readdirSync(conductorSessionsDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(conductorSessionsDir, file), "utf-8");
+          const session = JSON.parse(content);
+          const pid = parseInt(path.basename(file, ".json"), 10);
+          if (!alive.some((a) => a.pid === pid) && isProcessAlive(pid)) {
+            alive.push({
+              id: `conductor/${pid}`,
+              name: session.label || `Session ${pid}`,
+              type: "agent",
+              project: session.projectDir ? path.basename(session.projectDir) : "unknown",
+              role: "conductor",
+              pid,
+              startedAt: session.registeredAt || (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return alive;
+}
+function inboxPath(agentId) {
+  return path.join(getAgentDir(agentId), "inbox.jsonl");
+}
+function outboxPath(agentId) {
+  return path.join(getAgentDir(agentId), "outbox.jsonl");
+}
+function ackPath(agentId) {
+  return path.join(getAgentDir(agentId), "ack.json");
+}
+function peekInbox(agentId) {
+  const filePath = inboxPath(agentId);
+  if (!fs.existsSync(filePath)) return { hasNew: false, inboxSize: 0 };
+  const stat = fs.statSync(filePath);
+  const inboxSize = stat.size;
+  const ack = readAck(agentId);
+  if (!ack) {
+    return { hasNew: inboxSize > 0, inboxSize };
+  }
+  const ackSizePath = path.join(getAgentDir(agentId), "ack-size.json");
+  if (fs.existsSync(ackSizePath)) {
+    try {
+      const ackSize = JSON.parse(fs.readFileSync(ackSizePath, "utf-8"));
+      return { hasNew: inboxSize > (ackSize.size || 0), inboxSize };
+    } catch {
+    }
+  }
+  return { hasNew: inboxSize > 0, inboxSize };
+}
+function recordAckSize(agentId) {
+  const filePath = inboxPath(agentId);
+  const ackSizePath = path.join(getAgentDir(agentId), "ack-size.json");
+  try {
+    const size = fs.existsSync(filePath) ? fs.statSync(filePath).size : 0;
+    ensureAgentDir(agentId);
+    fs.writeFileSync(ackSizePath, JSON.stringify({ size }), "utf-8");
+  } catch {
+  }
+}
+function appendToInbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(inboxPath(agentId), message);
+}
+function readInbox(agentId, afterAck) {
+  const messages = readJsonlFile(inboxPath(agentId));
+  if (!afterAck) {
+    const ack = readAck(agentId);
+    if (ack) {
+      const ackIndex2 = messages.findIndex((m) => m.id === ack);
+      if (ackIndex2 >= 0) return messages.slice(ackIndex2 + 1);
+    }
+    return messages;
+  }
+  const ackIndex = messages.findIndex((m) => m.id === afterAck);
+  if (ackIndex >= 0) return messages.slice(ackIndex + 1);
+  return messages;
+}
+function appendToOutbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(outboxPath(agentId), message);
+}
+function readOutbox(agentId) {
+  return readJsonlFile(outboxPath(agentId));
+}
+function acknowledgeMessages(agentId, lastMessageId) {
+  const filePath = ackPath(agentId);
+  ensureAgentDir(agentId);
+  fs.writeFileSync(filePath, JSON.stringify({ lastAck: lastMessageId }), "utf-8");
+}
+function readAck(agentId) {
+  const filePath = ackPath(agentId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return content.lastAck || null;
+  } catch {
+    return null;
+  }
+}
+function garbageCollect(agentId) {
+  const ack = readAck(agentId);
+  if (!ack) return 0;
+  const filePath = inboxPath(agentId);
+  const messages = readJsonlFile(filePath);
+  const ackIndex = messages.findIndex((m) => m.id === ack);
+  if (ackIndex < 0) return 0;
+  const kept = messages.slice(ackIndex + 1);
+  const removed = messages.length - kept.length;
+  if (kept.length === 0) {
+    if (fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf-8");
+  } else {
+    fs.writeFileSync(filePath, kept.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
+  }
+  return removed;
+}
+function threadPath(threadId) {
+  return path.join(THREADS_DIR, `${threadId}.json`);
+}
+function createThread(topic, initiator) {
+  ensureScoreDirs();
+  const id = "thr-" + crypto.randomBytes(4).toString("hex");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const thread = {
+    id,
+    topic,
+    initiator,
+    participants: [initiator],
+    status: "active",
+    createdAt: now,
+    lastActivity: now,
+    messageCount: 0
+  };
+  fs.writeFileSync(threadPath(id), JSON.stringify(thread, null, 2), "utf-8");
+  return thread;
+}
+function loadThread(threadId) {
+  const filePath = threadPath(threadId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listThreads(status) {
+  ensureScoreDirs();
+  if (!fs.existsSync(THREADS_DIR)) return [];
+  const files = fs.readdirSync(THREADS_DIR).filter((f) => f.endsWith(".json"));
+  const threads = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(THREADS_DIR, file), "utf-8");
+      const thread = JSON.parse(content);
+      if (!status || thread.status === status) {
+        threads.push(thread);
+      }
+    } catch {
+    }
+  }
+  return threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+function updateThread(threadId, partial) {
+  const thread = loadThread(threadId);
+  if (!thread) return false;
+  const updated = { ...thread, ...partial };
+  fs.writeFileSync(threadPath(threadId), JSON.stringify(updated, null, 2), "utf-8");
+  return true;
+}
+function resolveThread(threadId, decision) {
+  return updateThread(threadId, {
+    status: "resolved",
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    decision
+  });
+}
+function getThreadMessages(threadId) {
+  const agents = listAgents();
+  const messages = [];
+  for (const agent of agents) {
+    const inbox = readJsonlFile(inboxPath(agent.id));
+    const outbox = readJsonlFile(outboxPath(agent.id));
+    for (const msg of [...inbox, ...outbox]) {
+      if (msg.threadRoot === threadId || msg.id === threadId) {
+        if (!messages.some((m) => m.id === msg.id)) {
+          messages.push(msg);
+        }
+      }
+    }
+  }
+  return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+function buildMessage(params) {
+  return {
+    id: crypto.randomUUID(),
+    parentId: params.parentId,
+    threadRoot: params.threadRoot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: params.sender,
+    recipients: params.recipients,
+    intent: params.intent,
+    content: {
+      text: params.text,
+      diff: params.diff,
+      decision: params.decision
+    },
+    symbols: params.symbols || [],
+    attachments: params.attachments,
+    metadata: params.metadata
+  };
+}
+function routeMessage(message) {
+  ensureScoreDirs();
+  appendToOutbox(message.sender.id, message);
+  let deliveryCount = 0;
+  if (message.recipients && message.recipients.length > 0) {
+    for (const recipient of message.recipients) {
+      appendToInbox(recipient.id, message);
+      deliveryCount++;
+    }
+  } else {
+    const agents = listAgents();
+    for (const agent of agents) {
+      if (agent.id !== message.sender.id) {
+        appendToInbox(agent.id, message);
+        deliveryCount++;
+      }
+    }
+  }
+  if (message.threadRoot) {
+    const thread = loadThread(message.threadRoot);
+    if (thread) {
+      const isParticipant = thread.participants.some((p) => p.id === message.sender.id);
+      const updatedParticipants = isParticipant ? thread.participants : [...thread.participants, message.sender];
+      updateThread(message.threadRoot, {
+        participants: updatedParticipants,
+        lastActivity: message.timestamp,
+        messageCount: thread.messageCount + 1
+      });
+    }
+  }
+  return deliveryCount;
+}
+function fileRequestPath(requestId) {
+  return path.join(FILE_REQUESTS_DIR, `${requestId}.json`);
+}
+function loadTrustConfig() {
+  if (!fs.existsSync(TRUST_CONFIG_PATH)) return DEFAULT_TRUST;
+  try {
+    const content = fs.readFileSync(TRUST_CONFIG_PATH, "utf-8");
+    try {
+      return JSON.parse(content);
+    } catch {
+      return DEFAULT_TRUST;
+    }
+  } catch {
+    return DEFAULT_TRUST;
+  }
+}
+function createFileRequest(params) {
+  ensureScoreDirs();
+  const requestId = "freq-" + crypto.randomBytes(4).toString("hex");
+  const record = {
+    request: {
+      requestId,
+      filePath: params.filePath,
+      reason: params.reason,
+      requester: params.requester,
+      urgency: params.urgency || "normal",
+      snippet: params.snippet,
+      threadRoot: params.threadRoot
+    },
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  return record;
+}
+function loadFileRequest(requestId) {
+  const filePath = fileRequestPath(requestId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listFileRequests(status) {
+  ensureScoreDirs();
+  if (!fs.existsSync(FILE_REQUESTS_DIR)) return [];
+  const files = fs.readdirSync(FILE_REQUESTS_DIR).filter((f) => f.endsWith(".json"));
+  const requests = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(FILE_REQUESTS_DIR, file), "utf-8");
+      const record = JSON.parse(content);
+      if (!status || record.status === status) {
+        requests.push(record);
+      }
+    } catch {
+    }
+  }
+  return requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function approveFileRequest(requestId, projectDir, redact) {
+  const record = loadFileRequest(requestId);
+  if (!record) return { success: false, error: `File request not found: ${requestId}` };
+  if (record.status !== "pending") return { success: false, error: `Request already ${record.status}` };
+  const absolutePath = path.resolve(projectDir, record.request.filePath);
+  if (!absolutePath.startsWith(path.resolve(projectDir))) {
+    return { success: false, error: "File path escapes project directory" };
+  }
+  if (!fs.existsSync(absolutePath)) {
+    return { success: false, error: `File not found: ${record.request.filePath}` };
+  }
+  try {
+    let content = fs.readFileSync(absolutePath, "utf-8");
+    let encoding = "utf8";
+    if (redact) {
+      const secretPatterns = [
+        /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]/i,
+        /(?:^|\s)(?:export\s+)?[A-Z_]+(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=/,
+        /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
+      ];
+      content = content.split("\n").map((line) => {
+        for (const pattern of secretPatterns) {
+          if (pattern.test(line)) return "[REDACTED]";
+        }
+        return line;
+      }).join("\n");
+    }
+    const hash = crypto.createHash("sha256").update(content).digest("hex");
+    const delivery = {
+      requestId,
+      filePath: record.request.filePath,
+      content,
+      encoding,
+      size: Buffer.byteLength(content),
+      hash
+    };
+    record.status = "approved";
+    record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+    record.delivery = delivery;
+    fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+    const deliveryMessage = buildMessage({
+      sender: { id: "system", name: "File Transfer", type: "human" },
+      recipients: [record.request.requester],
+      intent: "fileDelivery",
+      text: `File delivered: ${record.request.filePath} (${delivery.size} bytes, SHA-256: ${hash.slice(0, 12)}...)`,
+      threadRoot: record.request.threadRoot,
+      symbols: []
+    });
+    deliveryMessage.attachments = [{
+      name: path.basename(record.request.filePath),
+      type: "file",
+      content: delivery.content,
+      encoding: delivery.encoding
+    }];
+    routeMessage(deliveryMessage);
+    return { success: true, delivery };
+  } catch (err) {
+    return { success: false, error: `Failed to read file: ${err.message}` };
+  }
+}
+function denyFileRequest(requestId, reason) {
+  const record = loadFileRequest(requestId);
+  if (!record || record.status !== "pending") return false;
+  record.status = "denied";
+  record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  record.denyReason = reason;
+  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  const denialMessage = buildMessage({
+    sender: { id: "system", name: "File Transfer", type: "human" },
+    recipients: [record.request.requester],
+    intent: "fileDenied",
+    text: `File request denied: ${record.request.filePath}${reason ? ` \u2014 ${reason}` : ""}`,
+    threadRoot: record.request.threadRoot,
+    symbols: []
+  });
+  routeMessage(denialMessage);
+  return true;
+}
+function matchesGlob(filePath, pattern) {
+  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(filePath);
+}
+function isPathDenied(filePath, config, user) {
+  const trust = config || loadTrustConfig();
+  if (user && trust.users[user]) {
+    for (const pattern of trust.users[user].neverApprove) {
+      if (matchesGlob(filePath, pattern)) return true;
+    }
+  }
+  for (const pattern of trust.defaults.neverApprove) {
+    if (matchesGlob(filePath, pattern)) return true;
+  }
+  return false;
+}
+function isPathAutoApproved(filePath, config, user) {
+  const trust = config || loadTrustConfig();
+  if (isPathDenied(filePath, trust, user)) return false;
+  if (user && trust.users[user]) {
+    for (const pattern of trust.users[user].autoApprove) {
+      if (matchesGlob(filePath, pattern)) return true;
+    }
+  }
+  for (const pattern of trust.defaults.autoApprove) {
+    if (matchesGlob(filePath, pattern)) return true;
+  }
+  return false;
+}
+function expireOldRequests() {
+  const requests = listFileRequests("pending");
+  let expired = 0;
+  for (const record of requests) {
+    const age = Date.now() - new Date(record.createdAt).getTime();
+    if (age > FILE_REQUEST_TTL_MS) {
+      record.status = "expired";
+      record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+      fs.writeFileSync(
+        fileRequestPath(record.request.requestId),
+        JSON.stringify(record, null, 2),
+        "utf-8"
+      );
+      expired++;
+    }
+  }
+  return expired;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  SCORE_DIR,
+  ensureScoreDirs,
+  ensureMailDirs,
+  getAgentDir,
+  readJsonlFile,
+  appendJsonlLine,
+  resolveAgentIdentity,
+  registerAgent,
+  unregisterAgent,
+  listAgents,
+  cleanStaleAgents,
+  getMyIdentity,
+  markAgentPollTime,
+  updateAgentStatus,
+  isAgentAsleep,
+  discoverClaudeCodeSessions,
+  peekInbox,
+  recordAckSize,
+  appendToInbox,
+  readInbox,
+  appendToOutbox,
+  readOutbox,
+  acknowledgeMessages,
+  readAck,
+  garbageCollect,
+  createThread,
+  loadThread,
+  listThreads,
+  updateThread,
+  resolveThread,
+  getThreadMessages,
+  buildMessage,
+  routeMessage,
+  loadTrustConfig,
+  createFileRequest,
+  loadFileRequest,
+  listFileRequests,
+  approveFileRequest,
+  denyFileRequest,
+  isPathDenied,
+  isPathAutoApproved,
+  expireOldRequests
+};