contextwise 0.1.0

package/dist/chunk-P7JW7EPW.js

@@ -0,0 +1,4383 @@
+// src/config/schema.ts
+import { z } from "zod";
+var StdioUpstreamConfigSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).default({}),
+  cwd: z.string().optional(),
+  autoRestart: z.boolean().default(true)
+});
+var HttpUpstreamConfigSchema = z.object({
+  url: z.string().url(),
+  headers: z.record(z.string()).default({}),
+  transport: z.enum(["streamable-http", "sse", "auto"]).default("auto"),
+  autoReconnect: z.boolean().default(true)
+});
+var UpstreamServerConfigSchema = z.union([
+  StdioUpstreamConfigSchema,
+  HttpUpstreamConfigSchema
+]);
+function warnIfInsecureHttp(urlStr, headers) {
+  try {
+    const parsed = new URL(urlStr);
+    if (parsed.protocol === "http:") {
+      const isLocalhost = ["localhost", "127.0.0.1", "::1", "[::1]"].includes(parsed.hostname);
+      if (!isLocalhost && headers) {
+        const hasAuthHeader = Object.keys(headers).some(
+          (h) => ["authorization", "cookie", "x-api-key", "api-key", "token"].includes(h.toLowerCase())
+        );
+        if (hasAuthHeader) {
+          console.warn(
+            `[SECURITY WARNING] Upstream URL "${urlStr}" is using unencrypted HTTP with sensitive authentication headers to non-localhost destination "${parsed.hostname}".`
+          );
+        }
+      }
+    }
+  } catch {
+  }
+}
+function isStdioUpstream(config) {
+  return "command" in config;
+}
+function isHttpUpstream(config) {
+  return "url" in config;
+}
+var ProxyConfigSchema = z.object({
+  transport: z.enum(["stdio", "sse", "http"]).default("stdio"),
+  port: z.number().int().min(1024).max(65535).default(3456),
+  logLevel: z.enum(["debug", "info", "warn", "error", "silent"]).default("info")
+});
+var RoutingConfigSchema = z.object({
+  strategy: z.enum(["hybrid", "bm25", "vector", "passthrough"]).default("hybrid"),
+  topK: z.number().int().min(1).max(50).default(5),
+  similarityThreshold: z.number().min(0).max(1).default(0.45),
+  pinnedTools: z.array(z.string()).default([]),
+  maxActiveTools: z.number().int().min(1).max(100).default(10),
+  enableBrowseServers: z.boolean().default(false),
+  enableAddServer: z.boolean().default(false),
+  allowCustomCommands: z.boolean().default(false),
+  persistAddedServers: z.boolean().default(false)
+});
+var GuardrailsConfigSchema = z.object({
+  enableCache: z.boolean().default(true),
+  cacheTtlSeconds: z.number().int().min(1).default(120),
+  maxCallsPerMinute: z.number().int().min(1).default(60),
+  loopBreakerThreshold: z.number().int().min(1).default(3),
+  callTimeoutMs: z.number().int().min(1e3).default(3e4)
+});
+var ContextWiseConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string().default("1.0.0"),
+  proxy: ProxyConfigSchema.default({}),
+  routing: RoutingConfigSchema.default({}),
+  guardrails: GuardrailsConfigSchema.default({}),
+  upstreams: z.record(UpstreamServerConfigSchema).default({})
+});
+
+// src/vault/redaction.ts
+var RedactionFilter = class _RedactionFilter {
+  static instance = null;
+  registeredSecrets = /* @__PURE__ */ new Set();
+  static getInstance() {
+    if (!_RedactionFilter.instance) {
+      _RedactionFilter.instance = new _RedactionFilter();
+    }
+    return _RedactionFilter.instance;
+  }
+  /**
+   * Registers a plaintext secret value to be masked across all output streams.
+   */
+  registerSecret(secret) {
+    if (secret && typeof secret === "string") {
+      const trimmed = secret.trim();
+      if (trimmed.length >= 4) {
+        this.registeredSecrets.add(trimmed);
+      }
+    }
+  }
+  registerSecrets(secrets) {
+    for (const s of secrets) {
+      this.registerSecret(s);
+    }
+  }
+  getRegisteredCount() {
+    return this.registeredSecrets.size;
+  }
+  clear() {
+    this.registeredSecrets.clear();
+  }
+  /**
+   * Redacts registered secrets and known API key patterns from an input string.
+   */
+  redact(input) {
+    if (!input || typeof input !== "string") {
+      return input;
+    }
+    let sanitized = input;
+    for (const secret of this.registeredSecrets) {
+      sanitized = sanitized.replaceAll(secret, "[REDACTED_SECRET]");
+    }
+    sanitized = sanitized.replace(/ghp_[a-zA-Z0-9]{36}/g, "ghp_[REDACTED_GITHUB_TOKEN]");
+    sanitized = sanitized.replace(/sk-ant-[a-zA-Z0-9_-]{20,}/g, "sk-ant-[REDACTED_ANTHROPIC_KEY]");
+    sanitized = sanitized.replace(/sk-[a-zA-Z0-9]{32,}/g, "sk-[REDACTED_OPENAI_KEY]");
+    sanitized = sanitized.replace(
+      /([a-zA-Z0-9+]+:\/\/[^:]+:)([^@]+)(@.+)/g,
+      "$1[REDACTED_PASSWORD]$3"
+    );
+    return sanitized;
+  }
+};
+var redactionFilter = RedactionFilter.getInstance();
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 100
+};
+var Logger = class {
+  level = "info";
+  prefix;
+  constructor(prefix = "ContextWise", level = "info") {
+    this.prefix = prefix;
+    this.level = level;
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  formatMessage(level, message, meta) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const metaStr = meta !== void 0 ? ` ${typeof meta === "object" ? JSON.stringify(meta) : String(meta)}` : "";
+    const raw = `[${timestamp}] [${level.toUpperCase()}] [${this.prefix}] ${message}${metaStr}
+`;
+    return redactionFilter.redact(raw);
+  }
+  debug(message, meta) {
+    if (this.shouldLog("debug")) {
+      process.stderr.write(this.formatMessage("DEBUG", message, meta));
+    }
+  }
+  info(message, meta) {
+    if (this.shouldLog("info")) {
+      process.stderr.write(this.formatMessage("INFO", message, meta));
+    }
+  }
+  warn(message, meta) {
+    if (this.shouldLog("warn")) {
+      process.stderr.write(this.formatMessage("WARN", message, meta));
+    }
+  }
+  error(message, meta) {
+    if (this.shouldLog("error")) {
+      process.stderr.write(this.formatMessage("ERROR", message, meta));
+    }
+  }
+};
+var logger = new Logger("ContextWise");
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+var ConfigLoader = class {
+  /**
+   * Discovers and loads configuration from contextwise.json or imported client configs.
+   */
+  static load(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (process.env.CONTEXTWISE_CONFIG && !options.configPath) {
+      const envPath = isAbsolute(process.env.CONTEXTWISE_CONFIG) ? process.env.CONTEXTWISE_CONFIG : resolve(cwd, process.env.CONTEXTWISE_CONFIG);
+      if (existsSync(envPath)) {
+        return this.parseConfigFile(envPath);
+      }
+    }
+    if (options.configPath) {
+      const explicitPath = isAbsolute(options.configPath) ? options.configPath : resolve(cwd, options.configPath);
+      if (existsSync(explicitPath)) {
+        return this.parseConfigFile(explicitPath);
+      }
+      throw new Error(`Configuration file not found at: ${explicitPath}`);
+    }
+    const candidatePaths = [
+      resolve(cwd, "contextwise.json"),
+      resolve(cwd, ".contextwise.json"),
+      resolve(cwd, ".contextwise/config.json"),
+      resolve(homedir(), ".contextwise/config.json")
+    ];
+    for (const candidate of candidatePaths) {
+      if (existsSync(candidate)) {
+        logger.debug(`Loaded configuration from ${candidate}`);
+        return this.parseConfigFile(candidate);
+      }
+    }
+    if (options.autoImport !== false) {
+      const imported = this.autoImportClientConfigs(cwd);
+      if (imported && Object.keys(imported.upstreams).length > 0) {
+        logger.info(`Auto-discovered MCP servers from existing client configurations`);
+        return imported;
+      }
+    }
+    logger.debug("No configuration file found. Using defaults.");
+    return ContextWiseConfigSchema.parse({});
+  }
+  /**
+   * Parses and validates a JSON file against ContextWiseConfigSchema.
+   */
+  static parseConfigFile(filePath) {
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return ContextWiseConfigSchema.parse(parsed);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse config at ${filePath}: ${msg}`);
+    }
+  }
+  /**
+   * Scans for Cursor and Claude Desktop configs to auto-import upstreams.
+   */
+  static autoImportClientConfigs(cwd) {
+    const upstreams = {};
+    const cursorMcp = resolve(cwd, ".cursor", "mcp.json");
+    if (existsSync(cursorMcp)) {
+      try {
+        const raw = JSON.parse(readFileSync(cursorMcp, "utf-8"));
+        if (raw.mcpServers && typeof raw.mcpServers === "object") {
+          for (const [name, server] of Object.entries(raw.mcpServers)) {
+            if (name === "contextwise") continue;
+            const s = server;
+            if (typeof s.command === "string") {
+              upstreams[name] = {
+                command: s.command,
+                args: Array.isArray(s.args) ? s.args : [],
+                env: s.env ?? {},
+                autoRestart: true
+              };
+            } else if (typeof s.url === "string") {
+              upstreams[name] = {
+                url: s.url,
+                headers: s.headers ?? {},
+                transport: "auto",
+                autoReconnect: true
+              };
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed reading ${cursorMcp}: ${err}`);
+      }
+    }
+    const claudePath = this.getClaudeDesktopConfigPath();
+    if (claudePath && existsSync(claudePath)) {
+      try {
+        const raw = JSON.parse(readFileSync(claudePath, "utf-8"));
+        if (raw.mcpServers && typeof raw.mcpServers === "object") {
+          for (const [name, server] of Object.entries(raw.mcpServers)) {
+            if (name === "contextwise") continue;
+            const s = server;
+            if (typeof s.command === "string" && !upstreams[name]) {
+              upstreams[name] = {
+                command: s.command,
+                args: Array.isArray(s.args) ? s.args : [],
+                env: s.env ?? {},
+                autoRestart: true
+              };
+            } else if (typeof s.url === "string" && !upstreams[name]) {
+              upstreams[name] = {
+                url: s.url,
+                headers: s.headers ?? {},
+                transport: "auto",
+                autoReconnect: true
+              };
+            }
+          }
+        }
+      } catch (err) {
+        logger.warn(`Failed reading Claude config at ${claudePath}: ${err}`);
+      }
+    }
+    if (Object.keys(upstreams).length === 0) {
+      return null;
+    }
+    return ContextWiseConfigSchema.parse({
+      upstreams
+    });
+  }
+  static getClaudeDesktopConfigPath() {
+    const platform3 = process.platform;
+    const home = homedir();
+    if (platform3 === "win32") {
+      const appData = process.env.APPDATA || join(home, "AppData", "Roaming");
+      return join(appData, "Claude", "claude_desktop_config.json");
+    } else if (platform3 === "darwin") {
+      return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    } else {
+      return join(home, ".config", "Claude", "claude_desktop_config.json");
+    }
+  }
+};
+
+// src/core/supervisor.ts
+import { execSync } from "child_process";
+var ProcessSupervisor = class _ProcessSupervisor {
+  static instance = null;
+  trackedProcesses = /* @__PURE__ */ new Map();
+  hooksRegistered = false;
+  constructor() {
+    this.registerGlobalHooks();
+  }
+  static getInstance() {
+    if (!_ProcessSupervisor.instance) {
+      _ProcessSupervisor.instance = new _ProcessSupervisor();
+    }
+    return _ProcessSupervisor.instance;
+  }
+  /**
+   * Registers a child PID under supervision.
+   */
+  track(pid, name) {
+    if (!pid || pid <= 0) return;
+    this.trackedProcesses.set(pid, {
+      pid,
+      name,
+      startTime: /* @__PURE__ */ new Date()
+    });
+    logger.debug(`Supervising process ${name} (PID: ${pid})`);
+  }
+  /**
+   * Unregisters a child PID (e.g., normal graceful exit).
+   */
+  untrack(pid) {
+    this.trackedProcesses.delete(pid);
+    logger.debug(`Untracked process PID: ${pid}`);
+  }
+  /**
+   * Kills an entire process tree for a given root PID.
+   * Cross-platform: handles Windows taskkill /T /F and POSIX process group kills.
+   */
+  killProcessTree(pid, name) {
+    if (!pid || pid <= 0) return;
+    const procName = name ?? this.trackedProcesses.get(pid)?.name ?? "unknown";
+    logger.debug(`Terminating process tree for ${procName} (PID: ${pid})`);
+    try {
+      if (process.platform === "win32") {
+        execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore" });
+      } else {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          process.kill(pid, "SIGKILL");
+        }
+      }
+    } catch {
+    } finally {
+      this.untrack(pid);
+    }
+  }
+  /**
+   * Shuts down all supervised processes cleanly.
+   */
+  shutdownAll() {
+    if (this.trackedProcesses.size === 0) return;
+    logger.info(`Shutting down ${this.trackedProcesses.size} supervised processes...`);
+    for (const [pid, proc] of this.trackedProcesses.entries()) {
+      this.killProcessTree(pid, proc.name);
+    }
+    this.trackedProcesses.clear();
+  }
+  /**
+   * Returns list of currently tracked processes.
+   */
+  getTrackedProcesses() {
+    return Array.from(this.trackedProcesses.values());
+  }
+  registerGlobalHooks() {
+    if (this.hooksRegistered) return;
+    this.hooksRegistered = true;
+    const cleanup = () => {
+      this.shutdownAll();
+    };
+    process.on("exit", cleanup);
+    const handleSignal = (signal) => {
+      if (process.listenerCount(signal) > 1) {
+        return;
+      }
+      cleanup();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => handleSignal("SIGINT"));
+    process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  }
+};
+var supervisor = ProcessSupervisor.getInstance();
+
+// src/vault/crypto.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  diffieHellman,
+  generateKeyPairSync,
+  pbkdf2,
+  randomBytes
+} from "crypto";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { arch, homedir as homedir2, hostname, platform, userInfo } from "os";
+import { join as join2 } from "path";
+function encryptAesGcm(plaintext, key) {
+  if (key.length !== 32) {
+    throw new Error(`Invalid AES-256 key length: expected 32 bytes, got ${key.length}`);
+  }
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  let ciphertext = cipher.update(plaintext, "utf-8", "base64");
+  ciphertext += cipher.final("base64");
+  const authTag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    authTag: authTag.toString("base64"),
+    ciphertext
+  };
+}
+function decryptAesGcm(ciphertext, key, ivBase64, authTagBase64) {
+  if (key.length !== 32) {
+    throw new Error(`Invalid AES-256 key length: expected 32 bytes, got ${key.length}`);
+  }
+  const iv = Buffer.from(ivBase64, "base64");
+  const authTag = Buffer.from(authTagBase64, "base64");
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(ciphertext, "base64", "utf-8");
+  decrypted += decipher.final("utf-8");
+  return decrypted;
+}
+var VAULT_PBKDF2_ITERATIONS = 21e4;
+function deriveKeyFromPassphrase(passphrase, salt, iterations = VAULT_PBKDF2_ITERATIONS) {
+  return new Promise((resolve4, reject) => {
+    pbkdf2(passphrase, salt, iterations, 32, "sha512", (err, derivedKey) => {
+      if (err) reject(err);
+      else resolve4(derivedKey);
+    });
+  });
+}
+async function getOrCreateMachineKey() {
+  const saltDir = join2(homedir2(), ".contextwise");
+  const saltPath = join2(saltDir, ".machine_salt");
+  let salt;
+  if (existsSync2(saltPath)) {
+    salt = readFileSync2(saltPath);
+  } else {
+    mkdirSync(saltDir, { recursive: true });
+    salt = randomBytes(32);
+    writeFileSync(saltPath, salt, { mode: 384 });
+  }
+  if (process.env.CONTEXTWISE_VAULT_PASSPHRASE) {
+    return deriveKeyFromPassphrase(process.env.CONTEXTWISE_VAULT_PASSPHRASE, salt, VAULT_PBKDF2_ITERATIONS);
+  }
+  const user = (() => {
+    try {
+      return userInfo().username;
+    } catch {
+      return "default_user";
+    }
+  })();
+  const machineId = `${hostname()}-${user}-${platform()}-${arch()}-contextwise-vault-v1`;
+  return deriveKeyFromPassphrase(machineId, salt, VAULT_PBKDF2_ITERATIONS);
+}
+function generateKeyPairX25519() {
+  const { publicKey, privateKey } = generateKeyPairSync("x25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  return { publicKey, privateKey };
+}
+function deriveSharedSecretX25519(privateKeyPem, publicKeyPem) {
+  const privateKey = createPrivateKey(privateKeyPem);
+  const publicKey = createPublicKey(publicKeyPem);
+  const shared = diffieHellman({
+    privateKey,
+    publicKey
+  });
+  return createHash("sha256").update(shared).digest();
+}
+
+// src/vault/file_driver.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+function getDefaultVaultFilePath() {
+  if (process.env.CONTEXTWISE_VAULT_PATH) {
+    return process.env.CONTEXTWISE_VAULT_PATH;
+  }
+  if (process.env.CONTEXTWISE_STORAGE_DIR) {
+    return join3(process.env.CONTEXTWISE_STORAGE_DIR, "vault.enc.json");
+  }
+  return join3(homedir3(), ".contextwise", "vault.enc.json");
+}
+var EncryptedFileVaultDriver = class {
+  name = "encrypted_file";
+  filePath;
+  keyPromise;
+  cache = null;
+  constructor(filePath, customKey) {
+    this.filePath = filePath ?? getDefaultVaultFilePath();
+    this.keyPromise = customKey ? Promise.resolve(customKey) : getOrCreateMachineKey();
+  }
+  async isAvailable() {
+    return true;
+  }
+  async load() {
+    if (this.cache) {
+      return this.cache;
+    }
+    this.cache = /* @__PURE__ */ new Map();
+    if (!existsSync3(this.filePath)) {
+      return this.cache;
+    }
+    try {
+      const raw = readFileSync3(this.filePath, "utf-8");
+      const payload = JSON.parse(raw);
+      if (payload.cipher !== "aes-256-gcm" || !payload.data) {
+        logger.warn(`Corrupt or incompatible vault file at ${this.filePath}`);
+        return this.cache;
+      }
+      const key = await this.keyPromise;
+      const decryptedJson = decryptAesGcm(payload.data, key, payload.iv, payload.authTag);
+      const entries = JSON.parse(decryptedJson);
+      for (const [k, v] of Object.entries(entries)) {
+        this.cache.set(k, v);
+      }
+    } catch (err) {
+      logger.warn(`Failed to decrypt vault file at ${this.filePath}: ${err}`);
+    }
+    return this.cache;
+  }
+  async persist() {
+    if (!this.cache) return;
+    const dir = dirname2(this.filePath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const key = await this.keyPromise;
+    const entries = {};
+    for (const [k, v] of this.cache.entries()) {
+      entries[k] = v;
+    }
+    const plaintext = JSON.stringify(entries);
+    const { iv, authTag, ciphertext } = encryptAesGcm(plaintext, key);
+    const payload = {
+      version: 1,
+      kdf: {
+        algorithm: "pbkdf2-sha512",
+        salt: "machine-bound",
+        iterations: VAULT_PBKDF2_ITERATIONS
+      },
+      cipher: "aes-256-gcm",
+      iv,
+      authTag,
+      data: ciphertext
+    };
+    const tempPath = `${this.filePath}.${Date.now()}.tmp`;
+    writeFileSync2(tempPath, JSON.stringify(payload, null, 2), { mode: 384, encoding: "utf-8" });
+    try {
+      renameSync(tempPath, this.filePath);
+    } catch {
+      writeFileSync2(this.filePath, JSON.stringify(payload, null, 2), { mode: 384, encoding: "utf-8" });
+      try {
+        unlinkSync(tempPath);
+      } catch {
+      }
+    }
+  }
+  async get(key) {
+    const store = await this.load();
+    const entry = store.get(key);
+    return entry ? entry.value : null;
+  }
+  async set(key, value, scope = "personal") {
+    const store = await this.load();
+    const now = Date.now();
+    const existing = store.get(key);
+    store.set(key, {
+      value,
+      metadata: {
+        key,
+        scope,
+        backend: this.name,
+        createdAt: existing?.metadata.createdAt ?? now,
+        updatedAt: now
+      }
+    });
+    await this.persist();
+    logger.debug(`Stored secret "${key}" in ${this.name} vault`);
+  }
+  async delete(key) {
+    const store = await this.load();
+    if (!store.has(key)) {
+      return false;
+    }
+    store.delete(key);
+    await this.persist();
+    logger.debug(`Deleted secret "${key}" from ${this.name} vault`);
+    return true;
+  }
+  async list() {
+    const store = await this.load();
+    return Array.from(store.values()).map((e) => e.metadata);
+  }
+  /**
+   * Resets and clears all cached and persisted secrets.
+   */
+  async clear() {
+    this.cache = /* @__PURE__ */ new Map();
+    if (existsSync3(this.filePath)) {
+      try {
+        unlinkSync(this.filePath);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/vault/os_driver.ts
+import { execFileSync } from "child_process";
+import { platform as platform2 } from "os";
+var OsKeystoreDriver = class {
+  name = "os_keystore";
+  available = null;
+  serviceName = "ContextWise";
+  async isAvailable() {
+    if (this.available !== null) {
+      return this.available;
+    }
+    const currentPlatform = platform2();
+    try {
+      if (currentPlatform === "darwin") {
+        execFileSync("/usr/bin/security", ["list-keychains"], { stdio: "ignore" });
+        this.available = true;
+      } else {
+        this.available = false;
+      }
+    } catch {
+      logger.debug("Native OS Keystore is not directly accessible. Using Encrypted File Vault.");
+      this.available = false;
+    }
+    return this.available;
+  }
+  async get(key) {
+    if (!await this.isAvailable()) {
+      return null;
+    }
+    const currentPlatform = platform2();
+    try {
+      if (currentPlatform === "darwin") {
+        const stdout = execFileSync(
+          "/usr/bin/security",
+          ["find-generic-password", "-s", this.serviceName, "-a", key, "-w"],
+          { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+        );
+        return stdout.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value, _scope = "personal") {
+    if (!await this.isAvailable()) {
+      throw new Error("OS Keystore driver is not available on this system.");
+    }
+    const currentPlatform = platform2();
+    if (currentPlatform === "darwin") {
+      execFileSync(
+        "/usr/bin/security",
+        ["add-generic-password", "-U", "-s", this.serviceName, "-a", key, "-w", value],
+        { stdio: "ignore" }
+      );
+    } else {
+      throw new Error("OS Keystore set not implemented for this platform; fallback to encrypted file.");
+    }
+  }
+  async delete(key) {
+    if (!await this.isAvailable()) {
+      return false;
+    }
+    const currentPlatform = platform2();
+    try {
+      if (currentPlatform === "darwin") {
+        execFileSync(
+          "/usr/bin/security",
+          ["delete-generic-password", "-s", this.serviceName, "-a", key],
+          { stdio: "ignore" }
+        );
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async list() {
+    return [];
+  }
+};
+
+// src/vault/vault.ts
+var SecretVault = class {
+  driver;
+  initialized = false;
+  constructor(customDriver) {
+    this.driver = customDriver ?? new EncryptedFileVaultDriver();
+  }
+  async initialize() {
+    if (this.initialized) return;
+    const osDriver = new OsKeystoreDriver();
+    if (await osDriver.isAvailable()) {
+      this.driver = osDriver;
+    } else {
+      this.driver = new EncryptedFileVaultDriver();
+    }
+    this.initialized = true;
+  }
+  getActiveDriverName() {
+    return this.driver.name;
+  }
+  setDriver(driver) {
+    this.driver = driver;
+    this.initialized = true;
+  }
+  async get(key) {
+    await this.initialize();
+    const val = await this.driver.get(key);
+    if (val) {
+      redactionFilter.registerSecret(val);
+    }
+    return val;
+  }
+  async set(key, value, scope = "personal") {
+    await this.initialize();
+    await this.driver.set(key, value, scope);
+    redactionFilter.registerSecret(value);
+  }
+  async delete(key) {
+    await this.initialize();
+    return this.driver.delete(key);
+  }
+  async list() {
+    await this.initialize();
+    return this.driver.list();
+  }
+};
+var secretVault = new SecretVault();
+
+// src/vault/audit.ts
+var VaultAuditor = class {
+  /**
+   * Scans configuration for plaintext API keys, database credentials, and unvaulted secrets.
+   */
+  static async audit(config) {
+    await secretVault.initialize();
+    const upstreams = config.upstreams || {};
+    const serverNames = Object.keys(upstreams);
+    let vaultReferencedCount = 0;
+    const warnings = [];
+    for (const serverName of serverNames) {
+      const server = upstreams[serverName];
+      if (isStdioUpstream(server) && server.env) {
+        for (const [envVar, val] of Object.entries(server.env)) {
+          const strVal = String(val);
+          if (strVal.startsWith("vault://")) {
+            vaultReferencedCount++;
+            continue;
+          }
+          if (strVal.startsWith("env://")) {
+            continue;
+          }
+          const finding = this.evaluateSecret(serverName, envVar, strVal);
+          if (finding) {
+            warnings.push(finding);
+          }
+        }
+      }
+      if (isHttpUpstream(server) && server.headers) {
+        for (const [headerKey, headerVal] of Object.entries(server.headers)) {
+          const strVal = String(headerVal);
+          if (strVal.startsWith("vault://")) {
+            vaultReferencedCount++;
+            continue;
+          }
+          if (strVal.startsWith("env://")) {
+            continue;
+          }
+          const finding = this.evaluateSecret(serverName, `header:${headerKey}`, strVal);
+          if (finding) {
+            warnings.push(finding);
+          }
+        }
+      }
+    }
+    return {
+      timestamp: Date.now(),
+      totalUpstreams: serverNames.length,
+      vaultReferencedCount,
+      plaintextWarnings: warnings,
+      activeDriver: secretVault.getActiveDriverName(),
+      registeredSecretCount: redactionFilter.getRegisteredCount()
+    };
+  }
+  static evaluateSecret(serverName, keyName, value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("sk-ant-")) {
+      return {
+        serverName,
+        envVar: keyName,
+        severity: "critical",
+        reason: "Plaintext Anthropic API key exposed in configuration",
+        suggestion: `Store in vault: contextwise secret set ${serverName.toUpperCase()}_ANTHROPIC_KEY <value>`
+      };
+    }
+    if (trimmed.startsWith("sk-")) {
+      return {
+        serverName,
+        envVar: keyName,
+        severity: "critical",
+        reason: "Plaintext OpenAI API key exposed in configuration",
+        suggestion: `Store in vault: contextwise secret set ${serverName.toUpperCase()}_OPENAI_KEY <value>`
+      };
+    }
+    if (trimmed.startsWith("ghp_") || trimmed.startsWith("github_pat_")) {
+      return {
+        serverName,
+        envVar: keyName,
+        severity: "critical",
+        reason: "Plaintext GitHub Personal Access Token exposed in configuration",
+        suggestion: `Store in vault: contextwise secret set ${serverName.toUpperCase()}_GITHUB_TOKEN <value>`
+      };
+    }
+    if (/^[a-zA-Z0-9+]+:\/\/[^:]+:[^@]+@.+/.test(trimmed)) {
+      return {
+        serverName,
+        envVar: keyName,
+        severity: "critical",
+        reason: "Database URI with embedded password exposed in configuration",
+        suggestion: `Store connection string in vault: contextwise secret set ${serverName.toUpperCase()}_DB_URL <value>`
+      };
+    }
+    const lowerKey = keyName.toLowerCase();
+    const sensitiveNamePattern = /(key|token|secret|password|passwd|auth|bearer|credential)/;
+    if (sensitiveNamePattern.test(lowerKey)) {
+      return {
+        serverName,
+        envVar: keyName,
+        severity: "warn",
+        reason: `Potential credential stored in plaintext ("${keyName}")`,
+        suggestion: `Store in vault: contextwise secret set ${serverName.toUpperCase()}_${keyName.toUpperCase()} <value>`
+      };
+    }
+    return null;
+  }
+};
+
+// src/vault/resolver.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+var SecretResolver = class {
+  /**
+   * Resolves a single secret token reference (vault://, auth://, env://).
+   */
+  static async resolveSingleRef(ref, allowReferences = true) {
+    const trimmed = ref.trim();
+    if (trimmed.startsWith("vault://")) {
+      if (!allowReferences) {
+        throw new Error(
+          'Security violation: "vault://" secret references are strictly prohibited in dynamic/untrusted server configurations.'
+        );
+      }
+      const secretKey = trimmed.slice("vault://".length).trim();
+      if (!secretKey) {
+        throw new Error('Invalid vault reference format: expected "vault://<key>"');
+      }
+      const secretValue = await secretVault.get(secretKey);
+      if (secretValue === null || secretValue === void 0) {
+        throw new Error(
+          `Vault secret "${secretKey}" was not found in the ContextWise vault. Set it using: contextwise secret set "${secretKey}" <value>`
+        );
+      }
+      redactionFilter.registerSecret(secretValue);
+      return secretValue;
+    }
+    if (trimmed.startsWith("auth://") || trimmed.startsWith("mcp-auth://")) {
+      if (!allowReferences) {
+        throw new Error(
+          'Security violation: "auth://" secret references are strictly prohibited in dynamic/untrusted server configurations.'
+        );
+      }
+      const serverKey = trimmed.replace(/^(?:auth|mcp-auth):\/\//, "").trim();
+      if (!serverKey) {
+        throw new Error('Invalid auth reference format: expected "auth://<server>"');
+      }
+      const mcpAuthPath = join4(homedir4(), ".local", "share", "opencode", "mcp-auth.json");
+      if (existsSync4(mcpAuthPath)) {
+        try {
+          const authData = JSON.parse(readFileSync4(mcpAuthPath, "utf-8"));
+          const token = authData[serverKey]?.tokens?.accessToken;
+          if (token) {
+            redactionFilter.registerSecret(token);
+            return token;
+          }
+        } catch (e) {
+          logger.warn(`Failed to read token from ${mcpAuthPath}: ${e}`);
+        }
+      }
+      throw new Error(
+        `OAuth access token for "${serverKey}" was not found in ${mcpAuthPath}. Ensure you are authenticated in OpenCode with: opencode mcp auth ${serverKey}`
+      );
+    }
+    if (trimmed.startsWith("env://")) {
+      if (!allowReferences) {
+        throw new Error(
+          'Security violation: "env://" environment variable references are strictly prohibited in dynamic/untrusted server configurations.'
+        );
+      }
+      let varName = trimmed.slice("env://".length).trim();
+      if (varName.startsWith("${") && varName.endsWith("}")) {
+        varName = varName.slice(2, -1).trim();
+      }
+      const envVal = process.env[varName];
+      if (envVal === void 0) {
+        logger.warn(`Environment variable "${varName}" referenced via env:// is not defined`);
+        return "";
+      }
+      redactionFilter.registerSecret(envVal);
+      return envVal;
+    }
+    return trimmed;
+  }
+  /**
+   * Resolves a single configuration value that may contain a vault://, auth://, or env:// reference.
+   * If allowReferences is false, secret references are rejected to prevent unauthorized vault access.
+   */
+  static async resolveValue(val, allowReferences = true) {
+    if (!val || typeof val !== "string") {
+      return val;
+    }
+    const trimmed = val.trim();
+    const matches = Array.from(
+      trimmed.matchAll(/(vault:\/\/[^\s"',]+|auth:\/\/[^\s"',]+|mcp-auth:\/\/[^\s"',]+|env:\/\/(?:\$\{[^}]+\}|[^\s"',]+))/g)
+    );
+    if (matches.length > 0) {
+      let result = trimmed;
+      for (const m of matches) {
+        const fullRef = m[0];
+        const resolved = await this.resolveSingleRef(fullRef, allowReferences);
+        result = result.replace(fullRef, resolved);
+      }
+      return result;
+    }
+    if (trimmed.startsWith("sk-") || trimmed.startsWith("ghp_") || trimmed.startsWith("gho_") || trimmed.startsWith("glpat-") || trimmed.startsWith("xoxb-") || trimmed.startsWith("xoxp-") || /^eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/.test(trimmed)) {
+      redactionFilter.registerSecret(trimmed);
+    }
+    return val;
+  }
+  /**
+   * Resolves an environment dictionary, replacing all vault:// and env:// references.
+   */
+  static async resolveEnv(envMap, allowReferences = true) {
+    if (!envMap || typeof envMap !== "object") {
+      return {};
+    }
+    const resolved = {};
+    for (const [key, value] of Object.entries(envMap)) {
+      if (typeof value === "string") {
+        resolved[key] = await this.resolveValue(value, allowReferences);
+      } else {
+        resolved[key] = String(value);
+      }
+    }
+    return resolved;
+  }
+};
+
+// src/core/multiplexer.ts
+import { EventEmitter } from "events";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  getDefaultEnvironment,
+  StdioClientTransport
+} from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import {
+  ToolListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function escapeWindowsCmdArg(arg) {
+  if (!arg) return '""';
+  let escaped = arg.replace(/(\\*)"/g, '$1$1\\"');
+  escaped = escaped.replace(/(\\+)$/g, "$1$1");
+  if (/[\s&|<>()%^"!]/.test(escaped)) {
+    escaped = `"${escaped}"`;
+  }
+  return escaped;
+}
+function inferToolHints(toolName, desc = "", annotations) {
+  let readOnlyHint;
+  let destructiveHint;
+  let idempotentHint;
+  if (annotations && typeof annotations === "object") {
+    if (typeof annotations.readOnlyHint === "boolean") {
+      readOnlyHint = annotations.readOnlyHint;
+    } else if (typeof annotations.readOnly === "boolean") {
+      readOnlyHint = annotations.readOnly;
+    } else {
+      readOnlyHint = false;
+    }
+    if (typeof annotations.destructiveHint === "boolean") {
+      destructiveHint = annotations.destructiveHint;
+    } else if (typeof annotations.destructive === "boolean") {
+      destructiveHint = annotations.destructive;
+    } else {
+      destructiveHint = false;
+    }
+    if (typeof annotations.idempotentHint === "boolean") {
+      idempotentHint = annotations.idempotentHint;
+    } else {
+      idempotentHint = readOnlyHint;
+    }
+  } else {
+    const hasReadOnlyVerb = /(?:^|[_.-])(?:read|get|list|fetch|inspect|describe|view)(?:[_.-]|$)/i.test(toolName);
+    const hasMutatingVerb = /(?:^|[_.-])(?:query|exec|execute|run|create|update|insert|delete|drop|mutate|write|post|put|patch|set|add|send)(?:[_.-]|$)/i.test(toolName);
+    const hasExplicitReadOnlyDesc = /\b(read-only|readonly|does not modify)\b/i.test(desc);
+    readOnlyHint = hasReadOnlyVerb && !hasMutatingVerb || hasExplicitReadOnlyDesc;
+    destructiveHint = /(?:^|[_.-])(?:delete|drop|remove|truncate|kill|destroy|terminate|purge)(?:[_.-]|$)/i.test(toolName) || /\b(destructive|irreversible)\b/i.test(desc);
+    idempotentHint = readOnlyHint;
+  }
+  return { readOnlyHint, idempotentHint, destructiveHint };
+}
+var UpstreamMultiplexer = class extends EventEmitter {
+  connections = /* @__PURE__ */ new Map();
+  /** Mapping of exposed tool name -> { serverName, originalName } */
+  toolRoutingTable = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  /**
+   * Initializes connections to all configured upstream servers in parallel.
+   */
+  async connectAll(upstreams) {
+    const entries = Object.entries(upstreams);
+    if (entries.length === 0) {
+      logger.info("No upstream MCP servers configured.");
+      return;
+    }
+    logger.info(`Connecting to ${entries.length} upstream MCP servers...`);
+    const promises = entries.map(([name, config]) => this.connectServer(name, config));
+    await Promise.allSettled(promises);
+    this.rebuildRoutingTable();
+    logger.info(
+      `Multiplexer initialized. Total aggregated tools: ${this.toolRoutingTable.size}`
+    );
+  }
+  /**
+   * Connects to a single upstream server.
+   */
+  async connectServer(name, config) {
+    try {
+      logger.info(`Connecting upstream [${name}]...`);
+      let transport;
+      if (isStdioUpstream(config)) {
+        const baseEnv = getDefaultEnvironment();
+        const mergedEnv = { ...baseEnv };
+        if (config.env) {
+          const resolvedCustomEnv = await SecretResolver.resolveEnv(config.env);
+          for (const [k, v] of Object.entries(resolvedCustomEnv)) {
+            mergedEnv[k] = v;
+          }
+        }
+        let command = config.command;
+        let args = config.args ?? [];
+        if (process.platform === "win32") {
+          const cmdLower = config.command.toLowerCase();
+          if (["npx", "npm", "pnpm", "yarn", "bunx"].includes(cmdLower) || cmdLower.endsWith(".cmd") || cmdLower.endsWith(".bat")) {
+            command = "cmd.exe";
+            args = ["/d", "/s", "/c", config.command, ...args.map(escapeWindowsCmdArg)];
+          }
+        }
+        transport = new StdioClientTransport({
+          command,
+          args,
+          env: mergedEnv,
+          cwd: config.cwd,
+          stderr: "pipe"
+        });
+      } else if (isHttpUpstream(config)) {
+        warnIfInsecureHttp(config.url, config.headers);
+        const resolvedHeaders = config.headers ? await SecretResolver.resolveEnv(config.headers) : {};
+        const transportType = config.transport ?? "auto";
+        if (transportType === "streamable-http") {
+          transport = new StreamableHTTPClientTransport(new URL(config.url), {
+            requestInit: {
+              headers: resolvedHeaders
+            }
+          });
+        } else if (transportType === "sse") {
+          transport = new SSEClientTransport(new URL(config.url), {
+            requestInit: {
+              headers: resolvedHeaders
+            }
+          });
+        } else {
+          transport = new SSEClientTransport(new URL(config.url), {
+            requestInit: {
+              headers: resolvedHeaders
+            }
+          });
+        }
+      } else {
+        throw new Error(`Unsupported upstream configuration for server "${name}"`);
+      }
+      const client = new Client(
+        {
+          name: `contextwise-${name}`,
+          version: "0.1.0"
+        },
+        {
+          capabilities: {}
+        }
+      );
+      const conn = {
+        name,
+        config,
+        client,
+        transport,
+        status: "connecting",
+        tools: /* @__PURE__ */ new Map(),
+        reconnectAttempts: 0
+      };
+      this.connections.set(name, conn);
+      if (transport instanceof StdioClientTransport) {
+        if (transport.stderr) {
+          transport.stderr.on("data", (chunk) => {
+            const str = chunk.toString("utf-8").trim();
+            if (str) {
+              logger.debug(`[upstream:${name}:stderr] ${redactionFilter.redact(str)}`);
+            }
+          });
+        }
+      }
+      await client.connect(transport);
+      if (transport instanceof StdioClientTransport && transport.pid) {
+        supervisor.track(transport.pid, name);
+      }
+      conn.status = "connected";
+      conn.reconnectAttempts = 0;
+      logger.info(`Upstream [${name}] connected successfully.`);
+      await this.refreshServerTools(name);
+      transport.onclose = () => {
+        logger.warn(`Upstream [${name}] transport closed.`);
+        conn.status = "disconnected";
+        this.rebuildRoutingTable();
+        this.emit("toolsChanged", name, this.getAllTools());
+        const shouldReconnect = isStdioUpstream(config) ? config.autoRestart !== false : config.autoReconnect !== false;
+        if (shouldReconnect && conn.reconnectAttempts < 5) {
+          const delay = Math.min(1e3 * Math.pow(2, conn.reconnectAttempts), 15e3);
+          conn.reconnectAttempts += 1;
+          logger.info(`Scheduling auto-reconnect for [${name}] in ${delay}ms (attempt ${conn.reconnectAttempts}/5)...`);
+          setTimeout(() => {
+            if (this.connections.has(name)) {
+              this.connectServer(name, config).catch((err) => {
+                logger.error(`Reconnect attempt failed for [${name}]: ${err}`);
+              });
+            }
+          }, delay);
+        }
+      };
+      transport.onerror = (err) => {
+        logger.error(`Upstream [${name}] transport error: ${err.message || err}`);
+        conn.lastError = err.message || String(err);
+      };
+      client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+        logger.info(`[${name}] Received notifications/tools/list_changed. Refreshing tools...`);
+        await this.refreshServerTools(name);
+        this.emit("toolsChanged", name, this.getAllTools());
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error(`Failed to connect upstream [${name}]: ${msg}`);
+      const conn = this.connections.get(name);
+      if (conn) {
+        conn.status = "error";
+        conn.lastError = msg;
+      }
+    }
+  }
+  /**
+   * Refreshes the tools catalog for a specific upstream server.
+   */
+  async refreshServerTools(name) {
+    const conn = this.connections.get(name);
+    if (!conn || conn.status !== "connected") return;
+    try {
+      const response = await conn.client.listTools();
+      conn.tools.clear();
+      for (const tool of response.tools) {
+        const namespacedName = `${name}__${tool.name}`;
+        const desc = tool.description || "";
+        const annotations = tool.annotations;
+        const { readOnlyHint, idempotentHint, destructiveHint } = inferToolHints(tool.name, desc, annotations);
+        const namespacedTool = {
+          ...tool,
+          originalName: tool.name,
+          namespacedName,
+          serverName: name,
+          readOnlyHint,
+          idempotentHint,
+          destructiveHint
+        };
+        conn.tools.set(tool.name, namespacedTool);
+      }
+      logger.debug(`Loaded ${conn.tools.size} tools from upstream [${name}]`);
+      this.rebuildRoutingTable();
+    } catch (err) {
+      logger.error(`Error listing tools for [${name}]: ${err}`);
+    }
+  }
+  /**
+   * Rebuilds the global tool routing table with namespacing and fallback alias mapping.
+   */
+  rebuildRoutingTable() {
+    this.toolRoutingTable.clear();
+    for (const [serverName, conn] of this.connections.entries()) {
+      if (conn.status !== "connected") continue;
+      for (const [origName, tool] of conn.tools.entries()) {
+        this.toolRoutingTable.set(tool.namespacedName, {
+          serverName,
+          originalName: origName,
+          tool
+        });
+      }
+    }
+    const toolNameCounts = /* @__PURE__ */ new Map();
+    for (const conn of this.connections.values()) {
+      if (conn.status !== "connected") continue;
+      for (const origName of conn.tools.keys()) {
+        toolNameCounts.set(origName, (toolNameCounts.get(origName) ?? 0) + 1);
+      }
+    }
+    const RESERVED_NAMES = /* @__PURE__ */ new Set([
+      "contextwise_search_tools",
+      "contextwise_execute_tool",
+      "contextwise_browse_servers",
+      "contextwise_add_server"
+    ]);
+    for (const [serverName, conn] of this.connections.entries()) {
+      if (conn.status !== "connected") continue;
+      for (const [origName, tool] of conn.tools.entries()) {
+        if (toolNameCounts.get(origName) === 1 && !RESERVED_NAMES.has(origName)) {
+          this.toolRoutingTable.set(origName, {
+            serverName,
+            originalName: origName,
+            tool
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Returns all aggregated tools with namespaced definitions.
+   */
+  getAllTools() {
+    const list = [];
+    for (const conn of this.connections.values()) {
+      if (conn.status !== "connected") continue;
+      for (const tool of conn.tools.values()) {
+        list.push(tool);
+      }
+    }
+    return list;
+  }
+  /**
+   * Resolves a tool by name (namespaced or short name).
+   */
+  resolveTool(name) {
+    let resolved = this.toolRoutingTable.get(name);
+    if (resolved) return resolved;
+    const doubleUnderscore = name.replace(/^([a-zA-Z0-9_-]+?)_(.+)$/, "$1__$2");
+    resolved = this.toolRoutingTable.get(doubleUnderscore);
+    if (resolved) return resolved;
+    const dotToDouble = name.replace(/^([a-zA-Z0-9_-]+?)\.(.+)$/, "$1__$2");
+    resolved = this.toolRoutingTable.get(dotToDouble);
+    if (resolved) return resolved;
+    for (const serverName of this.connections.keys()) {
+      if (name.startsWith(`${serverName}_`) || name.startsWith(`${serverName}.`)) {
+        const stripped = name.slice(serverName.length + 1);
+        resolved = this.toolRoutingTable.get(stripped);
+        if (resolved) return resolved;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Executes a tool against its upstream MCP server with a timeout.
+   */
+  async executeTool(toolName, args = {}, timeoutMs = 3e4) {
+    const target = this.resolveTool(toolName);
+    if (!target) {
+      throw new Error(`Tool "${toolName}" not found in ContextWise registry.`);
+    }
+    const conn = this.connections.get(target.serverName);
+    if (!conn || conn.status !== "connected") {
+      throw new Error(
+        `Upstream server "${target.serverName}" for tool "${toolName}" is not currently connected.`
+      );
+    }
+    const safeArgs = args && typeof args === "object" ? args : {};
+    const start = performance.now();
+    logger.debug(`Dispatching tool call to [${target.serverName}]: ${target.originalName}`);
+    try {
+      const callPromise = conn.client.callTool({
+        name: target.originalName,
+        arguments: safeArgs
+      });
+      let timer = null;
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new Error(
+              `Tool execution for [${target.serverName}] ${target.originalName} timed out after ${timeoutMs}ms.`
+            )
+          );
+        }, timeoutMs);
+      });
+      const result = await Promise.race([callPromise, timeoutPromise]).finally(() => {
+        if (timer) clearTimeout(timer);
+      });
+      const latencyMs = Math.round(performance.now() - start);
+      return {
+        result,
+        latencyMs,
+        serverName: target.serverName
+      };
+    } catch (err) {
+      const latencyMs = Math.round(performance.now() - start);
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.error(
+        `Execution failed for [${target.serverName}] ${target.originalName}: ${msg}`
+      );
+      throw err;
+    }
+  }
+  /**
+   * Returns status summaries for all configured upstreams.
+   */
+  getStatus() {
+    const statuses = [];
+    for (const [name, conn] of this.connections.entries()) {
+      statuses.push({
+        name,
+        status: conn.status,
+        transportType: isStdioUpstream(conn.config) ? "stdio" : conn.transport instanceof StreamableHTTPClientTransport ? "streamable-http" : "sse",
+        toolsCount: conn.tools.size,
+        error: conn.lastError
+      });
+    }
+    return statuses;
+  }
+  /**
+   * Shuts down all upstream connections and processes.
+   */
+  async closeAll() {
+    logger.info("Closing all upstream multiplexer connections...");
+    for (const [name, conn] of this.connections.entries()) {
+      try {
+        if (conn.transport instanceof StdioClientTransport && conn.transport.pid) {
+          supervisor.killProcessTree(conn.transport.pid, name);
+        }
+        await conn.client.close();
+      } catch {
+      }
+    }
+    this.connections.clear();
+    this.toolRoutingTable.clear();
+  }
+};
+
+// src/catalog/normalizer.ts
+var ToolNormalizer = class {
+  /**
+   * Normalizes a NamespacedTool into a searchable document for BM25 and vector indexing.
+   */
+  static normalize(tool) {
+    const paramsList = [];
+    const schema = tool.inputSchema;
+    if (schema && typeof schema.properties === "object" && schema.properties !== null) {
+      const properties = schema.properties;
+      for (const [paramName, paramDef] of Object.entries(properties)) {
+        const type = typeof paramDef?.type === "string" ? paramDef.type : "any";
+        const desc = typeof paramDef?.description === "string" ? paramDef.description : "";
+        paramsList.push(`${paramName} (${type}): ${desc}`);
+      }
+    }
+    const parametersText = paramsList.join("; ");
+    const tags = this.inferTags(tool);
+    const tagsText = tags.join(", ");
+    const fullSearchableText = [
+      `Tool: ${tool.originalName} (${tool.namespacedName})`,
+      `Server: ${tool.serverName}`,
+      `Description: ${tool.description || ""}`,
+      paramsList.length > 0 ? `Parameters: ${parametersText}` : "",
+      tags.length > 0 ? `Tags: ${tagsText}` : ""
+    ].filter(Boolean).join("\n");
+    return {
+      id: tool.namespacedName,
+      toolName: tool.namespacedName,
+      originalName: tool.originalName,
+      serverName: tool.serverName,
+      description: tool.description || "",
+      parametersText,
+      tagsText,
+      fullSearchableText,
+      readOnlyHint: tool.readOnlyHint ?? false,
+      destructiveHint: tool.destructiveHint ?? false
+    };
+  }
+  /**
+   * Infers domain categorization tags from tool names and descriptions.
+   */
+  static inferTags(tool) {
+    const text = `${tool.namespacedName} ${tool.originalName} ${tool.description || ""}`.toLowerCase();
+    const tags = /* @__PURE__ */ new Set();
+    const tagRules = {
+      database: /\b(db|sql|postgres|mysql|sqlite|mongo|query|table|schema|database)\b/i,
+      filesystem: /\b(file|dir|directory|folder|read_file|write_file|fs|path)\b/i,
+      git: /\b(git|commit|branch|repo|repository|pull_request|pr|diff|merge)\b/i,
+      code: /\b(code|ast|syntax|refactor|symbol|definition|function)\b/i,
+      docker: /\b(docker|container|image|compose|podman)\b/i,
+      cloud: /\b(aws|gcp|azure|s3|ec2|lambda|cloud)\b/i,
+      communication: /\b(slack|discord|email|message|chat|notify|channel)\b/i,
+      web: /\b(http|url|fetch|request|scrape|browser|crawl|api)\b/i,
+      issue: /\b(jira|issue|linear|ticket|bug|task|tracker)\b/i
+    };
+    for (const [tag, regex] of Object.entries(tagRules)) {
+      if (regex.test(text)) {
+        tags.add(tag);
+      }
+    }
+    if (tool.readOnlyHint) tags.add("read-only");
+    if (tool.destructiveHint) tags.add("destructive");
+    return Array.from(tags);
+  }
+};
+
+// src/catalog/search.ts
+import MiniSearch from "minisearch";
+var HybridSearchEngine = class {
+  miniSearch;
+  toolMap = /* @__PURE__ */ new Map();
+  constructor() {
+    this.miniSearch = new MiniSearch({
+      fields: ["originalName", "toolName", "tagsText", "description", "parametersText"],
+      storeFields: ["id", "originalName", "serverName"],
+      searchOptions: {
+        boost: {
+          originalName: 4,
+          toolName: 3,
+          tagsText: 2.5,
+          description: 1.5,
+          parametersText: 1
+        },
+        prefix: true,
+        fuzzy: 0.2
+      }
+    });
+  }
+  /**
+   * Indexes a collection of tools.
+   */
+  indexTools(tools) {
+    this.miniSearch.removeAll();
+    this.toolMap.clear();
+    const documents = [];
+    for (const tool of tools) {
+      this.toolMap.set(tool.namespacedName, tool);
+      const doc = ToolNormalizer.normalize(tool);
+      documents.push(doc);
+    }
+    if (documents.length > 0) {
+      this.miniSearch.addAll(documents);
+      logger.debug(`Indexed ${documents.length} tools in hybrid search engine.`);
+    }
+  }
+  /**
+   * Adds or updates a single tool in the search index.
+   */
+  addTool(tool) {
+    if (this.toolMap.has(tool.namespacedName)) {
+      this.miniSearch.discard(tool.namespacedName);
+    }
+    this.toolMap.set(tool.namespacedName, tool);
+    this.miniSearch.add(ToolNormalizer.normalize(tool));
+  }
+  /**
+   * Searches for tools matching query string.
+   */
+  search(query, options = {}) {
+    const topK = Math.max(1, options.topK ?? 5);
+    const cleanQuery = (query || "").trim();
+    if (!cleanQuery) {
+      return [];
+    }
+    try {
+      const rawResults = this.miniSearch.search(cleanQuery, {
+        filter: (result) => {
+          const tool = this.toolMap.get(result.id);
+          if (!tool) return false;
+          if (options.serverName && tool.serverName !== options.serverName) return false;
+          if (options.domain) {
+            const tags = ToolNormalizer.inferTags(tool);
+            if (!tags.includes(options.domain.toLowerCase())) return false;
+          }
+          return true;
+        }
+      });
+      if (rawResults.length === 0) {
+        return [];
+      }
+      const topScore = rawResults[0].score;
+      const baseMinScore = options.minScore ?? 0.8;
+      if (topScore < baseMinScore) {
+        return [];
+      }
+      const relativeThreshold = options.similarityThreshold ?? 0.35;
+      const scoreCutoff = Math.max(baseMinScore, topScore * relativeThreshold);
+      const results = [];
+      for (const res of rawResults) {
+        const tool = this.toolMap.get(res.id);
+        if (!tool) continue;
+        if (res.score < scoreCutoff) {
+          continue;
+        }
+        results.push({
+          tool,
+          score: res.score,
+          matchTerms: res.match ? Object.keys(res.match) : [cleanQuery]
+        });
+        if (results.length >= topK) {
+          break;
+        }
+      }
+      return results;
+    } catch (err) {
+      logger.debug(`MiniSearch error on query "${cleanQuery}": ${err}`);
+      return [];
+    }
+  }
+  /**
+   * Returns total count of indexed tools.
+   */
+  get size() {
+    return this.toolMap.size;
+  }
+};
+var searchEngine = new HybridSearchEngine();
+
+// src/catalog/registry.ts
+var ToolRegistry = class {
+  allTools = /* @__PURE__ */ new Map();
+  pinnedToolNames = /* @__PURE__ */ new Set();
+  /** Set of dynamically activated tools in current session */
+  dynamicActiveTools = /* @__PURE__ */ new Map();
+  // toolName -> lastUsedTimestamp
+  maxActiveTools;
+  constructor(options = {}) {
+    this.maxActiveTools = options.maxActiveTools ?? 10;
+    if (options.pinnedToolNames) {
+      this.setPinnedTools(options.pinnedToolNames);
+    }
+  }
+  setMaxActiveTools(max) {
+    this.maxActiveTools = Math.max(1, max);
+  }
+  /**
+   * Updates LRU timestamp when a tool is invoked.
+   */
+  touchTool(name) {
+    const tool = this.getTool(name);
+    if (tool && this.dynamicActiveTools.has(tool.namespacedName)) {
+      this.dynamicActiveTools.set(tool.namespacedName, Date.now());
+    }
+  }
+  setPinnedTools(toolNames) {
+    this.pinnedToolNames = new Set(toolNames);
+    logger.debug(`Configured ${this.pinnedToolNames.size} pinned tools.`);
+  }
+  /**
+   * Registers or updates all tools from upstreams into the catalog.
+   */
+  setAllTools(tools) {
+    this.allTools.clear();
+    const toolNameCounts = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      toolNameCounts.set(tool.originalName, (toolNameCounts.get(tool.originalName) ?? 0) + 1);
+    }
+    const RESERVED_NAMES = /* @__PURE__ */ new Set([
+      "contextwise_search_tools",
+      "contextwise_execute_tool",
+      "contextwise_browse_servers",
+      "contextwise_add_server"
+    ]);
+    for (const tool of tools) {
+      this.allTools.set(tool.namespacedName, tool);
+      if (toolNameCounts.get(tool.originalName) === 1 && !RESERVED_NAMES.has(tool.originalName)) {
+        this.allTools.set(tool.originalName, tool);
+      }
+    }
+    searchEngine.indexTools(tools);
+    for (const key of this.dynamicActiveTools.keys()) {
+      if (!this.allTools.has(key)) {
+        this.dynamicActiveTools.delete(key);
+      }
+    }
+    logger.debug(`Catalog registry updated with ${tools.length} tools.`);
+  }
+  /**
+   * Retrieves a tool by either its namespaced name or original name.
+   */
+  getTool(name) {
+    return this.allTools.get(name);
+  }
+  /**
+   * Activates tools dynamically (e.g. when summoned by contextwise_search_tools).
+   * Evicts least-recently-activated tools if exceeding maxActiveTools.
+   */
+  activateTools(toolNames) {
+    const activated = [];
+    const now = Date.now();
+    for (const name of toolNames) {
+      const tool = this.getTool(name);
+      if (tool) {
+        this.dynamicActiveTools.set(tool.namespacedName, now);
+        activated.push(tool);
+      }
+    }
+    while (this.dynamicActiveTools.size > this.maxActiveTools) {
+      let oldestKey = null;
+      let oldestTime = Infinity;
+      for (const [key, time] of this.dynamicActiveTools.entries()) {
+        if (this.isPinned(key)) continue;
+        if (time < oldestTime) {
+          oldestTime = time;
+          oldestKey = key;
+        }
+      }
+      if (oldestKey) {
+        this.dynamicActiveTools.delete(oldestKey);
+        logger.debug(`Evicted inactive tool from session: ${oldestKey}`);
+      } else {
+        break;
+      }
+    }
+    return activated;
+  }
+  /**
+   * Returns whether a tool is pinned.
+   */
+  isPinned(name) {
+    const tool = this.getTool(name);
+    if (!tool) return false;
+    return this.pinnedToolNames.has(tool.originalName) || this.pinnedToolNames.has(tool.namespacedName);
+  }
+  /**
+   * Returns current active tool set to be presented to the AI client:
+   * (Pinned tools + Dynamically activated tools)
+   */
+  getActiveTools() {
+    const activeMap = /* @__PURE__ */ new Map();
+    for (const pinned of this.pinnedToolNames) {
+      const tool = this.getTool(pinned);
+      if (tool) {
+        activeMap.set(tool.namespacedName, tool);
+      }
+    }
+    for (const activeName of this.dynamicActiveTools.keys()) {
+      const tool = this.getTool(activeName);
+      if (tool) {
+        activeMap.set(tool.namespacedName, tool);
+      }
+    }
+    return Array.from(activeMap.values());
+  }
+  /**
+   * Returns all known tools in the catalog.
+   */
+  getAllTools() {
+    const unique = /* @__PURE__ */ new Map();
+    for (const tool of this.allTools.values()) {
+      unique.set(tool.namespacedName, tool);
+    }
+    return Array.from(unique.values());
+  }
+};
+var toolRegistry = new ToolRegistry();
+
+// src/guardrails/validator.ts
+import { createHash as createHash2 } from "crypto";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+var ToolArgumentValidator = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ajv;
+  validatorCache = /* @__PURE__ */ new Map();
+  constructor() {
+    const AjvClass = Ajv.default || Ajv;
+    this.ajv = new AjvClass({
+      allErrors: true,
+      strict: false,
+      coerceTypes: true
+    });
+    const addFormatsFn = addFormats.default || addFormats;
+    addFormatsFn(this.ajv);
+  }
+  computeSchemaHash(schema) {
+    try {
+      return createHash2("sha256").update(JSON.stringify(schema ?? "")).digest("hex").slice(0, 16);
+    } catch {
+      return "static";
+    }
+  }
+  /**
+   * Pre-flight validates tool arguments against the tool's inputSchema.
+   */
+  validate(toolName, schema, args) {
+    if (!schema || typeof schema !== "object") {
+      return { valid: true };
+    }
+    try {
+      const cacheKey = `${toolName}:${this.computeSchemaHash(schema)}`;
+      let validateFn = this.validatorCache.get(cacheKey);
+      if (!validateFn) {
+        const compiled = this.ajv.compile(schema);
+        this.validatorCache.set(cacheKey, compiled);
+        validateFn = compiled;
+      }
+      if (!validateFn) {
+        return { valid: true };
+      }
+      const valid = validateFn(args);
+      if (!valid && validateFn.errors) {
+        const errorMessages = validateFn.errors.map(
+          (err) => `${err.instancePath || "arguments"} ${err.message || "is invalid"}`
+        );
+        logger.debug(`Validation failed for tool ${toolName}:`, errorMessages);
+        return {
+          valid: false,
+          errors: errorMessages
+        };
+      }
+      return { valid: true };
+    } catch (err) {
+      logger.warn(`Schema compilation failed for tool ${toolName}: ${err}`);
+      return { valid: true };
+    }
+  }
+  clearCache() {
+    this.validatorCache.clear();
+  }
+};
+var argumentValidator = new ToolArgumentValidator();
+
+// src/utils/hash.ts
+import { createHash as createHash3 } from "crypto";
+function canonicalJsonStringify(obj, seen = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || obj === void 0) {
+    return "null";
+  }
+  if (typeof obj === "bigint") {
+    return `"${obj.toString()}"`;
+  }
+  if (typeof obj !== "object") {
+    return JSON.stringify(obj) ?? "null";
+  }
+  if (seen.has(obj)) {
+    return '"[Circular]"';
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return "[" + obj.map((item) => canonicalJsonStringify(item, seen)).join(",") + "]";
+  }
+  const record = obj;
+  const sortedKeys = Object.keys(record).sort();
+  const pairs = sortedKeys.map(
+    (key) => `${JSON.stringify(key)}:${canonicalJsonStringify(record[key], seen)}`
+  );
+  return "{" + pairs.join(",") + "}";
+}
+function sha256(input) {
+  return createHash3("sha256").update(input).digest("hex");
+}
+function generateToolCallCacheKey(serverName, toolName, args = {}) {
+  const canonicalArgs = canonicalJsonStringify(args);
+  return sha256(`${serverName}:${toolName}:${canonicalArgs}`);
+}
+
+// src/guardrails/cache.ts
+var ResponseCache = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTtlMs;
+  hits = 0;
+  misses = 0;
+  invalidations = 0;
+  constructor(defaultTtlSeconds = 120) {
+    this.defaultTtlMs = Math.max(1, defaultTtlSeconds || 120) * 1e3;
+  }
+  setTtlSeconds(seconds) {
+    this.defaultTtlMs = Math.max(1, seconds || 120) * 1e3;
+  }
+  /**
+   * Retrieves a cached result if available and unexpired.
+   */
+  get(serverName, toolName, args = {}) {
+    const safeArgs = args && typeof args === "object" ? args : {};
+    const key = generateToolCallCacheKey(serverName, toolName, safeArgs);
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return null;
+    }
+    this.hits++;
+    logger.debug(`Cache HIT for [${serverName}] ${toolName}`);
+    return entry.result;
+  }
+  /**
+   * Stores a tool result in the cache.
+   */
+  set(serverName, toolName, args = {}, result, ttlMs) {
+    if (!result || result.isError) return;
+    const safeArgs = args && typeof args === "object" ? args : {};
+    const key = generateToolCallCacheKey(serverName, toolName, safeArgs);
+    const effectiveTtl = Math.max(1e3, ttlMs ?? this.defaultTtlMs);
+    const expiresAt = Date.now() + effectiveTtl;
+    if (this.cache.size >= 1e3) {
+      const now = Date.now();
+      for (const [k, entry] of this.cache.entries()) {
+        if (now > entry.expiresAt) {
+          this.cache.delete(k);
+        }
+      }
+      if (this.cache.size >= 1e3) {
+        const oldestKey = this.cache.keys().next().value;
+        if (oldestKey) this.cache.delete(oldestKey);
+      }
+    }
+    this.cache.set(key, {
+      key,
+      serverName,
+      toolName,
+      result,
+      expiresAt
+    });
+    logger.debug(`Cached result for [${serverName}] ${toolName} (TTL: ${Math.round((ttlMs ?? this.defaultTtlMs) / 1e3)}s)`);
+  }
+  /**
+   * Invalidates all cache entries for a specific server (e.g. after a mutating call).
+   */
+  invalidateServer(serverName) {
+    let count = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.serverName === serverName) {
+        this.cache.delete(key);
+        count++;
+      }
+    }
+    if (count > 0) {
+      this.invalidations += count;
+      logger.debug(`Invalidated ${count} cache entries for server [${serverName}]`);
+    }
+    return count;
+  }
+  /**
+   * Clears the entire cache.
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Returns cache metrics.
+   */
+  getStats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.cache.size,
+      invalidations: this.invalidations
+    };
+  }
+};
+var responseCache = new ResponseCache();
+
+// src/guardrails/loop_breaker.ts
+var RunawayLoopBreaker = class {
+  callHistory = [];
+  consecutiveFailures = /* @__PURE__ */ new Map();
+  maxCallsPerMinute;
+  consecutiveFailureThreshold;
+  constructor(config = {}) {
+    this.maxCallsPerMinute = config.maxCallsPerMinute ?? 60;
+    this.consecutiveFailureThreshold = config.consecutiveFailureThreshold ?? 3;
+  }
+  updateConfig(config) {
+    if (config.maxCallsPerMinute !== void 0) {
+      this.maxCallsPerMinute = config.maxCallsPerMinute;
+    }
+    if (config.consecutiveFailureThreshold !== void 0) {
+      this.consecutiveFailureThreshold = config.consecutiveFailureThreshold;
+    }
+  }
+  /**
+   * Checks if a tool call is permitted before execution with detailed classification.
+   */
+  checkPreFlightDetailed(serverName, toolName, args = {}) {
+    const safeArgs = args && typeof args === "object" ? args : {};
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    this.callHistory = this.callHistory.filter((call) => call.timestamp > oneMinuteAgo);
+    if (this.callHistory.length >= this.maxCallsPerMinute) {
+      const message = `Rate limit exceeded: Session reached maximum of ${this.maxCallsPerMinute} tool calls per minute. Throttling execution.`;
+      logger.warn(message);
+      return { allowed: false, reason: "rate_limited", message };
+    }
+    const callKey = generateToolCallCacheKey(serverName, toolName, safeArgs);
+    const failureCount = this.consecutiveFailures.get(callKey) ?? 0;
+    if (failureCount >= this.consecutiveFailureThreshold) {
+      const message = `Circuit breaker tripped: Tool "${toolName}" has failed ${failureCount} consecutive times with identical arguments. Please alter arguments or change strategy.`;
+      logger.error(message);
+      return { allowed: false, reason: "circuit_breaker", message };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Checks if a tool call is permitted before execution.
+   * Returns null if allowed, or an error string if blocked by guardrails.
+   */
+  checkPreFlight(serverName, toolName, args = {}) {
+    const res = this.checkPreFlightDetailed(serverName, toolName, args);
+    return res.allowed ? null : res.message;
+  }
+  /**
+   * Records execution outcome of a tool call.
+   */
+  recordCall(serverName, toolName, args = {}, isError = false) {
+    const safeArgs = args && typeof args === "object" ? args : {};
+    const now = Date.now();
+    const callKey = generateToolCallCacheKey(serverName, toolName, safeArgs);
+    this.callHistory.push({
+      callKey,
+      toolName,
+      timestamp: now,
+      isError
+    });
+    if (isError) {
+      const current = this.consecutiveFailures.get(callKey) ?? 0;
+      this.consecutiveFailures.set(callKey, current + 1);
+      if (this.consecutiveFailures.size > 500) {
+        const firstKey = this.consecutiveFailures.keys().next().value;
+        if (firstKey) {
+          this.consecutiveFailures.delete(firstKey);
+        }
+      }
+    } else {
+      this.consecutiveFailures.delete(callKey);
+    }
+  }
+  /**
+   * Resets all history and breakers.
+   */
+  reset() {
+    this.callHistory = [];
+    this.consecutiveFailures.clear();
+  }
+};
+var loopBreaker = new RunawayLoopBreaker();
+
+// src/metrics/collector.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+var SCHEMA_TOKENS_PER_TOOL = 150;
+var CACHE_TOKENS_PER_HIT = 800;
+var LOOP_PREVENTION_TOKENS_PER_TRIP = 2500;
+var LLM_PRICING = {
+  CLAUDE_SONNET: 3,
+  // Claude 3.5 & 3.7 Sonnet ($3.00 / 1M)
+  GPT_4O: 2.5,
+  // OpenAI GPT-4o ($2.50 / 1M)
+  CLAUDE_OPUS: 15,
+  // Claude 3 Opus ($15.00 / 1M)
+  HAIKU_OR_MINI: 0.25
+  // Claude 3.5 Haiku / GPT-4o mini ($0.25 / 1M)
+};
+function calculateDollarSavings(tokens) {
+  return {
+    claudeSonnet: Number((tokens / 1e6 * LLM_PRICING.CLAUDE_SONNET).toFixed(2)),
+    gpt4o: Number((tokens / 1e6 * LLM_PRICING.GPT_4O).toFixed(2)),
+    claudeOpus: Number((tokens / 1e6 * LLM_PRICING.CLAUDE_OPUS).toFixed(2)),
+    haikuOrMini: Number((tokens / 1e6 * LLM_PRICING.HAIKU_OR_MINI).toFixed(2))
+  };
+}
+function getDefaultMetricsPath() {
+  if (process.env.CONTEXTWISE_METRICS_PATH) {
+    return process.env.CONTEXTWISE_METRICS_PATH;
+  }
+  return join5(homedir5(), ".contextwise", "metrics.json");
+}
+var MetricsCollector = class {
+  storagePath;
+  totalCatalogTools = 0;
+  currentlyExposedTools = 0;
+  debounceTimer = null;
+  data;
+  constructor(storagePath) {
+    this.storagePath = storagePath ?? getDefaultMetricsPath();
+    this.data = this.createDefaultData();
+    this.loadFromDisk();
+  }
+  createDefaultData() {
+    const now = Date.now();
+    return {
+      version: 1,
+      firstRecordedAt: now,
+      lastRecordedAt: now,
+      totalCalls: 0,
+      cachedCalls: 0,
+      errorCalls: 0,
+      throttles: 0,
+      loopsPrevented: 0,
+      totalLatencyMs: 0,
+      schemaPruningTokensSaved: 0,
+      cacheTokensSaved: 0,
+      loopPreventionTokensSaved: 0,
+      totalTokensSaved: 0,
+      recentCalls: []
+    };
+  }
+  setStoragePath(path) {
+    this.storagePath = path;
+    this.data = this.createDefaultData();
+    this.loadFromDisk();
+  }
+  getStoragePath() {
+    return this.storagePath;
+  }
+  /**
+   * Reloads persisted state from disk.
+   */
+  reload() {
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    try {
+      if (existsSync5(this.storagePath)) {
+        const raw = readFileSync5(this.storagePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object") {
+          this.data = {
+            ...this.createDefaultData(),
+            ...parsed
+          };
+          logger.debug(`Loaded metrics from ${this.storagePath}`);
+        }
+      }
+    } catch (err) {
+      logger.debug(`Could not load metrics from ${this.storagePath}: ${err}`);
+    }
+  }
+  /**
+   * Schedules a debounced disk flush.
+   */
+  schedulePersist() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.flushSync();
+    }, 200);
+  }
+  /**
+   * Synchronously writes metrics to disk.
+   */
+  flushSync() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    try {
+      const dir = dirname3(this.storagePath);
+      if (!existsSync5(dir)) {
+        mkdirSync3(dir, { recursive: true });
+      }
+      const tempFile = `${this.storagePath}.${Date.now()}.tmp`;
+      const json = JSON.stringify(this.data, null, 2);
+      writeFileSync3(tempFile, json, "utf-8");
+      renameSync2(tempFile, this.storagePath);
+    } catch {
+      try {
+        writeFileSync3(this.storagePath, JSON.stringify(this.data, null, 2), "utf-8");
+      } catch (err) {
+        logger.debug(`Failed persisting metrics: ${err}`);
+      }
+    }
+  }
+  /**
+   * Updates catalog sizing to calculate per-turn token savings.
+   */
+  updateToolCounts(catalogTotal, exposedTotal) {
+    this.totalCatalogTools = catalogTotal;
+    this.currentlyExposedTools = exposedTotal;
+  }
+  /**
+   * Records savings from pruning tools during schema listing.
+   */
+  recordSchemaPruning(catalogTotal, exposedTotal) {
+    this.updateToolCounts(catalogTotal, exposedTotal);
+    const avoidedTools = Math.max(0, catalogTotal - exposedTotal);
+    const tokensSaved = avoidedTools * SCHEMA_TOKENS_PER_TOOL;
+    this.data.schemaPruningTokensSaved += tokensSaved;
+    this.data.totalTokensSaved = this.data.schemaPruningTokensSaved + this.data.cacheTokensSaved + this.data.loopPreventionTokensSaved;
+    this.data.lastRecordedAt = Date.now();
+    this.schedulePersist();
+  }
+  /**
+   * Records a caught/prevented runaway loop or circuit breaker trip.
+   */
+  recordLoopPrevented(toolName, serverName) {
+    this.data.loopsPrevented += 1;
+    this.data.loopPreventionTokensSaved += LOOP_PREVENTION_TOKENS_PER_TRIP;
+    this.data.totalTokensSaved = this.data.schemaPruningTokensSaved + this.data.cacheTokensSaved + this.data.loopPreventionTokensSaved;
+    this.data.lastRecordedAt = Date.now();
+    logger.debug(
+      `Recorded prevented loop for ${toolName ?? "unknown"} on ${serverName ?? "unknown"} (saved ~${LOOP_PREVENTION_TOKENS_PER_TRIP} tokens)`
+    );
+    this.schedulePersist();
+  }
+  /**
+   * Records a rate-limit velocity throttle event (tracked separately from circuit trips).
+   */
+  recordThrottle(toolName, serverName) {
+    this.data.throttles = (this.data.throttles || 0) + 1;
+    this.data.lastRecordedAt = Date.now();
+    logger.debug(
+      `Recorded rate limit throttle for ${toolName ?? "unknown"} on ${serverName ?? "unknown"}`
+    );
+    this.schedulePersist();
+  }
+  /**
+   * Records a tool execution.
+   */
+  recordExecution(params) {
+    const isError = params.isError ?? false;
+    let tokensSavedThisCall = 0;
+    this.data.totalCalls += 1;
+    this.data.lastRecordedAt = Date.now();
+    if (params.cached) {
+      this.data.cachedCalls += 1;
+      this.data.cacheTokensSaved += CACHE_TOKENS_PER_HIT;
+      tokensSavedThisCall = CACHE_TOKENS_PER_HIT;
+    } else {
+      tokensSavedThisCall = 0;
+      this.data.totalLatencyMs += params.latencyMs;
+    }
+    if (isError) {
+      this.data.errorCalls += 1;
+    }
+    this.data.totalTokensSaved = this.data.schemaPruningTokensSaved + this.data.cacheTokensSaved + this.data.loopPreventionTokensSaved;
+    const metric = {
+      timestamp: Date.now(),
+      toolName: params.toolName,
+      serverName: params.serverName,
+      latencyMs: params.latencyMs,
+      cached: params.cached,
+      tokensSavedEstimate: tokensSavedThisCall,
+      isError
+    };
+    this.data.recentCalls.push(metric);
+    if (this.data.recentCalls.length > 100) {
+      this.data.recentCalls.shift();
+    }
+    logger.debug(
+      `Recorded metric for ${params.toolName} (latency: ${params.latencyMs}ms, cached: ${params.cached}, saved ~${tokensSavedThisCall} tokens)`
+    );
+    this.schedulePersist();
+  }
+  /**
+   * Returns aggregated metrics summary with dollar ROI calculations.
+   */
+  getSummary(activeUpstreamsCount = 0) {
+    const totalCalls = this.data.totalCalls;
+    const cachedCalls = this.data.cachedCalls;
+    const errorCalls = this.data.errorCalls;
+    const throttles = this.data.throttles || 0;
+    const loopsPrevented = this.data.loopsPrevented;
+    const executedCalls = totalCalls - cachedCalls;
+    const averageLatencyMs = executedCalls > 0 ? Math.round(this.data.totalLatencyMs / executedCalls) : 0;
+    const cacheHitRatePct = totalCalls > 0 ? Math.round(cachedCalls / totalCalls * 100) : 0;
+    const totalTokensSaved = this.data.totalTokensSaved;
+    const dollarSavings = calculateDollarSavings(totalTokensSaved);
+    return {
+      firstRecordedAt: this.data.firstRecordedAt,
+      lastRecordedAt: this.data.lastRecordedAt,
+      totalCalls,
+      cachedCalls,
+      cacheHitRatePct,
+      errorCalls,
+      throttles,
+      loopsPrevented,
+      averageLatencyMs,
+      schemaPruningTokensSaved: this.data.schemaPruningTokensSaved,
+      cacheTokensSaved: this.data.cacheTokensSaved,
+      loopPreventionTokensSaved: this.data.loopPreventionTokensSaved,
+      estimatedTotalTokensSaved: totalTokensSaved,
+      dollarSavings,
+      activeUpstreamsCount,
+      totalCatalogToolsCount: this.totalCatalogTools,
+      exposedToolsCount: this.currentlyExposedTools
+    };
+  }
+  /**
+   * Clears recorded metrics on disk and memory.
+   */
+  reset() {
+    this.data = this.createDefaultData();
+    this.flushSync();
+  }
+};
+var metricsCollector = new MetricsCollector();
+
+// src/router/meta_tools.ts
+var SEARCH_TOOLS_NAME = "contextwise_search_tools";
+var EXECUTE_TOOL_NAME = "contextwise_execute_tool";
+var BROWSE_SERVERS_NAME = "contextwise_browse_servers";
+var ADD_SERVER_NAME = "contextwise_add_server";
+var SEARCH_TOOLS_DEFINITION = {
+  name: SEARCH_TOOLS_NAME,
+  description: "Searches ContextWise tool catalog for relevant tools based on natural language intent. Returns matched tool signatures, parameter descriptions, and automatically makes them available to invoke.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: 'Natural language query describing what task you want to perform or which tool you need (e.g., "query postgres database", "read a file", "create git commit")'
+      },
+      domain: {
+        type: "string",
+        description: 'Optional domain tag to filter tools (e.g., "database", "filesystem", "git", "web", "docker")'
+      },
+      topK: {
+        type: "number",
+        description: "Maximum number of tools to return (default: 5)"
+      },
+      activate: {
+        type: "boolean",
+        description: "Whether to activate the matched tools into the active context window (default: true)"
+      }
+    },
+    required: ["query"]
+  }
+};
+var EXECUTE_TOOL_DEFINITION = {
+  name: EXECUTE_TOOL_NAME,
+  description: "Universally executes any indexed upstream tool, even if its schema is not pre-loaded into your active context window. Use this after finding tools via contextwise_search_tools.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      tool_name: {
+        type: "string",
+        description: "The name or namespaced name of the tool to execute"
+      },
+      arguments: {
+        type: "object",
+        description: "Arguments to pass to the target tool",
+        default: {}
+      }
+    },
+    required: ["tool_name"]
+  }
+};
+var BROWSE_SERVERS_DEFINITION = {
+  name: BROWSE_SERVERS_NAME,
+  description: "Browses available MCP servers from local curated presets, the Official MCP Registry, and Smithery. Displays which registry each server is listed in.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: 'Optional keyword to search for specific servers (e.g., "database", "git", "search", "linear")'
+      },
+      category: {
+        type: "string",
+        description: 'Optional category filter: "database", "developer", "web", "filesystem", "communication", "devops"',
+        enum: ["database", "developer", "web", "filesystem", "communication", "devops"]
+      },
+      source: {
+        type: "string",
+        description: 'Filter by registry source: "all" (default), "official", "smithery", or "curated"',
+        enum: ["all", "official", "smithery", "curated"]
+      }
+    }
+  }
+};
+var ADD_SERVER_DEFINITION = {
+  name: ADD_SERVER_NAME,
+  description: "Hot-loads a new MCP server into ContextWise in real time, persists it to contextwise.json, and immediately makes all its tools available to this session. Supports presets, Smithery packages, custom stdio commands, and remote SSE URLs.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: 'Unique identifier name for this server (e.g., "postgres", "github", "my-server")'
+      },
+      preset: {
+        type: "string",
+        description: 'Optional name of a verified preset to configure (e.g., "postgres", "sqlite", "github", "linear", "fetch", "puppeteer", "brave-search", "slack")'
+      },
+      smithery: {
+        type: "string",
+        description: 'Optional Smithery package name to install and run via @smithery/cli (e.g. "@smithery-ai/github" or "github")'
+      },
+      command: {
+        type: "string",
+        description: 'Executable command for stdio server (e.g., "npx", "python", "docker")'
+      },
+      args: {
+        type: "array",
+        items: { type: "string" },
+        description: "Command-line arguments to pass to the executable"
+      },
+      env: {
+        type: "object",
+        description: "Environment variables to pass (e.g., API keys, tokens)"
+      },
+      url: {
+        type: "string",
+        description: "Remote SSE endpoint URL if connecting to a remote MCP server over HTTP/SSE"
+      },
+      headers: {
+        type: "object",
+        description: "HTTP headers for remote SSE server (e.g. Authorization)"
+      }
+    },
+    required: ["name"]
+  }
+};
+
+// src/registry/known_servers.ts
+var KNOWN_SERVERS = [
+  // --- Databases ---
+  {
+    id: "postgres",
+    name: "postgres",
+    displayName: "PostgreSQL Database",
+    category: "database",
+    description: "Inspect schemas, browse tables, and execute read/write SQL queries on PostgreSQL.",
+    tags: ["database", "sql", "postgres", "tables"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-postgres"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "connectionString",
+        type: "arg",
+        description: "PostgreSQL connection URL",
+        placeholder: "postgresql://username:password@localhost:5432/mydb"
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/postgres"
+  },
+  {
+    id: "sqlite",
+    name: "sqlite",
+    displayName: "SQLite Database",
+    category: "database",
+    description: "Inspect schemas, browse tables, and execute SQL queries on local SQLite database files.",
+    tags: ["database", "sqlite", "sql", "local"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-sqlite", "--db-path"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "dbPath",
+        type: "arg",
+        description: "Absolute or relative path to SQLite .db file",
+        placeholder: "./database.sqlite"
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/sqlite"
+  },
+  // --- Developer Tools ---
+  {
+    id: "github",
+    name: "github",
+    displayName: "GitHub Integration",
+    category: "developer",
+    description: "Search repositories, manage pull requests, create issues, and inspect commit history on GitHub.",
+    tags: ["git", "github", "prs", "issues", "code"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-github"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "GITHUB_PERSONAL_ACCESS_TOKEN",
+        type: "env",
+        description: "GitHub Personal Access Token (classic or fine-grained)",
+        placeholder: "ghp_..."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/github"
+  },
+  {
+    id: "git",
+    name: "git",
+    displayName: "Local Git Repository",
+    category: "developer",
+    description: "Inspect working trees, git diffs, commits, branches, and logs directly on local git repos.",
+    tags: ["git", "diff", "commit", "branches", "repository"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-git", "--repository"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "repositoryPath",
+        type: "arg",
+        description: "Path to local Git repository root",
+        default: ".",
+        placeholder: "."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/git"
+  },
+  {
+    id: "gitlab",
+    name: "gitlab",
+    displayName: "GitLab Integration",
+    category: "developer",
+    description: "Manage GitLab projects, merge requests, issues, and pipelines.",
+    tags: ["git", "gitlab", "ci", "mr", "issues"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-gitlab"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "GITLAB_PERSONAL_ACCESS_TOKEN",
+        type: "env",
+        description: "GitLab Personal Access Token",
+        placeholder: "glpat-..."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/gitlab"
+  },
+  {
+    id: "linear",
+    name: "linear",
+    displayName: "Linear Project Tracking",
+    category: "developer",
+    description: "Search, create, and update Linear issues, teams, projects, and cycles.",
+    tags: ["issue", "linear", "ticket", "project", "tasks"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-linear"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "LINEAR_API_KEY",
+        type: "env",
+        description: "Linear API Key",
+        placeholder: "lin_api_..."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/linear"
+  },
+  // --- Web, Search & Browser Automation ---
+  {
+    id: "brave-search",
+    name: "brave-search",
+    displayName: "Brave Web Search",
+    category: "web",
+    description: "Privacy-preserving real-time web search and local location searches.",
+    tags: ["web", "search", "brave", "internet", "news"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-brave-search"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "BRAVE_API_KEY",
+        type: "env",
+        description: "Brave Search API Key from brave.com/search/api",
+        placeholder: "BSA..."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/brave-search"
+  },
+  {
+    id: "fetch",
+    name: "fetch",
+    displayName: "Web Fetch & Scraper",
+    category: "web",
+    description: "Fetch web pages, convert HTML to clean Markdown, and inspect HTTP headers.",
+    tags: ["web", "fetch", "http", "html", "scrape"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-fetch"],
+    defaultEnv: {},
+    requiredParams: [],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch"
+  },
+  {
+    id: "puppeteer",
+    name: "puppeteer",
+    displayName: "Puppeteer Browser Automation",
+    category: "web",
+    description: "Control headless Chrome to navigate pages, capture screenshots, evaluate JS, and interact with web apps.",
+    tags: ["web", "browser", "puppeteer", "automation", "screenshot"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-puppeteer"],
+    defaultEnv: {},
+    requiredParams: [],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/puppeteer"
+  },
+  // --- Filesystem & Memory ---
+  {
+    id: "filesystem",
+    name: "filesystem",
+    displayName: "Local Filesystem Access",
+    category: "filesystem",
+    description: "Secure scoped filesystem access to read, write, search, and manage files in allowed directories.",
+    tags: ["filesystem", "files", "disk", "directory", "storage"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-filesystem"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "allowedDirectory",
+        type: "arg",
+        description: "Root directory allowed for file operations",
+        default: ".",
+        placeholder: "./"
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem"
+  },
+  {
+    id: "memory",
+    name: "memory",
+    displayName: "Graph Knowledge Memory",
+    category: "filesystem",
+    description: "Long-term persistent knowledge graph memory using entities, relations, and observations.",
+    tags: ["memory", "knowledge", "graph", "persistence", "history"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-memory"],
+    defaultEnv: {},
+    requiredParams: [],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/memory"
+  },
+  // --- Communication ---
+  {
+    id: "slack",
+    name: "slack",
+    displayName: "Slack Workspace",
+    category: "communication",
+    description: "Read and send messages, list channels, and reply to threads in Slack workspaces.",
+    tags: ["slack", "chat", "communication", "message", "channels"],
+    command: "npx",
+    defaultArgs: ["-y", "@modelcontextprotocol/server-slack"],
+    defaultEnv: {},
+    requiredParams: [
+      {
+        name: "SLACK_BOT_TOKEN",
+        type: "env",
+        description: "Slack Bot User OAuth Token (xoxb-...)",
+        placeholder: "xoxb-..."
+      },
+      {
+        name: "SLACK_TEAM_ID",
+        type: "env",
+        description: "Slack Workspace Team ID (T...)",
+        placeholder: "T..."
+      }
+    ],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers/tree/main/src/slack"
+  },
+  // --- DevOps & Cloud ---
+  {
+    id: "docker",
+    name: "docker",
+    displayName: "Docker Container Engine",
+    category: "devops",
+    description: "List, start, stop, and inspect Docker containers, images, and volumes.",
+    tags: ["docker", "container", "devops", "images"],
+    command: "npx",
+    defaultArgs: ["-y", "mcp-server-docker"],
+    defaultEnv: {},
+    requiredParams: [],
+    documentationUrl: "https://github.com/modelcontextprotocol/servers"
+  }
+];
+var KnownServerRegistry = class {
+  /**
+   * Returns all known server definitions.
+   */
+  static getAll() {
+    return KNOWN_SERVERS;
+  }
+  /**
+   * Finds a known server by ID or name.
+   */
+  static find(idOrName) {
+    const clean = idOrName.trim().toLowerCase();
+    return KNOWN_SERVERS.find(
+      (s) => s.id === clean || s.name.toLowerCase() === clean
+    );
+  }
+  /**
+   * Searches known servers by query string and/or category.
+   */
+  static search(query, category) {
+    let list = KNOWN_SERVERS;
+    if (category) {
+      const catClean = category.toLowerCase();
+      list = list.filter((s) => s.category === catClean);
+    }
+    if (query && query.trim()) {
+      const q = query.trim().toLowerCase();
+      list = list.filter(
+        (s) => s.name.toLowerCase().includes(q) || s.displayName.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.tags.some((t) => t.includes(q))
+      );
+    }
+    return list;
+  }
+  /**
+   * Returns all unique categories available.
+   */
+  static getCategories() {
+    const set = /* @__PURE__ */ new Set();
+    for (const s of KNOWN_SERVERS) {
+      set.add(s.category);
+    }
+    return Array.from(set);
+  }
+  /**
+   * Builds an UpstreamServerConfig from a KnownServerDefinition and supplied parameters.
+   */
+  static buildConfig(serverDef, params = {}) {
+    const finalArgs = [...serverDef.defaultArgs, ...params.args ?? []];
+    const finalEnv = { ...serverDef.defaultEnv, ...params.env ?? {} };
+    return {
+      command: serverDef.command,
+      args: finalArgs,
+      env: finalEnv,
+      autoRestart: true
+    };
+  }
+};
+
+// src/registry/official_client.ts
+var OfficialRegistryClient = class {
+  static BASE_URL = "https://registry.modelcontextprotocol.io/v0.1/servers";
+  /**
+   * Searches the official canonical MCP registry for public servers.
+   */
+  static async search(query, limit = 10, timeoutMs = 3e3) {
+    try {
+      const url = new URL(this.BASE_URL);
+      if (query && query.trim()) {
+        url.searchParams.set("search", query.trim());
+      }
+      url.searchParams.set("limit", String(limit));
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      logger.debug(`Querying Official MCP Registry: ${url.toString()}`);
+      const res = await fetch(url.toString(), {
+        signal: controller.signal,
+        headers: {
+          Accept: "application/json",
+          "User-Agent": "ContextWise-Proxy/0.1.0"
+        }
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        logger.debug(`Official MCP Registry responded with status: ${res.status}`);
+        return [];
+      }
+      const data = await res.json();
+      if (!data.servers || !Array.isArray(data.servers)) {
+        return [];
+      }
+      return data.servers.filter((item) => Boolean(item && item.server && typeof item.server.name === "string")).map((item) => {
+        const s = item.server;
+        const remoteUrl = s.remotes?.[0]?.url;
+        const npmPkg = s.packages?.find((p) => p.registryType === "npm")?.identifier;
+        return {
+          id: s.name,
+          name: s.name,
+          displayName: s.title || s.name,
+          description: s.description || "No description provided.",
+          source: "official",
+          sourceLabel: "Official MCP Registry",
+          category: "community",
+          tags: ["official", "mcp-registry"],
+          installHint: `contextwise add "${s.name}"`,
+          homepage: s.repository?.url || s.remotes?.[0]?.url || `https://registry.modelcontextprotocol.io`,
+          requiredParams: [],
+          suggestedConfig: remoteUrl ? { url: remoteUrl, headers: {}, transport: "auto", autoReconnect: true } : npmPkg ? { command: "npx", args: ["-y", npmPkg], env: {}, autoRestart: true } : void 0
+        };
+      });
+    } catch (err) {
+      logger.debug(`Official MCP Registry query skipped or timed out: ${err}`);
+      return [];
+    }
+  }
+};
+
+// src/registry/smithery_client.ts
+var SmitheryClient = class {
+  static BASE_URL = "https://api.smithery.ai/servers";
+  /**
+   * Searches the Smithery.ai registry for community and hosted MCP servers.
+   */
+  static async search(query, apiKey, timeoutMs = 3e3) {
+    try {
+      const url = new URL(this.BASE_URL);
+      if (query && query.trim()) {
+        url.searchParams.set("q", query.trim());
+      }
+      const key = apiKey || process.env.SMITHERY_API_KEY;
+      const headers = {
+        Accept: "application/json",
+        "User-Agent": "ContextWise-Proxy/0.1.0"
+      };
+      if (key) {
+        headers["Authorization"] = `Bearer ${key}`;
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      logger.debug(`Querying Smithery Registry: ${url.toString()}`);
+      const res = await fetch(url.toString(), {
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) {
+        logger.debug(`Smithery API responded with status: ${res.status}`);
+        return [];
+      }
+      const data = await res.json();
+      if (!data.servers || !Array.isArray(data.servers)) {
+        return [];
+      }
+      return data.servers.filter((item) => Boolean(item && typeof item.qualifiedName === "string")).map((item) => ({
+        id: item.qualifiedName,
+        name: item.qualifiedName,
+        displayName: item.displayName || item.qualifiedName,
+        description: item.description || "No description provided.",
+        source: "smithery",
+        sourceLabel: "Smithery",
+        category: "marketplace",
+        tags: ["smithery", ...item.verified ? ["verified"] : []],
+        installHint: `contextwise add "${item.qualifiedName}" --smithery`,
+        homepage: item.homepage || `https://smithery.ai/servers/${item.qualifiedName}`,
+        verified: item.verified,
+        requiredParams: [],
+        suggestedConfig: this.buildServerConfig(item.qualifiedName, { apiKey: key })
+      }));
+    } catch (err) {
+      logger.debug(`Smithery Registry query skipped or timed out: ${err}`);
+      return [];
+    }
+  }
+  /**
+   * Builds an UpstreamServerConfig that runs a Smithery MCP server using @smithery/cli runner.
+   */
+  static buildServerConfig(qualifiedName, options = {}) {
+    const key = options.apiKey || process.env.SMITHERY_API_KEY;
+    const env = { ...options.env || {} };
+    if (key) {
+      env["SMITHERY_API_KEY"] = key;
+    }
+    return {
+      command: "npx",
+      args: ["-y", "@smithery/cli@latest", "run", qualifiedName],
+      env,
+      autoRestart: true
+    };
+  }
+};
+
+// src/registry/remote_registry.ts
+var UnifiedRegistryClient = class {
+  /**
+   * Searches across all available registries (Curated Presets, Official MCP Registry, and Smithery).
+   */
+  static async search(options = {}) {
+    const query = options.query?.trim();
+    const category = options.category?.trim();
+    const source = options.source ?? "all";
+    const limit = options.limit ?? 15;
+    const timeoutMs = options.timeoutMs ?? 3e3;
+    const results = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    if (source === "all" || source === "curated") {
+      const curated = KnownServerRegistry.search(query, category);
+      for (const s of curated) {
+        seenIds.add(s.id.toLowerCase());
+        seenIds.add(s.name.toLowerCase());
+        results.push({
+          id: s.id,
+          name: s.name,
+          displayName: s.displayName,
+          description: s.description,
+          source: "curated",
+          sourceLabel: "Curated / Verified",
+          category: s.category,
+          tags: s.tags,
+          installHint: `contextwise add ${s.id}`,
+          homepage: s.documentationUrl,
+          verified: true,
+          requiredParams: s.requiredParams,
+          suggestedConfig: KnownServerRegistry.buildConfig(s)
+        });
+      }
+    }
+    const remoteQuery = query || category;
+    const promises = [];
+    if (source === "all" || source === "official") {
+      promises.push(OfficialRegistryClient.search(remoteQuery, limit, timeoutMs));
+    }
+    if (source === "all" || source === "smithery") {
+      promises.push(
+        SmitheryClient.search(remoteQuery, options.smitheryApiKey, timeoutMs)
+      );
+    }
+    if (promises.length > 0) {
+      const settled = await Promise.allSettled(promises);
+      for (const res of settled) {
+        if (res.status === "fulfilled" && Array.isArray(res.value)) {
+          for (const server of res.value) {
+            const cleanId = server.id.toLowerCase();
+            const cleanName = server.name.toLowerCase();
+            if (!seenIds.has(cleanId) && !seenIds.has(cleanName)) {
+              seenIds.add(cleanId);
+              seenIds.add(cleanName);
+              results.push(server);
+            }
+          }
+        }
+      }
+    }
+    return results;
+  }
+};
+
+// src/registry/recommender.ts
+var ServerRecommender = class {
+  /**
+   * Generates actionable server recommendations when an agent lacks tools for a given task.
+   */
+  static async recommendForTask(query, domain, limit = 3) {
+    const servers = await UnifiedRegistryClient.search({
+      query,
+      category: domain,
+      limit
+    });
+    if (servers.length === 0) {
+      return {
+        hasRecommendations: false,
+        message: `No matching tools found for query "${query}", and no matching MCP servers were found in online registries.`,
+        recommendedServers: []
+      };
+    }
+    const lines = [
+      `\u26A0\uFE0F Capability Gap Detected: No active tools in your connected ContextWise servers match "${query}".`,
+      "",
+      `\u{1F4A1} Recommended MCP servers to add for this capability:`
+    ];
+    servers.forEach((s, idx) => {
+      let installExample = `${ADD_SERVER_NAME}(name: "${s.id}", preset: "${s.id}")`;
+      if (s.source === "smithery") {
+        installExample = `${ADD_SERVER_NAME}(name: "${s.id}", smithery: "${s.id}")`;
+      } else if (s.source === "official") {
+        installExample = `${ADD_SERVER_NAME}(name: "${s.id}")`;
+      }
+      const params = s.requiredParams && s.requiredParams.length > 0 ? `
+   - Required configuration: ${s.requiredParams.map((p) => `\`${p.name}\` (${p.type}: ${p.description})`).join(", ")}` : "";
+      lines.push(
+        `${idx + 1}. **${s.displayName}** (\`${s.id}\`) \u2014 Registry: **${s.sourceLabel}**`
+      );
+      lines.push(`   - ${s.description}${params}`);
+      lines.push(`   - Direct install call: \`${installExample}\``);
+    });
+    lines.push("");
+    lines.push(
+      `To proceed with this task, invoke \`${ADD_SERVER_NAME}\` with the chosen server (asking the user for any required credentials if needed). ContextWise will immediately hot-load the server and make its tools available in this session without restarting.`
+    );
+    return {
+      hasRecommendations: true,
+      message: lines.join("\n"),
+      recommendedServers: servers
+    };
+  }
+};
+
+// src/registry/manager.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname4, resolve as resolve2 } from "path";
+var ServerManager = class {
+  /**
+   * Finds the path to contextwise.json in the current working directory.
+   */
+  static findConfigPath(customPath, cwd = process.cwd()) {
+    if (customPath) {
+      return resolve2(cwd, customPath);
+    }
+    if (process.env.CONTEXTWISE_CONFIG) {
+      return resolve2(cwd, process.env.CONTEXTWISE_CONFIG);
+    }
+    const standardPath = resolve2(cwd, "contextwise.json");
+    if (existsSync6(standardPath)) {
+      return standardPath;
+    }
+    const dotPath = resolve2(cwd, ".contextwise.json");
+    if (existsSync6(dotPath)) {
+      return dotPath;
+    }
+    return standardPath;
+  }
+  /**
+   * Loads the current configuration or returns an empty default config.
+   */
+  static loadConfig(configPath, cwd = process.cwd()) {
+    const filePath = this.findConfigPath(configPath, cwd);
+    if (!existsSync6(filePath)) {
+      return {
+        config: ContextWiseConfigSchema.parse({}),
+        path: filePath
+      };
+    }
+    try {
+      const raw = readFileSync6(filePath, "utf-8");
+      return {
+        config: ContextWiseConfigSchema.parse(JSON.parse(raw)),
+        path: filePath
+      };
+    } catch (err) {
+      logger.warn(`Could not parse existing config at ${filePath}: ${err}. Starting fresh.`);
+      return {
+        config: ContextWiseConfigSchema.parse({}),
+        path: filePath
+      };
+    }
+  }
+  /**
+   * Persists an upstream server configuration to contextwise.json.
+   */
+  static saveUpstream(name, serverConfig, configPath, cwd = process.cwd()) {
+    const { config, path: filePath } = this.loadConfig(configPath, cwd);
+    config.upstreams[name] = serverConfig;
+    const dir = dirname4(filePath);
+    if (!existsSync6(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    writeFileSync4(filePath, JSON.stringify(config, null, 2), "utf-8");
+    logger.info(`Persisted upstream "${name}" into ${filePath}`);
+    return filePath;
+  }
+  /**
+   * Removes an upstream server from contextwise.json.
+   */
+  static removeUpstream(name, configPath, cwd = process.cwd()) {
+    const { config, path: filePath } = this.loadConfig(configPath, cwd);
+    if (!config.upstreams[name]) {
+      return false;
+    }
+    delete config.upstreams[name];
+    writeFileSync4(filePath, JSON.stringify(config, null, 2), "utf-8");
+    logger.info(`Removed upstream "${name}" from ${filePath}`);
+    return true;
+  }
+};
+
+// src/router/workspace.ts
+import { existsSync as existsSync7, readdirSync } from "fs";
+import { resolve as resolve3 } from "path";
+var WorkspaceContextPrimer = class {
+  /**
+   * Scans a workspace directory to detect technical domains and pre-prime relevant tools.
+   */
+  static analyzeWorkspace(dirPath = process.cwd()) {
+    const domains = /* @__PURE__ */ new Set();
+    const queries = /* @__PURE__ */ new Set();
+    try {
+      if (!existsSync7(dirPath)) {
+        return { detectedDomains: [], suggestedQueries: [] };
+      }
+      if (existsSync7(resolve3(dirPath, ".git"))) {
+        domains.add("git");
+        queries.add("git status and diff tools");
+      }
+      if (existsSync7(resolve3(dirPath, "Dockerfile")) || existsSync7(resolve3(dirPath, "docker-compose.yml")) || existsSync7(resolve3(dirPath, "compose.yaml"))) {
+        domains.add("docker");
+        queries.add("docker and container tools");
+      }
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const name = entry.name.toLowerCase();
+        if (name.endsWith(".sql") || name.endsWith(".sqlite") || name.endsWith(".sqlite3") || name === "prisma" || name.startsWith("prisma.") || name === "migrations" || name === "database" || /(?:^|[_.-])(?:db|database|sql)(?:[_.-]|$)/i.test(name)) {
+          domains.add("database");
+          queries.add("database and SQL query tools");
+          break;
+        }
+      }
+      domains.add("filesystem");
+    } catch (err) {
+      logger.warn(`Workspace analysis encountered error in ${dirPath}: ${err}`);
+    }
+    const detectedDomains = Array.from(domains);
+    const suggestedQueries = Array.from(queries);
+    logger.debug(`Workspace pre-primed domains: ${detectedDomains.join(", ")}`);
+    return { detectedDomains, suggestedQueries };
+  }
+};
+
+// src/router/router.ts
+var ContextRouter = class {
+  config;
+  registry;
+  searchEngine;
+  constructor(config = {}, registry = toolRegistry, search = searchEngine) {
+    this.config = {
+      strategy: config.strategy ?? "hybrid",
+      topK: config.topK ?? 5,
+      similarityThreshold: config.similarityThreshold ?? 0.45,
+      pinnedTools: config.pinnedTools ?? [],
+      maxActiveTools: config.maxActiveTools ?? 10,
+      enableBrowseServers: config.enableBrowseServers ?? false,
+      enableAddServer: config.enableAddServer ?? false,
+      allowCustomCommands: config.allowCustomCommands ?? false,
+      persistAddedServers: config.persistAddedServers ?? false
+    };
+    this.registry = registry;
+    this.searchEngine = search;
+    this.registry.setPinnedTools(this.config.pinnedTools);
+    if (this.config.maxActiveTools) {
+      this.registry.setMaxActiveTools(this.config.maxActiveTools);
+    }
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+    if (config.pinnedTools) {
+      this.registry.setPinnedTools(config.pinnedTools);
+    }
+    if (config.maxActiveTools) {
+      this.registry.setMaxActiveTools(config.maxActiveTools);
+    }
+  }
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Prime active tools based on workspace environment (Mode 4).
+   */
+  primeWorkspace(workspaceDir = process.cwd()) {
+    if (this.config.strategy === "passthrough") return;
+    const analysis = WorkspaceContextPrimer.analyzeWorkspace(workspaceDir);
+    for (const query of analysis.suggestedQueries) {
+      const results = this.searchEngine.search(query, { topK: 2, similarityThreshold: this.config.similarityThreshold });
+      if (results.length > 0) {
+        this.registry.activateTools(results.map((r) => r.tool.namespacedName));
+      }
+    }
+  }
+  /**
+   * Generates a succinct Dynamic Capability Manifest of connected upstream servers and tools.
+   */
+  generateCapabilityManifest() {
+    const allTools = this.registry.getAllTools();
+    if (allTools.length === 0) {
+      return "";
+    }
+    const serverMap = /* @__PURE__ */ new Map();
+    for (const tool of allTools) {
+      const server = tool.serverName;
+      if (!serverMap.has(server)) {
+        serverMap.set(server, []);
+      }
+      const list = serverMap.get(server);
+      if (!list.includes(tool.originalName)) {
+        list.push(tool.originalName);
+      }
+    }
+    const lines = [];
+    const sortedServers = Array.from(serverMap.entries()).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    for (const [serverName, toolNames] of sortedServers) {
+      const known = KnownServerRegistry.find(serverName);
+      const serverLabel = known?.displayName ? `${serverName} (${known.displayName})` : serverName;
+      const toolSummary = toolNames.length <= 4 ? toolNames.join(", ") : `${toolNames.slice(0, 3).join(", ")} (+${toolNames.length - 3} more)`;
+      lines.push(`\u2022 ${serverLabel}: ${toolSummary}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Returns list of tools to expose to downstream AI client.
+   */
+  getExposedTools() {
+    if (this.config.strategy === "passthrough") {
+      return this.registry.getAllTools().map((t) => ({
+        ...t,
+        name: t.namespacedName
+      }));
+    }
+    const activeTools = this.registry.getActiveTools().map((t) => ({
+      ...t,
+      name: t.namespacedName
+    }));
+    const manifest = this.generateCapabilityManifest();
+    const dynamicSearchTool = {
+      ...SEARCH_TOOLS_DEFINITION,
+      description: manifest ? `${SEARCH_TOOLS_DEFINITION.description}
+
+Connected MCP servers and available capabilities:
+${manifest}` : SEARCH_TOOLS_DEFINITION.description
+    };
+    const metaTools = [
+      dynamicSearchTool,
+      EXECUTE_TOOL_DEFINITION
+    ];
+    if (this.config.enableBrowseServers) {
+      metaTools.push(BROWSE_SERVERS_DEFINITION);
+    }
+    if (this.config.enableAddServer) {
+      metaTools.push(ADD_SERVER_DEFINITION);
+    }
+    const metaToolNames = new Set(metaTools.map((m) => m.name));
+    const safeActiveTools = activeTools.filter((t) => !metaToolNames.has(t.name));
+    return [...metaTools, ...safeActiveTools];
+  }
+  /**
+   * Handles contextwise_search_tools meta-tool call.
+   */
+  searchAndHydrate(query, domain, topK, activate = true) {
+    const k = topK ?? this.config.topK;
+    const results = this.searchEngine.search(query, {
+      topK: k,
+      domain,
+      similarityThreshold: this.config.similarityThreshold
+    });
+    if (results.length === 0) {
+      return {
+        message: `No matching tools found for query "${query}".`,
+        foundTools: [],
+        activatedNewTools: false
+      };
+    }
+    const toolNames = results.map((r) => r.tool.namespacedName);
+    let activatedNewTools = false;
+    if (activate) {
+      const beforeSet = new Set(this.registry.getActiveTools().map((t) => t.namespacedName));
+      this.registry.activateTools(toolNames);
+      const afterSet = new Set(this.registry.getActiveTools().map((t) => t.namespacedName));
+      activatedNewTools = beforeSet.size !== afterSet.size || [...afterSet].some((t) => !beforeSet.has(t));
+      if (activatedNewTools) {
+        logger.info(`Dynamically activated ${afterSet.size - beforeSet.size} tools for query "${query}"`);
+      }
+    }
+    const formatParams = (inputSchema) => {
+      if (!inputSchema || typeof inputSchema !== "object") return "none";
+      const s = inputSchema;
+      const props = s.properties || {};
+      const required = new Set(s.required || []);
+      const entries = Object.entries(props);
+      if (entries.length === 0) return "none";
+      return entries.map(([name, p]) => {
+        const type = p.type || "any";
+        const reqStr = required.has(name) ? "required" : "optional";
+        const descStr = p.description ? ` - ${p.description}` : "";
+        return `${name}: ${type} (${reqStr})${descStr}`;
+      }).join(", ");
+    };
+    const formatted = results.map((r) => ({
+      name: r.tool.namespacedName,
+      server: r.tool.serverName,
+      description: r.tool.description || "",
+      parameters: r.tool.inputSchema?.properties || {}
+    }));
+    const summaryText = [
+      `Found ${results.length} relevant tool(s) for "${query}":`,
+      ...results.map(
+        (r, idx) => `${idx + 1}. **${r.tool.namespacedName}** (${r.tool.serverName})
+   - ${r.tool.description || "No description"}
+   - Parameters: ${formatParams(r.tool.inputSchema)}`
+      ),
+      activate ? "\nThese tools have been activated into your active tool set and can also be called immediately via contextwise_execute_tool." : ""
+    ].filter(Boolean).join("\n");
+    return {
+      message: summaryText,
+      foundTools: formatted,
+      activatedNewTools
+    };
+  }
+};
+var contextRouter = new ContextRouter();
+
+// src/core/proxy.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var ContextWiseProxy = class {
+  server;
+  multiplexer;
+  router;
+  transport;
+  config;
+  isRunning = false;
+  constructor() {
+    this.server = new Server(
+      {
+        name: "contextwise",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {
+            listChanged: true
+          }
+        }
+      }
+    );
+    this.multiplexer = new UpstreamMultiplexer();
+    this.router = contextRouter;
+    this.setupRequestHandlers();
+  }
+  setupRequestHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      const exposedTools = this.router.getExposedTools();
+      const allToolsCount = toolRegistry.getAllTools().length;
+      metricsCollector.updateToolCounts(allToolsCount, exposedTools.length);
+      metricsCollector.recordSchemaPruning(allToolsCount, exposedTools.length);
+      logger.debug(
+        `Serving tools/list: exposing ${exposedTools.length} tools (out of ${allToolsCount} upstream tools)`
+      );
+      return {
+        tools: exposedTools
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args = {} } = request.params;
+      return this.handleToolCall(name, args);
+    });
+  }
+  /**
+   * Main tool execution pipeline handling meta-tools and proxied calls.
+   */
+  async handleToolCall(name, args = {}) {
+    if (name === SEARCH_TOOLS_NAME) {
+      return this.handleSearchToolsCall(args);
+    }
+    if (name === EXECUTE_TOOL_NAME) {
+      const targetToolName = String(args.tool_name || "");
+      const targetArgs = args.arguments || {};
+      if (!targetToolName) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: 'Error: Missing required parameter "tool_name" in contextwise_execute_tool.'
+            }
+          ]
+        };
+      }
+      return this.dispatchProxiedToolCall(targetToolName, targetArgs);
+    }
+    if (name === BROWSE_SERVERS_NAME) {
+      return this.handleBrowseServersCall(args);
+    }
+    if (name === ADD_SERVER_NAME) {
+      return this.handleAddServerCall(args);
+    }
+    return this.dispatchProxiedToolCall(name, args);
+  }
+  /**
+   * Handles contextwise_browse_servers execution.
+   */
+  async handleBrowseServersCall(args) {
+    const query = args.query ? String(args.query) : void 0;
+    const category = args.category ? String(args.category) : void 0;
+    const source = args.source ?? "all";
+    const servers = await UnifiedRegistryClient.search({
+      query,
+      category,
+      source,
+      limit: 12
+    });
+    if (servers.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No MCP servers found matching query: "${query || ""}" in category "${category || "all"}". You can still add any custom MCP server using ${ADD_SERVER_NAME}.`
+          }
+        ]
+      };
+    }
+    const lines = [
+      `### ContextWise MCP Server Catalog (${servers.length} results from online registries & local presets)`,
+      ""
+    ];
+    for (const s of servers) {
+      const verifiedBadge = s.verified ? " [Verified]" : "";
+      lines.push(
+        `\u2022 **${s.displayName}** (\`${s.id}\`) \u2014 Registry: **${s.sourceLabel}**${verifiedBadge}`
+      );
+      lines.push(`  ${s.description}`);
+      if (s.requiredParams && s.requiredParams.length > 0) {
+        lines.push(`  *Required Configuration:*`);
+        for (const p of s.requiredParams) {
+          lines.push(`    - \`${p.name}\` (${p.type}): ${p.description}`);
+        }
+      }
+      if (s.source === "smithery") {
+        lines.push(`  *Install with:* \`${ADD_SERVER_NAME}(name: "${s.id}", smithery: "${s.id}")\``);
+      } else if (s.source === "curated") {
+        lines.push(`  *Install with:* \`${ADD_SERVER_NAME}(name: "${s.name}", preset: "${s.id}")\``);
+      } else {
+        lines.push(`  *Install with:* \`${ADD_SERVER_NAME}(name: "${s.id}", ...)\``);
+      }
+      lines.push("");
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: lines.join("\n")
+        }
+      ]
+    };
+  }
+  /**
+   * Handles contextwise_add_server execution (hot-loading & persistence).
+   */
+  async handleAddServerCall(args) {
+    const routingConfig = this.router.getConfig();
+    if (!routingConfig.enableAddServer) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: "Error: Dynamic server addition is disabled by configuration for security. Enable it in contextwise.json with routing.enableAddServer: true."
+          }
+        ]
+      };
+    }
+    const rawName = String(args.name || "").trim();
+    if (!rawName) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: 'Error: Missing required parameter "name".' }]
+      };
+    }
+    const envObj = args.env || {};
+    const paramsObj = args.params || {};
+    const headersObj = args.headers || {};
+    for (const [source, obj] of Object.entries({ env: envObj, params: paramsObj, headers: headersObj })) {
+      for (const [key, val] of Object.entries(obj)) {
+        if (typeof val === "string" && /(?:vault|auth|mcp-auth|env):\/\//.test(val)) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Security violation: "vault://" and "env://" secret references cannot be passed via dynamic server addition (detected in ${source}.${key}).`
+              }
+            ]
+          };
+        }
+      }
+    }
+    let smitheryPackage = typeof args.smithery === "string" ? args.smithery : void 0;
+    if (!smitheryPackage && (rawName.startsWith("@smithery/") || rawName.startsWith("smithery:"))) {
+      smitheryPackage = rawName.replace(/^smithery:/, "");
+    }
+    const name = rawName.replace(/^@/, "").replace(/[^a-zA-Z0-9_-]/g, "_");
+    let serverConfig;
+    const presetId = String(args.preset || name).toLowerCase();
+    const knownPreset = KnownServerRegistry.find(presetId);
+    if (knownPreset) {
+      serverConfig = KnownServerRegistry.buildConfig(knownPreset, {
+        args: Array.isArray(args.args) ? args.args : [],
+        env: args.env || {}
+      });
+    } else if (smitheryPackage) {
+      serverConfig = SmitheryClient.buildServerConfig(smitheryPackage, {
+        env: args.env || {}
+      });
+    } else if (!routingConfig.allowCustomCommands) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Security restriction: Arbitrary commands and unverified URLs are restricted. Only verified presets and Smithery packages are permitted unless routing.allowCustomCommands is explicitly enabled in configuration.`
+          }
+        ]
+      };
+    } else if (args.url && typeof args.url === "string") {
+      serverConfig = {
+        url: args.url,
+        headers: args.headers || {},
+        transport: "auto",
+        autoReconnect: true
+      };
+    } else if (args.command && typeof args.command === "string") {
+      serverConfig = {
+        command: args.command,
+        args: Array.isArray(args.args) ? args.args : [],
+        env: args.env || {},
+        autoRestart: true
+      };
+    } else {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Could not configure server "${name}". Please specify a known "preset" (e.g. "postgres", "github", "sqlite", "fetch") or a "smithery" package name.`
+          }
+        ]
+      };
+    }
+    logger.info(`Adding and hot-loading new upstream server "${name}"...`);
+    try {
+      await this.multiplexer.connectServer(name, serverConfig);
+      const status = this.multiplexer.getStatus().find((s) => s.name === name);
+      if (!status || status.status !== "connected") {
+        const errorDetail = status?.error || "Unknown connection failure";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to connect to newly added upstream server "${name}": ${errorDetail}`
+            }
+          ]
+        };
+      }
+      if (routingConfig.persistAddedServers) {
+        ServerManager.saveUpstream(name, serverConfig);
+      }
+      const allTools = this.multiplexer.getAllTools();
+      toolRegistry.setAllTools(allTools);
+      try {
+        await this.server.sendToolListChanged();
+      } catch (notifyErr) {
+        logger.debug(`Client notification push: ${notifyErr}`);
+      }
+      const newTools = allTools.filter((t) => t.serverName === name).map((t) => t.namespacedName);
+      const persistMsg = routingConfig.persistAddedServers ? "persisted to contextwise.json, " : "loaded in session, ";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2713 Successfully added and connected upstream server "${name}"!
+
+Discovered ${newTools.length} tools:
+${newTools.map((t) => `\u2022 ${t}`).join("\n")}
+
+These tools are now indexed, ${persistMsg}and ready for immediate invocation in this session.`
+          }
+        ]
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Error adding server "${name}": ${msg}`
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Handles contextwise_search_tools execution.
+   */
+  async handleSearchToolsCall(args) {
+    const query = String(args.query || "");
+    const domain = args.domain ? String(args.domain) : void 0;
+    const topK = typeof args.topK === "number" ? args.topK : void 0;
+    const activate = args.activate !== false;
+    if (!query) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: 'Error: Missing required parameter "query".'
+          }
+        ]
+      };
+    }
+    const searchResult = this.router.searchAndHydrate(query, domain, topK, activate);
+    if (searchResult.activatedNewTools) {
+      try {
+        await this.server.sendToolListChanged();
+        logger.debug("Fired notifications/tools/list_changed notification to client.");
+      } catch (err) {
+        logger.debug(`Could not push list_changed notification: ${err}`);
+      }
+    }
+    if (searchResult.foundTools.length === 0) {
+      logger.info(`No active tools found for "${query}". Checking registries for recommended servers...`);
+      const rec = await ServerRecommender.recommendForTask(query, domain);
+      if (rec.hasRecommendations) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: rec.message
+            }
+          ]
+        };
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: searchResult.message
+        }
+      ]
+    };
+  }
+  /**
+   * Dispatches tool call through guardrails and upstream multiplexer.
+   */
+  async dispatchProxiedToolCall(toolName, args) {
+    const resolved = this.multiplexer.resolveTool(toolName);
+    if (!resolved) {
+      const rec = await ServerRecommender.recommendForTask(toolName);
+      const errorMsg = rec.hasRecommendations ? `Tool "${toolName}" was not found in ContextWise registry.
+
+${rec.message}` : `Tool "${toolName}" was not found in ContextWise registry. Use ${SEARCH_TOOLS_NAME} to find available tools.`;
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: errorMsg
+          }
+        ]
+      };
+    }
+    const { serverName, originalName, tool } = resolved;
+    const redactResult = (result) => {
+      if (!result || !Array.isArray(result.content)) return result;
+      return {
+        ...result,
+        content: result.content.map((item) => {
+          if (item && item.type === "text" && typeof item.text === "string") {
+            return {
+              ...item,
+              text: redactionFilter.redact(item.text)
+            };
+          }
+          return item;
+        })
+      };
+    };
+    if (tool.inputSchema) {
+      const validation = argumentValidator.validate(
+        toolName,
+        tool.inputSchema,
+        args
+      );
+      if (!validation.valid) {
+        const errorMsg = `Pre-flight validation failed for "${toolName}":
+${validation.errors?.join("\n")}`;
+        loopBreaker.recordCall(serverName, originalName, args, true);
+        return {
+          isError: true,
+          content: [{ type: "text", text: redactionFilter.redact(errorMsg) }]
+        };
+      }
+    }
+    const preFlight = loopBreaker.checkPreFlightDetailed(serverName, originalName, args);
+    if (!preFlight.allowed) {
+      if (preFlight.reason === "rate_limited") {
+        metricsCollector.recordThrottle(toolName, serverName);
+      } else {
+        metricsCollector.recordLoopPrevented(toolName, serverName);
+      }
+      return {
+        isError: true,
+        content: [{ type: "text", text: preFlight.message }]
+      };
+    }
+    const isReadOnly = tool.readOnlyHint || tool.idempotentHint;
+    if (isReadOnly && this.config?.guardrails.enableCache !== false) {
+      const cached = responseCache.get(serverName, originalName, args);
+      if (cached) {
+        toolRegistry.touchTool(toolName);
+        metricsCollector.recordExecution({
+          toolName,
+          serverName,
+          latencyMs: 1,
+          cached: true
+        });
+        return redactResult(cached);
+      }
+    }
+    try {
+      const timeoutMs = this.config?.guardrails.callTimeoutMs ?? 3e4;
+      const execution = await this.multiplexer.executeTool(toolName, args, timeoutMs);
+      const isError = Boolean(execution.result.isError);
+      loopBreaker.recordCall(serverName, originalName, args, isError);
+      if (!isError) {
+        toolRegistry.touchTool(toolName);
+      }
+      if (isError) {
+      } else if (isReadOnly && this.config?.guardrails.enableCache !== false) {
+        responseCache.set(serverName, originalName, args, execution.result);
+      } else {
+        responseCache.invalidateServer(serverName);
+      }
+      metricsCollector.recordExecution({
+        toolName,
+        serverName,
+        latencyMs: execution.latencyMs,
+        cached: false,
+        isError
+      });
+      return redactResult(execution.result);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      loopBreaker.recordCall(serverName, originalName, args, true);
+      metricsCollector.recordExecution({
+        toolName,
+        serverName,
+        latencyMs: 10,
+        cached: false,
+        isError: true
+      });
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: redactionFilter.redact(`Upstream error executing "${toolName}": ${msg}`)
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Starts ContextWise proxy using given configuration.
+   */
+  async start(config) {
+    this.config = config;
+    this.isRunning = true;
+    logger.setLevel(config.proxy.logLevel);
+    logger.info("Starting ContextWise MCP Proxy Gateway...");
+    this.router.updateConfig(config.routing);
+    responseCache.setTtlSeconds(config.guardrails.cacheTtlSeconds);
+    loopBreaker.updateConfig({
+      maxCallsPerMinute: config.guardrails.maxCallsPerMinute,
+      consecutiveFailureThreshold: config.guardrails.loopBreakerThreshold
+    });
+    await this.multiplexer.connectAll(config.upstreams);
+    const allTools = this.multiplexer.getAllTools();
+    toolRegistry.setAllTools(allTools);
+    this.multiplexer.on("toolsChanged", async (_serverName, updatedTools) => {
+      toolRegistry.setAllTools(updatedTools);
+      try {
+        await this.server.sendToolListChanged();
+      } catch (err) {
+        logger.debug(`Notification push error: ${err}`);
+      }
+    });
+    this.router.primeWorkspace(process.cwd());
+    this.transport = new StdioServerTransport();
+    await this.server.connect(this.transport);
+    logger.info("ContextWise MCP Proxy is running and ready for client connections.");
+  }
+  /**
+   * Gracefully shuts down proxy and upstream connections.
+   */
+  async stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    metricsCollector.flushSync();
+    logger.info("Shutting down ContextWise proxy...");
+    await this.multiplexer.closeAll();
+    if (this.transport) {
+      await this.transport.close();
+    }
+    await this.server.close();
+    logger.info("ContextWise proxy stopped cleanly.");
+  }
+  getMultiplexer() {
+    return this.multiplexer;
+  }
+  getRouter() {
+    return this.router;
+  }
+};
+var proxy = new ContextWiseProxy();
+
+// src/cloud/client.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+var ContextWiseCloudClient = class {
+  apiUrl;
+  storageDir;
+  allowOfflineSimulation;
+  token = null;
+  constructor(options = {}) {
+    this.apiUrl = options.apiUrl || process.env.CONTEXTWISE_API_URL || "https://contextwise.dev";
+    this.storageDir = options.storageDir || process.env.CONTEXTWISE_STORAGE_DIR || join6(homedir6(), ".contextwise");
+    this.allowOfflineSimulation = options.allowOfflineSimulation ?? false;
+    this.loadToken();
+  }
+  getTokenPath() {
+    return join6(this.storageDir, "auth.json");
+  }
+  loadToken() {
+    const tokenPath = this.getTokenPath();
+    if (existsSync8(tokenPath)) {
+      try {
+        const raw = readFileSync7(tokenPath, "utf-8");
+        this.token = JSON.parse(raw);
+      } catch {
+        this.token = null;
+      }
+    }
+  }
+  saveToken(token) {
+    if (!existsSync8(this.storageDir)) {
+      mkdirSync5(this.storageDir, { recursive: true });
+    }
+    this.token = token;
+    writeFileSync5(this.getTokenPath(), JSON.stringify(token, null, 2), {
+      mode: 384,
+      encoding: "utf-8"
+    });
+  }
+  clearToken() {
+    this.token = null;
+    const tokenPath = this.getTokenPath();
+    if (existsSync8(tokenPath)) {
+      try {
+        unlinkSync2(tokenPath);
+      } catch {
+      }
+    }
+  }
+  getToken() {
+    if (!this.token) {
+      this.loadToken();
+    }
+    return this.token;
+  }
+  isAuthenticated() {
+    const token = this.getToken();
+    if (!token) return false;
+    return token.expiresAt > Date.now();
+  }
+  /**
+   * Starts RFC 8628 device authorization flow.
+   */
+  async startDeviceFlow() {
+    const res = await fetch(`${this.apiUrl}/v1/auth/device/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to initiate device login: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Polls device token until user approves the code in their browser.
+   */
+  async pollDeviceToken(deviceCode, intervalSeconds = 5, maxWaitMs = 15 * 60 * 1e3) {
+    const start = Date.now();
+    const intervalMs = Math.max(intervalSeconds * 1e3, 2e3);
+    while (Date.now() - start < maxWaitMs) {
+      await new Promise((r) => setTimeout(r, intervalMs));
+      try {
+        const res = await fetch(`${this.apiUrl}/v1/auth/device/token`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ device_code: deviceCode })
+        });
+        if (res.ok) {
+          const data = await res.json();
+          const authToken = {
+            token: data.token,
+            userId: data.userId,
+            email: data.email,
+            expiresAt: data.expiresAt
+          };
+          this.saveToken(authToken);
+          return authToken;
+        }
+        if (res.status === 428) {
+          continue;
+        }
+        const errData = await res.json().catch(() => ({}));
+        throw new Error(errData.message || `Device authorization failed: HTTP ${res.status}`);
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("Device authorization failed")) {
+          throw err;
+        }
+      }
+    }
+    throw new Error("Device authorization timed out. Please try logging in again.");
+  }
+  /**
+   * Authenticates using a user API token or personal access key.
+   */
+  async loginWithKey(apiKey) {
+    const trimmed = apiKey.trim();
+    if (!trimmed) {
+      throw new Error("API key cannot be empty");
+    }
+    try {
+      const res = await fetch(`${this.apiUrl}/v1/auth/verify`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${trimmed}`
+        }
+      });
+      if (!res.ok) {
+        if (res.status === 401 || res.status === 403) {
+          throw new Error("Invalid or expired ContextWise Cloud API key.");
+        }
+        throw new Error(`Cloud API returned HTTP ${res.status}: ${res.statusText}`);
+      }
+      const data = await res.json();
+      const authToken = {
+        token: trimmed,
+        userId: data.userId,
+        email: data.email,
+        expiresAt: data.expiresAt || Date.now() + 30 * 24 * 3600 * 1e3
+      };
+      this.saveToken(authToken);
+      return authToken;
+    } catch (err) {
+      if (this.allowOfflineSimulation && (trimmed.startsWith("cw_test_") || trimmed.startsWith("cw_live_"))) {
+        const dummyToken = {
+          token: trimmed,
+          userId: "usr_dev_" + trimmed.slice(-6),
+          email: "developer@contextwise.dev",
+          expiresAt: Date.now() + 30 * 24 * 3600 * 1e3
+        };
+        this.saveToken(dummyToken);
+        return dummyToken;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Retrieves profile information for current authenticated account.
+   */
+  async whoami() {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error('Not logged in. Run "contextwise login" first.');
+    }
+    try {
+      const res = await fetch(`${this.apiUrl}/v1/user/profile`, {
+        headers: { Authorization: `Bearer ${token.token}` }
+      });
+      if (res.ok) {
+        return await res.json();
+      }
+      if (!this.allowOfflineSimulation) {
+        throw new Error(`Failed to fetch profile: HTTP ${res.status} ${res.statusText}`);
+      }
+    } catch (err) {
+      if (!this.allowOfflineSimulation) {
+        throw err;
+      }
+    }
+    return {
+      userId: token.userId,
+      email: token.email,
+      plan: "free",
+      subscriptionStatus: "inactive",
+      currentPeriodEnd: null,
+      workspaces: [
+        {
+          id: "ws_default",
+          name: "Personal Workspace",
+          role: "owner",
+          activeRevision: 1,
+          updatedAt: Date.now()
+        }
+      ],
+      devices: []
+    };
+  }
+  /**
+   * Initiates Stripe Checkout session for Pro or Team upgrade.
+   */
+  async createCheckoutSession(plan = "pro", interval = "month") {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error('Not logged in. Run "contextwise login" first.');
+    }
+    const res = await fetch(`${this.apiUrl}/v1/billing/checkout`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token.token}`
+      },
+      body: JSON.stringify({ plan, interval })
+    });
+    if (!res.ok) {
+      const errData = await res.json().catch(() => ({}));
+      throw new Error(errData.message || `Failed to create checkout session: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Generates Stripe Customer Portal session to manage subscription and invoices.
+   */
+  async createPortalSession() {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error('Not logged in. Run "contextwise login" first.');
+    }
+    const res = await fetch(`${this.apiUrl}/v1/billing/portal`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token.token}`
+      }
+    });
+    if (!res.ok) {
+      const errData = await res.json().catch(() => ({}));
+      throw new Error(errData.message || `Failed to open billing portal: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Pushes a workspace snapshot (config + encrypted vault) to the Cloudflare Workers / D1 backend.
+   */
+  async pushSync(payload) {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error('Not logged in. Run "contextwise login" first.');
+    }
+    try {
+      const res = await fetch(`${this.apiUrl}/v1/sync/push`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token.token}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (res.ok) {
+        return await res.json();
+      }
+      if (res.status === 402) {
+        const payData = await res.json().catch(() => ({}));
+        throw new Error(
+          `${payData.message || "Cloud Sync requires an upgraded subscription."}
+Upgrade at: ${payData.upgradeUrl || "https://contextwise.dev/#pricing"}`
+        );
+      }
+      if (res.status === 409) {
+        const conflictData = await res.json();
+        return {
+          status: "conflict",
+          revision: payload.baseRevision,
+          serverRevision: conflictData.serverRevision,
+          serverPayload: conflictData.serverPayload
+        };
+      }
+      throw new Error(`Push sync failed: HTTP ${res.status} ${res.statusText}`);
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("requires an upgraded subscription") || err.message.includes("Cloud Sync requires"))) {
+        throw err;
+      }
+      if (this.allowOfflineSimulation) {
+        logger.debug(`Cloud API push endpoint unreachable (${err}). Using local snapshot commit.`);
+        return {
+          status: "committed",
+          revision: payload.baseRevision + 1
+        };
+      }
+      throw err;
+    }
+  }
+  /**
+   * Pulls the latest workspace snapshot (config + encrypted vault) from the cloud backend.
+   */
+  async pullSync(workspaceId, sinceRevision = 0) {
+    const token = this.getToken();
+    if (!token) {
+      throw new Error('Not logged in. Run "contextwise login" first.');
+    }
+    try {
+      const res = await fetch(
+        `${this.apiUrl}/v1/sync/pull?workspaceId=${encodeURIComponent(
+          workspaceId
+        )}&since=${sinceRevision}`,
+        {
+          headers: { Authorization: `Bearer ${token.token}` }
+        }
+      );
+      if (res.ok) {
+        return await res.json();
+      }
+      if (res.status === 304) {
+        return null;
+      }
+    } catch (err) {
+      logger.debug(`Cloud API pull endpoint unreachable: ${err}`);
+    }
+    return null;
+  }
+};
+var cloudClient = new ContextWiseCloudClient();
+
+// src/cloud/crypto.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
+import { randomBytes as randomBytes2 } from "crypto";
+function createEnvelope(workspaceKey, recipientPublicKeyPem) {
+  const ephemeral = generateKeyPairX25519();
+  const sharedKey = deriveSharedSecretX25519(ephemeral.privateKey, recipientPublicKeyPem);
+  const { iv, authTag, ciphertext } = encryptAesGcm(
+    workspaceKey.toString("base64"),
+    sharedKey
+  );
+  return {
+    recipientPublicKey: recipientPublicKeyPem,
+    ephemeralPublicKey: ephemeral.publicKey,
+    iv,
+    authTag,
+    ciphertext
+  };
+}
+function openEnvelope(envelope, recipientPrivateKeyPem) {
+  const sharedKey = deriveSharedSecretX25519(
+    recipientPrivateKeyPem,
+    envelope.ephemeralPublicKey
+  );
+  const decryptedBase64 = decryptAesGcm(
+    envelope.ciphertext,
+    sharedKey,
+    envelope.iv,
+    envelope.authTag
+  );
+  return Buffer.from(decryptedBase64, "base64");
+}
+function getOrCreateDeviceIdentity(storageDir) {
+  const dir = storageDir || process.env.CONTEXTWISE_STORAGE_DIR || join7(homedir7(), ".contextwise");
+  const filePath = join7(dir, "device.json");
+  if (existsSync9(filePath)) {
+    try {
+      const data = JSON.parse(readFileSync8(filePath, "utf-8"));
+      if (data.deviceId && data.publicKey && data.privateKey) {
+        return data;
+      }
+    } catch {
+    }
+  }
+  if (!existsSync9(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
+  const { publicKey, privateKey } = generateKeyPairX25519();
+  const deviceId = `cw_dev_${randomBytes2(8).toString("hex")}`;
+  const identity = {
+    deviceId,
+    publicKey,
+    privateKey
+  };
+  writeFileSync6(filePath, JSON.stringify(identity, null, 2), {
+    mode: 384,
+    encoding: "utf-8"
+  });
+  return identity;
+}
+
+// src/cloud/sync_manager.ts
+import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
+var SyncManager = class {
+  syncStatePath;
+  localConfigPath;
+  constructor(storageDir, localConfigPath) {
+    const dir = storageDir || process.env.CONTEXTWISE_STORAGE_DIR || join8(homedir8(), ".contextwise");
+    this.syncStatePath = join8(dir, "sync.json");
+    this.localConfigPath = localConfigPath;
+  }
+  loadSyncState() {
+    if (existsSync10(this.syncStatePath)) {
+      try {
+        const raw = readFileSync9(this.syncStatePath, "utf-8");
+        return JSON.parse(raw);
+      } catch {
+      }
+    }
+    return {
+      workspaceId: "ws_default",
+      revision: 0,
+      lastSyncedAt: 0
+    };
+  }
+  saveSyncState(state) {
+    writeFileSync7(this.syncStatePath, JSON.stringify(state, null, 2), {
+      mode: 384,
+      encoding: "utf-8"
+    });
+  }
+  /**
+   * Pushes local configuration and encrypted vault payload to the cloud.
+   */
+  async push(workspaceId) {
+    const state = this.loadSyncState();
+    const wsId = workspaceId || state.workspaceId;
+    const device = getOrCreateDeviceIdentity();
+    const localConfig = ConfigLoader.load();
+    const vaultPath = getDefaultVaultFilePath();
+    let encryptedVault;
+    if (existsSync10(vaultPath)) {
+      try {
+        const rawVault = readFileSync9(vaultPath, "utf-8");
+        encryptedVault = JSON.parse(rawVault);
+      } catch {
+        encryptedVault = this.createEmptyEncryptedVault();
+      }
+    } else {
+      encryptedVault = this.createEmptyEncryptedVault();
+    }
+    const payload = {
+      workspaceId: wsId,
+      deviceId: device.deviceId,
+      baseRevision: state.revision,
+      config: localConfig,
+      encryptedVault,
+      timestamp: Date.now()
+    };
+    const result = await cloudClient.pushSync(payload);
+    if (result.status === "committed") {
+      state.workspaceId = wsId;
+      state.revision = result.revision;
+      state.lastSyncedAt = Date.now();
+      this.saveSyncState(state);
+      logger.info(`Successfully pushed revision #${result.revision} to ContextWise Cloud.`);
+    }
+    return result;
+  }
+  /**
+   * Pulls the latest cloud configuration and merges upstream servers.
+   */
+  async pull(workspaceId) {
+    const state = this.loadSyncState();
+    const wsId = workspaceId || state.workspaceId;
+    const pullResult = await cloudClient.pullSync(wsId, state.revision);
+    if (!pullResult) {
+      logger.info("Local configuration is already up to date.");
+      return null;
+    }
+    if (pullResult.config && pullResult.config.upstreams) {
+      this.mergeConfigIntoLocal(pullResult.config);
+    }
+    if (pullResult.encryptedVault && pullResult.encryptedVault.data) {
+      const vaultPath = getDefaultVaultFilePath();
+      writeFileSync7(vaultPath, JSON.stringify(pullResult.encryptedVault, null, 2), {
+        mode: 384,
+        encoding: "utf-8"
+      });
+    }
+    state.revision = pullResult.revision;
+    state.lastSyncedAt = Date.now();
+    this.saveSyncState(state);
+    logger.info(`Pulled and applied cloud revision #${pullResult.revision}.`);
+    return pullResult;
+  }
+  /**
+   * Semantically merges remote configuration into local contextwise.json.
+   */
+  mergeConfigIntoLocal(remoteConfig) {
+    const validatedRemote = ContextWiseConfigSchema.parse(remoteConfig);
+    const configPath = this.localConfigPath || process.env.CONTEXTWISE_CONFIG || join8(process.cwd(), "contextwise.json");
+    let localConfig;
+    if (existsSync10(configPath)) {
+      try {
+        localConfig = ContextWiseConfigSchema.parse(JSON.parse(readFileSync9(configPath, "utf-8")));
+      } catch {
+        localConfig = ContextWiseConfigSchema.parse({});
+      }
+    } else {
+      localConfig = ContextWiseConfigSchema.parse({});
+    }
+    for (const [name, s] of Object.entries(validatedRemote.upstreams || {})) {
+      if (isStdioUpstream(s) && !localConfig.upstreams[name]) {
+        logger.warn(
+          `[Cloud Sync Security] Remote configuration contains new stdio upstream "${name}" (${s.command}). Verify this server in contextwise.json before execution.`
+        );
+      }
+    }
+    const mergedUpstreams = {
+      ...validatedRemote.upstreams || {},
+      ...localConfig.upstreams || {}
+    };
+    const merged = {
+      ...localConfig,
+      upstreams: mergedUpstreams
+    };
+    writeFileSync7(configPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  createEmptyEncryptedVault() {
+    return {
+      version: 1,
+      kdf: {
+        algorithm: "pbkdf2-sha512",
+        salt: "empty",
+        iterations: 5e4
+      },
+      cipher: "aes-256-gcm",
+      iv: "",
+      authTag: "",
+      data: ""
+    };
+  }
+  getStatus() {
+    const token = cloudClient.getToken();
+    const state = this.loadSyncState();
+    const device = getOrCreateDeviceIdentity();
+    return {
+      isLoggedIn: cloudClient.isAuthenticated(),
+      userEmail: token?.email,
+      workspaceId: state.workspaceId,
+      revision: state.revision,
+      lastSyncedAt: state.lastSyncedAt,
+      deviceId: device.deviceId
+    };
+  }
+};
+var syncManager = new SyncManager();
+
+export {
+  StdioUpstreamConfigSchema,
+  HttpUpstreamConfigSchema,
+  UpstreamServerConfigSchema,
+  warnIfInsecureHttp,
+  isStdioUpstream,
+  isHttpUpstream,
+  ProxyConfigSchema,
+  RoutingConfigSchema,
+  GuardrailsConfigSchema,
+  ContextWiseConfigSchema,
+  RedactionFilter,
+  redactionFilter,
+  Logger,
+  logger,
+  ConfigLoader,
+  ProcessSupervisor,
+  supervisor,
+  encryptAesGcm,
+  decryptAesGcm,
+  VAULT_PBKDF2_ITERATIONS,
+  deriveKeyFromPassphrase,
+  getOrCreateMachineKey,
+  generateKeyPairX25519,
+  deriveSharedSecretX25519,
+  getDefaultVaultFilePath,
+  EncryptedFileVaultDriver,
+  OsKeystoreDriver,
+  SecretVault,
+  secretVault,
+  VaultAuditor,
+  SecretResolver,
+  escapeWindowsCmdArg,
+  inferToolHints,
+  UpstreamMultiplexer,
+  ToolNormalizer,
+  HybridSearchEngine,
+  searchEngine,
+  ToolRegistry,
+  toolRegistry,
+  ToolArgumentValidator,
+  argumentValidator,
+  canonicalJsonStringify,
+  sha256,
+  generateToolCallCacheKey,
+  ResponseCache,
+  responseCache,
+  RunawayLoopBreaker,
+  loopBreaker,
+  SCHEMA_TOKENS_PER_TOOL,
+  CACHE_TOKENS_PER_HIT,
+  LOOP_PREVENTION_TOKENS_PER_TRIP,
+  LLM_PRICING,
+  calculateDollarSavings,
+  getDefaultMetricsPath,
+  MetricsCollector,
+  metricsCollector,
+  SEARCH_TOOLS_NAME,
+  EXECUTE_TOOL_NAME,
+  BROWSE_SERVERS_NAME,
+  ADD_SERVER_NAME,
+  SEARCH_TOOLS_DEFINITION,
+  EXECUTE_TOOL_DEFINITION,
+  BROWSE_SERVERS_DEFINITION,
+  ADD_SERVER_DEFINITION,
+  KNOWN_SERVERS,
+  KnownServerRegistry,
+  OfficialRegistryClient,
+  SmitheryClient,
+  UnifiedRegistryClient,
+  ServerRecommender,
+  ServerManager,
+  WorkspaceContextPrimer,
+  ContextRouter,
+  contextRouter,
+  ContextWiseProxy,
+  proxy,
+  ContextWiseCloudClient,
+  cloudClient,
+  createEnvelope,
+  openEnvelope,
+  getOrCreateDeviceIdentity,
+  SyncManager,
+  syncManager
+};
+//# sourceMappingURL=chunk-P7JW7EPW.js.map