@omote/core 0.10.5 → 0.10.6

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,220 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/telemetry/exporters/otlp.ts
+var otlp_exports = {};
+__export(otlp_exports, {
+  OTLPExporter: () => OTLPExporter
+});
+function toOTLPAttributeValue(value) {
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "number") return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+  return { boolValue: value };
+}
+function toOTLPAttributes(attrs) {
+  return Object.entries(attrs).filter(([, v]) => v !== void 0).map(([key, value]) => ({ key, value: toOTLPAttributeValue(value) }));
+}
+function spanToOTLPSpan(span) {
+  return {
+    traceId: span.traceId,
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId || "",
+    name: span.name,
+    kind: 1,
+    // INTERNAL
+    startTimeUnixNano: String(span.epochMs * 1e6),
+    endTimeUnixNano: String(span.endEpochMs * 1e6),
+    attributes: toOTLPAttributes(span.attributes),
+    status: {
+      code: span.status === "ok" ? StatusCode.OK : StatusCode.ERROR,
+      message: span.error?.message || ""
+    }
+  };
+}
+function metricToOTLPMetric(metric) {
+  const attributes = toOTLPAttributes(metric.attributes);
+  const timeUnixNano = String(metric.timestamp * 1e6);
+  if (metric.type === "counter") {
+    return {
+      name: metric.name,
+      sum: {
+        dataPoints: [{
+          attributes,
+          timeUnixNano,
+          asInt: metric.value
+        }],
+        aggregationTemporality: 1,
+        // DELTA
+        isMonotonic: true
+      }
+    };
+  }
+  if (metric.histogramData) {
+    return {
+      name: metric.name,
+      histogram: {
+        dataPoints: [{
+          attributes,
+          timeUnixNano,
+          count: metric.histogramData.count,
+          sum: metric.histogramData.sum,
+          min: metric.histogramData.min,
+          max: metric.histogramData.max,
+          explicitBounds: metric.histogramData.bucketBoundaries,
+          bucketCounts: metric.histogramData.bucketCounts
+        }],
+        aggregationTemporality: 1
+        // DELTA
+      }
+    };
+  }
+  return {
+    name: metric.name,
+    gauge: {
+      dataPoints: [{
+        attributes,
+        timeUnixNano,
+        asDouble: metric.value
+      }]
+    }
+  };
+}
+var StatusCode, OTLPExporter;
+var init_otlp = __esm({
+  "src/telemetry/exporters/otlp.ts"() {
+    "use strict";
+    StatusCode = {
+      UNSET: 0,
+      OK: 1,
+      ERROR: 2
+    };
+    OTLPExporter = class {
+      constructor(config, serviceName = "omote-sdk", serviceVersion = "0.1.0") {
+        this.spanBuffer = [];
+        this.metricBuffer = [];
+        this.flushIntervalId = null;
+        this.BUFFER_SIZE = 100;
+        this.FLUSH_INTERVAL_MS = 5e3;
+        this.isShutdown = false;
+        const parsed = new URL(config.endpoint);
+        if (parsed.protocol !== "https:") {
+          const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+          if (!isLocalhost) {
+            throw new Error("OTLP endpoint must use HTTPS (or localhost for development)");
+          }
+        }
+        this.config = {
+          endpoint: config.endpoint,
+          timeoutMs: config.timeoutMs ?? 1e4,
+          headers: config.headers ? { ...config.headers } : {}
+        };
+        this.serviceName = serviceName;
+        this.serviceVersion = serviceVersion;
+        this.flushIntervalId = setInterval(() => {
+          this.flush().catch(console.error);
+        }, this.FLUSH_INTERVAL_MS);
+      }
+      exportSpan(span) {
+        if (this.isShutdown) return;
+        this.spanBuffer.push(span);
+        if (this.spanBuffer.length >= this.BUFFER_SIZE) {
+          this.flush().catch(console.error);
+        }
+      }
+      exportMetric(metric) {
+        if (this.isShutdown) return;
+        this.metricBuffer.push(metric);
+        if (this.metricBuffer.length >= this.BUFFER_SIZE) {
+          this.flush().catch(console.error);
+        }
+      }
+      async flush() {
+        if (this.isShutdown) return;
+        const spans = this.spanBuffer.splice(0);
+        const metrics = this.metricBuffer.splice(0);
+        const promises = [];
+        if (spans.length > 0) {
+          promises.push(this.exportSpans(spans));
+        }
+        if (metrics.length > 0) {
+          promises.push(this.exportMetrics(metrics));
+        }
+        await Promise.all(promises);
+      }
+      async shutdown() {
+        if (this.flushIntervalId) {
+          clearInterval(this.flushIntervalId);
+          this.flushIntervalId = null;
+        }
+        await this.flush();
+        this.isShutdown = true;
+      }
+      async exportSpans(spans) {
+        const resourceAttrs = [
+          { key: "service.name", value: { stringValue: this.serviceName } },
+          { key: "service.version", value: { stringValue: this.serviceVersion } },
+          { key: "telemetry.sdk.name", value: { stringValue: "omote-sdk" } },
+          { key: "telemetry.sdk.language", value: { stringValue: "javascript" } }
+        ];
+        const body = {
+          resourceSpans: [{
+            resource: { attributes: resourceAttrs },
+            scopeSpans: [{
+              scope: { name: "omote-sdk", version: this.serviceVersion },
+              spans: spans.map(spanToOTLPSpan)
+            }]
+          }]
+        };
+        const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/traces";
+        await this.sendRequest(endpoint, body);
+      }
+      async exportMetrics(metrics) {
+        const resourceAttrs = [
+          { key: "service.name", value: { stringValue: this.serviceName } },
+          { key: "service.version", value: { stringValue: this.serviceVersion } }
+        ];
+        const body = {
+          resourceMetrics: [{
+            resource: { attributes: resourceAttrs },
+            scopeMetrics: [{
+              scope: { name: "omote-sdk", version: this.serviceVersion },
+              metrics: metrics.map(metricToOTLPMetric)
+            }]
+          }]
+        };
+        const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/metrics";
+        await this.sendRequest(endpoint, body);
+      }
+      async sendRequest(endpoint, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        try {
+          const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...this.config.headers
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            console.warn(`[OTLP] Export failed: ${response.status} ${response.statusText}`);
+          }
+        } catch (error) {
+          if (error.name === "AbortError") {
+            console.warn("[OTLP] Export timed out");
+          } else {
+            console.warn("[OTLP] Export error:", error);
+          }
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -57,7 +274,6 @@ __export(index_exports, {
   EmotionResolver: () => EmotionResolver,
   EmphasisDetector: () => EmphasisDetector,
   ErrorCodes: () => ErrorCodes,
-  ErrorTypes: () => ErrorTypes,
   EventEmitter: () => EventEmitter,
   FaceCompositor: () => FaceCompositor,
   HF_CDN_URLS: () => HF_CDN_URLS,
@@ -329,6 +545,8 @@ var jsonFormatter = (entry) => {
   if (entry.data && Object.keys(entry.data).length > 0) {
     output.data = entry.data;
   }
+  if (entry.traceId) output.traceId = entry.traceId;
+  if (entry.spanId) output.spanId = entry.spanId;
   if (entry.error) {
     output.error = {
       name: entry.error.name,
@@ -350,6 +568,9 @@ var prettyFormatter = (entry) => {
     const color = LEVEL_COLORS[entry.level];
     output = `${COLORS.gray}${time}${COLORS.reset} ${color}${level}${COLORS.reset} ${COLORS.cyan}[${module2}]${COLORS.reset} ${message}`;
   }
+  if (entry.traceId) {
+    output += ` [trace:${entry.traceId.slice(0, 8)}]`;
+  }
   if (entry.data && Object.keys(entry.data).length > 0) {
     const dataStr = safeStringify(entry.data);
     if (dataStr.length > 80) {
@@ -454,198 +675,6 @@ var ConsoleExporter = class {
   }
 };
 
-// src/telemetry/exporters/otlp.ts
-var StatusCode = {
-  UNSET: 0,
-  OK: 1,
-  ERROR: 2
-};
-function spanToOTLP(span, serviceName, serviceVersion) {
-  const attributes = Object.entries(span.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
-    key,
-    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
-  }));
-  return {
-    resourceSpans: [{
-      resource: {
-        attributes: [
-          { key: "service.name", value: { stringValue: serviceName } },
-          { key: "service.version", value: { stringValue: serviceVersion } },
-          { key: "telemetry.sdk.name", value: { stringValue: "omote-sdk" } },
-          { key: "telemetry.sdk.language", value: { stringValue: "javascript" } }
-        ]
-      },
-      scopeSpans: [{
-        scope: {
-          name: "omote-sdk",
-          version: serviceVersion
-        },
-        spans: [{
-          traceId: span.traceId,
-          spanId: span.spanId,
-          parentSpanId: span.parentSpanId || "",
-          name: span.name,
-          kind: 1,
-          // INTERNAL
-          startTimeUnixNano: String(span.startTime * 1e6),
-          endTimeUnixNano: String(span.endTime * 1e6),
-          attributes,
-          status: {
-            code: span.status === "ok" ? StatusCode.OK : StatusCode.ERROR,
-            message: span.error?.message || ""
-          }
-        }]
-      }]
-    }]
-  };
-}
-function metricToOTLP(metric, serviceName, serviceVersion) {
-  const attributes = Object.entries(metric.attributes).filter(([, v]) => v !== void 0).map(([key, value]) => ({
-    key,
-    value: typeof value === "string" ? { stringValue: value } : typeof value === "number" ? Number.isInteger(value) ? { intValue: value } : { doubleValue: value } : { boolValue: value }
-  }));
-  const dataPoint = {
-    attributes,
-    timeUnixNano: String(metric.timestamp * 1e6),
-    ...metric.type === "counter" ? { asInt: metric.value } : { asDouble: metric.value }
-  };
-  return {
-    resourceMetrics: [{
-      resource: {
-        attributes: [
-          { key: "service.name", value: { stringValue: serviceName } },
-          { key: "service.version", value: { stringValue: serviceVersion } }
-        ]
-      },
-      scopeMetrics: [{
-        scope: {
-          name: "omote-sdk",
-          version: serviceVersion
-        },
-        metrics: [{
-          name: metric.name,
-          ...metric.type === "counter" ? {
-            sum: {
-              dataPoints: [dataPoint],
-              aggregationTemporality: 2,
-              // CUMULATIVE
-              isMonotonic: true
-            }
-          } : {
-            gauge: {
-              dataPoints: [dataPoint]
-            }
-          }
-        }]
-      }]
-    }]
-  };
-}
-var OTLPExporter = class {
-  constructor(config, serviceName = "omote-sdk", serviceVersion = "0.1.0") {
-    this.spanBuffer = [];
-    this.metricBuffer = [];
-    this.flushIntervalId = null;
-    this.BUFFER_SIZE = 100;
-    this.FLUSH_INTERVAL_MS = 5e3;
-    this.isShutdown = false;
-    const parsed = new URL(config.endpoint);
-    if (parsed.protocol !== "https:") {
-      const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
-      if (!isLocalhost) {
-        throw new Error("OTLP endpoint must use HTTPS (or localhost for development)");
-      }
-    }
-    this.config = {
-      endpoint: config.endpoint,
-      timeoutMs: config.timeoutMs ?? 1e4,
-      headers: config.headers ? { ...config.headers } : {}
-    };
-    this.serviceName = serviceName;
-    this.serviceVersion = serviceVersion;
-    this.flushIntervalId = setInterval(() => {
-      this.flush().catch(console.error);
-    }, this.FLUSH_INTERVAL_MS);
-  }
-  exportSpan(span) {
-    if (this.isShutdown) return;
-    this.spanBuffer.push(span);
-    if (this.spanBuffer.length >= this.BUFFER_SIZE) {
-      this.flush().catch(console.error);
-    }
-  }
-  exportMetric(metric) {
-    if (this.isShutdown) return;
-    this.metricBuffer.push(metric);
-    if (this.metricBuffer.length >= this.BUFFER_SIZE) {
-      this.flush().catch(console.error);
-    }
-  }
-  async flush() {
-    if (this.isShutdown) return;
-    const spans = this.spanBuffer.splice(0);
-    const metrics = this.metricBuffer.splice(0);
-    const promises = [];
-    if (spans.length > 0) {
-      promises.push(this.exportSpans(spans));
-    }
-    if (metrics.length > 0) {
-      promises.push(this.exportMetrics(metrics));
-    }
-    await Promise.all(promises);
-  }
-  async shutdown() {
-    if (this.flushIntervalId) {
-      clearInterval(this.flushIntervalId);
-      this.flushIntervalId = null;
-    }
-    await this.flush();
-    this.isShutdown = true;
-  }
-  async exportSpans(spans) {
-    const resourceSpans = spans.map(
-      (span) => spanToOTLP(span, this.serviceName, this.serviceVersion).resourceSpans[0]
-    );
-    const body = { resourceSpans };
-    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/traces";
-    await this.sendRequest(endpoint, body);
-  }
-  async exportMetrics(metrics) {
-    const resourceMetrics = metrics.map(
-      (metric) => metricToOTLP(metric, this.serviceName, this.serviceVersion).resourceMetrics[0]
-    );
-    const body = { resourceMetrics };
-    const endpoint = this.config.endpoint.replace(/\/$/, "") + "/v1/metrics";
-    await this.sendRequest(endpoint, body);
-  }
-  async sendRequest(endpoint, body) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.config.headers
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        console.warn(`[OTLP] Export failed: ${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      if (error.name === "AbortError") {
-        console.warn("[OTLP] Export timed out");
-      } else {
-        console.warn("[OTLP] Export error:", error);
-      }
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-
 // src/logging/Clock.ts
 var defaultClock = {
   now: () => performance.now(),
@@ -660,6 +689,7 @@ function getClock() {
 }
 
 // src/telemetry/OmoteTelemetry.ts
+var DEFAULT_HISTOGRAM_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4, 3e4, 6e4];
 function generateId(length = 16) {
   const bytes = new Uint8Array(length);
   crypto.getRandomValues(bytes);
@@ -679,6 +709,7 @@ function getTelemetry() {
 var OmoteTelemetry = class {
   constructor(config) {
     this.exporter = null;
+    this.exporterReady = null;
     this.activeTraceId = null;
     this.metricsIntervalId = null;
     // Span stack for log-to-span correlation
@@ -697,14 +728,18 @@ var OmoteTelemetry = class {
       metricsIntervalMs: config.metricsIntervalMs ?? 6e4
     };
     if (this.config.enabled) {
-      this.initExporter();
-      this.startMetricsCollection();
+      if (config.customExporter) {
+        this.exporter = config.customExporter;
+        this.startMetricsCollection();
+      } else {
+        this.exporterReady = this.initExporter();
+      }
     }
   }
   /**
    * Initialize the configured exporter
    */
-  initExporter() {
+  async initExporter() {
     switch (this.config.exporter) {
       case "console":
         this.exporter = new ConsoleExporter({ enabled: true });
@@ -714,16 +749,20 @@ var OmoteTelemetry = class {
           console.warn("[Telemetry] OTLP exporter requires exporterConfig with endpoint");
           return;
         }
-        this.exporter = new OTLPExporter(
-          this.config.exporterConfig,
-          this.config.serviceName,
-          this.config.serviceVersion
-        );
+        {
+          const { OTLPExporter: OTLPExporter2 } = await Promise.resolve().then(() => (init_otlp(), otlp_exports));
+          this.exporter = new OTLPExporter2(
+            this.config.exporterConfig,
+            this.config.serviceName,
+            this.config.serviceVersion
+          );
+        }
         break;
       case "none":
       default:
         this.exporter = null;
     }
+    this.startMetricsCollection();
   }
   /**
    * Start periodic metrics collection
@@ -768,6 +807,7 @@ var OmoteTelemetry = class {
     const spanId = generateId(8);
     const parentSpanId = parentContext?.spanId;
     const startTime = getClock().now();
+    const epochMs = Date.now();
     if (!parentContext && !this.activeTraceId) {
       this.activeTraceId = traceId;
     }
@@ -783,6 +823,7 @@ var OmoteTelemetry = class {
       if (idx !== -1) this.spanStack.splice(idx, 1);
       const endTime = getClock().now();
       const durationMs = endTime - startTime;
+      const endEpochMs = epochMs + (endTime - startTime);
       if (status === "error" && !sampled) {
         sampled = this.shouldSample(true);
       }
@@ -795,6 +836,8 @@ var OmoteTelemetry = class {
         startTime,
         endTime,
         durationMs,
+        epochMs,
+        endEpochMs,
         status,
         attributes: spanAttributes,
         error
@@ -869,7 +912,7 @@ var OmoteTelemetry = class {
    * });
    * ```
    */
-  recordHistogram(name, value, attributes = {}) {
+  recordHistogram(name, value, attributes = {}, bucketBoundaries = DEFAULT_HISTOGRAM_BUCKETS) {
     if (!this.config.enabled || !this.config.metricsEnabled) return;
     const key = this.getMetricKey(name, attributes);
     const existing = this.histograms.get(key);
@@ -878,8 +921,27 @@ var OmoteTelemetry = class {
       existing.sum += value;
       if (value < existing.min) existing.min = value;
       if (value > existing.max) existing.max = value;
+      let placed = false;
+      for (let i = 0; i < existing.bucketBoundaries.length; i++) {
+        if (value <= existing.bucketBoundaries[i]) {
+          existing.bucketCounts[i]++;
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) existing.bucketCounts[existing.bucketCounts.length - 1]++;
     } else {
-      this.histograms.set(key, { count: 1, sum: value, min: value, max: value, attributes });
+      const bucketCounts = new Array(bucketBoundaries.length + 1).fill(0);
+      let placed = false;
+      for (let i = 0; i < bucketBoundaries.length; i++) {
+        if (value <= bucketBoundaries[i]) {
+          bucketCounts[i]++;
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) bucketCounts[bucketCounts.length - 1]++;
+      this.histograms.set(key, { count: 1, sum: value, min: value, max: value, bucketBoundaries, bucketCounts, attributes });
     }
   }
   /**
@@ -896,7 +958,7 @@ var OmoteTelemetry = class {
    */
   flushMetrics() {
     if (!this.exporter) return;
-    const timestamp = getClock().now();
+    const timestamp = Date.now();
     for (const [key, data] of this.counters) {
       if (data.value === 0) continue;
       const name = key.split("|")[0];
@@ -925,19 +987,29 @@ var OmoteTelemetry = class {
           min: data.min,
           max: data.max
         },
-        timestamp
+        timestamp,
+        histogramData: {
+          count: data.count,
+          sum: data.sum,
+          min: data.min,
+          max: data.max,
+          bucketBoundaries: [...data.bucketBoundaries],
+          bucketCounts: [...data.bucketCounts]
+        }
       };
       this.exporter.exportMetric(metric);
       data.count = 0;
       data.sum = 0;
       data.min = Infinity;
       data.max = -Infinity;
+      data.bucketCounts.fill(0);
     }
   }
   /**
    * Force flush all pending data
    */
   async flush() {
+    if (this.exporterReady) await this.exporterReady;
     this.flushMetrics();
     await this.exporter?.flush();
   }
@@ -1059,12 +1131,12 @@ var Logger = class _Logger {
 };
 var loggerCache = /* @__PURE__ */ new Map();
 function createLogger(module2) {
-  let logger36 = loggerCache.get(module2);
-  if (!logger36) {
-    logger36 = new Logger(module2);
-    loggerCache.set(module2, logger36);
+  let logger37 = loggerCache.get(module2);
+  if (!logger37) {
+    logger37 = new Logger(module2);
+    loggerCache.set(module2, logger37);
   }
-  return logger36;
+  return logger37;
 }
 var noopLogger = {
   module: "noop",
@@ -1140,6 +1212,67 @@ var ErrorCodes = {
   NET_WEBSOCKET_ERROR: "OMOTE_NET_003"
 };
 
+// src/telemetry/types.ts
+var MetricNames = {
+  // --- Inference ---
+  /** Histogram: Inference latency in ms */
+  INFERENCE_LATENCY: "omote.inference.latency",
+  /** Histogram: Model load time in ms */
+  MODEL_LOAD_TIME: "omote.model.load_time",
+  /** Counter: Total inference operations */
+  INFERENCE_TOTAL: "omote.inference.total",
+  /** Counter: Total errors */
+  ERRORS_TOTAL: "omote.errors.total",
+  /** Counter: Cache hits */
+  CACHE_HITS: "omote.cache.hits",
+  /** Counter: Cache misses */
+  CACHE_MISSES: "omote.cache.misses",
+  /** Counter: Cache stale (version/etag mismatch) */
+  CACHE_STALE: "omote.cache.stale",
+  /** Counter: Cache quota warning (>90% used) */
+  CACHE_QUOTA_WARNING: "omote.cache.quota_warning",
+  /** Counter: Cache eviction (LRU) */
+  CACHE_EVICTION: "omote.cache.eviction",
+  // --- Pipeline ---
+  /** Histogram: Voice turn latency (speech end → transcript ready, excludes playback) */
+  VOICE_TURN_LATENCY: "omote.voice.turn.latency",
+  /** Histogram: ASR transcription latency in ms */
+  VOICE_TRANSCRIPTION_LATENCY: "omote.voice.transcription.latency",
+  /** Histogram: Response handler latency in ms */
+  VOICE_RESPONSE_LATENCY: "omote.voice.response.latency",
+  /** Counter: Total transcriptions */
+  VOICE_TRANSCRIPTIONS: "omote.voice.transcriptions",
+  /** Counter: Total interruptions */
+  VOICE_INTERRUPTIONS: "omote.voice.interruptions",
+  // --- Playback ---
+  /** Histogram: PlaybackPipeline session duration in ms */
+  PLAYBACK_SESSION_DURATION: "omote.playback.session.duration",
+  /** Histogram: Audio chunk processing latency in ms */
+  PLAYBACK_CHUNK_LATENCY: "omote.playback.chunk.latency",
+  // --- TTS ---
+  /** Histogram: TTSSpeaker.connect() latency in ms */
+  TTS_CONNECT_LATENCY: "omote.tts.connect.latency",
+  /** Histogram: TTSSpeaker.speak() latency in ms */
+  TTS_SPEAK_LATENCY: "omote.tts.speak.latency",
+  /** Counter: TTSSpeaker.stop() aborted speak calls */
+  TTS_SPEAK_ABORTED: "omote.tts.speak.aborted",
+  // --- Mic ---
+  /** Counter: MicLipSync sessions started */
+  MIC_SESSIONS: "omote.mic.sessions",
+  // --- Frame budget ---
+  /** Histogram: CharacterController.update() latency in µs */
+  AVATAR_FRAME_LATENCY: "omote.avatar.frame.latency_us",
+  /** Histogram: FaceCompositor.compose() latency in µs */
+  COMPOSITOR_COMPOSE_LATENCY: "omote.compositor.compose.latency_us",
+  /** Counter: Frames exceeding budget threshold */
+  AVATAR_FRAME_DROPS: "omote.avatar.frame.drops",
+  // --- Audio scheduling ---
+  /** Counter: Audio scheduling gaps (playback fell behind) */
+  AUDIO_SCHEDULE_GAP: "omote.audio.schedule_gap"
+};
+var INFERENCE_LATENCY_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3];
+var MODEL_LOAD_TIME_BUCKETS = [100, 500, 1e3, 2500, 5e3, 1e4, 3e4, 6e4];
+
 // src/audio/MicrophoneCapture.ts
 var logger = createLogger("MicrophoneCapture");
 var MicrophoneCapture = class {
@@ -1176,6 +1309,7 @@ var MicrophoneCapture = class {
       return;
     }
     if (this._isRecording) return;
+    const span = getTelemetry()?.startSpan("MicrophoneCapture.start");
     try {
       this.stream = await navigator.mediaDevices.getUserMedia({
         audio: {
@@ -1249,6 +1383,8 @@ var MicrophoneCapture = class {
       source.connect(this.processor);
       this.processor.connect(this.context.destination);
       this._isRecording = true;
+      getTelemetry()?.incrementCounter(MetricNames.MIC_SESSIONS);
+      span?.end();
       logger.info("Started recording", {
         contextState: this.context.state,
         sampleRate: this.config.sampleRate,
@@ -1269,6 +1405,7 @@ var MicrophoneCapture = class {
         message: err.message,
         details: err
       });
+      span?.endWithError(err instanceof Error ? err : new Error(String(err)));
     }
   }
   stop() {
@@ -1470,6 +1607,7 @@ var AudioScheduler = class {
     if (scheduleTime < ctx.currentTime) {
       const gap = ctx.currentTime - scheduleTime;
       const gapMs = gap * 1e3;
+      getTelemetry()?.incrementCounter(MetricNames.AUDIO_SCHEDULE_GAP, 1, { gap_ms: Math.round(gapMs) });
       if (gap > 0.5) {
         logger2.error("Critical audio scheduling gap", {
           code: ErrorCodes.AUD_SCHEDULE_GAP,
@@ -2047,6 +2185,8 @@ var _A2EProcessor = class _A2EProcessor {
           const t0 = getClock().now();
           const result = await this.backend.infer(chunk, this.identityIndex);
           const inferMs = Math.round(getClock().now() - t0);
+          getTelemetry()?.recordHistogram(MetricNames.INFERENCE_LATENCY, inferMs);
+          getTelemetry()?.incrementCounter(MetricNames.INFERENCE_TOTAL);
           const effectiveSamples = actualSamples ?? chunk.length;
           const actualDuration = effectiveSamples / this.sampleRate;
           const actualFrameCount = Math.ceil(actualDuration * FRAME_RATE);
@@ -2093,79 +2233,13 @@ var _A2EProcessor = class _A2EProcessor {
       error: error.message,
       code
     });
+    getTelemetry()?.incrementCounter(MetricNames.ERRORS_TOTAL, 1, { source: "A2EProcessor", code });
     this.onError?.(error);
   }
 };
 _A2EProcessor.MAX_PENDING_CHUNKS = 10;
 var A2EProcessor = _A2EProcessor;
 
-// src/telemetry/types.ts
-var MetricNames = {
-  // --- Inference ---
-  /** Histogram: Inference latency in ms */
-  INFERENCE_LATENCY: "omote.inference.latency",
-  /** Histogram: Model load time in ms */
-  MODEL_LOAD_TIME: "omote.model.load_time",
-  /** Counter: Total inference operations */
-  INFERENCE_TOTAL: "omote.inference.total",
-  /** Counter: Total errors */
-  ERRORS_TOTAL: "omote.errors.total",
-  /** Counter: Cache hits */
-  CACHE_HITS: "omote.cache.hits",
-  /** Counter: Cache misses */
-  CACHE_MISSES: "omote.cache.misses",
-  /** Counter: Cache stale (version/etag mismatch) */
-  CACHE_STALE: "omote.cache.stale",
-  /** Counter: Cache quota warning (>90% used) */
-  CACHE_QUOTA_WARNING: "omote.cache.quota_warning",
-  /** Counter: Cache eviction (LRU) */
-  CACHE_EVICTION: "omote.cache.eviction",
-  // --- Pipeline ---
-  /** Histogram: Voice turn latency (speech end → transcript ready, excludes playback) */
-  VOICE_TURN_LATENCY: "omote.voice.turn.latency",
-  /** Histogram: ASR transcription latency in ms */
-  VOICE_TRANSCRIPTION_LATENCY: "omote.voice.transcription.latency",
-  /** Histogram: Response handler latency in ms */
-  VOICE_RESPONSE_LATENCY: "omote.voice.response.latency",
-  /** Counter: Total transcriptions */
-  VOICE_TRANSCRIPTIONS: "omote.voice.transcriptions",
-  /** Counter: Total interruptions */
-  VOICE_INTERRUPTIONS: "omote.voice.interruptions",
-  // --- Playback ---
-  /** Histogram: PlaybackPipeline session duration in ms */
-  PLAYBACK_SESSION_DURATION: "omote.playback.session.duration",
-  /** Histogram: Audio chunk processing latency in ms */
-  PLAYBACK_CHUNK_LATENCY: "omote.playback.chunk.latency",
-  // --- TTS ---
-  /** Histogram: TTSSpeaker.connect() latency in ms */
-  TTS_CONNECT_LATENCY: "omote.tts.connect.latency",
-  /** Histogram: TTSSpeaker.speak() latency in ms */
-  TTS_SPEAK_LATENCY: "omote.tts.speak.latency",
-  /** Counter: TTSSpeaker.stop() aborted speak calls */
-  TTS_SPEAK_ABORTED: "omote.tts.speak.aborted",
-  // --- Mic ---
-  /** Counter: MicLipSync sessions started */
-  MIC_SESSIONS: "omote.mic.sessions",
-  // --- Frame budget ---
-  /** Histogram: CharacterController.update() latency in µs */
-  AVATAR_FRAME_LATENCY: "omote.avatar.frame.latency_us",
-  /** Histogram: FaceCompositor.compose() latency in µs */
-  COMPOSITOR_COMPOSE_LATENCY: "omote.compositor.compose.latency_us",
-  /** Counter: Frames exceeding budget threshold */
-  AVATAR_FRAME_DROPS: "omote.avatar.frame.drops"
-};
-var ErrorTypes = {
-  INFERENCE: "inference_error",
-  NETWORK: "network_error",
-  TIMEOUT: "timeout",
-  USER: "user_error",
-  RUNTIME: "runtime_error",
-  MEDIA: "media_error",
-  MODEL: "model_error"
-};
-var INFERENCE_LATENCY_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3];
-var MODEL_LOAD_TIME_BUCKETS = [100, 500, 1e3, 2500, 5e3, 1e4, 3e4, 6e4];
-
 // src/inference/blendshapeUtils.ts
 var ARKIT_BLENDSHAPES = [
   "browDownLeft",
@@ -2901,6 +2975,9 @@ function resetModelUrls() {
 }
 var HF_CDN_URLS = HF_MODEL_URLS;
 
+// src/telemetry/index.ts
+init_otlp();
+
 // src/utils/runtime.ts
 var logger8 = createLogger("Runtime");
 function isIOSSafari() {
@@ -4365,7 +4442,7 @@ var SenseVoiceUnifiedAdapter = class {
       });
       span?.setAttributes({ "model.backend": "wasm", "model.load_time_ms": result.loadTimeMs });
       span?.end();
-      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+      telemetry?.recordHistogram(MetricNames.MODEL_LOAD_TIME, result.loadTimeMs, {
         model: "sensevoice-unified",
         backend: "wasm"
       });
@@ -4389,11 +4466,11 @@ var SenseVoiceUnifiedAdapter = class {
         try {
           const result = await this.worker.transcribe(audio);
           const latencyMs = getClock().now() - startTime;
-          telemetry?.recordHistogram("omote.inference.latency", latencyMs, {
+          telemetry?.recordHistogram(MetricNames.INFERENCE_LATENCY, latencyMs, {
             model: "sensevoice-unified",
             backend: "wasm"
           });
-          telemetry?.incrementCounter("omote.inference.total", 1, {
+          telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
             model: "sensevoice-unified",
             backend: "wasm",
             status: "success"
@@ -4402,7 +4479,7 @@ var SenseVoiceUnifiedAdapter = class {
           span?.end();
           resolve(result);
         } catch (err) {
-          telemetry?.incrementCounter("omote.inference.total", 1, {
+          telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
             model: "sensevoice-unified",
             backend: "wasm",
             status: "error"
@@ -4470,7 +4547,7 @@ var A2EUnifiedAdapter = class {
       });
       span?.setAttributes({ "model.backend": result.backend, "model.load_time_ms": result.loadTimeMs });
       span?.end();
-      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+      telemetry?.recordHistogram(MetricNames.MODEL_LOAD_TIME, result.loadTimeMs, {
         model: "a2e-unified",
         backend: result.backend
       });
@@ -5839,14 +5916,14 @@ var KokoroTTSUnifiedAdapter = class {
       });
       span?.setAttributes({ "model.backend": this._backend, "model.load_time_ms": loadTimeMs });
       span?.end();
-      telemetry?.recordHistogram("omote.model.load_time", loadTimeMs, {
+      telemetry?.recordHistogram(MetricNames.MODEL_LOAD_TIME, loadTimeMs, {
         model: "kokoro-tts-unified",
         backend: this._backend
       });
       return { backend: this._backend, loadTimeMs, defaultVoice: this.config.defaultVoice };
     } catch (error) {
       span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-      getTelemetry()?.incrementCounter("omote.errors.total", 1, {
+      getTelemetry()?.incrementCounter(MetricNames.ERRORS_TOTAL, 1, {
         model: "kokoro-tts-unified",
         error_type: "load_failed"
       });
@@ -5911,22 +5988,27 @@ var KokoroTTSUnifiedAdapter = class {
         try {
           const result = await this.worker.inferKokoro(tokens, style, speed);
           const latencyMs = getClock().now() - startTime;
-          telemetry?.recordHistogram("omote.inference.latency", latencyMs, {
+          telemetry?.recordHistogram(MetricNames.INFERENCE_LATENCY, latencyMs, {
             model: "kokoro-tts-unified",
             backend: this._backend
           });
-          telemetry?.incrementCounter("omote.inference.total", 1, {
+          telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
             model: "kokoro-tts-unified",
             backend: this._backend,
             status: "success"
           });
           resolve(result.audio);
         } catch (err) {
-          telemetry?.incrementCounter("omote.inference.total", 1, {
+          telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
             model: "kokoro-tts-unified",
             backend: this._backend,
             status: "error"
           });
+          const span = telemetry?.startSpan("KokoroTTSUnifiedAdapter.inferError", {
+            "model.name": "kokoro-tts-unified",
+            "model.backend": this._backend
+          });
+          span?.endWithError(err instanceof Error ? err : new Error(String(err)));
           reject(err);
         }
       });
@@ -6004,7 +6086,7 @@ var SileroVADUnifiedAdapter = class {
       });
       span?.setAttributes({ "model.backend": "wasm", "model.load_time_ms": result.loadTimeMs });
       span?.end();
-      telemetry?.recordHistogram("omote.model.load_time", result.loadTimeMs, {
+      telemetry?.recordHistogram(MetricNames.MODEL_LOAD_TIME, result.loadTimeMs, {
         model: "silero-vad-unified",
         backend: "wasm"
       });
@@ -6615,6 +6697,7 @@ function createKokoroTTS(config = {}) {
 }
 
 // src/audio/createTTSPlayer.ts
+var logger22 = createLogger("TTSPlayer");
 function createTTSPlayer(config) {
   return new TTSPlayer(config);
 }
@@ -6628,19 +6711,27 @@ var TTSPlayer = class extends TTSSpeaker {
   }
   /** Load TTS model and connect in audio-only mode. */
   async load() {
-    let worker = this.ttsConfig.unifiedWorker;
-    if (!worker) {
-      worker = await acquireSharedWorker();
-      this.ttsPlayerUsesSharedWorker = true;
-    }
-    this.backend = createKokoroTTS({
-      defaultVoice: this.ttsConfig.voice,
-      modelUrl: this.ttsConfig.modelUrl,
-      voiceBaseUrl: this.ttsConfig.voiceBaseUrl,
-      unifiedWorker: worker
-    });
-    await this.backend.load();
-    await this.connect(this.backend, { audioOnly: true });
+    const span = getTelemetry()?.startSpan("TTSPlayer.load");
+    try {
+      let worker = this.ttsConfig.unifiedWorker;
+      if (!worker) {
+        worker = await acquireSharedWorker();
+        this.ttsPlayerUsesSharedWorker = true;
+      }
+      this.backend = createKokoroTTS({
+        defaultVoice: this.ttsConfig.voice,
+        modelUrl: this.ttsConfig.modelUrl,
+        voiceBaseUrl: this.ttsConfig.voiceBaseUrl,
+        unifiedWorker: worker
+      });
+      await this.backend.load();
+      await this.connect(this.backend, { audioOnly: true });
+      logger22.info("TTSPlayer loaded");
+      span?.end();
+    } catch (err) {
+      span?.endWithError(err instanceof Error ? err : new Error(String(err)));
+      throw err;
+    }
   }
   /** Whether the TTS model is loaded and ready. */
   get isLoaded() {
@@ -6659,7 +6750,7 @@ var TTSPlayer = class extends TTSSpeaker {
 };
 
 // src/inference/createSenseVoice.ts
-var logger22 = createLogger("createSenseVoice");
+var logger23 = createLogger("createSenseVoice");
 var LazySenseVoice = class {
   constructor(config) {
     this.inner = null;
@@ -6707,7 +6798,7 @@ var LazySenseVoice = class {
 function createSenseVoice(config = {}) {
   const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.senseVoice;
   if (config.unifiedWorker) {
-    logger22.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
+    logger23.info("Creating SenseVoiceUnifiedAdapter (shared unified worker)");
     return new SenseVoiceUnifiedAdapter(config.unifiedWorker, {
       modelUrl,
       tokensUrl: config.tokensUrl,
@@ -6715,12 +6806,12 @@ function createSenseVoice(config = {}) {
       textNorm: config.textNorm
     });
   }
-  logger22.info("Creating SenseVoiceUnifiedAdapter (dedicated worker, lazy init)");
+  logger23.info("Creating SenseVoiceUnifiedAdapter (dedicated worker, lazy init)");
   return new LazySenseVoice(config);
 }
 
 // src/inference/createSileroVAD.ts
-var logger23 = createLogger("createSileroVAD");
+var logger24 = createLogger("createSileroVAD");
 var LazySileroVAD = class {
   constructor(config) {
     this.inner = null;
@@ -6781,15 +6872,15 @@ function createSileroVAD(config = {}) {
   const modelUrl = config.modelUrl ?? DEFAULT_MODEL_URLS.sileroVad;
   const resolvedConfig = { ...config, modelUrl };
   if (config.unifiedWorker) {
-    logger23.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
+    logger24.info("Creating SileroVADUnifiedAdapter (shared unified worker)");
     return new SileroVADUnifiedAdapter(config.unifiedWorker, resolvedConfig);
   }
-  logger23.info("Creating SileroVADUnifiedAdapter (dedicated worker, lazy init)");
+  logger24.info("Creating SileroVADUnifiedAdapter (dedicated worker, lazy init)");
   return new LazySileroVAD(config);
 }
 
 // src/audio/SpeechListener.ts
-var logger24 = createLogger("SpeechListener");
+var logger25 = createLogger("SpeechListener");
 var _SpeechListener = class _SpeechListener extends EventEmitter {
   constructor(config) {
     super();
@@ -6913,11 +7004,11 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
       }
       span?.end();
       this.setState("ready");
-      logger24.info("SpeechListener models loaded");
+      logger25.info("SpeechListener models loaded");
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       span?.endWithError(err);
-      logger24.error("Model loading failed", { message: err.message });
+      logger25.error("Model loading failed", { message: err.message });
       this.emit("error", err);
       this.setState("idle");
       throw err;
@@ -6950,7 +7041,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     });
     await this.mic.start();
     this.setState("listening");
-    logger24.info("Listening started");
+    logger25.info("Listening started");
   }
   /** Stop listening — deactivates mic, clears buffers. */
   stop() {
@@ -6970,7 +7061,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     if (this._state !== "idle") {
       this.setState("ready");
     }
-    logger24.info("Listening stopped");
+    logger25.info("Listening stopped");
   }
   /** Pause VAD/ASR but keep mic active for audio:chunk events (for interruption detection). */
   pause() {
@@ -6991,7 +7082,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
   }
   /** Dispose all resources. */
   async dispose() {
-    logger24.debug("Disposing SpeechListener");
+    logger25.debug("Disposing SpeechListener");
     this.stop();
     this.epoch++;
     await Promise.allSettled([
@@ -7026,14 +7117,14 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
           this.audioBufferSamples = 0;
           this.lastProgressiveResult = null;
           this.lastProgressiveSamples = 0;
-          logger24.debug("Speech start");
+          logger25.debug("Speech start");
           this.emit("speech:start");
           this.startProgressiveTranscription();
         }
         this.audioBuffer.push(new Float32Array(samples));
         this.audioBufferSamples += samples.length;
         if (this.audioBufferSamples >= _SpeechListener.MAX_AUDIO_BUFFER_SAMPLES) {
-          logger24.warn("Audio buffer exceeded max, forcing transcription flush");
+          logger25.warn("Audio buffer exceeded max, forcing transcription flush");
           this.onSilenceDetected();
           return;
         }
@@ -7049,7 +7140,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
         }
       }
     } catch (err) {
-      logger24.warn("VAD error", { error: String(err) });
+      logger25.warn("VAD error", { error: String(err) });
     }
   }
   // ---------------------------------------------------------------------------
@@ -7067,11 +7158,11 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     const capturedEpoch = this.epoch;
     this.isSpeechActive = false;
     const durationMs = getClock().now() - this.speechStartTime;
-    logger24.debug("Speech end", { durationMs: Math.round(durationMs) });
+    logger25.debug("Speech end", { durationMs: Math.round(durationMs) });
     this.emit("speech:end", { durationMs });
     this.clearSilenceTimer();
     this.processEndOfSpeech(capturedEpoch).catch((err) => {
-      logger24.error("End of speech processing failed", { error: String(err) });
+      logger25.error("End of speech processing failed", { error: String(err) });
       if (this.epoch === capturedEpoch) {
         this.emit("error", err instanceof Error ? err : new Error(String(err)));
         this.setState("listening");
@@ -7103,7 +7194,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     const minEnergy = this.config.minAudioEnergy ?? 0.02;
     const durationSec = totalSamples / 16e3;
     if (durationSec < minDuration) {
-      logger24.info("Audio too short, discarding", { durationSec });
+      logger25.info("Audio too short, discarding", { durationSec });
       this.setState("listening");
       return;
     }
@@ -7113,7 +7204,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     }
     rms = Math.sqrt(rms / fullAudio.length);
     if (rms < minEnergy) {
-      logger24.info("Audio too quiet, discarding", { rms });
+      logger25.info("Audio too quiet, discarding", { rms });
       this.setState("listening");
       return;
     }
@@ -7130,7 +7221,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     }
     if (this.epoch !== capturedEpoch) return;
     if (!transcript || !transcript.text.trim()) {
-      logger24.info("No transcript, resuming listening");
+      logger25.info("No transcript, resuming listening");
       this.setState("listening");
       return;
     }
@@ -7166,7 +7257,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
         } catch (err) {
           this.progressiveErrorCount = (this.progressiveErrorCount ?? 0) + 1;
           if (this.progressiveErrorCount % 10 === 1) {
-            logger24.warn("Progressive transcription error", {
+            logger25.warn("Progressive transcription error", {
               code: ErrorCodes.SPH_ASR_ERROR,
               error: String(err),
               count: this.progressiveErrorCount
@@ -7218,9 +7309,9 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
     } catch (error) {
       span?.endWithError(error instanceof Error ? error : new Error(String(error)));
       this.asrErrorCount++;
-      logger24.warn("Transcription failed", { attempt: this.asrErrorCount, error: String(error) });
+      logger25.warn("Transcription failed", { attempt: this.asrErrorCount, error: String(error) });
       if (this.asrErrorCount >= 3 && this.config.models) {
-        logger24.warn("3 consecutive ASR errors, recreating session");
+        logger25.warn("3 consecutive ASR errors, recreating session");
         try {
           await this.asr.dispose();
           this.asr = createSenseVoice({
@@ -7233,7 +7324,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
           await this.asr.load();
           this.asrErrorCount = 0;
         } catch (recreateErr) {
-          logger24.error("ASR session recreation failed", { error: String(recreateErr) });
+          logger25.error("ASR session recreation failed", { error: String(recreateErr) });
         }
       }
       return null;
@@ -7262,7 +7353,7 @@ var _SpeechListener = class _SpeechListener extends EventEmitter {
   // ---------------------------------------------------------------------------
   setState(state) {
     if (this._state === state) return;
-    logger24.debug("State transition", { from: this._state, to: state });
+    logger25.debug("State transition", { from: this._state, to: state });
     this._state = state;
     this.emit("state", state);
   }
@@ -7281,7 +7372,7 @@ _SpeechListener.MAX_AUDIO_BUFFER_SAMPLES = 16e3 * 30;
 var SpeechListener = _SpeechListener;
 
 // src/audio/InterruptionHandler.ts
-var logger25 = createLogger("InterruptionHandler");
+var logger26 = createLogger("InterruptionHandler");
 var InterruptionHandler = class extends EventEmitter {
   constructor(config = {}) {
     super();
@@ -7302,7 +7393,7 @@ var InterruptionHandler = class extends EventEmitter {
       enabled: true,
       ...config
     };
-    logger25.debug("Constructed with config", {
+    logger26.debug("Constructed with config", {
       vadThreshold: this.config.vadThreshold,
       minSpeechDurationMs: this.config.minSpeechDurationMs,
       silenceTimeoutMs: this.config.silenceTimeoutMs,
@@ -7333,7 +7424,7 @@ var InterruptionHandler = class extends EventEmitter {
   processVADResult(vadProbability, audioEnergy = 0) {
     if (!this.config.enabled) return;
     if (this.aiIsSpeaking) {
-      logger25.trace("VAD during AI speech", {
+      logger26.trace("VAD during AI speech", {
         vadProbability,
         audioEnergy,
         threshold: this.config.vadThreshold
@@ -7347,12 +7438,12 @@ var InterruptionHandler = class extends EventEmitter {
   }
   /** Notify that AI started/stopped speaking */
   setAISpeaking(speaking) {
-    logger25.debug("AI speaking state changed", { speaking });
+    logger26.debug("AI speaking state changed", { speaking });
     this.aiIsSpeaking = speaking;
   }
   /** Enable/disable interruption detection */
   setEnabled(enabled) {
-    logger25.debug("Enabled state changed", { enabled });
+    logger26.debug("Enabled state changed", { enabled });
     this.config.enabled = enabled;
     if (!enabled) {
       this.reset();
@@ -7396,7 +7487,8 @@ var InterruptionHandler = class extends EventEmitter {
       const speechDuration = now - this.speechStartTime;
       if (speechDuration >= this.config.minSpeechDurationMs) {
         this.interruptionTriggeredThisSession = true;
-        logger25.debug("Interruption triggered", { rms, durationMs: speechDuration });
+        logger26.debug("Interruption triggered", { rms, durationMs: speechDuration });
+        getTelemetry()?.incrementCounter(MetricNames.VOICE_INTERRUPTIONS, 1, { source: "detector" });
         this.emit("interruption.triggered", { rms, durationMs: speechDuration });
       }
     }
@@ -7416,7 +7508,7 @@ var InterruptionHandler = class extends EventEmitter {
 };
 
 // src/inference/SafariSpeechRecognition.ts
-var logger26 = createLogger("SafariSpeech");
+var logger27 = createLogger("SafariSpeech");
 var SafariSpeechRecognition = class _SafariSpeechRecognition {
   constructor(config = {}) {
     this.recognition = null;
@@ -7435,7 +7527,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       interimResults: config.interimResults ?? true,
       maxAlternatives: config.maxAlternatives ?? 1
     };
-    logger26.debug("SafariSpeechRecognition created", {
+    logger27.debug("SafariSpeechRecognition created", {
       language: this.config.language,
       continuous: this.config.continuous
     });
@@ -7496,7 +7588,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async start() {
     if (this.isListening) {
-      logger26.warn("Already listening");
+      logger27.warn("Already listening");
       return;
     }
     if (!_SafariSpeechRecognition.isAvailable()) {
@@ -7526,7 +7618,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       this.isListening = true;
       this.startTime = getClock().now();
       this.accumulatedText = "";
-      logger26.info("Speech recognition started", {
+      logger27.info("Speech recognition started", {
         language: this.config.language
       });
       span?.end();
@@ -7541,7 +7633,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    */
   async stop() {
     if (!this.isListening || !this.recognition) {
-      logger26.warn("Not currently listening");
+      logger27.warn("Not currently listening");
       return {
         text: this.accumulatedText,
         language: this.config.language,
@@ -7570,7 +7662,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     if (this.recognition && this.isListening) {
       this.recognition.abort();
       this.isListening = false;
-      logger26.info("Speech recognition aborted");
+      logger27.info("Speech recognition aborted");
     }
   }
   /**
@@ -7592,7 +7684,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
    * Dispose of recognition resources
    */
   dispose() {
-    logger26.debug("Disposed");
+    logger27.debug("Disposed");
     if (this.recognition) {
       if (this.isListening) {
         this.recognition.abort();
@@ -7602,7 +7694,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     this.isListening = false;
     this.resultCallbacks = [];
     this.errorCallbacks = [];
-    logger26.debug("SafariSpeechRecognition disposed");
+    logger27.debug("SafariSpeechRecognition disposed");
   }
   /**
    * Set up event handlers for the recognition instance
@@ -7630,7 +7722,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
               confidence: alternative.confidence
             };
             this.emitResult(speechResult);
-            logger26.trace("Speech result", {
+            logger27.trace("Speech result", {
               text: text.substring(0, 50),
               isFinal,
               confidence: alternative.confidence
@@ -7640,12 +7732,12 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
         span?.end();
       } catch (error) {
         span?.endWithError(error instanceof Error ? error : new Error(String(error)));
-        logger26.error("Error processing speech result", { error });
+        logger27.error("Error processing speech result", { error });
       }
     };
     this.recognition.onerror = (event) => {
       const error = new Error(`Speech recognition error: ${event.error} - ${event.message}`);
-      logger26.error("Speech recognition error", { error: event.error, message: event.message });
+      logger27.error("Speech recognition error", { error: event.error, message: event.message });
       this.emitError(error);
       if (this.stopRejecter) {
         this.stopRejecter(error);
@@ -7655,7 +7747,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
     };
     this.recognition.onend = () => {
       this.isListening = false;
-      logger26.info("Speech recognition ended", {
+      logger27.info("Speech recognition ended", {
         totalText: this.accumulatedText.length,
         durationMs: getClock().now() - this.startTime
       });
@@ -7672,13 +7764,13 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       }
     };
     this.recognition.onstart = () => {
-      logger26.debug("Speech recognition started by browser");
+      logger27.debug("Speech recognition started by browser");
     };
     this.recognition.onspeechstart = () => {
-      logger26.debug("Speech detected");
+      logger27.debug("Speech detected");
     };
     this.recognition.onspeechend = () => {
-      logger26.debug("Speech ended");
+      logger27.debug("Speech ended");
     };
   }
   /**
@@ -7689,7 +7781,7 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(result);
       } catch (error) {
-        logger26.error("Error in result callback", { error });
+        logger27.error("Error in result callback", { error });
       }
     }
   }
@@ -7701,14 +7793,14 @@ var SafariSpeechRecognition = class _SafariSpeechRecognition {
       try {
         callback(error);
       } catch (callbackError) {
-        logger26.error("Error in error callback", { error: callbackError });
+        logger27.error("Error in error callback", { error: callbackError });
       }
     }
   }
 };
 
 // src/inference/ElevenLabsTTSBackend.ts
-var logger27 = createLogger("ElevenLabsTTS");
+var logger28 = createLogger("ElevenLabsTTS");
 var DEFAULT_MODEL = "eleven_multilingual_v2";
 var DEFAULT_OUTPUT_FORMAT = "pcm_16000";
 var DEFAULT_STABILITY = 0.5;
@@ -7753,7 +7845,7 @@ var ElevenLabsTTSBackend = class {
    */
   async load() {
     this._isLoaded = true;
-    logger27.info("ElevenLabs TTS ready", { voiceId: this.voiceId, model: this.model });
+    logger28.info("ElevenLabs TTS ready", { voiceId: this.voiceId, model: this.model });
   }
   // ─── Stream ─────────────────────────────────────────────────────────────
   /**
@@ -7799,7 +7891,7 @@ var ElevenLabsTTSBackend = class {
       if (!response.ok) {
         const errorText = await response.text().catch(() => "unknown");
         const msg = `ElevenLabsTTS: HTTP ${response.status} \u2014 ${this.getHttpErrorMessage(response.status, errorText)}`;
-        logger27.error(msg);
+        logger28.error(msg);
         throw new Error(msg);
       }
       if (!response.body) {
@@ -7809,7 +7901,7 @@ var ElevenLabsTTSBackend = class {
         const latency2 = getClock().now() - startTime;
         span?.setAttributes({ "tts.duration_s": duration, "tts.latency_ms": latency2 });
         span?.end();
-        telemetry?.recordHistogram("omote.inference.latency", latency2, {
+        telemetry?.recordHistogram(MetricNames.INFERENCE_LATENCY, latency2, {
           model: "elevenlabs-tts",
           backend: "cloud"
         });
@@ -7822,7 +7914,7 @@ var ElevenLabsTTSBackend = class {
         while (true) {
           if (options?.signal?.aborted) {
             reader.cancel();
-            logger27.debug("Stream aborted by signal");
+            logger28.debug("Stream aborted by signal");
             return;
           }
           const { done, value } = await reader.read();
@@ -7841,32 +7933,32 @@ var ElevenLabsTTSBackend = class {
       }
       const latency = getClock().now() - startTime;
       const totalDuration = totalSamples / this._sampleRate;
-      logger27.debug("Stream complete", {
+      logger28.debug("Stream complete", {
         totalDuration: `${totalDuration.toFixed(2)}s`,
         latencyMs: Math.round(latency),
         totalSamples
       });
       span?.setAttributes({ "tts.duration_s": totalDuration, "tts.latency_ms": latency });
       span?.end();
-      telemetry?.recordHistogram("omote.inference.latency", latency, {
+      telemetry?.recordHistogram(MetricNames.INFERENCE_LATENCY, latency, {
         model: "elevenlabs-tts",
         backend: "cloud"
       });
-      telemetry?.incrementCounter("omote.inference.total", 1, {
+      telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
         model: "elevenlabs-tts",
         backend: "cloud",
         status: "success"
       });
     } catch (err) {
       if (err instanceof DOMException && err.name === "AbortError") {
-        logger27.debug("Stream aborted");
+        logger28.debug("Stream aborted");
         span?.end();
         return;
       }
       const errMsg = err instanceof Error ? err.message : String(err);
-      logger27.error("Stream failed", { error: errMsg });
+      logger28.error("Stream failed", { error: errMsg });
       span?.endWithError(err instanceof Error ? err : new Error(String(err)));
-      telemetry?.incrementCounter("omote.inference.total", 1, {
+      telemetry?.incrementCounter(MetricNames.INFERENCE_TOTAL, 1, {
         model: "elevenlabs-tts",
         backend: "cloud",
         status: "error"
@@ -7877,7 +7969,7 @@ var ElevenLabsTTSBackend = class {
   // ─── Dispose ────────────────────────────────────────────────────────────
   async dispose() {
     this._isLoaded = false;
-    logger27.info("ElevenLabs TTS disposed");
+    logger28.info("ElevenLabs TTS disposed");
   }
   // ─── Private ────────────────────────────────────────────────────────────
   getHttpErrorMessage(status, body) {
@@ -7897,7 +7989,7 @@ var ElevenLabsTTSBackend = class {
 };
 
 // src/emotion/Emotion.ts
-var logger28 = createLogger("EmotionController");
+var logger29 = createLogger("EmotionController");
 var EMOTION_NAMES = [
   "amazement",
   "anger",
@@ -7919,7 +8011,7 @@ function createEmotionVector(weights = {}) {
     if (idx >= 0) {
       vector[idx] = Math.max(0, Math.min(1, value));
     } else {
-      logger28.warn(`Invalid emotion name in createEmotionVector: "${name}"`);
+      logger29.warn(`Invalid emotion name in createEmotionVector: "${name}"`);
     }
   }
   return vector;
@@ -8002,7 +8094,7 @@ var EmotionController = class {
     this.targetEmotion.set(newEmotion);
     this.currentEmotion.set(newEmotion);
     this.transitionProgress = 1;
-    logger28.debug("set", { weights });
+    logger29.debug("set", { weights });
   }
   /**
    * Set emotion from preset immediately
@@ -8012,7 +8104,7 @@ var EmotionController = class {
     this.targetEmotion.set(newEmotion);
     this.currentEmotion.set(newEmotion);
     this.transitionProgress = 1;
-    logger28.debug("setPreset", { preset });
+    logger29.debug("setPreset", { preset });
   }
   /**
    * Transition to new emotion over time
@@ -8026,7 +8118,7 @@ var EmotionController = class {
     this.transitionDuration = durationMs;
     this.transitionStartTime = getClock().now();
     this.transitionProgress = 0;
-    logger28.debug("transitionTo", { weights, durationMs });
+    logger29.debug("transitionTo", { weights, durationMs });
   }
   /**
    * Transition to preset over time
@@ -8059,7 +8151,7 @@ var EmotionController = class {
     this.currentEmotion.fill(0);
     this.targetEmotion.fill(0);
     this.transitionProgress = 1;
-    logger28.debug("reset");
+    logger29.debug("reset");
   }
 };
 
@@ -8140,7 +8232,7 @@ var DEFAULT_ANIMATION_CONFIG = {
 };
 
 // src/animation/AnimationGraph.ts
-var logger29 = createLogger("AnimationGraph");
+var logger30 = createLogger("AnimationGraph");
 var AnimationGraph = class extends EventEmitter {
   constructor(config = {}) {
     super();
@@ -8173,7 +8265,7 @@ var AnimationGraph = class extends EventEmitter {
     this.stateEnterTime = Date.now();
     this.lastUpdateTime = Date.now();
     this.cachedOutput = this.computeOutput();
-    logger29.info("constructor", {
+    logger30.info("constructor", {
       initialState: this.config.initialState,
       stateCount: this.config.states.length,
       transitionCount: this.config.transitions.length
@@ -8244,7 +8336,7 @@ var AnimationGraph = class extends EventEmitter {
   setState(stateName, blendDuration = 300) {
     const targetState = this.config.states.find((s) => s.name === stateName);
     if (!targetState) {
-      logger29.warn(`State '${stateName}' not found`);
+      logger30.warn(`State '${stateName}' not found`);
       return;
     }
     if (targetState.name === this.currentState.name && !this.isTransitioning) {
@@ -8322,7 +8414,7 @@ var AnimationGraph = class extends EventEmitter {
       (s) => s.name === transition.to
     );
     if (!targetState) {
-      logger29.warn(`Target state '${transition.to}' not found`);
+      logger30.warn(`Target state '${transition.to}' not found`);
       return;
     }
     const fromState = this.currentState.name;
@@ -8336,7 +8428,7 @@ var AnimationGraph = class extends EventEmitter {
     if (!this.currentState.emotionBlendEnabled) {
       this.targetEmotionWeight = 0;
     }
-    logger29.debug("state transition", {
+    logger30.debug("state transition", {
       from: fromState,
       to: targetState.name,
       trigger: event,
@@ -8373,7 +8465,7 @@ var AnimationGraph = class extends EventEmitter {
     if (this.currentState.timeout <= 0) return;
     const elapsed = now - this.stateEnterTime;
     if (elapsed >= this.currentState.timeout) {
-      logger29.debug("timeout transition", {
+      logger30.debug("timeout transition", {
         state: this.currentState.name,
         elapsed,
         timeout: this.currentState.timeout
@@ -8603,7 +8695,7 @@ var EmphasisDetector = class {
 
 // src/animation/ProceduralLifeLayer.ts
 var import_simplex_noise = require("simplex-noise");
-var logger30 = createLogger("ProceduralLifeLayer");
+var logger31 = createLogger("ProceduralLifeLayer");
 var simplex2d = (0, import_simplex_noise.createNoise2D)();
 var LIFE_BS_INDEX = /* @__PURE__ */ new Map();
 for (let i = 0; i < ARKIT_BLENDSHAPES.length; i++) {
@@ -8709,7 +8801,7 @@ var ProceduralLifeLayer = class {
     }
     this.blinkInterval = this.nextBlinkInterval();
     this.gazeBreakInterval = randomRange(...this.gazeBreakIntervalRange);
-    logger30.debug("constructor", {
+    logger31.debug("constructor", {
       blinkIntervalRange: this.blinkIntervalRange,
       useLogNormalBlinks: this.useLogNormalBlinks,
       gazeBreakIntervalRange: this.gazeBreakIntervalRange,
@@ -8813,7 +8905,7 @@ var ProceduralLifeLayer = class {
    * Reset all internal state to initial values.
    */
   reset() {
-    logger30.debug("reset");
+    logger31.debug("reset");
     this.blinkTimer = 0;
     this.blinkInterval = this.nextBlinkInterval();
     this.blinkPhase = PHASE_OPEN;
@@ -8865,7 +8957,7 @@ var ProceduralLifeLayer = class {
       this.blinkTimer = 0;
       this.blinkInterval = this.nextBlinkInterval();
       this.asymmetryRight = 0.95 + Math.random() * 0.08;
-      logger30.trace("blink", { nextInterval: this.blinkInterval });
+      logger31.trace("blink", { nextInterval: this.blinkInterval });
     }
     if (this.blinkPhase > PHASE_OPEN) {
       this.blinkProgress += delta;
@@ -8946,7 +9038,7 @@ var ProceduralLifeLayer = class {
       this.gazeBreakTargetX = (Math.random() - 0.5) * 2 * amp;
       this.gazeBreakTargetY = (Math.random() - 0.5) * amp * 0.4;
       this.gazeBreakInterval = randomRange(...params.interval);
-      logger30.trace("gaze break", {
+      logger31.trace("gaze break", {
         targetX: this.gazeBreakTargetX.toFixed(3),
         targetY: this.gazeBreakTargetY.toFixed(3),
         nextInterval: this.gazeBreakInterval.toFixed(2),
@@ -9189,7 +9281,7 @@ var ALL_AUS = [...new Set(
 )];
 
 // src/face/EmotionResolver.ts
-var logger31 = createLogger("EmotionResolver");
+var logger32 = createLogger("EmotionResolver");
 var BS_INDEX = /* @__PURE__ */ new Map();
 for (let i = 0; i < ARKIT_BLENDSHAPES.length; i++) {
   BS_INDEX.set(ARKIT_BLENDSHAPES[i], i);
@@ -9216,7 +9308,7 @@ var EmotionResolver = class {
       if (!emotionWeight || emotionWeight < 0.01) continue;
       const auActivations = EMOTION_TO_AU[emotionName];
       if (!auActivations) {
-        logger31.warn(`Unknown emotion name with no AU mapping: "${emotionName}"`);
+        logger32.warn(`Unknown emotion name with no AU mapping: "${emotionName}"`);
         continue;
       }
       for (const activation of auActivations) {
@@ -9241,7 +9333,7 @@ var EmotionResolver = class {
 };
 
 // src/face/FaceCompositor.ts
-var logger32 = createLogger("FaceCompositor");
+var logger33 = createLogger("FaceCompositor");
 function smoothstep(t) {
   return t * t * (3 - 2 * t);
 }
@@ -9272,7 +9364,7 @@ var FaceCompositor = class {
     if (config?.profile) {
       this.applyProfileArrays(config.profile);
     }
-    logger32.debug("constructor", {
+    logger33.debug("constructor", {
       emotionSmoothing: this.emotionSmoothing,
       hasProfile: !!config?.profile,
       hasLifeLayer: !!config?.lifeLayer
@@ -9345,7 +9437,7 @@ var FaceCompositor = class {
    */
   setEmotion(weights) {
     this.stickyEmotion = weights;
-    logger32.debug("setEmotion", { weights });
+    logger33.debug("setEmotion", { weights });
   }
   /**
    * Update character profile at runtime.
@@ -9354,7 +9446,7 @@ var FaceCompositor = class {
     this.multiplier.fill(1);
     this.offset.fill(0);
     this.applyProfileArrays(profile);
-    logger32.debug("setProfile", {
+    logger33.debug("setProfile", {
       multiplierKeys: profile.multiplier ? Object.keys(profile.multiplier).length : 0,
       offsetKeys: profile.offset ? Object.keys(profile.offset).length : 0
     });
@@ -9368,7 +9460,7 @@ var FaceCompositor = class {
     this.lifeBuffer.fill(0);
     this.stickyEmotion = void 0;
     this.lifeLayer.reset();
-    logger32.debug("reset");
+    logger33.debug("reset");
   }
   /** Expand partial profile maps into dense Float32Arrays */
   applyProfileArrays(profile) {
@@ -9453,7 +9545,7 @@ function parseEmotionTags(text) {
 }
 
 // src/character/CharacterController.ts
-var logger33 = createLogger("CharacterController");
+var logger34 = createLogger("CharacterController");
 var FRAME_BUDGET_US = 33e3;
 var EMOTION_MAP = {
   // Synced with EmotionPresets (packages/core/src/emotion/Emotion.ts)
@@ -9523,7 +9615,7 @@ var CharacterController = class {
     this.gazeYawInfluence = config?.gaze?.yawInfluence ?? 0.4;
     this.gazePitchInfluence = config?.gaze?.pitchInfluence ?? 0.3;
     this.gazeSmoothing = config?.gaze?.smoothing ?? 5;
-    logger33.debug("constructor", {
+    logger34.debug("constructor", {
       gazeEnabled: this.gazeEnabled,
       gazeYawInfluence: this.gazeYawInfluence,
       gazePitchInfluence: this.gazePitchInfluence,
@@ -9587,13 +9679,13 @@ var CharacterController = class {
     const resolved = resolveEmotion(emotion);
     if (resolved) {
       this._compositor.setEmotion(resolved);
-      logger33.debug("setEmotion", { emotion, resolved });
+      logger34.debug("setEmotion", { emotion, resolved });
     }
   }
   /** Update character profile at runtime. */
   setProfile(profile) {
     this._compositor.setProfile(profile);
-    logger33.debug("setProfile", {
+    logger34.debug("setProfile", {
       multiplierKeys: profile.multiplier ? Object.keys(profile.multiplier).length : 0,
       offsetKeys: profile.offset ? Object.keys(profile.offset).length : 0
     });
@@ -9628,11 +9720,11 @@ var CharacterController = class {
     this._compositor.reset();
     this.gazeHeadYaw = 0;
     this.gazeHeadPitch = -0.1;
-    logger33.debug("reset");
+    logger34.debug("reset");
   }
   dispose() {
     this.reset();
-    logger33.debug("dispose");
+    logger34.debug("dispose");
   }
   // ---------------------------------------------------------------------------
   // Eye angle math (extracted from r3f useGazeTracking.computeEyeTargets)
@@ -9714,7 +9806,7 @@ var CharacterController = class {
 };
 
 // src/orchestration/MicLipSync.ts
-var logger34 = createLogger("MicLipSync");
+var logger35 = createLogger("MicLipSync");
 var MicLipSync = class extends EventEmitter {
   constructor(config) {
     super();
@@ -9733,7 +9825,7 @@ var MicLipSync = class extends EventEmitter {
     this.vadChunkSize = 0;
     this.vadBuffer = null;
     this.vadBufferOffset = 0;
-    logger34.info("MicLipSync created", {
+    logger35.info("MicLipSync created", {
       sampleRate: config.sampleRate ?? 16e3,
       micChunkSize: config.micChunkSize ?? 512,
       hasVAD: !!config.vad,
@@ -9755,12 +9847,12 @@ var MicLipSync = class extends EventEmitter {
         this._currentFrame = scaled;
         if (!this._firstFrameEmitted) {
           this._firstFrameEmitted = true;
-          logger34.trace("First blendshape frame emitted");
+          logger35.trace("First blendshape frame emitted");
         }
         this.emit("frame", { blendshapes: scaled, rawBlendshapes: raw });
       },
       onError: (error) => {
-        logger34.error("A2E inference error", { message: error.message });
+        logger35.error("A2E inference error", { message: error.message });
         this.emit("error", error);
       }
     });
@@ -9769,7 +9861,7 @@ var MicLipSync = class extends EventEmitter {
       this.processor.pushAudio(float32);
       if (this.vad) {
         this.vadQueue = this.vadQueue.then(() => this.processVAD(float32)).catch((err) => {
-          logger34.warn("VAD processing error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
+          logger35.warn("VAD processing error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
           this.emit("error", err instanceof Error ? err : new Error(String(err)));
         });
       }
@@ -9805,7 +9897,7 @@ var MicLipSync = class extends EventEmitter {
   /** Start microphone capture and inference loop */
   async start() {
     if (this._state === "active") return;
-    logger34.info("Starting MicLipSync");
+    logger35.info("Starting MicLipSync");
     getTelemetry()?.incrementCounter(MetricNames.MIC_SESSIONS);
     await this.mic.start();
     this.processor.startDrip();
@@ -9815,7 +9907,7 @@ var MicLipSync = class extends EventEmitter {
   /** Stop microphone and inference */
   stop() {
     if (this._state === "idle") return;
-    logger34.info("Stopping MicLipSync");
+    logger35.info("Stopping MicLipSync");
     this.processor.stopDrip();
     this.mic.stop();
     this._isSpeaking = false;
@@ -9864,7 +9956,7 @@ var MicLipSync = class extends EventEmitter {
             this.emit("speech:end", { durationMs });
           }
         } catch (err) {
-          logger34.warn("VAD process error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
+          logger35.warn("VAD process error", { error: String(err), code: ErrorCodes.SPH_VAD_ERROR });
           this.emit("error", err instanceof Error ? err : new Error(String(err)));
         }
         this.vadBufferOffset = 0;
@@ -9882,7 +9974,7 @@ var MicLipSync = class extends EventEmitter {
 };
 
 // src/orchestration/VoiceOrchestrator.ts
-var logger35 = createLogger("VoiceOrchestrator");
+var logger36 = createLogger("VoiceOrchestrator");
 var VoiceOrchestrator = class extends EventEmitter {
   constructor() {
     super(...arguments);
@@ -9934,12 +10026,16 @@ var VoiceOrchestrator = class extends EventEmitter {
     const epoch = ++this.connectEpoch;
     this._mode = config.mode ?? "local";
     this._sessionId = crypto.randomUUID();
+    const span = getTelemetry()?.startSpan("VoiceOrchestrator.connect", {
+      "mode": this._mode,
+      "session.id": this._sessionId
+    });
     if (config.onStateChange) this.on("state", config.onStateChange);
     if (config.onLoadingProgress) this.on("loading:progress", config.onLoadingProgress);
     if (config.onError) this.on("error", config.onError);
     if (config.onTranscriptEvent) this.on("transcript", config.onTranscriptEvent);
     if (config.onInterruption) this.on("interruption", config.onInterruption);
-    logger35.info("Connecting voice orchestrator", { mode: this._mode });
+    logger36.info("Connecting voice orchestrator", { mode: this._mode });
     try {
       if (this._mode === "local") {
         const localCfg = config;
@@ -10020,9 +10116,11 @@ var VoiceOrchestrator = class extends EventEmitter {
       } else {
         this.wireCloudTranscript(config);
       }
-      logger35.info("Voice orchestrator connected", { mode: this._mode });
+      logger36.info("Voice orchestrator connected", { mode: this._mode });
+      span?.end();
     } catch (err) {
-      logger35.error("Voice orchestrator connect failed, cleaning up", { error: String(err) });
+      logger36.error("Voice orchestrator connect failed, cleaning up", { error: String(err) });
+      span?.endWithError(err instanceof Error ? err : new Error(String(err)));
       await this.disconnect();
       throw err;
     }
@@ -10131,6 +10229,7 @@ var VoiceOrchestrator = class extends EventEmitter {
     const handler = async (result) => {
       this.emit("transcript", result);
       if (!result.isFinal || !result.text.trim()) return;
+      const turnStart = getClock().now();
       this.setState("thinking");
       this.speechListener?.pause();
       this.interruption?.setAISpeaking(true);
@@ -10147,10 +10246,11 @@ var VoiceOrchestrator = class extends EventEmitter {
           await this.speak(text);
         }
       } catch (e) {
-        logger35.error("Voice transcript handler error", { error: String(e) });
+        logger36.error("Voice transcript handler error", { error: String(e) });
       } finally {
         this.interruption?.setAISpeaking(false);
         this.speechListener?.resume();
+        getTelemetry()?.recordHistogram(MetricNames.VOICE_TURN_LATENCY, getClock().now() - turnStart);
         this.setState("listening");
       }
     };
@@ -10161,6 +10261,8 @@ var VoiceOrchestrator = class extends EventEmitter {
     const handler = async (result) => {
       this.emit("transcript", result);
       if (!result.isFinal || !result.text.trim()) return;
+      const turnStart = getClock().now();
+      let firstChunkSent = false;
       this.setState("thinking");
       this.speechListener?.pause();
       this.interruption?.setAISpeaking(true);
@@ -10177,10 +10279,15 @@ var VoiceOrchestrator = class extends EventEmitter {
           setEmotion: (emotion) => this.playbackPipeline?.setEmotion(emotion),
           send: async (chunk) => {
             if (abortController.signal.aborted) return;
+            if (!firstChunkSent) {
+              firstChunkSent = true;
+              getTelemetry()?.recordHistogram(MetricNames.VOICE_RESPONSE_LATENCY, getClock().now() - turnStart);
+            }
             await this.playbackPipeline.onAudioChunk(chunk);
           },
           done: async () => {
             if (abortController.signal.aborted) return;
+            getTelemetry()?.recordHistogram(MetricNames.VOICE_TURN_LATENCY, getClock().now() - turnStart);
             await this.playbackPipeline.end();
           },
           signal: abortController.signal,
@@ -10188,7 +10295,7 @@ var VoiceOrchestrator = class extends EventEmitter {
         });
       } catch (e) {
         if (!abortController.signal.aborted) {
-          logger35.error("Cloud response handler error", { error: String(e) });
+          logger36.error("Cloud response handler error", { error: String(e) });
         }
       } finally {
         this.responseAbortController = null;
@@ -10202,9 +10309,10 @@ var VoiceOrchestrator = class extends EventEmitter {
   // -------------------------------------------------------------------------
   handleInterruption() {
     if (this._state !== "speaking") return;
-    logger35.info("Interruption triggered");
+    logger36.info("Interruption triggered");
     this.stopSpeaking();
     this.emit("interruption");
+    getTelemetry()?.incrementCounter(MetricNames.VOICE_INTERRUPTIONS, 1, { source: "orchestrator" });
     this.speechListener?.resume();
     this.setState("listening");
   }