@rynfar/meridian 1.34.1 → 1.35.0

package/dist/{cli-bwchvbfb.js → cli-0kfa6j99.js}

@@ -20,9 +20,1133 @@ 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);
+});
 
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -2187,7 +3311,8 @@ var DEFAULT_PROXY_CONFIG = {
   idleTimeoutSeconds: 120,
   silent: false,
   profiles: undefined,
-  defaultProfile: undefined
+  defaultProfile: undefined,
+  version: undefined
 };
 
 // src/env.ts
@@ -2198,6 +3323,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 +7402,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 +7419,7 @@ function getCapacity() {
   return parsed;
 }
 
-class TelemetryStore {
+class MemoryTelemetryStore {
   buffer;
   head = 0;
   count = 0;
@@ -6329,94 +7466,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 +7474,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,7 +7525,7 @@ 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";
@@ -6866,7 +7903,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 +7912,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
@@ -7014,6 +8051,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();
@@ -7121,7 +8247,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 +8389,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 +8407,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;
@@ -14268,7 +15394,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 +15412,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 +15505,8 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
 var DEFAULT_MAX_STORED_SESSIONS = 1e4;
 var STALE_LOCK_THRESHOLD_MS = 30000;
 function getMaxStoredSessions() {
@@ -14431,11 +15557,11 @@ function getStorePath() {
   if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  return join2(dir, "sessions.json");
+  return join3(dir, "sessions.json");
 }
 function getDefaultCacheDir() {
-  const newDir = join2(homedir(), ".cache", "meridian");
-  const oldDir = join2(homedir(), ".cache", "opencode-claude-max-proxy");
+  const newDir = join3(homedir2(), ".cache", "meridian");
+  const oldDir = join3(homedir2(), ".cache", "opencode-claude-max-proxy");
   if (existsSync3(newDir))
     return newDir;
   if (existsSync3(oldDir)) {
@@ -14867,7 +15993,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 +16012,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,6 +16023,7 @@ 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;
@@ -14908,7 +16035,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);
@@ -15031,14 +16158,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", {
@@ -15471,7 +16598,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,
@@ -15969,7 +17096,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 +17215,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 +17259,12 @@ 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("/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 +17273,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 +17281,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 +17300,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 +17328,7 @@ data: ${JSON.stringify({
     });
   });
   app.get("/profiles", async (c) => {
-    const { profilePageHtml } = await import("./profilePage-9nkbct3w.js");
+    const { profilePageHtml } = await import("./profilePage-e90fq8ye.js");
     return c.html(profilePageHtml);
   });
   app.post("/profiles/active", async (c) => {