@rynfar/meridian 1.34.1 → 1.37.0

package/dist/{cli-bwchvbfb.js → cli-ygx1djsx.js}

@@ -1,8 +1,9 @@
 import {
+  init_profileBar,
   profileBarCss,
   profileBarHtml,
   profileBarJs
-} from "./cli-g9ypdz51.js";
+} from "./cli-pr79d7nw.js";
 import {
   checkPluginConfigured
 } from "./cli-rtab0qa6.js";
@@ -20,9 +21,1519 @@ import {
   setActiveProfile
 } from "./cli-vdp9s10c.js";
 import {
+  __commonJS,
+  __esm,
   __export,
-  __require
-} from "./cli-a05ws7rb.js";
+  __require,
+  __toCommonJS,
+  __toESM
+} from "./cli-p9swy5t3.js";
+
+// src/telemetry/percentiles.ts
+function computePercentiles(values) {
+  if (values.length === 0)
+    return { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 };
+  const sorted = [...values].sort((a, b) => a - b);
+  const sum = sorted.reduce((a, b) => a + b, 0);
+  return {
+    p50: sorted[Math.floor(sorted.length * 0.5)],
+    p95: sorted[Math.floor(sorted.length * 0.95)],
+    p99: sorted[Math.floor(sorted.length * 0.99)],
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    avg: Math.round(sum / sorted.length)
+  };
+}
+function computeSummary(metrics, windowMs) {
+  if (metrics.length === 0) {
+    const emptyPhase = { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 };
+    return {
+      windowMs,
+      totalRequests: 0,
+      errorCount: 0,
+      requestsPerMinute: 0,
+      queueWait: emptyPhase,
+      proxyOverhead: emptyPhase,
+      ttfb: emptyPhase,
+      upstreamDuration: emptyPhase,
+      totalDuration: emptyPhase,
+      byModel: {},
+      byMode: {},
+      tokenUsage: {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheReadTokens: 0,
+        totalCacheCreationTokens: 0,
+        avgCacheHitRate: 0,
+        cacheMissOnResumeCount: 0
+      }
+    };
+  }
+  const errorCount = metrics.filter((m) => m.error !== null).length;
+  const oldest = metrics[metrics.length - 1].timestamp;
+  const newest = metrics[0].timestamp;
+  const spanMs = Math.max(newest - oldest, 1);
+  const requestsPerMinute = metrics.length / spanMs * 60000;
+  const queueWaits = metrics.map((m) => m.queueWaitMs);
+  const overheads = metrics.map((m) => m.proxyOverheadMs);
+  const ttfbs = metrics.filter((m) => m.ttfbMs !== null).map((m) => m.ttfbMs);
+  const upstreams = metrics.map((m) => m.upstreamDurationMs);
+  const totals = metrics.map((m) => m.totalDurationMs);
+  const byModel = {};
+  for (const m of metrics) {
+    const modelKey = m.requestModel || m.model;
+    const entry = byModel[modelKey] ??= { count: 0, totalMs: 0 };
+    entry.count++;
+    entry.totalMs += m.totalDurationMs;
+  }
+  const byMode = {};
+  for (const m of metrics) {
+    const entry = byMode[m.mode] ??= { count: 0, totalMs: 0 };
+    entry.count++;
+    entry.totalMs += m.totalDurationMs;
+  }
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreationTokens = 0;
+  let cacheHitRateSum = 0;
+  let cacheHitRateCount = 0;
+  let cacheMissOnResumeCount = 0;
+  for (const m of metrics) {
+    totalInputTokens += m.inputTokens ?? 0;
+    totalOutputTokens += m.outputTokens ?? 0;
+    totalCacheReadTokens += m.cacheReadInputTokens ?? 0;
+    totalCacheCreationTokens += m.cacheCreationInputTokens ?? 0;
+    if (m.cacheHitRate !== undefined) {
+      cacheHitRateSum += m.cacheHitRate;
+      cacheHitRateCount++;
+    }
+    if (m.isResume && m.cacheHitRate !== undefined && m.cacheHitRate === 0) {
+      cacheMissOnResumeCount++;
+    }
+  }
+  return {
+    windowMs,
+    totalRequests: metrics.length,
+    errorCount,
+    requestsPerMinute: Math.round(requestsPerMinute * 100) / 100,
+    queueWait: computePercentiles(queueWaits),
+    proxyOverhead: computePercentiles(overheads),
+    ttfb: ttfbs.length > 0 ? computePercentiles(ttfbs) : { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 },
+    upstreamDuration: computePercentiles(upstreams),
+    totalDuration: computePercentiles(totals),
+    byModel: Object.fromEntries(Object.entries(byModel).map(([k, v]) => [k, { count: v.count, avgTotalMs: Math.round(v.totalMs / v.count) }])),
+    byMode: Object.fromEntries(Object.entries(byMode).map(([k, v]) => [k, { count: v.count, avgTotalMs: Math.round(v.totalMs / v.count) }])),
+    tokenUsage: {
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalCacheCreationTokens,
+      avgCacheHitRate: cacheHitRateCount > 0 ? Math.round(cacheHitRateSum / cacheHitRateCount * 100) / 100 : 0,
+      cacheMissOnResumeCount
+    }
+  };
+}
+var init_percentiles = () => {};
+
+// node_modules/@neon-rs/load/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.load = exports.currentTarget = undefined;
+  var path = __importStar(__require("path"));
+  var fs = __importStar(__require("fs"));
+  function currentTarget() {
+    let os = null;
+    switch (process.platform) {
+      case "android":
+        switch (process.arch) {
+          case "arm":
+            return "android-arm-eabi";
+          case "arm64":
+            return "android-arm64";
+        }
+        os = "Android";
+        break;
+      case "win32":
+        switch (process.arch) {
+          case "x64":
+            return "win32-x64-msvc";
+          case "arm64":
+            return "win32-arm64-msvc";
+          case "ia32":
+            return "win32-ia32-msvc";
+        }
+        os = "Windows";
+        break;
+      case "darwin":
+        switch (process.arch) {
+          case "x64":
+            return "darwin-x64";
+          case "arm64":
+            return "darwin-arm64";
+        }
+        os = "macOS";
+        break;
+      case "linux":
+        switch (process.arch) {
+          case "x64":
+          case "arm64":
+            return isGlibc() ? `linux-${process.arch}-gnu` : `linux-${process.arch}-musl`;
+          case "arm":
+            return "linux-arm-gnueabihf";
+        }
+        os = "Linux";
+        break;
+      case "freebsd":
+        if (process.arch === "x64") {
+          return "freebsd-x64";
+        }
+        os = "FreeBSD";
+        break;
+    }
+    if (os) {
+      throw new Error(`Neon: unsupported ${os} architecture: ${process.arch}`);
+    }
+    throw new Error(`Neon: unsupported system: ${process.platform}`);
+  }
+  exports.currentTarget = currentTarget;
+  function isGlibc() {
+    const report = process.report?.getReport();
+    if (typeof report !== "object" || !report || !("header" in report)) {
+      return false;
+    }
+    const header = report.header;
+    return typeof header === "object" && !!header && "glibcVersionRuntime" in header;
+  }
+  function load(dirname2) {
+    const m = path.join(dirname2, "index.node");
+    return fs.existsSync(m) ? __require(m) : null;
+  }
+  exports.load = load;
+});
+
+// node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      report = isLinux() && process.report ? process.report.getReport() : {};
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
+});
+
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var LDD_PATH = "/usr/bin/ldd";
+  var readFileSync2 = (path) => fs.readFileSync(path, "utf-8");
+  var readFile = (path) => new Promise((resolve2, reject) => {
+    fs.readFile(path, "utf-8", (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve2(data);
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    readFileSync: readFileSync2,
+    readFile
+  };
+});
+
+// node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS((exports, module) => {
+  var childProcess = __require("child_process");
+  var { isLinux, getReport } = require_process();
+  var { LDD_PATH, readFile, readFileSync: readFileSync2 } = require_filesystem();
+  var cachedFamilyFilesystem;
+  var cachedVersionFilesystem;
+  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+  var commandOut = "";
+  var safeCommand = () => {
+    if (!commandOut) {
+      return new Promise((resolve2) => {
+        childProcess.exec(command, (err, out) => {
+          commandOut = err ? " " : out;
+          resolve2(commandOut);
+        });
+      });
+    }
+    return commandOut;
+  };
+  var safeCommandSync = () => {
+    if (!commandOut) {
+      try {
+        commandOut = childProcess.execSync(command, { encoding: "utf8" });
+      } catch (_err) {
+        commandOut = " ";
+      }
+    }
+    return commandOut;
+  };
+  var GLIBC = "glibc";
+  var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
+  var MUSL = "musl";
+  var GLIBC_ON_LDD = GLIBC.toUpperCase();
+  var MUSL_ON_LDD = MUSL.toLowerCase();
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var familyFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return GLIBC;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return MUSL;
+      }
+    }
+    return null;
+  };
+  var familyFromCommand = (out) => {
+    const [getconf, ldd1] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return GLIBC;
+    }
+    if (ldd1 && ldd1.includes(MUSL)) {
+      return MUSL;
+    }
+    return null;
+  };
+  var getFamilyFromLddContent = (content) => {
+    if (content.includes(MUSL_ON_LDD)) {
+      return MUSL;
+    }
+    if (content.includes(GLIBC_ON_LDD)) {
+      return GLIBC;
+    }
+    return null;
+  };
+  var familyFromFilesystem = async () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromFilesystemSync = () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = readFileSync2(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var family = async () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = await familyFromFilesystem();
+      if (!family2) {
+        family2 = familyFromReport();
+      }
+      if (!family2) {
+        const out = await safeCommand();
+        family2 = familyFromCommand(out);
+      }
+    }
+    return family2;
+  };
+  var familySync = () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = familyFromFilesystemSync();
+      if (!family2) {
+        family2 = familyFromReport();
+      }
+      if (!family2) {
+        const out = safeCommandSync();
+        family2 = familyFromCommand(out);
+      }
+    }
+    return family2;
+  };
+  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+  var versionFromFilesystem = async () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromFilesystemSync = () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = readFileSync2(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return report.header.glibcVersionRuntime;
+    }
+    return null;
+  };
+  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+  var versionFromCommand = (out) => {
+    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return versionSuffix(getconf);
+    }
+    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+      return versionSuffix(ldd2);
+    }
+    return null;
+  };
+  var version = async () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = await versionFromFilesystem();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  var versionSync = () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = versionFromFilesystemSync();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  module.exports = {
+    GLIBC,
+    MUSL,
+    family,
+    familySync,
+    isNonGlibcLinux,
+    isNonGlibcLinuxSync,
+    version,
+    versionSync
+  };
+});
+
+// node_modules/libsql/auth.js
+var require_auth = __commonJS((exports, module) => {
+  var Authorization = {
+    ALLOW: 0,
+    DENY: 1
+  };
+  module.exports = Authorization;
+});
+
+// node_modules/libsql/sqlite-error.js
+var require_sqlite_error = __commonJS((exports, module) => {
+  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+  function SqliteError(message, code, rawCode) {
+    if (new.target !== SqliteError) {
+      return new SqliteError(message, code);
+    }
+    if (typeof code !== "string") {
+      throw new TypeError("Expected second argument to be a string");
+    }
+    Error.call(this, message);
+    descriptor.value = "" + message;
+    Object.defineProperty(this, "message", descriptor);
+    Error.captureStackTrace(this, SqliteError);
+    this.code = code;
+    this.rawCode = rawCode;
+  }
+  Object.setPrototypeOf(SqliteError, Error);
+  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+  Object.defineProperty(SqliteError.prototype, "name", descriptor);
+  module.exports = SqliteError;
+});
+
+// node_modules/libsql/index.js
+var require_libsql = __commonJS((exports, module) => {
+  var __dirname = "/home/runner/work/meridian/meridian/node_modules/libsql";
+  var { load, currentTarget } = require_dist();
+  var { familySync, GLIBC, MUSL } = require_detect_libc();
+  function requireNative() {
+    if (process.env.LIBSQL_JS_DEV) {
+      return load(__dirname);
+    }
+    let target = currentTarget();
+    if (familySync() == GLIBC) {
+      switch (target) {
+        case "linux-x64-musl":
+          target = "linux-x64-gnu";
+          break;
+        case "linux-arm64-musl":
+          target = "linux-arm64-gnu";
+          break;
+      }
+    }
+    if (target === "linux-arm-gnueabihf" && familySync() == MUSL) {
+      target = "linux-arm-musleabihf";
+    }
+    return __require(`@libsql/${target}`);
+  }
+  var {
+    databaseOpen,
+    databaseOpenWithSync,
+    databaseInTransaction,
+    databaseInterrupt,
+    databaseClose,
+    databaseSyncSync,
+    databaseSyncUntilSync,
+    databaseExecSync,
+    databasePrepareSync,
+    databaseDefaultSafeIntegers,
+    databaseAuthorizer,
+    databaseLoadExtension,
+    databaseMaxWriteReplicationIndex,
+    statementRaw,
+    statementIsReader,
+    statementGet,
+    statementRun,
+    statementInterrupt,
+    statementRowsSync,
+    statementColumns,
+    statementSafeIntegers,
+    rowsNext
+  } = requireNative();
+  var Authorization = require_auth();
+  var SqliteError = require_sqlite_error();
+  function convertError(err) {
+    if (err.libsqlError) {
+      return new SqliteError(err.message, err.code, err.rawCode);
+    }
+    return err;
+  }
+
+  class Database {
+    constructor(path, opts) {
+      const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
+      if (opts && opts.syncUrl) {
+        var authToken = "";
+        if (opts.syncAuth) {
+          console.warn("Warning: The `syncAuth` option is deprecated, please use `authToken` option instead.");
+          authToken = opts.syncAuth;
+        } else if (opts.authToken) {
+          authToken = opts.authToken;
+        }
+        const encryptionKey = opts?.encryptionKey ?? "";
+        const syncPeriod = opts?.syncPeriod ?? 0;
+        const readYourWrites = opts?.readYourWrites ?? true;
+        const offline = opts?.offline ?? false;
+        const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
+        this.db = databaseOpenWithSync(path, opts.syncUrl, authToken, encryptionCipher, encryptionKey, syncPeriod, readYourWrites, offline, remoteEncryptionKey);
+      } else {
+        const authToken2 = opts?.authToken ?? "";
+        const encryptionKey = opts?.encryptionKey ?? "";
+        const timeout = opts?.timeout ?? 0;
+        const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
+        this.db = databaseOpen(path, authToken2, encryptionCipher, encryptionKey, timeout, remoteEncryptionKey);
+      }
+      this.memory = path === ":memory:";
+      this.readonly = false;
+      this.name = "";
+      this.open = true;
+      const db = this.db;
+      Object.defineProperties(this, {
+        inTransaction: {
+          get() {
+            return databaseInTransaction(db);
+          }
+        }
+      });
+    }
+    sync() {
+      return databaseSyncSync.call(this.db);
+    }
+    syncUntil(replicationIndex) {
+      return databaseSyncUntilSync.call(this.db, replicationIndex);
+    }
+    prepare(sql) {
+      try {
+        const stmt = databasePrepareSync.call(this.db, sql);
+        return new Statement(stmt);
+      } catch (err) {
+        throw convertError(err);
+      }
+    }
+    transaction(fn) {
+      if (typeof fn !== "function")
+        throw new TypeError("Expected first argument to be a function");
+      const db = this;
+      const wrapTxn = (mode) => {
+        return (...bindParameters) => {
+          db.exec("BEGIN " + mode);
+          try {
+            const result = fn(...bindParameters);
+            db.exec("COMMIT");
+            return result;
+          } catch (err) {
+            db.exec("ROLLBACK");
+            throw err;
+          }
+        };
+      };
+      const properties = {
+        default: { value: wrapTxn("") },
+        deferred: { value: wrapTxn("DEFERRED") },
+        immediate: { value: wrapTxn("IMMEDIATE") },
+        exclusive: { value: wrapTxn("EXCLUSIVE") },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    }
+    pragma(source, options) {
+      if (options == null)
+        options = {};
+      if (typeof source !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      const simple = options["simple"];
+      const stmt = this.prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    }
+    backup(filename, options) {
+      throw new Error("not implemented");
+    }
+    serialize(options) {
+      throw new Error("not implemented");
+    }
+    function(name, options, fn) {
+      if (options == null)
+        options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function")
+        throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object")
+        throw new TypeError("Expected second argument to be an options object");
+      if (!name)
+        throw new TypeError("User-defined function name cannot be an empty string");
+      throw new Error("not implemented");
+    }
+    aggregate(name, options) {
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null)
+        throw new TypeError("Expected second argument to be an options object");
+      if (!name)
+        throw new TypeError("User-defined function name cannot be an empty string");
+      throw new Error("not implemented");
+    }
+    table(name, factory) {
+      if (typeof name !== "string")
+        throw new TypeError("Expected first argument to be a string");
+      if (!name)
+        throw new TypeError("Virtual table module name cannot be an empty string");
+      throw new Error("not implemented");
+    }
+    authorizer(rules) {
+      databaseAuthorizer.call(this.db, rules);
+    }
+    loadExtension(...args) {
+      databaseLoadExtension.call(this.db, ...args);
+    }
+    maxWriteReplicationIndex() {
+      return databaseMaxWriteReplicationIndex.call(this.db);
+    }
+    exec(sql) {
+      try {
+        databaseExecSync.call(this.db, sql);
+      } catch (err) {
+        throw convertError(err);
+      }
+    }
+    interrupt() {
+      databaseInterrupt.call(this.db);
+    }
+    close() {
+      databaseClose.call(this.db);
+      this.open = false;
+    }
+    defaultSafeIntegers(toggle) {
+      databaseDefaultSafeIntegers.call(this.db, toggle ?? true);
+      return this;
+    }
+    unsafeMode(...args) {
+      throw new Error("not implemented");
+    }
+  }
+
+  class Statement {
+    constructor(stmt) {
+      this.stmt = stmt;
+      this.pluckMode = false;
+    }
+    raw(raw2) {
+      statementRaw.call(this.stmt, raw2 ?? true);
+      return this;
+    }
+    pluck(pluckMode) {
+      this.pluckMode = pluckMode ?? true;
+      return this;
+    }
+    get reader() {
+      return statementIsReader.call(this.stmt);
+    }
+    run(...bindParameters) {
+      try {
+        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+          return statementRun.call(this.stmt, bindParameters[0]);
+        } else {
+          return statementRun.call(this.stmt, bindParameters.flat());
+        }
+      } catch (err) {
+        throw convertError(err);
+      }
+    }
+    get(...bindParameters) {
+      try {
+        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+          return statementGet.call(this.stmt, bindParameters[0]);
+        } else {
+          return statementGet.call(this.stmt, bindParameters.flat());
+        }
+      } catch (err) {
+        throw convertError(err);
+      }
+    }
+    iterate(...bindParameters) {
+      var rows = undefined;
+      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+        rows = statementRowsSync.call(this.stmt, bindParameters[0]);
+      } else {
+        rows = statementRowsSync.call(this.stmt, bindParameters.flat());
+      }
+      const iter = {
+        nextRows: Array(100),
+        nextRowIndex: 100,
+        next() {
+          try {
+            if (this.nextRowIndex === 100) {
+              rowsNext.call(rows, this.nextRows);
+              this.nextRowIndex = 0;
+            }
+            const row = this.nextRows[this.nextRowIndex];
+            this.nextRows[this.nextRowIndex] = undefined;
+            if (!row) {
+              return { done: true };
+            }
+            this.nextRowIndex++;
+            return { value: row, done: false };
+          } catch (err) {
+            throw convertError(err);
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iter;
+    }
+    all(...bindParameters) {
+      try {
+        const result = [];
+        for (const row of this.iterate(...bindParameters)) {
+          if (this.pluckMode) {
+            result.push(row[Object.keys(row)[0]]);
+          } else {
+            result.push(row);
+          }
+        }
+        return result;
+      } catch (err) {
+        throw convertError(err);
+      }
+    }
+    interrupt() {
+      statementInterrupt.call(this.stmt);
+    }
+    columns() {
+      return statementColumns.call(this.stmt);
+    }
+    safeIntegers(toggle) {
+      statementSafeIntegers.call(this.stmt, toggle ?? true);
+      return this;
+    }
+  }
+  module.exports = Database;
+  module.exports.Authorization = Authorization;
+  module.exports.SqliteError = SqliteError;
+});
+
+// src/telemetry/sqlite.ts
+var exports_sqlite = {};
+__export(exports_sqlite, {
+  createSqliteStores: () => createSqliteStores
+});
+function openDatabase(dbPath) {
+  const db = new import_libsql.default(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.exec(METRICS_SCHEMA);
+  db.exec(LOGS_SCHEMA);
+  return db;
+}
+
+class SqliteTelemetryStore {
+  db;
+  retentionMs;
+  insertCount = 0;
+  insertStmt;
+  countStmt;
+  constructor(db, retentionDays) {
+    this.db = db;
+    this.retentionMs = retentionDays * 24 * 60 * 60 * 1000;
+    this.insertStmt = db.prepare(`
+      INSERT INTO metrics (
+        request_id, timestamp, adapter, model, request_model, mode,
+        is_resume, is_passthrough, lineage_type,
+        has_deferred_tools, deferred_tool_count, tool_count, discovered_tools, session_discovered_count,
+        message_count, sdk_session_id,
+        status, queue_wait_ms, proxy_overhead_ms, ttfb_ms,
+        upstream_duration_ms, total_duration_ms, content_blocks, text_events, error,
+        input_tokens, output_tokens, cache_read_input_tokens,
+        cache_creation_input_tokens, cache_hit_rate
+      ) VALUES (
+        @requestId, @timestamp, @adapter, @model, @requestModel, @mode,
+        @isResume, @isPassthrough, @lineageType,
+        @hasDeferredTools, @deferredToolCount, @toolCount, @discoveredTools, @sessionDiscoveredCount,
+        @messageCount, @sdkSessionId,
+        @status, @queueWaitMs, @proxyOverheadMs, @ttfbMs,
+        @upstreamDurationMs, @totalDurationMs, @contentBlocks, @textEvents, @error,
+        @inputTokens, @outputTokens, @cacheReadInputTokens,
+        @cacheCreationInputTokens, @cacheHitRate
+      )
+    `);
+    this.countStmt = db.prepare("SELECT COUNT(*) as cnt FROM metrics");
+  }
+  record(metric) {
+    try {
+      this.insertStmt.run({
+        requestId: metric.requestId,
+        timestamp: metric.timestamp,
+        adapter: metric.adapter ?? null,
+        model: metric.model,
+        requestModel: metric.requestModel ?? null,
+        mode: metric.mode,
+        isResume: metric.isResume ? 1 : 0,
+        isPassthrough: metric.isPassthrough ? 1 : 0,
+        lineageType: metric.lineageType ?? null,
+        hasDeferredTools: metric.hasDeferredTools ? 1 : metric.hasDeferredTools === false ? 0 : null,
+        deferredToolCount: metric.deferredToolCount ?? null,
+        toolCount: metric.toolCount ?? null,
+        discoveredTools: metric.discoveredTools ? JSON.stringify(metric.discoveredTools) : null,
+        sessionDiscoveredCount: metric.sessionDiscoveredCount ?? null,
+        messageCount: metric.messageCount ?? null,
+        sdkSessionId: metric.sdkSessionId ?? null,
+        status: metric.status,
+        queueWaitMs: metric.queueWaitMs,
+        proxyOverheadMs: metric.proxyOverheadMs,
+        ttfbMs: metric.ttfbMs ?? null,
+        upstreamDurationMs: metric.upstreamDurationMs,
+        totalDurationMs: metric.totalDurationMs,
+        contentBlocks: metric.contentBlocks,
+        textEvents: metric.textEvents,
+        error: metric.error ?? null,
+        inputTokens: metric.inputTokens ?? null,
+        outputTokens: metric.outputTokens ?? null,
+        cacheReadInputTokens: metric.cacheReadInputTokens ?? null,
+        cacheCreationInputTokens: metric.cacheCreationInputTokens ?? null,
+        cacheHitRate: metric.cacheHitRate ?? null
+      });
+    } catch (err) {
+      console.error("[telemetry] SQLite write failed, skipping:", err);
+      return;
+    }
+    if (++this.insertCount % CLEANUP_INTERVAL === 0) {
+      this.cleanup();
+    }
+  }
+  get size() {
+    try {
+      return this.countStmt.get().cnt;
+    } catch {
+      return 0;
+    }
+  }
+  getRecent(options = {}) {
+    const { limit = 50, since, model } = options;
+    const conditions = [];
+    const params = { limit };
+    if (since !== undefined) {
+      conditions.push("timestamp >= @since");
+      params.since = since;
+    }
+    if (model !== undefined) {
+      conditions.push("model = @model");
+      params.model = model;
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sql = `SELECT * FROM metrics ${where} ORDER BY timestamp DESC, id DESC LIMIT @limit`;
+    try {
+      const rows = this.db.prepare(sql).all(params);
+      return rows.map(rowToMetric);
+    } catch {
+      return [];
+    }
+  }
+  getLastForSession(sdkSessionId) {
+    try {
+      const row = this.db.prepare(`SELECT * FROM metrics WHERE sdk_session_id = ? AND error IS NULL ORDER BY timestamp DESC, id DESC LIMIT 1`).get(sdkSessionId);
+      return row ? rowToMetric(row) : undefined;
+    } catch {
+      return;
+    }
+  }
+  summarize(windowMs = 60 * 60 * 1000) {
+    const since = Date.now() - windowMs;
+    const metrics = this.getRecent({ limit: 1e5, since });
+    return computeSummary(metrics, windowMs);
+  }
+  clear() {
+    try {
+      this.db.exec("DELETE FROM metrics");
+    } catch {}
+  }
+  cleanup() {
+    try {
+      const cutoff = Date.now() - this.retentionMs;
+      this.db.prepare("DELETE FROM metrics WHERE timestamp < ?").run(cutoff);
+      this.db.prepare("DELETE FROM diagnostic_logs WHERE timestamp < ?").run(cutoff);
+      this.db.pragma("wal_checkpoint(TRUNCATE)");
+    } catch (err) {
+      console.error("[telemetry] SQLite cleanup failed:", err);
+    }
+  }
+}
+
+class SqliteDiagnosticLogStore {
+  db;
+  insertStmt;
+  constructor(db) {
+    this.db = db;
+    this.insertStmt = db.prepare(`
+      INSERT INTO diagnostic_logs (timestamp, level, category, request_id, message)
+      VALUES (@timestamp, @level, @category, @requestId, @message)
+    `);
+  }
+  log(entry) {
+    try {
+      this.insertStmt.run({
+        timestamp: Date.now(),
+        level: entry.level,
+        category: entry.category,
+        requestId: entry.requestId ?? null,
+        message: entry.message
+      });
+    } catch (err) {
+      console.error("[telemetry] SQLite log write failed:", err);
+    }
+  }
+  session(message, requestId) {
+    this.log({ level: "info", category: "session", message, requestId });
+  }
+  lineage(message, requestId) {
+    this.log({ level: "warn", category: "lineage", message, requestId });
+  }
+  error(message, requestId) {
+    this.log({ level: "error", category: "error", message, requestId });
+  }
+  getRecent(options = {}) {
+    const { limit = 100, since, category } = options;
+    const conditions = [];
+    const params = { limit };
+    if (since !== undefined) {
+      conditions.push("timestamp >= @since");
+      params.since = since;
+    }
+    if (category !== undefined) {
+      conditions.push("category = @category");
+      params.category = category;
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const sql = `SELECT * FROM diagnostic_logs ${where} ORDER BY timestamp DESC, id DESC LIMIT @limit`;
+    try {
+      const rows = this.db.prepare(sql).all(params);
+      return rows.map((r) => ({
+        timestamp: r.timestamp,
+        level: r.level,
+        category: r.category,
+        requestId: r.request_id ?? undefined,
+        message: r.message
+      }));
+    } catch {
+      return [];
+    }
+  }
+  clear() {
+    try {
+      this.db.exec("DELETE FROM diagnostic_logs");
+    } catch {}
+  }
+}
+function rowToMetric(r) {
+  return {
+    requestId: r.request_id,
+    timestamp: r.timestamp,
+    adapter: r.adapter ?? undefined,
+    model: r.model,
+    requestModel: r.request_model ?? undefined,
+    mode: r.mode,
+    isResume: r.is_resume === 1,
+    isPassthrough: r.is_passthrough === 1,
+    lineageType: r.lineage_type ?? undefined,
+    hasDeferredTools: r.has_deferred_tools === 1 ? true : r.has_deferred_tools === 0 ? false : undefined,
+    deferredToolCount: r.deferred_tool_count ?? undefined,
+    toolCount: r.tool_count ?? undefined,
+    discoveredTools: r.discovered_tools ? JSON.parse(r.discovered_tools) : undefined,
+    sessionDiscoveredCount: r.session_discovered_count ?? undefined,
+    messageCount: r.message_count ?? undefined,
+    sdkSessionId: r.sdk_session_id ?? undefined,
+    status: r.status,
+    queueWaitMs: r.queue_wait_ms,
+    proxyOverheadMs: r.proxy_overhead_ms,
+    ttfbMs: r.ttfb_ms ?? null,
+    upstreamDurationMs: r.upstream_duration_ms,
+    totalDurationMs: r.total_duration_ms,
+    contentBlocks: r.content_blocks,
+    textEvents: r.text_events,
+    error: r.error ?? null,
+    inputTokens: r.input_tokens ?? undefined,
+    outputTokens: r.output_tokens ?? undefined,
+    cacheReadInputTokens: r.cache_read_input_tokens ?? undefined,
+    cacheCreationInputTokens: r.cache_creation_input_tokens ?? undefined,
+    cacheHitRate: r.cache_hit_rate ?? undefined
+  };
+}
+function createSqliteStores(dbPath, retentionDays) {
+  const db = openDatabase(dbPath);
+  return {
+    telemetry: new SqliteTelemetryStore(db, retentionDays),
+    diagnostics: new SqliteDiagnosticLogStore(db),
+    close: () => {
+      try {
+        db.close();
+      } catch {}
+    }
+  };
+}
+var import_libsql, METRICS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS metrics (
+  id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+  request_id           TEXT    NOT NULL,
+  timestamp            INTEGER NOT NULL,
+  adapter              TEXT,
+  model                TEXT    NOT NULL,
+  request_model        TEXT,
+  mode                 TEXT    NOT NULL,
+  is_resume            INTEGER NOT NULL,
+  is_passthrough       INTEGER NOT NULL,
+  lineage_type         TEXT,
+  has_deferred_tools   INTEGER,
+  deferred_tool_count  INTEGER,
+  tool_count           INTEGER,
+  discovered_tools     TEXT,
+  session_discovered_count INTEGER,
+  message_count        INTEGER,
+  sdk_session_id       TEXT,
+  status               INTEGER NOT NULL,
+  queue_wait_ms        REAL    NOT NULL,
+  proxy_overhead_ms    REAL    NOT NULL,
+  ttfb_ms              REAL,
+  upstream_duration_ms REAL    NOT NULL,
+  total_duration_ms    REAL    NOT NULL,
+  content_blocks       INTEGER NOT NULL,
+  text_events          INTEGER NOT NULL,
+  error                TEXT,
+  input_tokens         INTEGER,
+  output_tokens        INTEGER,
+  cache_read_input_tokens INTEGER,
+  cache_creation_input_tokens INTEGER,
+  cache_hit_rate       REAL
+);
+CREATE INDEX IF NOT EXISTS idx_metrics_ts    ON metrics(timestamp);
+CREATE INDEX IF NOT EXISTS idx_metrics_model ON metrics(model);
+CREATE INDEX IF NOT EXISTS idx_metrics_session_success ON metrics(sdk_session_id, timestamp DESC, id DESC);
+`, LOGS_SCHEMA = `
+CREATE TABLE IF NOT EXISTS diagnostic_logs (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp  INTEGER NOT NULL,
+  level      TEXT    NOT NULL,
+  category   TEXT    NOT NULL,
+  request_id TEXT,
+  message    TEXT    NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_logs_ts  ON diagnostic_logs(timestamp);
+CREATE INDEX IF NOT EXISTS idx_logs_cat ON diagnostic_logs(category);
+`, CLEANUP_INTERVAL = 1000;
+var init_sqlite = __esm(() => {
+  init_percentiles();
+  import_libsql = __toESM(require_libsql(), 1);
+});
+
+// src/proxy/sdkFeatures.ts
+var exports_sdkFeatures = {};
+__export(exports_sdkFeatures, {
+  validateFeatureUpdate: () => validateFeatureUpdate,
+  updateAdapterFeatures: () => updateAdapterFeatures,
+  resetAdapterFeatures: () => resetAdapterFeatures,
+  getFeaturesForAdapter: () => getFeaturesForAdapter,
+  getAllFeatureConfigs: () => getAllFeatureConfigs
+});
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync as renameSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+function getConfigPath() {
+  const dir = join5(homedir4(), ".config", "meridian");
+  if (!existsSync4(dir))
+    mkdirSync2(dir, { recursive: true });
+  return join5(dir, "sdk-features.json");
+}
+function readConfig() {
+  const now = Date.now();
+  if (cachedConfig && now - lastReadTime < CACHE_TTL_MS)
+    return cachedConfig;
+  const path3 = getConfigPath();
+  try {
+    if (existsSync4(path3)) {
+      cachedConfig = JSON.parse(readFileSync3(path3, "utf-8"));
+    } else {
+      cachedConfig = {};
+    }
+  } catch {
+    cachedConfig = {};
+  }
+  lastReadTime = now;
+  return cachedConfig;
+}
+function writeConfig(config) {
+  const path3 = getConfigPath();
+  const tmp = `${path3}.tmp`;
+  try {
+    writeFileSync2(tmp, JSON.stringify(config, null, 2));
+    renameSync2(tmp, path3);
+    cachedConfig = config;
+    lastReadTime = Date.now();
+  } catch (e) {
+    console.error("[sdk-features] write failed:", e.message);
+  }
+}
+function getFeaturesForAdapter(adapterName) {
+  const config = readConfig();
+  const userOverrides = config[adapterName] ?? {};
+  const adapterDefaults = ADAPTER_DEFAULTS[adapterName] ?? {};
+  return {
+    ...DEFAULT_FEATURES,
+    ...adapterDefaults,
+    ...userOverrides
+  };
+}
+function getAllFeatureConfigs() {
+  const adapters = ["opencode", "crush", "forgecode", "pi", "droid", "passthrough"];
+  const result = {};
+  for (const name of adapters) {
+    result[name] = getFeaturesForAdapter(name);
+  }
+  return result;
+}
+function validateFeatureUpdate(raw2) {
+  if (raw2 === null || typeof raw2 !== "object" || Array.isArray(raw2)) {
+    throw new Error("body must be a JSON object");
+  }
+  const input = raw2;
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (!(key in DEFAULT_FEATURES))
+      continue;
+    const expected = typeof DEFAULT_FEATURES[key];
+    if (key === "claudeMd") {
+      if (typeof value !== "string" || !VALID_CLAUDE_MD_VALUES.has(value)) {
+        throw new Error(`claudeMd must be one of: ${[...VALID_CLAUDE_MD_VALUES].join(", ")}`);
+      }
+      result[key] = value;
+    } else if (key === "thinking") {
+      if (typeof value !== "string" || !VALID_THINKING_VALUES.has(value)) {
+        throw new Error(`thinking must be one of: ${[...VALID_THINKING_VALUES].join(", ")}`);
+      }
+      result[key] = value;
+    } else if (expected === "boolean") {
+      if (typeof value !== "boolean")
+        throw new Error(`${key} must be a boolean`);
+      result[key] = value;
+    } else if (expected === "number") {
+      if (typeof value !== "number" || !isFinite(value))
+        throw new Error(`${key} must be a finite number`);
+      result[key] = value;
+    } else if (expected === "string") {
+      if (typeof value !== "string")
+        throw new Error(`${key} must be a string`);
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function updateAdapterFeatures(adapterName, features) {
+  const config = readConfig();
+  config[adapterName] = { ...config[adapterName] ?? {}, ...features };
+  writeConfig(config);
+}
+function resetAdapterFeatures(adapterName) {
+  const config = readConfig();
+  delete config[adapterName];
+  writeConfig(config);
+}
+var DEFAULT_FEATURES, ADAPTER_DEFAULTS, cachedConfig = null, lastReadTime = 0, CACHE_TTL_MS = 5000, VALID_CLAUDE_MD_VALUES, VALID_THINKING_VALUES;
+var init_sdkFeatures = __esm(() => {
+  DEFAULT_FEATURES = {
+    codeSystemPrompt: false,
+    clientSystemPrompt: true,
+    claudeMd: "off",
+    memory: false,
+    dreaming: false,
+    thinking: "disabled",
+    thinkingPassthrough: false,
+    sharedMemory: false,
+    maxBudgetUsd: 0,
+    fallbackModel: "",
+    sdkDebug: false,
+    additionalDirectories: ""
+  };
+  ADAPTER_DEFAULTS = {};
+  VALID_CLAUDE_MD_VALUES = new Set(["off", "project", "full"]);
+  VALID_THINKING_VALUES = new Set(["adaptive", "enabled", "disabled"]);
+});
+
+// src/telemetry/settingsPage.ts
+var exports_settingsPage = {};
+__export(exports_settingsPage, {
+  settingsPageHtml: () => settingsPageHtml
+});
+var settingsPageHtml;
+var init_settingsPage = __esm(() => {
+  init_profileBar();
+  settingsPageHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Meridian — SDK Features</title>
+<link rel="icon" type="image/svg+xml" href="/telemetry/icon.svg">
+<style>
+  :root {
+    --bg: #0d1117; --surface: #161b22; --border: #30363d;
+    --text: #e6edf3; --muted: #8b949e; --accent: #58a6ff;
+    --green: #3fb950; --yellow: #d29922; --red: #f85149;
+    --purple: #bc8cff;
+  }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+         background: var(--bg); color: var(--text); padding: 0; line-height: 1.5; }
+  ${profileBarCss}
+  .content { max-width: 900px; margin: 0 auto; padding: 24px; }
+  h1 { font-size: 20px; font-weight: 600; margin-bottom: 4px; }
+  .subtitle { color: var(--muted); font-size: 13px; margin-bottom: 24px; }
+  .nav { display: flex; gap: 16px; margin-bottom: 24px; font-size: 13px; }
+  .nav a { color: var(--muted); text-decoration: none; }
+  .nav a:hover { color: var(--accent); }
+  .nav a.active { color: var(--accent); }
+
+  .adapter-card {
+    background: var(--surface); border: 1px solid var(--border); border-radius: 8px;
+    padding: 20px; margin-bottom: 16px;
+  }
+  .adapter-header {
+    display: flex; align-items: center; justify-content: space-between;
+    margin-bottom: 16px;
+  }
+  .adapter-name { font-size: 16px; font-weight: 600; }
+  .adapter-badge {
+    font-size: 10px; padding: 2px 8px; border-radius: 10px;
+    text-transform: uppercase; letter-spacing: 0.5px;
+  }
+  .badge-active { background: rgba(63, 185, 80, 0.15); color: var(--green); }
+  .badge-inactive { background: rgba(139, 148, 158, 0.15); color: var(--muted); }
+
+  .feature-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+  @media (max-width: 600px) { .feature-grid { grid-template-columns: 1fr; } }
+
+  .feature-row {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 10px 14px; border-radius: 6px;
+    background: var(--bg); border: 1px solid var(--border);
+  }
+  .feature-info { display: flex; flex-direction: column; }
+  .feature-label { font-size: 13px; font-weight: 500; }
+  .feature-desc { font-size: 11px; color: var(--muted); margin-top: 2px; }
+
+  /* Toggle switch */
+  .toggle { position: relative; width: 36px; height: 20px; flex-shrink: 0; }
+  .toggle input { opacity: 0; width: 0; height: 0; }
+  .toggle-track {
+    position: absolute; cursor: pointer; top: 0; left: 0; right: 0; bottom: 0;
+    background: var(--border); border-radius: 10px; transition: background 0.2s;
+  }
+  .toggle-track::after {
+    content: ""; position: absolute; height: 14px; width: 14px;
+    left: 3px; bottom: 3px; background: var(--muted); border-radius: 50%;
+    transition: transform 0.2s, background 0.2s;
+  }
+  .toggle input:checked + .toggle-track { background: var(--accent); }
+  .toggle input:checked + .toggle-track::after {
+    transform: translateX(16px); background: var(--text);
+  }
+
+  /* Select dropdown */
+  .feature-select {
+    background: var(--surface); color: var(--text); border: 1px solid var(--border);
+    border-radius: 6px; padding: 4px 8px; font-size: 12px; cursor: pointer;
+  }
+
+  .save-indicator {
+    position: fixed; bottom: 24px; right: 24px;
+    background: var(--green); color: #000; padding: 8px 16px;
+    border-radius: 6px; font-size: 13px; font-weight: 500;
+    opacity: 0; transition: opacity 0.3s; pointer-events: none;
+  }
+  .save-indicator.visible { opacity: 1; }
+
+  .reset-btn {
+    background: none; border: 1px solid var(--border); color: var(--muted);
+    border-radius: 6px; padding: 4px 12px; font-size: 11px; cursor: pointer;
+  }
+  .reset-btn:hover { border-color: var(--red); color: var(--red); }
+</style>
+</head>
+<body>
+${profileBarHtml}
+<div class="content">
+  <h1>SDK Features <span style="font-size:11px;padding:2px 8px;border-radius:10px;background:rgba(210,153,34,0.15);color:var(--yellow);vertical-align:middle;margin-left:8px">Experimental</span></h1>
+  <p class="subtitle" style="max-width:720px;line-height:1.6">
+    Unlock Claude Code features for any connected agent. Capabilities like auto-memory, dreaming, and CLAUDE.md — normally
+    exclusive to Claude Code — become available to OpenCode, Crush, Droid, and any other harness routed through Meridian.
+    Each agent keeps its own toolchain while gaining access to these additional features.<br><br>
+    <strong style="color:var(--text)">System prompts:</strong> For these features to work correctly, both the Claude Code prompt and your client prompt
+    should be enabled. When both are active, they are appended together — Claude Code's base instructions come first,
+    followed by your agent's specific instructions.
+  </p>
+
+  <div id="adapters"></div>
+</div>
+
+<div class="save-indicator" id="saveIndicator">Saved</div>
+
+<script>
+const FEATURES = [
+  { key: 'codeSystemPrompt', label: 'Claude Code Prompt', desc: 'Include the built-in Claude Code system prompt (tool usage rules, safety guidelines, coding best practices)', type: 'toggle' },
+  { key: 'clientSystemPrompt', label: 'Client Prompt', desc: 'Include the system prompt sent by the connecting agent (e.g. OpenCode or Crush instructions)', type: 'toggle' },
+  { key: 'claudeMd', label: 'CLAUDE.md', desc: 'Load CLAUDE.md instruction files — Off: none, Project: ./CLAUDE.md only, Full: ~/.claude/CLAUDE.md + ./CLAUDE.md', type: 'select', options: ['off', 'project', 'full'] },
+  { key: 'memory', label: 'Memory', desc: 'Read and write memories across sessions', type: 'toggle' },
+  { key: 'dreaming', label: 'Auto-Dream', desc: 'Background memory consolidation', type: 'toggle' },
+  { key: 'thinking', label: 'Thinking', desc: 'Extended thinking mode', type: 'select', options: ['disabled', 'adaptive', 'enabled'] },
+  { key: 'thinkingPassthrough', label: 'Thinking Passthrough', desc: 'Forward thinking blocks to the client', type: 'toggle' },
+  { key: 'sharedMemory', label: 'Shared Memory', desc: 'Share memory with Claude Code (~/.claude) instead of isolated storage', type: 'toggle' },
+  { key: 'maxBudgetUsd', label: 'Max Budget (USD)', desc: 'Per-request cost cap — query aborts if exceeded (0 = disabled)', type: 'number' },
+  { key: 'fallbackModel', label: 'Fallback Model', desc: 'Auto-fallback model if primary fails', type: 'select', options: ['', 'sonnet', 'opus', 'haiku', 'sonnet[1m]', 'opus[1m]'] },
+  { key: 'sdkDebug', label: 'SDK Debug Logging', desc: 'Enable verbose SDK debug output to proxy stderr', type: 'toggle' },
+  { key: 'additionalDirectories', label: 'Additional Directories', desc: 'Comma-separated extra paths Claude can access (monorepo libs, etc.)', type: 'text' },
+];
+
+const ADAPTER_LABELS = {
+  opencode: 'OpenCode',
+  crush: 'Crush',
+  forgecode: 'ForgeCode',
+  pi: 'Pi',
+  droid: 'Droid',
+  passthrough: 'LiteLLM / Passthrough',
+};
+
+let currentConfig = {};
+
+async function loadConfig() {
+  const res = await fetch('/settings/api/features');
+  currentConfig = await res.json();
+  render();
+}
+
+async function saveFeature(adapter, key, value) {
+  const patch = {};
+  patch[key] = value;
+  await fetch('/settings/api/features/' + adapter, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(patch),
+  });
+  currentConfig[adapter][key] = value;
+  showSaved();
+}
+
+async function resetAdapter(adapter) {
+  await fetch('/settings/api/features/' + adapter, { method: 'DELETE' });
+  await loadConfig();
+  showSaved();
+}
+
+function showSaved() {
+  const el = document.getElementById('saveIndicator');
+  el.classList.add('visible');
+  setTimeout(() => el.classList.remove('visible'), 1500);
+}
+
+function hasAnyEnabled(features) {
+  return features.codeSystemPrompt || !features.clientSystemPrompt || features.claudeMd !== 'off' || features.memory || features.dreaming ||
+         features.thinking !== 'disabled' || features.thinkingPassthrough ||
+         features.sharedMemory || features.maxBudgetUsd > 0 ||
+         features.fallbackModel || features.sdkDebug ||
+         features.additionalDirectories;
+}
+
+function render() {
+  const container = document.getElementById('adapters');
+  container.innerHTML = '';
+
+  for (const [adapter, label] of Object.entries(ADAPTER_LABELS)) {
+    const features = currentConfig[adapter] || {};
+    const active = hasAnyEnabled(features);
+
+    const card = document.createElement('div');
+    card.className = 'adapter-card';
+    card.innerHTML = '<div class="adapter-header">' +
+      '<span class="adapter-name">' + label + '</span>' +
+      '<div style="display:flex;gap:8px;align-items:center">' +
+        '<span class="adapter-badge ' + (active ? 'badge-active' : 'badge-inactive') + '">' +
+          (active ? 'Active' : 'Default') +
+        '</span>' +
+        '<button class="reset-btn" onclick="resetAdapter(\\''+adapter+'\\')">Reset</button>' +
+      '</div>' +
+    '</div>';
+
+    const grid = document.createElement('div');
+    grid.className = 'feature-grid';
+
+    for (const feat of FEATURES) {
+      const row = document.createElement('div');
+      row.className = 'feature-row';
+
+      const info = '<div class="feature-info"><span class="feature-label">' +
+        feat.label + '</span><span class="feature-desc">' + feat.desc + '</span></div>';
+
+      if (feat.type === 'toggle') {
+        const checked = features[feat.key] ? 'checked' : '';
+        row.innerHTML = info +
+          '<label class="toggle"><input type="checkbox" ' + checked +
+          ' onchange="saveFeature(\\''+adapter+'\\', \\''+feat.key+'\\', this.checked)">' +
+          '<span class="toggle-track"></span></label>';
+      } else if (feat.type === 'select') {
+        const options = feat.options.map(o => {
+          const label = o === '' ? '(None)' : o.charAt(0).toUpperCase()+o.slice(1);
+          return '<option value="'+o+'"'+(features[feat.key]===o?' selected':'')+'>'+label+'</option>';
+        }).join('');
+        row.innerHTML = info +
+          '<select class="feature-select" onchange="saveFeature(\\''+adapter+'\\', \\''+feat.key+'\\', this.value)">' +
+          options + '</select>';
+      } else if (feat.type === 'number') {
+        const value = features[feat.key] ?? 0;
+        row.innerHTML = info +
+          '<input type="number" class="feature-select" style="width:80px;text-align:right" min="0" step="0.01" value="'+value+'"' +
+          ' onchange="saveFeature(\\''+adapter+'\\', \\''+feat.key+'\\', parseFloat(this.value)||0)">';
+      } else if (feat.type === 'text') {
+        const value = (features[feat.key] ?? '').toString().replace(/"/g, '&quot;');
+        row.innerHTML = info +
+          '<input type="text" class="feature-select" style="width:180px" value="'+value+'"' +
+          ' onchange="saveFeature(\\''+adapter+'\\', \\''+feat.key+'\\', this.value)">';
+      }
+
+      grid.appendChild(row);
+    }
+
+    card.appendChild(grid);
+    container.appendChild(card);
+  }
+}
+
+loadConfig();
+${profileBarJs}
+</script>
+</body>
+</html>`;
+});
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -2187,7 +3698,8 @@ var DEFAULT_PROXY_CONFIG = {
   idleTimeoutSeconds: 120,
   silent: false,
   profiles: undefined,
-  defaultProfile: undefined
+  defaultProfile: undefined,
+  version: undefined
 };
 
 // src/env.ts
@@ -2198,6 +3710,13 @@ function envBool(suffix) {
   const val = env(suffix);
   return val === "1" || val === "true" || val === "yes";
 }
+function envInt(suffix, defaultValue) {
+  const val = env(suffix);
+  if (!val)
+    return defaultValue;
+  const parsed = parseInt(val, 10);
+  return Number.isFinite(parsed) ? parsed : defaultValue;
+}
 
 // src/proxy/server.ts
 import { exec as execCallback2 } from "child_process";
@@ -6270,7 +7789,12 @@ function stripMcpPrefix(toolName) {
   return toolName;
 }
 
+// src/telemetry/index.ts
+import { join } from "node:path";
+import { homedir } from "node:os";
+
 // src/telemetry/store.ts
+init_percentiles();
 var DEFAULT_CAPACITY = 1000;
 function getCapacity() {
   const raw2 = process.env.MERIDIAN_TELEMETRY_SIZE ?? process.env.CLAUDE_PROXY_TELEMETRY_SIZE;
@@ -6282,7 +7806,7 @@ function getCapacity() {
   return parsed;
 }
 
-class TelemetryStore {
+class MemoryTelemetryStore {
   buffer;
   head = 0;
   count = 0;
@@ -6329,94 +7853,7 @@ class TelemetryStore {
   summarize(windowMs = 60 * 60 * 1000) {
     const since = Date.now() - windowMs;
     const metrics = this.getRecent({ limit: this.capacity, since });
-    if (metrics.length === 0) {
-      const emptyPhase = { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 };
-      return {
-        windowMs,
-        totalRequests: 0,
-        errorCount: 0,
-        requestsPerMinute: 0,
-        queueWait: emptyPhase,
-        proxyOverhead: emptyPhase,
-        ttfb: emptyPhase,
-        upstreamDuration: emptyPhase,
-        totalDuration: emptyPhase,
-        byModel: {},
-        byMode: {},
-        tokenUsage: {
-          totalInputTokens: 0,
-          totalOutputTokens: 0,
-          totalCacheReadTokens: 0,
-          totalCacheCreationTokens: 0,
-          avgCacheHitRate: 0,
-          cacheMissOnResumeCount: 0
-        }
-      };
-    }
-    const errorCount = metrics.filter((m) => m.error !== null).length;
-    const oldest = metrics[metrics.length - 1].timestamp;
-    const newest = metrics[0].timestamp;
-    const spanMs = Math.max(newest - oldest, 1);
-    const requestsPerMinute = metrics.length / spanMs * 60000;
-    const queueWaits = metrics.map((m) => m.queueWaitMs);
-    const overheads = metrics.map((m) => m.proxyOverheadMs);
-    const ttfbs = metrics.filter((m) => m.ttfbMs !== null).map((m) => m.ttfbMs);
-    const upstreams = metrics.map((m) => m.upstreamDurationMs);
-    const totals = metrics.map((m) => m.totalDurationMs);
-    const byModel = {};
-    for (const m of metrics) {
-      const modelKey = m.requestModel || m.model;
-      const entry = byModel[modelKey] ??= { count: 0, totalMs: 0 };
-      entry.count++;
-      entry.totalMs += m.totalDurationMs;
-    }
-    const byMode = {};
-    for (const m of metrics) {
-      const entry = byMode[m.mode] ??= { count: 0, totalMs: 0 };
-      entry.count++;
-      entry.totalMs += m.totalDurationMs;
-    }
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheReadTokens = 0;
-    let totalCacheCreationTokens = 0;
-    let cacheHitRateSum = 0;
-    let cacheHitRateCount = 0;
-    let cacheMissOnResumeCount = 0;
-    for (const m of metrics) {
-      totalInputTokens += m.inputTokens ?? 0;
-      totalOutputTokens += m.outputTokens ?? 0;
-      totalCacheReadTokens += m.cacheReadInputTokens ?? 0;
-      totalCacheCreationTokens += m.cacheCreationInputTokens ?? 0;
-      if (m.cacheHitRate !== undefined) {
-        cacheHitRateSum += m.cacheHitRate;
-        cacheHitRateCount++;
-      }
-      if (m.isResume && m.cacheHitRate !== undefined && m.cacheHitRate === 0) {
-        cacheMissOnResumeCount++;
-      }
-    }
-    return {
-      windowMs,
-      totalRequests: metrics.length,
-      errorCount,
-      requestsPerMinute: Math.round(requestsPerMinute * 100) / 100,
-      queueWait: computePercentiles(queueWaits),
-      proxyOverhead: computePercentiles(overheads),
-      ttfb: ttfbs.length > 0 ? computePercentiles(ttfbs) : { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 },
-      upstreamDuration: computePercentiles(upstreams),
-      totalDuration: computePercentiles(totals),
-      byModel: Object.fromEntries(Object.entries(byModel).map(([k, v]) => [k, { count: v.count, avgTotalMs: Math.round(v.totalMs / v.count) }])),
-      byMode: Object.fromEntries(Object.entries(byMode).map(([k, v]) => [k, { count: v.count, avgTotalMs: Math.round(v.totalMs / v.count) }])),
-      tokenUsage: {
-        totalInputTokens,
-        totalOutputTokens,
-        totalCacheReadTokens,
-        totalCacheCreationTokens,
-        avgCacheHitRate: cacheHitRateCount > 0 ? Math.round(cacheHitRateSum / cacheHitRateCount * 100) / 100 : 0,
-        cacheMissOnResumeCount
-      }
-    };
+    return computeSummary(metrics, windowMs);
   }
   clear() {
     this.buffer = new Array(this.capacity).fill(null);
@@ -6424,25 +7861,12 @@ class TelemetryStore {
     this.count = 0;
   }
 }
-function computePercentiles(values) {
-  if (values.length === 0)
-    return { p50: 0, p95: 0, p99: 0, min: 0, max: 0, avg: 0 };
-  const sorted = [...values].sort((a, b) => a - b);
-  const sum = sorted.reduce((a, b) => a + b, 0);
-  return {
-    p50: sorted[Math.floor(sorted.length * 0.5)],
-    p95: sorted[Math.floor(sorted.length * 0.95)],
-    p99: sorted[Math.floor(sorted.length * 0.99)],
-    min: sorted[0],
-    max: sorted[sorted.length - 1],
-    avg: Math.round(sum / sorted.length)
-  };
-}
-var telemetryStore = new TelemetryStore;
+var telemetryStore = new MemoryTelemetryStore;
+
 // src/telemetry/logStore.ts
 var DEFAULT_CAPACITY2 = 500;
 
-class DiagnosticLogStore {
+class MemoryDiagnosticLogStore {
   buffer;
   head = 0;
   count = 0;
@@ -6488,13 +7912,14 @@ class DiagnosticLogStore {
     this.count = 0;
   }
 }
-var diagnosticLog = new DiagnosticLogStore;
+var diagnosticLog = new MemoryDiagnosticLogStore;
 // src/telemetry/routes.ts
 import { existsSync, readFileSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/telemetry/dashboard.ts
+init_profileBar();
 var dashboardHtml = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -6866,7 +8291,7 @@ function createTelemetryRoutes() {
     const limit = Number.parseInt(c.req.query("limit") || "50", 10);
     const since = c.req.query("since") ? Number.parseInt(c.req.query("since"), 10) : undefined;
     const model = c.req.query("model") || undefined;
-    const requests = telemetryStore.getRecent({
+    const requests = telemetryStore2.getRecent({
       limit: Math.min(limit, 500),
       since,
       model
@@ -6875,14 +8300,14 @@ function createTelemetryRoutes() {
   });
   routes.get("/summary", (c) => {
     const windowMs = Number.parseInt(c.req.query("window") || "3600000", 10);
-    const summary = telemetryStore.summarize(windowMs);
+    const summary = telemetryStore2.summarize(windowMs);
     return c.json(summary);
   });
   routes.get("/logs", (c) => {
     const limit = Number.parseInt(c.req.query("limit") || "100", 10);
     const since = c.req.query("since") ? Number.parseInt(c.req.query("since"), 10) : undefined;
     const category = c.req.query("category") || undefined;
-    const logs = diagnosticLog.getRecent({
+    const logs = diagnosticLog2.getRecent({
       limit: Math.min(limit, 500),
       since,
       category
@@ -6892,6 +8317,7 @@ function createTelemetryRoutes() {
   return routes;
 }
 // src/telemetry/landing.ts
+init_profileBar();
 var landingHtml = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -7004,7 +8430,7 @@ function render(h,s){
   o+='</div>';
   if(s.byModel&&Object.keys(s.byModel).length>0){o+='<div class="section"><div class="section-title">Models (24h)</div><div class="grid">';for(const[n,d]of Object.entries(s.byModel))o+=card(n,d.count,'avg '+ms(d.avgTotalMs),'');o+='</div></div>'}
   o+='<div class="section"><div class="section-title">Connect an Agent</div><div class="snippet"><div class="snippet-tabs"><div class="snippet-tab active" onclick="showTab(this,&apos;opencode&apos;)">OpenCode</div><div class="snippet-tab" onclick="showTab(this,&apos;crush&apos;)">Crush</div><div class="snippet-tab" onclick="showTab(this,&apos;generic&apos;)">Any Tool</div></div><div id="tab-opencode"><code>ANTHROPIC_API_KEY=x ANTHROPIC_BASE_URL=http://'+location.host+' opencode</code></div><div id="tab-crush" style="display:none"><code>'+JSON.stringify({providers:{meridian:{type:"anthropic",base_url:"http://"+location.host,api_key:"x",models:[{id:"claude-sonnet-4-5-20250514",name:"Sonnet 4.5"}]}}},null,2)+'</code></div><div id="tab-generic" style="display:none"><code>export ANTHROPIC_API_KEY=x\\nexport ANTHROPIC_BASE_URL=http://'+location.host+'</code></div></div></div>';
-  o+='<div class="links"><a href="/telemetry" class="link">\uD83D\uDCCA Telemetry</a><a href="/profiles" class="link">\uD83D\uDC64 Profiles</a><a href="/health" class="link">\uD83E\uDE7A Health</a><a href="/telemetry/summary" class="link">\uD83D\uDCC8 Stats API</a><a href="https://github.com/rynfar/meridian" class="link">⚙️ GitHub</a></div>';
+  o+='<div class="links"><a href="/telemetry" class="link">\uD83D\uDCCA Telemetry</a><a href="/settings" class="link">\uD83D\uDD27 Settings</a><a href="/profiles" class="link">\uD83D\uDC64 Profiles</a><a href="/health" class="link">\uD83E\uDE7A Health</a><a href="/telemetry/summary" class="link">\uD83D\uDCC8 Stats API</a><a href="https://github.com/rynfar/meridian" class="link">⚙️ GitHub</a></div>';
   o+='<div class="footer">Meridian · Built on the <a href="https://github.com/anthropics/claude-code-sdk-js">Claude Code SDK</a></div>';
   document.getElementById('content').innerHTML=o;
 }
@@ -7014,6 +8440,95 @@ refresh();setInterval(refresh,10000);
 </script>
 </body>
 </html>`;
+
+// src/telemetry/index.ts
+init_percentiles();
+
+// src/telemetry/prometheus.ts
+var DURATION_BUCKETS = [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 1e4, 30000];
+var PHASES = [
+  { key: "queue_wait", extract: (m) => m.queueWaitMs },
+  { key: "proxy_overhead", extract: (m) => m.proxyOverheadMs },
+  { key: "ttfb", extract: (m) => m.ttfbMs },
+  { key: "upstream", extract: (m) => m.upstreamDurationMs },
+  { key: "total", extract: (m) => m.totalDurationMs }
+];
+function escapeLabelValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+}
+function formatLabels(labels) {
+  return Object.entries(labels).map(([k, v]) => `${k}="${escapeLabelValue(v)}"`).join(",");
+}
+function renderPrometheusMetrics(store) {
+  const metrics = store.getRecent({ limit: 1e4 });
+  const lines = [];
+  lines.push("# HELP meridian_requests_total Total proxy requests");
+  lines.push("# TYPE meridian_requests_total counter");
+  const counters = new Map;
+  for (const m of metrics) {
+    const key = `${m.model}\x00${m.mode}\x00${m.status}`;
+    counters.set(key, (counters.get(key) ?? 0) + 1);
+  }
+  for (const [key, count] of counters) {
+    const [model, mode, status] = key.split("\x00");
+    lines.push(`meridian_requests_total{${formatLabels({ model, mode, status })}} ${count}`);
+  }
+  lines.push("");
+  lines.push("# HELP meridian_request_duration_ms Request duration by phase in milliseconds");
+  lines.push("# TYPE meridian_request_duration_ms histogram");
+  for (const phase of PHASES) {
+    const values = [];
+    for (const m of metrics) {
+      const v = phase.extract(m);
+      if (v !== null)
+        values.push(v);
+    }
+    const phaseLabel = `phase="${escapeLabelValue(phase.key)}"`;
+    for (const le of DURATION_BUCKETS) {
+      const count = values.filter((v) => v <= le).length;
+      lines.push(`meridian_request_duration_ms_bucket{${phaseLabel},le="${le}"} ${count}`);
+    }
+    lines.push(`meridian_request_duration_ms_bucket{${phaseLabel},le="+Inf"} ${values.length}`);
+    const sum = values.reduce((a, b) => a + b, 0);
+    lines.push(`meridian_request_duration_ms_sum{${phaseLabel}} ${sum}`);
+    lines.push(`meridian_request_duration_ms_count{${phaseLabel}} ${values.length}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/telemetry/index.ts
+init_sqlite();
+function getDefaultDbPath() {
+  return join(homedir(), ".config", "meridian", "telemetry.db");
+}
+function createStores() {
+  if (!envBool("TELEMETRY_PERSIST")) {
+    return {
+      telemetry: new MemoryTelemetryStore,
+      diagnostics: new MemoryDiagnosticLogStore
+    };
+  }
+  try {
+    const { createSqliteStores: createSqliteStores2 } = (init_sqlite(), __toCommonJS(exports_sqlite));
+    const dbPath = env("TELEMETRY_DB") ?? getDefaultDbPath();
+    const retention = envInt("TELEMETRY_RETENTION_DAYS", 7);
+    const stores = createSqliteStores2(dbPath, retention);
+    console.error(`[telemetry] SQLite persistence enabled: ${dbPath} (${retention}d retention)`);
+    return { telemetry: stores.telemetry, diagnostics: stores.diagnostics };
+  } catch {
+    console.warn("[telemetry] MERIDIAN_TELEMETRY_PERSIST is set but libsql is not installed. Run: npm install libsql");
+    return {
+      telemetry: new MemoryTelemetryStore,
+      diagnostics: new MemoryDiagnosticLogStore
+    };
+  }
+}
+var stores = createStores();
+var telemetryStore2 = stores.telemetry;
+var diagnosticLog2 = stores.diagnostics;
+
 // src/proxy/errors.ts
 function classifyError(errMsg) {
   const lower = errMsg.toLowerCase();
@@ -7106,7 +8621,8 @@ function isExpiredTokenError(errMsg) {
 function isStaleSessionError(error) {
   if (!(error instanceof Error))
     return false;
-  return error.message.includes("No message found with message.uuid");
+  const msg = error.message;
+  return msg.includes("No message found with message.uuid") || msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume");
 }
 function isRateLimitError(errMsg) {
   const lower = errMsg.toLowerCase();
@@ -7121,7 +8637,7 @@ function isExtraUsageRequiredError(errMsg) {
 import { exec as execCallback } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join, dirname as dirname2 } from "path";
+import { join as join2, dirname as dirname2 } from "path";
 import { promisify } from "util";
 var exec = promisify(execCallback);
 var AUTH_STATUS_CACHE_TTL_MS = 60000;
@@ -7263,7 +8779,7 @@ async function resolveClaudeExecutableAsync() {
     if (runningUnderBun) {
       try {
         const sdkPath = fileURLToPath2(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
-        const sdkCliJs = join(dirname2(sdkPath), "cli.js");
+        const sdkCliJs = join2(dirname2(sdkPath), "cli.js");
         if (existsSync2(sdkCliJs)) {
           cachedClaudePath = sdkCliJs;
           return sdkCliJs;
@@ -7281,7 +8797,7 @@ async function resolveClaudeExecutableAsync() {
     if (!runningUnderBun) {
       try {
         const sdkPath = fileURLToPath2(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
-        const sdkCliJs = join(dirname2(sdkPath), "cli.js");
+        const sdkCliJs = join2(dirname2(sdkPath), "cli.js");
         if (existsSync2(sdkCliJs)) {
           cachedClaudePath = sdkCliJs;
           return sdkCliJs;
@@ -7479,6 +8995,42 @@ function getLastUserMessage(messages) {
   return messages.slice(-1);
 }
 
+// src/proxy/auth.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+function getConfiguredKey() {
+  return process.env.MERIDIAN_API_KEY || undefined;
+}
+function safeCompare(a, b) {
+  const hashA = createHmac("sha256", "meridian").update(a).digest();
+  const hashB = createHmac("sha256", "meridian").update(b).digest();
+  return timingSafeEqual(hashA, hashB);
+}
+function extractKey(c) {
+  const apiKey = c.req.header("x-api-key");
+  if (apiKey)
+    return apiKey;
+  const auth = c.req.header("authorization");
+  if (auth?.startsWith("Bearer "))
+    return auth.slice(7);
+  return;
+}
+async function requireAuth(c, next) {
+  const key = getConfiguredKey();
+  if (!key)
+    return next();
+  const provided = extractKey(c);
+  if (!provided || !safeCompare(provided, key)) {
+    return c.json({
+      type: "error",
+      error: {
+        type: "authentication_error",
+        message: "Invalid or missing API key"
+      }
+    }, 401);
+  }
+  return next();
+}
+
 // src/proxy/fileChanges.ts
 function extractFileChange(toolName, toolInput, mcpPrefix) {
   if (!toolName.startsWith(mcpPrefix))
@@ -7965,6 +9517,9 @@ var crushAdapter = {
   buildSystemContextAddendum(_body, _sdkAgents) {
     return "";
   },
+  supportsThinking() {
+    return true;
+  },
   extractFileChangesFromToolUse(toolName, toolInput) {
     const input = toolInput;
     const filePath = input?.file_path ?? input?.path;
@@ -8249,6 +9804,10 @@ function detectAdapter(c) {
   return defaultAdapter;
 }
 
+// src/proxy/query.ts
+import { join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
 // src/mcpTools.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool } from "@anthropic-ai/claude-agent-sdk";
 import * as fs from "node:fs/promises";
@@ -13941,6 +15500,18 @@ function createOpencodeMcpServer() {
 }
 
 // src/proxy/query.ts
+function resolveSystemPrompt(systemContext, passthrough, settingSources, codeSystemPrompt, clientSystemPrompt) {
+  const hasSettings = settingSources != null && settingSources.length > 0;
+  const usePreset = codeSystemPrompt ?? (hasSettings || !passthrough && !!systemContext);
+  const includeClient = clientSystemPrompt ?? true;
+  const clientContext = includeClient ? systemContext : undefined;
+  if (usePreset) {
+    return clientContext ? { systemPrompt: { type: "preset", preset: "claude_code", append: clientContext } } : { systemPrompt: { type: "preset", preset: "claude_code" } };
+  }
+  if (clientContext)
+    return { systemPrompt: clientContext };
+  return {};
+}
 function buildQueryOptions(ctx) {
   const {
     prompt,
@@ -13963,7 +15534,17 @@ function buildQueryOptions(ctx) {
     effort,
     thinking,
     taskBudget,
-    betas
+    betas,
+    settingSources,
+    codeSystemPrompt,
+    clientSystemPrompt,
+    memory,
+    dreaming,
+    sharedMemory,
+    maxBudgetUsd,
+    fallbackModel,
+    sdkDebug,
+    additionalDirectories
   } = ctx;
   const blockedTools = [...adapter.getBlockedBuiltinTools(), ...adapter.getAgentIncompatibleTools()];
   const mcpServerName = adapter.getMcpServerName();
@@ -13979,9 +15560,7 @@ function buildQueryOptions(ctx) {
       ...stream2 ? { includePartialMessages: true } : {},
       permissionMode: "bypassPermissions",
       allowDangerouslySkipPermissions: true,
-      ...systemContext ? {
-        systemPrompt: passthrough ? systemContext : { type: "preset", preset: "claude_code", append: systemContext }
-      } : {},
+      ...resolveSystemPrompt(systemContext, passthrough, settingSources, codeSystemPrompt, clientSystemPrompt),
       ...passthrough ? {
         disallowedTools: blockedTools,
         ...passthroughMcp ? {
@@ -13994,11 +15573,19 @@ function buildQueryOptions(ctx) {
         mcpServers: { [mcpServerName]: createOpencodeMcpServer() }
       },
       plugins: [],
+      ...settingSources && settingSources.length > 0 ? {
+        settingSources,
+        settings: {
+          autoMemoryEnabled: ctx.memory ?? true,
+          autoDreamEnabled: ctx.dreaming ?? false
+        }
+      } : {},
       ...onStderr ? { stderr: onStderr } : {},
       env: {
         ...cleanEnv,
         ENABLE_TOOL_SEARCH: hasDeferredTools ? "true" : "false",
         ...passthrough ? { ENABLE_CLAUDEAI_MCP_SERVERS: "false" } : {},
+        ...sharedMemory ? { CLAUDE_CONFIG_DIR: join3(homedir2(), ".claude") } : {},
         ...process.getuid?.() === 0 ? { IS_SANDBOX: "1" } : {}
       },
       ...Object.keys(sdkAgents).length > 0 ? { agents: sdkAgents } : {},
@@ -14008,7 +15595,11 @@ function buildQueryOptions(ctx) {
       ...effort ? { effort } : {},
       ...thinking ? { thinking } : {},
       ...taskBudget ? { taskBudget } : {},
-      ...betas && betas.length > 0 ? { betas } : {}
+      ...betas && betas.length > 0 ? { betas } : {},
+      ...maxBudgetUsd && maxBudgetUsd > 0 ? { maxBudgetUsd } : {},
+      ...fallbackModel ? { fallbackModel } : {},
+      ...sdkDebug ? { debug: true } : {},
+      ...additionalDirectories && additionalDirectories.length > 0 ? { additionalDirectories } : {}
     }
   };
 }
@@ -14268,7 +15859,7 @@ function verifyLineage(cached, messages, cacheKey2, cache) {
   if (suffixOverlap >= MIN_SUFFIX_FOR_COMPACTION && cached.messageHashes.length >= MIN_STORED_FOR_COMPACTION && suffixStartInIncoming > 0) {
     const compactionMsg = `Compaction detected (key=${cacheKey2.slice(0, 8)}…): suffix overlap ${suffixOverlap}/${cached.messageHashes.length}. Allowing resume.`;
     console.error(`[PROXY] ${compactionMsg}`);
-    diagnosticLog.lineage(compactionMsg);
+    diagnosticLog2.lineage(compactionMsg);
     cached.lineageHash = computeLineageHash(messages);
     cached.messageHashes = incomingHashes;
     cached.messageCount = messages.length;
@@ -14286,13 +15877,13 @@ function verifyLineage(cached, messages, cacheKey2, cache) {
     }
     const undoMsg = `Undo detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${prefixOverlap}/${cached.messageHashes.length}, rollback UUID: ${rollbackUuid || "none (legacy session)"}.`;
     console.error(`[PROXY] ${undoMsg}`);
-    diagnosticLog.lineage(undoMsg);
+    diagnosticLog2.lineage(undoMsg);
     return { type: "undo", session: cached, prefixOverlap, rollbackUuid };
   }
   if (prefixOverlap > 0 && messages.length > cached.messageCount) {
     const modifiedMsg = `Modified continuation (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${prefixOverlap}/${cached.messageHashes.length}, incoming ${messages.length} msgs. Allowing resume.`;
     console.error(`[PROXY] ${modifiedMsg}`);
-    diagnosticLog.lineage(modifiedMsg);
+    diagnosticLog2.lineage(modifiedMsg);
     cached.lineageHash = computeLineageHash(messages.slice(0, messages.length));
     cached.messageHashes = incomingHashes;
     cached.messageCount = messages.length;
@@ -14379,8 +15970,8 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 var DEFAULT_MAX_STORED_SESSIONS = 1e4;
 var STALE_LOCK_THRESHOLD_MS = 30000;
 function getMaxStoredSessions() {
@@ -14431,11 +16022,11 @@ function getStorePath() {
   if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  return join2(dir, "sessions.json");
+  return join4(dir, "sessions.json");
 }
 function getDefaultCacheDir() {
-  const newDir = join2(homedir(), ".cache", "meridian");
-  const oldDir = join2(homedir(), ".cache", "opencode-claude-max-proxy");
+  const newDir = join4(homedir3(), ".cache", "meridian");
+  const oldDir = join4(homedir3(), ".cache", "opencode-claude-max-proxy");
   if (existsSync3(newDir))
     return newDir;
   if (existsSync3(oldDir)) {
@@ -14867,7 +16458,7 @@ function checkTokenHealth(requestId, sdkSessionId, usage, turnNumber, isResume,
     isResume,
     isPassthrough
   };
-  const prevMetric = telemetryStore.getLastForSession(sdkSessionId);
+  const prevMetric = telemetryStore2.getLastForSession(sdkSessionId);
   const previous = prevMetric ? {
     requestId: prevMetric.requestId,
     turnNumber: turnNumber - 1,
@@ -14886,7 +16477,7 @@ function checkTokenHealth(requestId, sdkSessionId, usage, turnNumber, isResume,
       console.error(line);
     }
     for (const a of anomalies) {
-      diagnosticLog.log({
+      diagnosticLog2.log({
         level: a.severity === "critical" ? "error" : "warn",
         category: "token",
         message: `${requestId} ${a.type}: ${a.detail}`,
@@ -14897,10 +16488,19 @@ function checkTokenHealth(requestId, sdkSessionId, usage, turnNumber, isResume,
 }
 function createProxyServer(config = {}) {
   const finalConfig = { ...DEFAULT_PROXY_CONFIG, ...config };
+  const serverVersion = finalConfig.version ?? "unknown";
   restoreActiveProfile(finalConfig.profiles);
   const sessionDiscoveredTools = new Map;
   const app = new Hono2;
   app.use("*", cors());
+  app.use("/v1/*", requireAuth);
+  app.use("/messages", requireAuth);
+  app.use("/telemetry/*", requireAuth);
+  app.use("/telemetry", requireAuth);
+  app.use("/metrics", requireAuth);
+  app.use("/profiles/*", requireAuth);
+  app.use("/profiles", requireAuth);
+  app.use("/auth/*", requireAuth);
   app.get("/", (c) => {
     const accept = c.req.header("accept") || "";
     if (accept.includes("application/json") && !accept.includes("text/html")) {
@@ -14908,7 +16508,7 @@ function createProxyServer(config = {}) {
         status: "ok",
         service: "meridian",
         format: "anthropic",
-        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/models", "/telemetry", "/health"]
+        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/models", "/telemetry", "/metrics", "/health"]
       });
     }
     return c.html(landingHtml);
@@ -15003,6 +16603,14 @@ function createProxyServer(config = {}) {
             console.error(`[PROXY] ${requestMeta.requestId} ignoring malformed x-opencode-thinking header: ${e instanceof Error ? e.message : String(e)}`);
           }
         }
+        const { getFeaturesForAdapter: getFeaturesForAdapter2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
+        const sdkFeatures = getFeaturesForAdapter2(adapter.name);
+        if (!thinking) {
+          if (sdkFeatures.thinking === "adaptive")
+            thinking = { type: "adaptive" };
+          else if (sdkFeatures.thinking === "enabled")
+            thinking = { type: "enabled" };
+        }
         const thinkingBetaStripped = betaFilter.stripped.some((b) => b.startsWith("interleaved-thinking"));
         if (thinkingBetaStripped) {
           thinking = { type: "disabled" };
@@ -15031,14 +16639,14 @@ function createProxyServer(config = {}) {
         const toolCount = body.tools?.length ?? 0;
         const requestLogLine = `${requestMeta.requestId} adapter=${adapter.name} model=${model} stream=${stream2} tools=${toolCount} lineage=${lineageType} session=${resumeSessionId?.slice(0, 8) || "new"}${isUndo && undoRollbackUuid ? ` rollback=${undoRollbackUuid.slice(0, 8)}` : ""}${agentMode ? ` agent=${agentMode}` : ""} active=${activeSessions}/${MAX_CONCURRENT_SESSIONS} msgCount=${msgCount}`;
         console.error(`[PROXY] ${requestLogLine} msgs=${msgSummary}`);
-        diagnosticLog.session(`${requestLogLine}`, requestMeta.requestId);
+        diagnosticLog2.session(`${requestLogLine}`, requestMeta.requestId);
         if (lineageResult.type === "diverged" && profileSessionId) {
           const recovery = lookupSessionRecovery(profileSessionId);
           if (recovery) {
             const prevId = recovery.previousClaudeSessionId || recovery.claudeSessionId;
             const recoveryMsg = `${requestMeta.requestId} SESSION RECOVERY: previous conversation available. Run: claude --resume ${prevId}`;
             console.error(`[PROXY] ${recoveryMsg}`);
-            diagnosticLog.session(recoveryMsg, requestMeta.requestId);
+            diagnosticLog2.session(recoveryMsg, requestMeta.requestId);
           }
         }
         claudeLog("request.received", {
@@ -15155,6 +16763,7 @@ function createProxyServer(config = {}) {
         }
         const adapterPassthrough = adapter.usesPassthrough?.();
         const passthrough = adapterPassthrough !== undefined ? adapterPassthrough : envBool("PASSTHROUGH");
+        const settingSources = envBool("LOAD_CONTEXT") || sdkFeatures.claudeMd === "full" ? ["user", "project"] : sdkFeatures.claudeMd === "project" ? ["project"] : adapter.getSettingSources?.() ?? [];
         const capturedToolUses = [];
         const fileChanges = [];
         let passthroughMcp;
@@ -15246,7 +16855,17 @@ function createProxyServer(config = {}) {
                     effort,
                     thinking,
                     taskBudget,
-                    betas
+                    betas,
+                    settingSources,
+                    codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                    clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                    memory: sdkFeatures.memory,
+                    dreaming: sdkFeatures.dreaming,
+                    sharedMemory: sdkFeatures.sharedMemory,
+                    maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                    fallbackModel: sdkFeatures.fallbackModel,
+                    sdkDebug: sdkFeatures.sdkDebug,
+                    additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined
                   }))) {
                     if (event.type === "assistant" && !event.error) {
                       didYieldContent = true;
@@ -15290,7 +16909,17 @@ function createProxyServer(config = {}) {
                       effort,
                       thinking,
                       taskBudget,
-                      betas
+                      betas,
+                      settingSources,
+                      codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                      clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                      memory: sdkFeatures.memory,
+                      dreaming: sdkFeatures.dreaming,
+                      sharedMemory: sdkFeatures.sharedMemory,
+                      maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                      fallbackModel: sdkFeatures.fallbackModel,
+                      sdkDebug: sdkFeatures.sdkDebug,
+                      additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined
                     }));
                     return;
                   }
@@ -15375,7 +17004,7 @@ function createProxyServer(config = {}) {
                       claudeLog("passthrough.toolsearch_filtered", { mode: "non_stream" });
                       continue;
                     }
-                    if (passthrough && !adapter.supportsThinking?.() && (b.type === "thinking" || b.type === "redacted_thinking")) {
+                    if (passthrough && !adapter.supportsThinking?.() && !sdkFeatures.thinkingPassthrough && (b.type === "thinking" || b.type === "redacted_thinking")) {
                       claudeLog("passthrough.thinking_stripped", { mode: "non_stream", type: b.type });
                       continue;
                     }
@@ -15471,7 +17100,7 @@ Subprocess stderr: ${stderrOutput}`;
           });
           const nonStreamQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
           checkTokenHealth(requestMeta.requestId, currentSessionId || resumeSessionId, lastUsage, allMessages.length, isResume, passthrough);
-          telemetryStore.record({
+          telemetryStore2.record({
             requestId: requestMeta.requestId,
             timestamp: Date.now(),
             adapter: adapter.name,
@@ -15514,7 +17143,12 @@ Subprocess stderr: ${stderrOutput}`;
             content: contentBlocks,
             model: body.model,
             stop_reason: stopReason,
-            usage: { input_tokens: 0, output_tokens: 0 }
+            usage: {
+              input_tokens: lastUsage?.input_tokens ?? 0,
+              output_tokens: lastUsage?.output_tokens ?? 0,
+              cache_read_input_tokens: lastUsage?.cache_read_input_tokens,
+              cache_creation_input_tokens: lastUsage?.cache_creation_input_tokens
+            }
           }), {
             headers: {
               "Content-Type": "application/json",
@@ -15590,7 +17224,17 @@ Subprocess stderr: ${stderrOutput}`;
                       effort,
                       thinking,
                       taskBudget,
-                      betas
+                      betas,
+                      settingSources,
+                      codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                      clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                      memory: sdkFeatures.memory,
+                      dreaming: sdkFeatures.dreaming,
+                      sharedMemory: sdkFeatures.sharedMemory,
+                      maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                      fallbackModel: sdkFeatures.fallbackModel,
+                      sdkDebug: sdkFeatures.sdkDebug,
+                      additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined
                     }))) {
                       if (event.type === "stream_event") {
                         didYieldClientEvent = true;
@@ -15634,7 +17278,17 @@ Subprocess stderr: ${stderrOutput}`;
                         effort,
                         thinking,
                         taskBudget,
-                        betas
+                        betas,
+                        settingSources,
+                        codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                        clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
+                        memory: sdkFeatures.memory,
+                        dreaming: sdkFeatures.dreaming,
+                        sharedMemory: sdkFeatures.sharedMemory,
+                        maxBudgetUsd: sdkFeatures.maxBudgetUsd,
+                        fallbackModel: sdkFeatures.fallbackModel,
+                        sdkDebug: sdkFeatures.sdkDebug,
+                        additionalDirectories: sdkFeatures.additionalDirectories ? sdkFeatures.additionalDirectories.split(",").map((d) => d.trim()).filter(Boolean) : undefined
                       }));
                       return;
                     }
@@ -15771,7 +17425,7 @@ data: ${JSON.stringify({ type: "message_stop" })}
                     }
                     if (eventType === "content_block_start") {
                       const block = event.content_block;
-                      if (passthrough && !adapter.supportsThinking?.() && (block?.type === "thinking" || block?.type === "redacted_thinking")) {
+                      if (passthrough && !adapter.supportsThinking?.() && !sdkFeatures.thinkingPassthrough && (block?.type === "thinking" || block?.type === "redacted_thinking")) {
                         if (eventIndex !== undefined)
                           skipBlockIndices.add(eventIndex);
                         claudeLog("passthrough.thinking_stripped", { mode: "stream", type: block.type, index: eventIndex });
@@ -15969,7 +17623,7 @@ data: {"type":"message_stop"}
                 });
                 const streamQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
                 checkTokenHealth(requestMeta.requestId, currentSessionId || resumeSessionId, lastUsage, allMessages.length, isResume, passthrough);
-                telemetryStore.record({
+                telemetryStore2.record({
                   requestId: requestMeta.requestId,
                   timestamp: Date.now(),
                   adapter: adapter.name,
@@ -16088,7 +17742,7 @@ data: ${JSON.stringify({
         const classified = classifyError(errMsg);
         claudeLog("proxy.error", { error: errMsg, classified: classified.type });
         const errorQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
-        telemetryStore.record({
+        telemetryStore2.record({
           requestId: requestMeta.requestId,
           timestamp: Date.now(),
           adapter: adapter.name,
@@ -16132,6 +17786,39 @@ data: ${JSON.stringify({
   app.post("/v1/messages", (c) => handleWithQueue(c, "/v1/messages"));
   app.post("/messages", (c) => handleWithQueue(c, "/messages"));
   app.route("/telemetry", createTelemetryRoutes());
+  app.get("/settings", (c) => {
+    const { settingsPageHtml: settingsPageHtml2 } = (init_settingsPage(), __toCommonJS(exports_settingsPage));
+    return c.html(settingsPageHtml2);
+  });
+  app.get("/settings/api/features", (c) => {
+    const { getAllFeatureConfigs: getAllFeatureConfigs2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
+    return c.json(getAllFeatureConfigs2());
+  });
+  app.patch("/settings/api/features/:adapter", async (c) => {
+    const { validateFeatureUpdate: validateFeatureUpdate2, updateAdapterFeatures: updateAdapterFeatures2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
+    const adapter = c.req.param("adapter");
+    const body = await c.req.json();
+    let validated;
+    try {
+      validated = validateFeatureUpdate2(body);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+    updateAdapterFeatures2(adapter, validated);
+    return c.json({ ok: true });
+  });
+  app.delete("/settings/api/features/:adapter", (c) => {
+    const { resetAdapterFeatures: resetAdapterFeatures2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
+    const adapter = c.req.param("adapter");
+    resetAdapterFeatures2(adapter);
+    return c.json({ ok: true });
+  });
+  app.get("/metrics", (c) => {
+    const body = renderPrometheusMetrics(telemetryStore2);
+    return c.body(body, 200, {
+      "Content-Type": "text/plain; version=0.0.4; charset=utf-8"
+    });
+  });
   app.get("/health", async (c) => {
     try {
       const healthProfile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile);
@@ -16140,6 +17827,7 @@ data: ${JSON.stringify({
       if (!auth) {
         return c.json({
           status: "degraded",
+          version: serverVersion,
           error: "Could not verify auth status",
           mode: envBool("PASSTHROUGH") ? "passthrough" : "internal"
         });
@@ -16147,12 +17835,14 @@ data: ${JSON.stringify({
       if (!auth.loggedIn) {
         return c.json({
           status: "unhealthy",
+          version: serverVersion,
           error: "Not logged in. Run: claude login",
           auth: { loggedIn: false }
         }, 503);
       }
       return c.json({
         status: "healthy",
+        version: serverVersion,
         auth: {
           loggedIn: true,
           email: auth.email,
@@ -16164,6 +17854,7 @@ data: ${JSON.stringify({
     } catch {
       return c.json({
         status: "degraded",
+        version: serverVersion,
         error: "Could not verify auth status",
         mode: envBool("PASSTHROUGH") ? "passthrough" : "internal"
       });
@@ -16191,7 +17882,7 @@ data: ${JSON.stringify({
     });
   });
   app.get("/profiles", async (c) => {
-    const { profilePageHtml } = await import("./profilePage-9nkbct3w.js");
+    const { profilePageHtml } = await import("./profilePage-g5t5t6av.js");
     return c.html(profilePageHtml);
   });
   app.post("/profiles/active", async (c) => {