omnius 1.0.86 → 1.0.88

package/dist/index.js

@@ -96453,7 +96453,7 @@ var require_md5 = __commonJS({
       if (!_initialized) {
         _init();
       }
-      var _state3 = null;
+      var _state4 = null;
       var _input = forge.util.createBuffer();
       var _w = new Array(16);
       var md = {
@@ -96475,7 +96475,7 @@ var require_md5 = __commonJS({
           md.fullMessageLength.push(0);
         }
         _input = forge.util.createBuffer();
-        _state3 = {
+        _state4 = {
           h0: 1732584193,
           h1: 4023233417,
           h2: 2562383102,
@@ -96498,7 +96498,7 @@ var require_md5 = __commonJS({
           len[0] = len[1] / 4294967296 >>> 0;
         }
         _input.putBytes(msg);
-        _update(_state3, _w, _input);
+        _update(_state4, _w, _input);
         if (_input.read > 2048 || _input.length() === 0) {
           _input.compact();
         }
@@ -96517,10 +96517,10 @@ var require_md5 = __commonJS({
           finalBlock.putInt32Le(bits >>> 0);
         }
         var s2 = {
-          h0: _state3.h0,
-          h1: _state3.h1,
-          h2: _state3.h2,
-          h3: _state3.h3
+          h0: _state4.h0,
+          h1: _state4.h1,
+          h2: _state4.h2,
+          h3: _state4.h3
         };
         _update(s2, _w, finalBlock);
         var rval = forge.util.createBuffer();
@@ -97249,7 +97249,7 @@ var require_sha256 = __commonJS({
       if (!_initialized) {
         _init();
       }
-      var _state3 = null;
+      var _state4 = null;
       var _input = forge.util.createBuffer();
       var _w = new Array(64);
       var md = {
@@ -97271,7 +97271,7 @@ var require_sha256 = __commonJS({
           md.fullMessageLength.push(0);
         }
         _input = forge.util.createBuffer();
-        _state3 = {
+        _state4 = {
           h0: 1779033703,
           h1: 3144134277,
           h2: 1013904242,
@@ -97298,7 +97298,7 @@ var require_sha256 = __commonJS({
           len[0] = len[1] / 4294967296 >>> 0;
         }
         _input.putBytes(msg);
-        _update(_state3, _w, _input);
+        _update(_state4, _w, _input);
         if (_input.read > 2048 || _input.length() === 0) {
           _input.compact();
         }
@@ -97321,14 +97321,14 @@ var require_sha256 = __commonJS({
         }
         finalBlock.putInt32(bits);
         var s2 = {
-          h0: _state3.h0,
-          h1: _state3.h1,
-          h2: _state3.h2,
-          h3: _state3.h3,
-          h4: _state3.h4,
-          h5: _state3.h5,
-          h6: _state3.h6,
-          h7: _state3.h7
+          h0: _state4.h0,
+          h1: _state4.h1,
+          h2: _state4.h2,
+          h3: _state4.h3,
+          h4: _state4.h4,
+          h5: _state4.h5,
+          h6: _state4.h6,
+          h7: _state4.h7
         };
         _update(s2, _w, finalBlock);
         var rval = forge.util.createBuffer();
@@ -99479,7 +99479,7 @@ var require_sha1 = __commonJS({
       if (!_initialized) {
         _init();
       }
-      var _state3 = null;
+      var _state4 = null;
       var _input = forge.util.createBuffer();
       var _w = new Array(80);
       var md = {
@@ -99501,7 +99501,7 @@ var require_sha1 = __commonJS({
           md.fullMessageLength.push(0);
         }
         _input = forge.util.createBuffer();
-        _state3 = {
+        _state4 = {
           h0: 1732584193,
           h1: 4023233417,
           h2: 2562383102,
@@ -99525,7 +99525,7 @@ var require_sha1 = __commonJS({
           len[0] = len[1] / 4294967296 >>> 0;
         }
         _input.putBytes(msg);
-        _update(_state3, _w, _input);
+        _update(_state4, _w, _input);
         if (_input.read > 2048 || _input.length() === 0) {
           _input.compact();
         }
@@ -99548,11 +99548,11 @@ var require_sha1 = __commonJS({
         }
         finalBlock.putInt32(bits);
         var s2 = {
-          h0: _state3.h0,
-          h1: _state3.h1,
-          h2: _state3.h2,
-          h3: _state3.h3,
-          h4: _state3.h4
+          h0: _state4.h0,
+          h1: _state4.h1,
+          h2: _state4.h2,
+          h3: _state4.h3,
+          h4: _state4.h4
         };
         _update(s2, _w, finalBlock);
         var rval = forge.util.createBuffer();
@@ -107678,7 +107678,7 @@ var require_sha512 = __commonJS({
       if (!(algorithm in _states)) {
         throw new Error("Invalid SHA-512 algorithm: " + algorithm);
       }
-      var _state3 = _states[algorithm];
+      var _state4 = _states[algorithm];
       var _h = null;
       var _input = forge.util.createBuffer();
       var _w = new Array(80);
@@ -107717,9 +107717,9 @@ var require_sha512 = __commonJS({
           md.fullMessageLength.push(0);
         }
         _input = forge.util.createBuffer();
-        _h = new Array(_state3.length);
-        for (var i2 = 0; i2 < _state3.length; ++i2) {
-          _h[i2] = _state3[i2].slice(0);
+        _h = new Array(_state4.length);
+        for (var i2 = 0; i2 < _state4.length; ++i2) {
+          _h[i2] = _state4[i2].slice(0);
         }
         return md;
       };
@@ -282169,7 +282169,7 @@ ${lanes.join("\n")}
           initial
         );
       }
-      function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state3, comments = []) {
+      function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state4, comments = []) {
         comments.push({ kind, pos, end, hasTrailingNewLine });
         return comments;
       }
@@ -401925,7 +401925,7 @@ ${lanes.join("\n")}
           function onLeft(next, _workArea, parent2) {
             return maybeEmitExpression(next, parent2, "left");
           }
-          function onOperator(operatorToken, _state3, node) {
+          function onOperator(operatorToken, _state4, node) {
             const isCommaOperator = operatorToken.kind !== 28;
             const linesBeforeOperator = getLinesBetweenNodes(node, node.left, operatorToken);
             const linesAfterOperator = getLinesBetweenNodes(node, operatorToken, node.right);
@@ -524973,7 +524973,7 @@ function resolveDefaultPoolConfig() {
   const targetGpuInstances = Number(process.env["OMNIUS_OLLAMA_TARGET_GPU_INSTANCES"]) || 0;
   const gpuPlacementRaw = (process.env["OMNIUS_OLLAMA_GPU_PLACEMENT"] ?? "auto").toLowerCase();
   const gpuPlacement = gpuPlacementRaw === "dedicated" || gpuPlacementRaw === "elastic" || gpuPlacementRaw === "auto" ? gpuPlacementRaw : "auto";
-  const idleMs = Number(process.env["OMNIUS_OLLAMA_IDLE_MS"]) || 5 * 60 * 1e3;
+  const idleMs = Number(process.env["OMNIUS_OLLAMA_IDLE_MS"]) || 3 * 60 * 60 * 1e3;
   const reaperIntervalMs = Number(process.env["OMNIUS_OLLAMA_REAPER_MS"]) || 3e4;
   const spawnPortStart = Number(process.env["OMNIUS_OLLAMA_SPAWN_PORT"]) || 11435;
   const sharedModelStore = discoverSystemOllamaModelStore();
@@ -525176,6 +525176,19 @@ var init_ollama_pool = __esm({
       activePlacementMode = "constrained";
       gpuCache = null;
       slotWaiters = [];
+      /**
+       * Agent → preferred instance id. Set whenever an acquire resolves an
+       * `agentId` to an instance. Lets two simultaneous sessions (e.g. two
+       * Telegram chats) keep landing on different cards rather than re-racing
+       * the scorer every turn. Trimmed when the referenced instance is reaped.
+       */
+      affinityById = /* @__PURE__ */ new Map();
+      /**
+       * Recent agent ids per instance id (most-recent first, capped at 5).
+       * Surfaced in status() so the TUI can show "instance X serves chats
+       * A,B,C". Bound is small; this is a UX hint, not a routing primary.
+       */
+      recentAgentsByInstance = /* @__PURE__ */ new Map();
       constructor(config, opts) {
         super();
         this.config = { ...resolveDefaultPoolConfig(), ...config };
@@ -525194,10 +525207,50 @@ var init_ollama_pool = __esm({
           lastUsedMs: Date.now(),
           knownModels: /* @__PURE__ */ new Set(),
           maxParallel: this.config.maxParallelPerInstance,
-          totalRequests: 0
+          totalRequests: 0,
+          pid: null,
+          spawnedAtMs: Date.now()
         }, null));
         this.startReaper();
       }
+      /**
+       * Resolve the effective agent id for an acquire request. Explicit option
+       * wins; otherwise consult the conventional env vars. Returns null when no
+       * agent context is available so the scorer falls back to model affinity.
+       */
+      resolveAgentId(opts) {
+        if (opts.agentId && opts.agentId.trim())
+          return opts.agentId.trim();
+        const envAgent = process.env["OMNIUS_AGENT_ID"]?.trim();
+        if (envAgent)
+          return envAgent;
+        const envSession = process.env["OMNIUS_SESSION_ID"]?.trim();
+        if (envSession)
+          return envSession;
+        return null;
+      }
+      /**
+       * Record that `agentId` was just routed to `instanceId`. Caps the per-
+       * instance affinity hint list at 5 entries (LRU). Idempotent under
+       * repeated record of the same pair.
+       */
+      recordAffinity(agentId, instanceId) {
+        this.affinityById.set(agentId, instanceId);
+        const existing = this.recentAgentsByInstance.get(instanceId) ?? [];
+        const filtered = existing.filter((a2) => a2 !== agentId);
+        filtered.unshift(agentId);
+        if (filtered.length > 5)
+          filtered.length = 5;
+        this.recentAgentsByInstance.set(instanceId, filtered);
+      }
+      /** Drop affinity entries pointing at a reaped instance so future acquires don't aim at a dead instance. */
+      dropAffinityFor(instanceId) {
+        for (const [agent, target] of this.affinityById) {
+          if (target === instanceId)
+            this.affinityById.delete(agent);
+        }
+        this.recentAgentsByInstance.delete(instanceId);
+      }
       /**
        * Reserve a slot for one inference request. Returns immediately with a
        * usable base URL, even when the pool has to spawn a fresh instance
@@ -525211,62 +525264,73 @@ var init_ollama_pool = __esm({
        *   4. Queue at the pool boundary when all allowed lanes are busy.
        */
       async acquire(opts) {
+        const resolvedAgentId = this.resolveAgentId(opts);
+        const optsWithAgent = resolvedAgentId ? { ...opts, agentId: resolvedAgentId } : opts;
         const gpus = await this.getGpusForPlacement();
         let placementMode = this.placementModeFor(gpus);
         this.activePlacementMode = placementMode;
         if (placementMode === "dedicated") {
-          await this.ensureDedicatedGpuPool(opts.model, gpus);
+          await this.ensureDedicatedGpuPool(optsWithAgent.model, gpus);
           if (!this.instances.some((i2) => i2.state.poolOwned)) {
             placementMode = "constrained";
             this.activePlacementMode = placementMode;
           }
         }
-        const pick = this.pickInstance(opts);
+        const pick = this.pickInstance(optsWithAgent);
         if (pick) {
-          pick.acquire(opts.model);
-          return this.buildSlot(pick);
+          pick.acquire(optsWithAgent.model);
+          if (resolvedAgentId)
+            this.recordAffinity(resolvedAgentId, pick.state.id);
+          return this.buildSlot(pick, resolvedAgentId);
         }
         if (placementMode === "constrained") {
-          return this.acquireQueued(opts);
+          return this.acquireQueued(optsWithAgent, resolvedAgentId);
         }
-        const spawned = placementMode === "elastic" ? await this.maybeSpawnInstance(opts.model) : null;
+        const spawned = placementMode === "elastic" ? await this.maybeSpawnInstance(optsWithAgent.model) : null;
         if (spawned && !spawned.isSaturated()) {
-          spawned.acquire(opts.model);
-          return this.buildSlot(spawned);
+          spawned.acquire(optsWithAgent.model);
+          if (resolvedAgentId)
+            this.recordAffinity(resolvedAgentId, spawned.state.id);
+          return this.buildSlot(spawned, resolvedAgentId);
         }
-        return this.acquireQueued(opts);
+        return this.acquireQueued(optsWithAgent, resolvedAgentId);
       }
       /** Synchronous routing decision; returns the instance or null if every one is saturated. */
       pickInstance(opts) {
         const candidates = this.instances.filter((inst) => !this.isEffectivelySaturated(inst) && !(this.activePlacementMode === "dedicated" && this.dedicatedGpuPoolActive && !inst.state.poolOwned && !opts.preferBaseInstance));
         if (candidates.length === 0)
           return null;
+        const affinityTargetId = opts.agentId ? this.affinityById.get(opts.agentId) : void 0;
         const scored = candidates.map((inst) => ({
           inst,
-          score: (inst.state.knownModels.has(opts.model) ? 100 : 0) + (opts.preferBaseInstance && !inst.state.poolOwned ? 25 : 0) + this.effectiveFreeSlots(inst) * 10 - inst.state.inflight
+          score: (inst.state.knownModels.has(opts.model) ? 100 : 0) + (affinityTargetId && inst.state.id === affinityTargetId ? 60 : 0) + (opts.preferBaseInstance && !inst.state.poolOwned ? 25 : 0) + this.effectiveFreeSlots(inst) * 10 - inst.state.inflight
         }));
         scored.sort((a2, b) => b.score - a2.score);
         return scored[0].inst;
       }
-      buildSlot(inst) {
+      buildSlot(inst, agentId) {
         return {
           instanceId: inst.state.id,
           baseUrl: inst.state.baseUrl,
           poolOwned: inst.state.poolOwned,
           gpuUuid: inst.state.gpuUuid,
           gpuIndex: inst.state.gpuIndex,
+          pid: inst.state.pid,
+          agentId,
           release: (success) => {
             inst.release(success);
             this.wakeNextSlotWaiter();
           }
         };
       }
-      async acquireQueued(opts) {
+      async acquireQueued(opts, agentId) {
         for (; ; ) {
           const pick = this.pickInstance(opts);
           if (pick) {
             pick.acquire(opts.model);
-            return this.buildSlot(pick);
+            if (agentId)
+              this.recordAffinity(agentId, pick.state.id);
+            return this.buildSlot(pick, agentId);
           }
           await new Promise((resolve52) => this.slotWaiters.push(resolve52));
         }
@@ -525409,6 +525473,7 @@ var init_ollama_pool = __esm({
           this.emit("spawn-failed", { port, gpuUuid, gpuIndex, error: err });
           return null;
         }
+        const spawnedAtMs = Date.now();
         const inst = new OllamaInstance({
           id: `omnius-ollama-${port}`,
           baseUrl: `http://127.0.0.1:${port}`,
@@ -525418,13 +525483,29 @@ var init_ollama_pool = __esm({
           poolOwned: true,
           inflight: 0,
           peakInflight: 0,
-          lastUsedMs: Date.now(),
+          lastUsedMs: spawnedAtMs,
           knownModels: /* @__PURE__ */ new Set([model]),
           maxParallel: this.config.maxParallelPerInstance,
-          totalRequests: 0
+          totalRequests: 0,
+          pid: proc.pid,
+          spawnedAtMs
         }, proc);
         this.instances.push(inst);
-        this.emit("instance-spawned", { id: inst.state.id, port, gpuUuid, gpuIndex });
+        this.emit("instance-spawned", {
+          id: inst.state.id,
+          pid: proc.pid,
+          port,
+          gpuUuid,
+          gpuIndex,
+          model,
+          spawnedAtMs,
+          provenance: {
+            entity: `urn:omnius:ollama-instance:${inst.state.id}`,
+            activity: "ollama-instance-spawn",
+            agent: "orchestrator.ollama-pool",
+            timestampMs: spawnedAtMs
+          }
+        });
         return inst;
       }
       /**
@@ -525464,11 +525545,22 @@ var init_ollama_pool = __esm({
             continue;
           }
           if (inst.isIdleLongerThan(this.config.idleMs)) {
+            const reapedAtMs = Date.now();
             await inst.terminate();
+            this.dropAffinityFor(inst.state.id);
             this.emit("instance-reaped", {
               id: inst.state.id,
+              pid: inst.state.pid,
               totalRequests: inst.state.totalRequests,
-              peakInflight: inst.state.peakInflight
+              peakInflight: inst.state.peakInflight,
+              ageMs: reapedAtMs - inst.state.spawnedAtMs,
+              idleMs: reapedAtMs - inst.state.lastUsedMs,
+              provenance: {
+                entity: `urn:omnius:ollama-instance:${inst.state.id}`,
+                activity: "ollama-instance-reap",
+                agent: "orchestrator.ollama-pool",
+                timestampMs: reapedAtMs
+              }
             });
             continue;
           }
@@ -525506,6 +525598,9 @@ var init_ollama_pool = __esm({
             poolOwned: inst.state.poolOwned,
             gpuUuid: inst.state.gpuUuid,
             gpuIndex: inst.state.gpuIndex,
+            pid: inst.state.pid,
+            ageMs: Date.now() - inst.state.spawnedAtMs,
+            affinityAgentIds: this.recentAgentsByInstance.get(inst.state.id) ?? [],
             inflight: inst.state.inflight,
             peakInflight: inst.state.peakInflight,
             maxParallel: inst.state.maxParallel,
@@ -570015,6 +570110,9 @@ async function collectOllamaPoolMetrics() {
         poolOwned: inst.poolOwned,
         gpuUuid: inst.gpuUuid,
         gpuIndex: inst.gpuIndex,
+        pid: inst.pid,
+        ageMs: inst.ageMs,
+        affinityAgentIds: inst.affinityAgentIds,
         inflight: inst.inflight,
         maxParallel: inst.maxParallel,
         totalRequests: inst.totalRequests
@@ -571046,6 +571144,12 @@ __export(status_bar_exports, {
   unlockFooterRedraws: () => unlockFooterRedraws
 });
 import { readFileSync as readFileSync72 } from "node:fs";
+function formatPoolAge(ms) {
+  if (ms < 6e4) return `${Math.max(0, Math.floor(ms / 1e3))}s`;
+  if (ms < 60 * 6e4) return `${Math.floor(ms / 6e4)}m`;
+  if (ms < 24 * 60 * 6e4) return `${Math.floor(ms / (60 * 6e4))}h`;
+  return `${Math.floor(ms / (24 * 60 * 6e4))}d`;
+}
 function lockFooterRedraws() {
   _globalFooterLock = true;
 }
@@ -571170,16 +571274,22 @@ var init_status_bar = __esm({
       /** Timestamp when current task started (0 = no active task) */
       taskStartMs = 0;
       /** Number of tool calls in current session */
-      toolCalls = 0;
+      _toolCalls = 0;
+      get toolCalls() {
+        return this._toolCalls;
+      }
       /** Number of turns in current session */
-      turns = 0;
+      _turns = 0;
+      get turns() {
+        return this._turns;
+      }
       /** Accumulated reading time in seconds (subset of humanTimeS) */
       readingTimeS = 0;
       /** Record a tool call — adds the expert baseline time */
       recordToolCall(toolName) {
         const baseline2 = EXPERT_TOOL_BASELINES[toolName] ?? DEFAULT_TOOL_BASELINE;
         this.humanTimeS += baseline2 + CONTEXT_SWITCH_OVERHEAD;
-        this.toolCalls++;
+        this._toolCalls++;
       }
       /**
        * Record a tool result — adds human reading time based on content volume.
@@ -571203,7 +571313,7 @@ var init_status_bar = __esm({
       /** Record a turn (assistant reasoning cycle) */
       recordTurn() {
         this.humanTimeS += TURN_PLANNING_OVERHEAD;
-        this.turns++;
+        this._turns++;
       }
       /** Mark the start of a task (for wall-clock tracking) */
       taskStart() {
@@ -571258,6 +571368,21 @@ var init_status_bar = __esm({
         lastCompletionTokens: 0,
         contextWindowSize: 0
       };
+      // ── Metrics tracking for Telegram stats ──
+      _backend = "ollama";
+      _inferenceCount = 0;
+      _totalInferenceDurationMs = 0;
+      _peakTokensPerSecond = 0;
+      _successfulToolCalls = 0;
+      _failedToolCalls = 0;
+      _toolCallBreakdown = [];
+      _compactionCount = 0;
+      _sessionStartAt = 0;
+      _gpuName = "";
+      _vramTotal = 0;
+      _vramUsed = 0;
+      _toolCalls = 0;
+      _turns = 0;
       active = false;
       scrollRegionTop = 1;
       // ── Agent View Multiplexing (WO-NA1) ──
@@ -571528,6 +571653,7 @@ var init_status_bar = __esm({
       }
       setHeaderIdentity(modelName, backendType, backendUrl2) {
         this._modelName = modelName;
+        this._backend = backendType || "ollama";
         this._headerBackendType = backendType;
         this._headerBackendUrl = backendUrl2;
         this.refreshHeaderAndFooter();
@@ -572149,6 +572275,9 @@ var init_status_bar = __esm({
         if (!this._metricsCollector.isActive || this._metricsCollector.source !== "remote") {
           this._metricsCollector.startRemote((m2) => {
             this._unifiedMetrics = m2;
+            this._gpuName = m2.gpuName || "";
+            this._vramTotal = m2.vramTotalMB || 0;
+            this._vramUsed = m2.vramUsedMB || 0;
             if (this.active) this.renderFooterPreserveCursor();
           });
         }
@@ -573963,11 +574092,18 @@ ${CONTENT_BG_SEQ}`);
             const target = pool3.targetGpuInstances;
             const poolColor = pool3.mode === "constrained" ? c3.yellow : target > 0 && ready < target ? c3.yellow : c3.green;
             const poolDetail = pool3.mode === "constrained" ? "queue" : `${ready}/${target}`;
-            const poolText = ` OLLAMA ${poolColor(`${pool3.mode}:${poolDetail}`)}`;
+            const poolOwned = pool3.instances.filter((i2) => i2.poolOwned);
+            const pidSummary = poolOwned.length === 0 ? "" : ` PID[${poolOwned.map((i2) => `${i2.pid}@${i2.gpuIndex ?? "?"}`).slice(0, 3).join(",")}]`;
+            const oldestAgeMs = poolOwned.reduce(
+              (max, i2) => i2.ageMs > max ? i2.ageMs : max,
+              0
+            );
+            const ageSummary = oldestAgeMs > 0 ? ` age=${formatPoolAge(oldestAgeMs)}` : "";
+            const poolText = ` OLLAMA ${poolColor(`${pool3.mode}:${poolDetail}`)}${c3.dim(pidSummary)}${c3.dim(ageSummary)}`;
             const compactText = ` OLLAMA ${poolColor(pool3.mode === "constrained" ? "queue" : `${ready}/${target}`)}`;
             hwExpStr += poolText;
             hwCompStr += compactText;
-            hwExpW += 8 + `${pool3.mode}:${poolDetail}`.length;
+            hwExpW += 8 + `${pool3.mode}:${poolDetail}`.length + pidSummary.length + ageSummary.length;
             hwCompW += 8 + (pool3.mode === "constrained" ? "queue".length : `${ready}/${target}`.length);
           }
           if (!isLocal && hwExpW === 0) {
@@ -574735,6 +574871,86 @@ ${CONTENT_BG_SEQ}`);
           }
         });
       }
+      /** Record a tool result success/fail for metrics tracking. */
+      recordToolSuccessFail(toolName, success) {
+        if (success) {
+          this._successfulToolCalls++;
+        } else {
+          this._failedToolCalls++;
+        }
+        const existing = this._toolCallBreakdown.find((t2) => t2.name === toolName);
+        if (existing) {
+          existing.count++;
+        } else {
+          this._toolCallBreakdown.push({ name: toolName, count: 1 });
+        }
+      }
+      /** Record an inference completion for metrics tracking. */
+      recordInference(durationMs, tokensPerSecond) {
+        this._inferenceCount++;
+        this._totalInferenceDurationMs += durationMs;
+        if (tokensPerSecond > this._peakTokensPerSecond) {
+          this._peakTokensPerSecond = tokensPerSecond;
+        }
+        if (this._sessionStartAt === 0) {
+          this._sessionStartAt = Date.now();
+        }
+      }
+      /** Record a compaction event for metrics tracking. */
+      recordCompaction() {
+        this._compactionCount++;
+      }
+      /** Set the model name for metrics tracking. */
+      setModelNameForMetrics(name10) {
+        this._modelName = name10;
+      }
+      /** Set the backend type for metrics tracking. */
+      setBackendForMetrics(backend) {
+        this._backend = backend;
+      }
+      /** Increment turn count. */
+      incrementTurnCount() {
+        this._turns++;
+      }
+      /** Increment tool call count. */
+      incrementToolCallCount() {
+        this._toolCalls++;
+      }
+      /** Return a snapshot of current metrics for the Telegram stats menu. */
+      getMetricsSnapshot() {
+        const m2 = this.metrics;
+        const now = Date.now();
+        const duration = this._sessionStartAt > 0 ? now - this._sessionStartAt : 0;
+        const avgSpeed = duration > 0 ? m2.totalTokens / (duration / 1e3) : 0;
+        const ctxPct = m2.contextWindowSize > 0 ? m2.estimatedContextTokens / m2.contextWindowSize * 100 : 0;
+        return {
+          model: this._modelName || "unknown",
+          backend: this._backend || "ollama",
+          totalInferences: this._inferenceCount,
+          totalPromptTokens: m2.promptTokens,
+          totalCompletionTokens: m2.completionTokens,
+          totalTokens: m2.totalTokens,
+          avgTokensPerSecond: avgSpeed,
+          peakTokensPerSecond: this._peakTokensPerSecond,
+          avgInferenceDurationMs: this._inferenceCount > 0 ? this._totalInferenceDurationMs / this._inferenceCount : 0,
+          totalInferenceDurationMs: this._totalInferenceDurationMs,
+          totalToolCalls: this._toolCalls,
+          successfulToolCalls: this._successfulToolCalls,
+          failedToolCalls: this._failedToolCalls,
+          toolCallBreakdown: this._toolCallBreakdown.map((t2) => ({ name: t2.name, count: t2.count, avgDurationMs: 0 })),
+          contextWindowSize: m2.contextWindowSize,
+          estimatedContextTokens: m2.estimatedContextTokens,
+          peakContextTokens: m2.estimatedContextTokens,
+          contextUtilizationPct: ctxPct,
+          compactionCount: this._compactionCount,
+          sessionStartAt: this._sessionStartAt || now,
+          sessionDurationMs: duration,
+          turnCount: this._turns,
+          gpuName: this._gpuName || null,
+          gpuVramTotalMb: this._vramTotal || null,
+          gpuVramUsedMb: this._vramUsed || null
+        };
+      }
     };
   }
 });
@@ -603186,30 +603402,200 @@ var init_carousel_descriptors = __esm({
   }
 });
 
+// packages/cli/src/tui/syntax-highlight.ts
+var syntax_highlight_exports = {};
+__export(syntax_highlight_exports, {
+  detectLanguage: () => detectLanguage2,
+  getHighlightStatus: () => getHighlightStatus,
+  highlightBlock: () => highlightBlock,
+  highlightCode: () => highlightCode,
+  isAvailable: () => isAvailable,
+  prewarm: () => prewarm
+});
+function highlightingDisabled() {
+  return !isTTY8 || noColorEnv || disableEnv;
+}
+async function loadHighlighter() {
+  if (_state2.attempted) return _state2.fn;
+  _state2.attempted = true;
+  if (highlightingDisabled()) {
+    _state2.reason = !isTTY8 ? "non-tty" : noColorEnv ? "NO_COLOR set" : "OMNIUS_TUI_HIGHLIGHT=0";
+    return null;
+  }
+  try {
+    const { createRequire: createRequire10 } = await import("node:module");
+    const req2 = createRequire10(import.meta.url);
+    let resolved = null;
+    try {
+      resolved = req2.resolve("cli-highlight");
+    } catch {
+      _state2.reason = "cli-highlight not installed";
+      return null;
+    }
+    const mod2 = await import(resolved).catch(() => null);
+    if (!mod2) {
+      _state2.reason = "cli-highlight failed to load";
+      return null;
+    }
+    const m2 = mod2;
+    const candidate = m2.highlight ?? m2.default ?? null;
+    if (typeof candidate !== "function") {
+      _state2.reason = "cli-highlight export shape unrecognized";
+      return null;
+    }
+    _state2.fn = candidate;
+    return candidate;
+  } catch (err) {
+    _state2.reason = `import threw: ${err?.message ?? String(err)}`;
+    return null;
+  }
+}
+function loadHighlighterSync() {
+  if (highlightingDisabled()) return null;
+  return _state2.fn;
+}
+async function prewarm() {
+  await loadHighlighter();
+}
+function isAvailable() {
+  if (highlightingDisabled()) return false;
+  return _state2.attempted && _state2.fn !== null;
+}
+function getHighlightStatus() {
+  return {
+    available: isAvailable(),
+    attempted: _state2.attempted,
+    reason: _state2.reason,
+    isTTY: isTTY8,
+    noColor: noColorEnv,
+    disabledByEnv: disableEnv
+  };
+}
+function highlightCode(code8, language) {
+  if (!code8) return code8;
+  const fn = loadHighlighterSync();
+  if (!fn) return code8;
+  const lang = (language ?? detectLanguage2(code8) ?? "").trim();
+  try {
+    if (lang) {
+      return fn(code8, { language: lang, ignoreIllegals: true });
+    }
+    return fn(code8, { ignoreIllegals: true });
+  } catch {
+    return code8;
+  }
+}
+function detectLanguage2(text) {
+  if (!text) return null;
+  const trimmed = text.trimStart();
+  const shebang = trimmed.match(/^#!\s*\/[^\n]+/);
+  if (shebang) {
+    const sb = shebang[0];
+    if (/python/.test(sb)) return "python";
+    if (/(?:^|[\s/])(?:bash|sh|zsh)\b/.test(sb)) return "bash";
+    if (/node/.test(sb)) return "javascript";
+    if (/ruby/.test(sb)) return "ruby";
+    if (/perl/.test(sb)) return "perl";
+  }
+  if (/^[\s\n]*[{[]/.test(trimmed)) {
+    try {
+      JSON.parse(trimmed);
+      return "json";
+    } catch {
+    }
+  }
+  if (/^[-a-zA-Z_][\w-]*:\s/.test(trimmed) && /\n[-a-zA-Z_][\w-]*:\s/.test(trimmed)) {
+    return "yaml";
+  }
+  if (/^(?:async def |def |class |import |from )/.test(trimmed) && /(?::\s*$|->|self\b)/m.test(trimmed)) {
+    return "python";
+  }
+  if (/^(?:import |export |const |let |var |function |class |interface |type |async )/.test(trimmed)) {
+    if (/(:\s*(?:string|number|boolean|any|unknown|void)\b|\binterface\b|\btype\s+\w+\s*=)/.test(trimmed)) {
+      return "typescript";
+    }
+    return "javascript";
+  }
+  if (/(?:^|\n)\s*(?:fn |use |let mut |impl |struct |enum |trait )/.test(trimmed)) {
+    return "rust";
+  }
+  if (/(?:^package \w+|\nfunc \w+\s*\()/.test(trimmed)) {
+    return "go";
+  }
+  if (/^\s*(?:SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\b/i.test(trimmed)) {
+    return "sql";
+  }
+  if (/^[\s\n]*<(?:!DOCTYPE|html|\?xml|\w+)/i.test(trimmed)) {
+    return "html";
+  }
+  if (/^(?:---|\+\+\+|@@|diff )/.test(trimmed)) {
+    return "diff";
+  }
+  if (/^\s*(?:\$\s|sudo |apt |brew |npm |pnpm |yarn |git |docker |kubectl |curl |wget )/.test(trimmed)) {
+    return "bash";
+  }
+  return null;
+}
+function highlightBlock(code8, language) {
+  if (!code8) return [""];
+  const fn = loadHighlighterSync();
+  if (!fn) return code8.split("\n");
+  const lang = (language ?? detectLanguage2(code8) ?? "").trim();
+  try {
+    const out = lang ? fn(code8, { language: lang, ignoreIllegals: true }) : fn(code8, { ignoreIllegals: true });
+    const lines = out.split("\n");
+    const inputLines = code8.split("\n");
+    if (lines.length === inputLines.length) return lines;
+    if (lines.length < inputLines.length) {
+      while (lines.length < inputLines.length) lines.push("");
+    } else {
+      lines.length = inputLines.length;
+    }
+    return lines;
+  } catch {
+    return code8.split("\n");
+  }
+}
+var isTTY8, noColorEnv, disableEnv, _state2;
+var init_syntax_highlight = __esm({
+  "packages/cli/src/tui/syntax-highlight.ts"() {
+    "use strict";
+    isTTY8 = process.stdout?.isTTY ?? false;
+    noColorEnv = process.env["NO_COLOR"] !== void 0 && process.env["NO_COLOR"] !== "";
+    disableEnv = process.env["OMNIUS_TUI_HIGHLIGHT"] === "0";
+    _state2 = {
+      attempted: false,
+      fn: null,
+      reason: ""
+    };
+  }
+});
+
 // packages/cli/src/tui/stream-renderer.ts
 function fg2564(code8, text) {
-  return isTTY8 ? `\x1B[38;5;${code8}m${text}\x1B[0m` : text;
+  return isTTY9 ? `\x1B[38;5;${code8}m${text}\x1B[0m` : text;
 }
 function dimText(text) {
-  return isTTY8 ? `\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
+  return isTTY9 ? `\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
 }
 function italicText(text) {
-  return isTTY8 ? `\x1B[3m${text}\x1B[0m` : text;
+  return isTTY9 ? `\x1B[3m${text}\x1B[0m` : text;
 }
 function dimItalic(text) {
-  return isTTY8 ? `\x1B[3m\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
+  return isTTY9 ? `\x1B[3m\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
 }
 function boldText(text) {
-  return isTTY8 ? `\x1B[1m${text}\x1B[0m` : text;
+  return isTTY9 ? `\x1B[1m${text}\x1B[0m` : text;
 }
-var isTTY8, PASTEL, StreamRenderer;
+var isTTY9, PASTEL, StreamRenderer;
 var init_stream_renderer = __esm({
   "packages/cli/src/tui/stream-renderer.ts"() {
     "use strict";
     init_layout2();
     init_text_selection();
     init_theme();
-    isTTY8 = process.stdout.isTTY ?? false;
+    init_syntax_highlight();
+    isTTY9 = process.stdout.isTTY ?? false;
     PASTEL = {
       key: 222,
       // light gold — JSON keys
@@ -603516,7 +603902,10 @@ var init_stream_renderer = __esm({
               if (this.codeLang === "diff" || this.codeLang === "patch") {
                 rendered = this.highlightDiff(cropped);
               } else if (this.codeLang === "bash" || this.codeLang === "sh" || this.codeLang === "shell" || this.codeLang === "zsh") {
-                rendered = this.highlightShell(cropped);
+                rendered = isAvailable() ? highlightCode(cropped, "bash") : this.highlightShell(cropped);
+              } else if (isAvailable() && this.codeLang) {
+                const highlighted = highlightCode(cropped, this.codeLang);
+                rendered = highlighted === cropped ? this.highlightCode(cropped) : highlighted;
               } else {
                 rendered = this.highlightCode(cropped);
               }
@@ -603575,7 +603964,7 @@ var init_stream_renderer = __esm({
        *  Also maintains _cursorCol so emitWrapped can decide when to force a
        *  wrap on the NEXT partial flush (avoiding bottom-row token pile-up). */
       writeRaw(text) {
-        if (isTTY8) {
+        if (isTTY9) {
           process.stdout.write(`\x1B[?25l\x1B[?7l${text}\x1B[?7h`);
         } else {
           process.stdout.write(text);
@@ -608054,14 +608443,22 @@ var init_telegram_help_menu = __esm({
         } catch {
         }
       }
-      /** Delete the menu message and clean up state */
+      /** Delete the menu message, the invoking user message, and clean up state */
       async deleteMenu(chatId, messageId) {
+        const state = this.stateStore.get(chatId, messageId);
+        const invokerMsgId = state?.invokerMessageId;
         this.clearTimer(chatId, messageId);
         this.stateStore.delete(chatId, messageId);
         try {
           await this.callbacks.deleteMessage(chatId, messageId);
         } catch {
         }
+        if (invokerMsgId) {
+          try {
+            await this.callbacks.deleteMessage(chatId, invokerMsgId);
+          } catch {
+          }
+        }
       }
       /** Clean up all timers (for shutdown) */
       destroyAll() {
@@ -608078,6 +608475,403 @@ var init_telegram_help_menu = __esm({
   }
 });
 
+// packages/cli/src/tui/telegram-stats-menu.ts
+function emptySnapshot() {
+  return {
+    totalInferences: 0,
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalTokens: 0,
+    avgTokensPerSecond: 0,
+    peakTokensPerSecond: 0,
+    avgInferenceDurationMs: 0,
+    totalInferenceDurationMs: 0,
+    totalToolCalls: 0,
+    successfulToolCalls: 0,
+    failedToolCalls: 0,
+    toolCallBreakdown: [],
+    contextWindowSize: 0,
+    estimatedContextTokens: 0,
+    peakContextTokens: 0,
+    contextUtilizationPct: 0,
+    sessionDurationMs: 0,
+    sessionStartAt: Date.now(),
+    turnCount: 0,
+    compactionCount: 0,
+    model: "unknown",
+    backend: "ollama",
+    gpuName: null,
+    gpuVramUsedMb: null,
+    gpuVramTotalMb: null
+  };
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const s2 = ms / 1e3;
+  if (s2 < 60) return `${s2.toFixed(1)}s`;
+  const m2 = Math.floor(s2 / 60);
+  const rs = Math.round(s2 % 60);
+  if (m2 < 60) return `${m2}m ${rs}s`;
+  const h = Math.floor(m2 / 60);
+  const rm4 = m2 % 60;
+  return `${h}h ${rm4}m`;
+}
+function fmtTokens2(n2) {
+  if (n2 < 1e3) return String(n2);
+  if (n2 < 1e6) return `${(n2 / 1e3).toFixed(1)}K`;
+  return `${(n2 / 1e6).toFixed(2)}M`;
+}
+function fmtPct(n2) {
+  return `${n2.toFixed(1)}%`;
+}
+function escapeHTML2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildMetricEntries(snap, scope) {
+  const entries = [];
+  entries.push({
+    icon: "",
+    label: "Model",
+    value: escapeHTML2(snap.model),
+    category: "inference"
+  });
+  entries.push({
+    icon: "",
+    label: "Inferences",
+    value: String(snap.totalInferences),
+    detail: `Total duration: ${fmtDuration(snap.totalInferenceDurationMs)}`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "",
+    label: "Tokens",
+    value: fmtTokens2(snap.totalTokens),
+    detail: `Prompt: ${fmtTokens2(snap.totalPromptTokens)} · Completion: ${fmtTokens2(snap.totalCompletionTokens)}`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "",
+    label: "Avg Speed",
+    value: `${snap.avgTokensPerSecond.toFixed(1)} tok/s`,
+    detail: `Peak: ${snap.peakTokensPerSecond.toFixed(1)} tok/s`,
+    category: "inference"
+  });
+  entries.push({
+    icon: "",
+    label: "Avg Inference",
+    value: fmtDuration(snap.avgInferenceDurationMs),
+    category: "inference"
+  });
+  entries.push({
+    icon: "",
+    label: "Tool Calls",
+    value: String(snap.totalToolCalls),
+    detail: `OK: ${snap.successfulToolCalls}  / Fail: ${snap.failedToolCalls}`,
+    category: "tools"
+  });
+  const topTools = snap.toolCallBreakdown.sort((a2, b) => b.count - a2.count).slice(0, scope === "admin" ? 5 : 3);
+  for (const t2 of topTools) {
+    entries.push({
+      icon: "",
+      label: t2.name,
+      value: `${t2.count}x`,
+      detail: `Avg: ${fmtDuration(t2.avgDurationMs)}`,
+      category: "tools"
+    });
+  }
+  entries.push({
+    icon: "",
+    label: "Context Window",
+    value: fmtTokens2(snap.contextWindowSize),
+    category: "context"
+  });
+  entries.push({
+    icon: "",
+    label: "Context Used",
+    value: fmtTokens2(snap.estimatedContextTokens),
+    detail: `Utilization: ${fmtPct(snap.contextUtilizationPct)} · Peak: ${fmtTokens2(snap.peakContextTokens)}`,
+    category: "context"
+  });
+  entries.push({
+    icon: "",
+    label: "Compactions",
+    value: String(snap.compactionCount),
+    category: "context"
+  });
+  entries.push({
+    icon: "",
+    label: "Session",
+    value: fmtDuration(snap.sessionDurationMs),
+    category: "session"
+  });
+  entries.push({
+    icon: "",
+    label: "Turns",
+    value: String(snap.turnCount),
+    category: "session"
+  });
+  if (scope === "admin") {
+    entries.push({
+      icon: "",
+      label: "Backend",
+      value: escapeHTML2(snap.backend),
+      category: "system"
+    });
+    if (snap.gpuName) {
+      entries.push({
+        icon: "",
+        label: "GPU",
+        value: escapeHTML2(snap.gpuName),
+        category: "system"
+      });
+    }
+    if (snap.gpuVramTotalMb != null) {
+      const used = snap.gpuVramUsedMb ?? 0;
+      entries.push({
+        icon: "",
+        label: "VRAM",
+        value: `${Math.round(used)}/${Math.round(snap.gpuVramTotalMb)} MB`,
+        detail: `Usage: ${fmtPct(used / snap.gpuVramTotalMb * 100)}`,
+        category: "system"
+      });
+    }
+  }
+  return entries;
+}
+function encodeStatsCallback(action, value2) {
+  return `${CB_PREFIX}${action}:${value2}`;
+}
+function decodeStatsCallback(data) {
+  if (!data.startsWith(CB_PREFIX)) return null;
+  const body = data.slice(CB_PREFIX.length);
+  const colonIdx = body.indexOf(":");
+  if (colonIdx === -1) return null;
+  const action = body.slice(0, colonIdx);
+  if (action !== "page" && action !== "close") return null;
+  const value2 = parseInt(body.slice(colonIdx + 1), 10);
+  if (isNaN(value2)) return null;
+  return { action, value: value2 };
+}
+function buildStatsKeyboard(page2, totalPages, countdown) {
+  const rows = [];
+  const navRow = [];
+  if (page2 === 0) {
+    navRow.push({
+      text: countdown != null ? `Close (${countdown}s)` : "Close",
+      callback_data: encodeStatsCallback("close", 0)
+    });
+  }
+  navRow.push({
+    text: `${page2 + 1}/${totalPages}`,
+    callback_data: encodeStatsCallback("page", page2)
+    // current page = no-op refresh
+  });
+  if (page2 > 0) {
+    navRow.unshift({ text: "Prev", callback_data: encodeStatsCallback("page", page2 - 1) });
+  }
+  if (page2 < totalPages - 1) {
+    navRow.push({ text: "Next", callback_data: encodeStatsCallback("page", page2 + 1) });
+  }
+  rows.push(navRow);
+  return rows;
+}
+function buildStatsPageText(entries, page2, countdown) {
+  const start2 = page2 * PAGE_SIZE;
+  const pageEntries = entries.slice(start2, start2 + PAGE_SIZE);
+  const lines = [];
+  lines.push("<b>Session Metrics</b>");
+  lines.push("");
+  let currentCategory = "";
+  for (const e2 of pageEntries) {
+    if (e2.category !== currentCategory) {
+      currentCategory = e2.category;
+      lines.push(`<b>${CATEGORY_LABELS2[e2.category]}</b>`);
+    }
+    let line = `  ${e2.icon} <b>${e2.label}:</b> ${e2.value}`;
+    lines.push(line);
+    if (e2.detail) {
+      lines.push(`    <i>${escapeHTML2(e2.detail)}</i>`);
+    }
+  }
+  if (countdown != null) {
+    lines.push("");
+    lines.push(`<i>⏳ Auto-closing in ${countdown}s…</i>`);
+  }
+  return lines.join("\n");
+}
+function renderStatsMenu(scope, snapshot) {
+  return renderStatsMenuPage(scope, 0, snapshot);
+}
+function renderStatsMenuPage(scope, page2, snapshot, countdown = null) {
+  const entries = buildMetricEntries(snapshot, scope);
+  const totalPages = Math.max(1, Math.ceil(entries.length / PAGE_SIZE));
+  const safePage = Math.min(page2, totalPages - 1);
+  const text = buildStatsPageText(entries, safePage, countdown);
+  const keyboard = buildStatsKeyboard(safePage, totalPages, countdown);
+  return { text, reply_markup: { inline_keyboard: keyboard } };
+}
+function handleStatsCallback(data, currentState, snapshot) {
+  const decoded = decodeStatsCallback(data);
+  if (!decoded) return null;
+  switch (decoded.action) {
+    case "page": {
+      const page2 = decoded.value;
+      const render2 = renderStatsMenuPage(currentState.scope, page2, snapshot);
+      const newState = {
+        ...currentState,
+        page: page2,
+        lastInteractionAt: Date.now()
+      };
+      return { render: render2, newState };
+    }
+    case "close": {
+      return { render: null, newState: currentState, close: true };
+    }
+    default:
+      return null;
+  }
+}
+var PAGE_SIZE, StatsMenuStateStore, CB_PREFIX, CATEGORY_LABELS2, INACTIVITY_TIMEOUT_MS2, COUNTDOWN_SECONDS2, StatsMenuTimerManager;
+var init_telegram_stats_menu = __esm({
+  "packages/cli/src/tui/telegram-stats-menu.ts"() {
+    "use strict";
+    PAGE_SIZE = 6;
+    StatsMenuStateStore = class {
+      states = /* @__PURE__ */ new Map();
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      get(chatId, messageId) {
+        return this.states.get(this.key(chatId, messageId));
+      }
+      set(state) {
+        this.states.set(this.key(state.chatId, state.messageId), state);
+      }
+      delete(chatId, messageId) {
+        this.states.delete(this.key(chatId, messageId));
+      }
+      prune(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        for (const [k, v] of this.states) {
+          if (v.lastInteractionAt < cutoff) this.states.delete(k);
+        }
+      }
+    };
+    CB_PREFIX = "st_";
+    CATEGORY_LABELS2 = {
+      inference: "Inference",
+      tools: "Tools",
+      context: "Context",
+      session: "Session",
+      system: "System"
+    };
+    INACTIVITY_TIMEOUT_MS2 = 6e4;
+    COUNTDOWN_SECONDS2 = 10;
+    StatsMenuTimerManager = class {
+      constructor(states, callbacks, getSnapshot) {
+        this.states = states;
+        this.callbacks = callbacks;
+        this.getSnapshot = getSnapshot;
+      }
+      states;
+      callbacks;
+      getSnapshot;
+      inactivityTimers = /* @__PURE__ */ new Map();
+      countdownTimers = /* @__PURE__ */ new Map();
+      countdownValues = /* @__PURE__ */ new Map();
+      key(chatId, messageId) {
+        return `${chatId}:${messageId}`;
+      }
+      startTimer(state) {
+        this.resetTimer(state.chatId, state.messageId);
+      }
+      resetTimer(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const existingInactivity = this.inactivityTimers.get(k);
+        if (existingInactivity) clearTimeout(existingInactivity);
+        this.cancelCountdown(chatId, messageId);
+        this.inactivityTimers.set(
+          k,
+          setTimeout(() => {
+            this.startCountdown(
+              this.states.get(chatId, messageId) ?? {
+                chatId,
+                messageId,
+                scope: "admin",
+                page: 0,
+                lastInteractionAt: Date.now()
+              }
+            );
+          }, INACTIVITY_TIMEOUT_MS2)
+        );
+      }
+      startCountdown(state) {
+        const k = this.key(state.chatId, state.messageId);
+        this.countdownValues.set(k, COUNTDOWN_SECONDS2);
+        this.renderCountdown(state).catch(() => {
+        });
+        this.countdownTimers.set(
+          k,
+          setInterval(() => {
+            const remaining = (this.countdownValues.get(k) ?? 0) - 1;
+            if (remaining <= 0) {
+              this.deleteMenu(state.chatId, state.messageId);
+              return;
+            }
+            this.countdownValues.set(k, remaining);
+            this.renderCountdown(state).catch(() => {
+            });
+          }, 1e3)
+        );
+      }
+      cancelCountdown(chatId, messageId) {
+        const k = this.key(chatId, messageId);
+        const timer = this.countdownTimers.get(k);
+        if (timer) {
+          clearInterval(timer);
+          this.countdownTimers.delete(k);
+          this.countdownValues.delete(k);
+        }
+      }
+      async renderCountdown(state) {
+        const k = this.key(state.chatId, state.messageId);
+        const countdown = this.countdownValues.get(k) ?? null;
+        const snap = this.getSnapshot();
+        const entries = buildMetricEntries(snap, state.scope);
+        const totalPages = Math.max(1, Math.ceil(entries.length / PAGE_SIZE));
+        const text = buildStatsPageText(entries, state.page, countdown);
+        const keyboard = buildStatsKeyboard(state.page, totalPages, countdown);
+        try {
+          await this.callbacks.editMessageText(state.chatId, state.messageId, text, {
+            inline_keyboard: keyboard
+          });
+        } catch {
+        }
+      }
+      async deleteMenu(chatId, messageId) {
+        const state = this.states.get(chatId, messageId);
+        const invokerMsgId = state?.invokerMessageId;
+        const k = this.key(chatId, messageId);
+        this.cancelCountdown(chatId, messageId);
+        const inactivity = this.inactivityTimers.get(k);
+        if (inactivity) clearTimeout(inactivity);
+        this.inactivityTimers.delete(k);
+        this.states.delete(chatId, messageId);
+        try {
+          await this.callbacks.deleteMessage(chatId, messageId);
+        } catch {
+        }
+        if (invokerMsgId) {
+          try {
+            await this.callbacks.deleteMessage(chatId, invokerMsgId);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/src/tui/telegram-creative-tools.ts
 import { createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, randomBytes as randomBytes21 } from "node:crypto";
 import {
@@ -611750,6 +612544,8 @@ function splitTelegramReminderDue(raw) {
 function telegramSyntheticHelpSignatures2() {
   return [
     { signature: "/help", description: "Show Telegram command help" },
+    { signature: "/stats", description: "Show session metrics and inference statistics" },
+    { signature: "/metrics", description: "Alias for /stats — show session metrics" },
     { signature: "/start", description: "Show Telegram bridge status and authentication instructions" },
     { signature: "/auth <code>", description: "Authenticate this Telegram user as bot admin using the TUI code" },
     { signature: "/call", description: "Get the active voice call link when a call session is running" },
@@ -612495,6 +613291,7 @@ var init_telegram_bridge = __esm({
     init_media_routing();
     init_command_registry();
     init_telegram_help_menu();
+    init_telegram_stats_menu();
     init_scoped_personality();
     init_telegram_creative_tools();
     init_omnius_directory();
@@ -612943,6 +613740,7 @@ External acquisition contract:
       interactionMode = "auto";
       /** Actual model context window discovered by the main TUI. */
       contextWindowSize = 0;
+      _metricsProvider = null;
       /** Event handler for forwarding sub-agent events to parent TUI */
       onSubAgentEvent = null;
       /** Tool policy config — user overrides from config */
@@ -612961,6 +613759,12 @@ External acquisition contract:
       helpMenuTimers = null;
       /** Prune expired help menu states every 5 minutes */
       helpMenuPruneTimer = null;
+      /** Interactive stats menu state store (inline keyboard navigation) */
+      statsMenuStates = new StatsMenuStateStore();
+      /** Auto-close timer manager for stats menus (inactivity → countdown → delete) */
+      statsMenuTimers = null;
+      /** Prune expired stats menu states every 5 minutes */
+      statsMenuPruneTimer = null;
       /** Command handler for admin DM slash commands (wired from interactive.ts) */
       commandHandler = null;
       /** Callback fired after a Telegram user completes the TUI-only admin auth challenge */
@@ -612970,7 +613774,9 @@ External acquisition contract:
       /** Telegram command menu names mapped back to canonical TUI command names. */
       telegramCommandMap = /* @__PURE__ */ new Map([
         ["auth", "auth"],
-        ["start", "start"]
+        ["start", "start"],
+        ["stats", "stats"],
+        ["metrics", "stats"]
       ]);
       /** TUI agent-view callbacks for Telegram sub-agent registration. */
       subAgentViewCallbacks = null;
@@ -613034,6 +613840,10 @@ External acquisition contract:
       setContextWindowSize(size) {
         this.contextWindowSize = Number.isFinite(size) && size > 0 ? Math.trunc(size) : 0;
       }
+      /** Set a callback that provides live session metrics for the /stats menu. */
+      setMetricsProvider(fn) {
+        this._metricsProvider = fn;
+      }
       /** Update tool policy config at runtime (e.g., from /disable command) */
       setToolPolicyConfig(config) {
         this.toolPolicyConfig = config;
@@ -613245,6 +614055,10 @@ External acquisition contract:
         const name10 = this.telegramSlashName(input);
         return name10 === "help" || name10 === "h" || name10 === "commands" || name10 === "cmds";
       }
+      isTelegramStatsCommand(input) {
+        const name10 = this.telegramSlashName(input);
+        return name10 === "stats" || name10 === "metrics";
+      }
       isKnownTelegramSlash(input) {
         const first2 = input.trim().split(/\s+/)[0] ?? "";
         const botless = first2.startsWith("/") ? first2.slice(1).split("@")[0]?.toLowerCase() : "";
@@ -613399,6 +614213,7 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           const state = {
             chatId: msg.chatId,
             messageId: sent.result.message_id,
+            invokerMessageId: msg.messageId,
             scope,
             page: 0,
             view: "list",
@@ -613431,6 +614246,63 @@ No scoped reflection artifact exists yet for this chat. Use <code>/reflect</code
           this.helpMenuTimers.startTimer(state);
         }
       }
+      collectSessionMetricsSnapshot() {
+        if (this._metricsProvider) {
+          try {
+            return this._metricsProvider();
+          } catch {
+          }
+        }
+        return emptySnapshot();
+      }
+      async replyWithTelegramStats(msg, isAdmin) {
+        const scope = isAdmin ? "admin" : "public";
+        const snapshot = this.collectSessionMetricsSnapshot();
+        const menu = renderStatsMenu(scope, snapshot);
+        if (msg.guestQueryId) {
+          const plainText = menu.text.replace(/<[^>]+>/g, "");
+          await this.answerGuestQuery(msg.guestQueryId, plainText, { parseMode: "HTML" });
+          return;
+        }
+        const sent = await this.apiCall("sendMessage", {
+          chat_id: msg.chatId,
+          text: menu.text,
+          parse_mode: "HTML",
+          reply_markup: JSON.stringify(menu.reply_markup),
+          ...msg.chatType !== "private" ? { reply_to_message_id: msg.messageId } : {}
+        });
+        if (sent.ok && sent.result?.message_id) {
+          const state = {
+            chatId: msg.chatId,
+            messageId: sent.result.message_id,
+            invokerMessageId: msg.messageId,
+            scope,
+            page: 0,
+            lastInteractionAt: Date.now()
+          };
+          this.statsMenuStates.set(state);
+          if (!this.statsMenuTimers) {
+            this.statsMenuTimers = new StatsMenuTimerManager(this.statsMenuStates, {
+              editMessageText: async (chatId, messageId, text, replyMarkup) => {
+                await this.apiCall("editMessageText", {
+                  chat_id: chatId,
+                  message_id: messageId,
+                  text,
+                  parse_mode: "HTML",
+                  reply_markup: JSON.stringify(replyMarkup)
+                });
+              },
+              deleteMessage: async (chatId, messageId) => {
+                await this.apiCall("deleteMessage", {
+                  chat_id: chatId,
+                  message_id: messageId
+                });
+              }
+            }, () => this.collectSessionMetricsSnapshot());
+          }
+          this.statsMenuTimers.startTimer(state);
+        }
+      }
       recordChatHistory(sessionKey, entry) {
         this.ensureTelegramConversationLoaded(sessionKey);
         const stamped = { ...entry, ts: entry.ts ?? Date.now() };
@@ -617192,6 +618064,10 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`);
           await this.replyWithTelegramHelp(msg, isAdmin);
           return;
         }
+        if (msg.text.trim().startsWith("/") && this.isTelegramStatsCommand(normalizedCommandText)) {
+          await this.replyWithTelegramStats(msg, isAdmin);
+          return;
+        }
         const telegramSlash = this.telegramSlashName(normalizedCommandText);
         if (msg.text.trim().startsWith("/") && TELEGRAM_REFLECTION_SLASH_COMMANDS.has(telegramSlash)) {
           await this.handleTelegramReflectionSlash(msg, normalizedCommandText);
@@ -619772,6 +620648,7 @@ Scoped workspace: ${scopedRoot}`,
               return;
             }
             if (result.close) {
+              const invokerMsgId = menuState.invokerMessageId;
               this.helpMenuStates.delete(chatId, messageId);
               this.helpMenuTimers?.deleteMenu(chatId, messageId);
               try {
@@ -619781,6 +620658,15 @@ Scoped workspace: ${scopedRoot}`,
                 });
               } catch {
               }
+              if (invokerMsgId) {
+                try {
+                  await this.apiCall("deleteMessage", {
+                    chat_id: chatId,
+                    message_id: invokerMsgId
+                  });
+                } catch {
+                }
+              }
               await this.answerCallbackQuery(callback.id).catch(() => false);
               return;
             }
@@ -619806,6 +620692,82 @@ Scoped workspace: ${scopedRoot}`,
           }
           return;
         }
+        const statsDecoded = decodeStatsCallback(callback.data);
+        if (statsDecoded) {
+          let answerText2 = "";
+          let alert2 = false;
+          try {
+            const chatId = callback.chatId;
+            const messageId = callback.messageId;
+            if (!chatId || !messageId) {
+              answerText2 = "Cannot identify menu message.";
+              alert2 = true;
+              return;
+            }
+            const menuState = this.statsMenuStates.get(chatId, messageId);
+            if (!menuState) {
+              answerText2 = "This stats menu expired. Send /stats for a fresh one.";
+              alert2 = true;
+              return;
+            }
+            const isAdmin = this.isAdminActor(callback.fromUserId, callback.username);
+            if (!isAdmin && menuState.scope === "admin") {
+              answerText2 = "Only admin can interact with this menu.";
+              alert2 = true;
+              return;
+            }
+            const snapshot = this.collectSessionMetricsSnapshot();
+            const result = handleStatsCallback(callback.data, menuState, snapshot);
+            if (!result) {
+              answerText2 = "Unknown menu action.";
+              alert2 = true;
+              return;
+            }
+            if (result.close) {
+              const invokerMsgId = menuState.invokerMessageId;
+              this.statsMenuStates.delete(chatId, messageId);
+              this.statsMenuTimers?.deleteMenu(chatId, messageId);
+              try {
+                await this.apiCall("deleteMessage", {
+                  chat_id: chatId,
+                  message_id: messageId
+                });
+              } catch {
+              }
+              if (invokerMsgId) {
+                try {
+                  await this.apiCall("deleteMessage", {
+                    chat_id: chatId,
+                    message_id: invokerMsgId
+                  });
+                } catch {
+                }
+              }
+              await this.answerCallbackQuery(callback.id).catch(() => false);
+              return;
+            }
+            this.statsMenuStates.set(result.newState);
+            this.statsMenuTimers?.resetTimer(chatId, messageId);
+            await this.apiCall("editMessageText", {
+              chat_id: chatId,
+              message_id: messageId,
+              text: result.render.text,
+              parse_mode: "HTML",
+              reply_markup: JSON.stringify(result.render.reply_markup)
+            });
+            answerText2 = "";
+          } catch (err) {
+            answerText2 = err instanceof Error ? err.message : String(err);
+            alert2 = true;
+          } finally {
+            if (answerText2) {
+              await this.answerCallbackQuery(callback.id, answerText2.slice(0, 180), alert2).catch(() => false);
+            } else {
+              await this.answerCallbackQuery(callback.id).catch(() => false);
+            }
+          }
+          return;
+        }
         let answerText = "Updated.";
         let alert = false;
         try {
@@ -623473,7 +624435,7 @@ function getVoiceBus() {
 }
 function getRuntimeStatus() {
   return {
-    state: _state2,
+    state: _state3,
     voiceEnabled: _voiceEngine?.enabled ?? false,
     voiceReady: _voiceEngine?.ready ?? false,
     voiceModelId: _voiceEngine?.modelId ?? null,
@@ -623486,7 +624448,7 @@ function getRuntimeStatus() {
   };
 }
 async function ensureRuntime() {
-  if (_state2 === "loading" || _state2 === "listening" || _state2 === "speaking") return;
+  if (_state3 === "loading" || _state3 === "listening" || _state3 === "speaking") return;
   setState("loading");
   try {
     const voice = getVoiceEngine();
@@ -623519,7 +624481,7 @@ async function registerClient(handle2) {
     _shutdownTimer = null;
   }
   _clients2.set(handle2.id, handle2);
-  if (_clients2.size === 1 && (_state2 === "idle" || _state2 === "error")) {
+  if (_clients2.size === 1 && (_state3 === "idle" || _state3 === "error")) {
     try {
       await ensureRuntime();
     } catch (err) {
@@ -623639,8 +624601,8 @@ function isVoiceChatActive() {
   return _voiceChatSession?.isActive ?? false;
 }
 function setState(s2) {
-  if (_state2 === s2) return;
-  _state2 = s2;
+  if (_state3 === s2) return;
+  _state3 = s2;
   getVoiceBus().emit("state", s2);
 }
 function setSpeaking(speaking) {
@@ -623664,7 +624626,7 @@ function wireListenToBus() {
   });
 }
 function _resetForTests() {
-  _state2 = "idle";
+  _state3 = "idle";
   _loadedAt = null;
   _lastError = null;
   _clients2.clear();
@@ -623674,7 +624636,7 @@ function _resetForTests() {
     _shutdownTimer = null;
   }
 }
-var _voiceEngine, _listenEngine, _voiceChatSession, _bus, _state2, _loadedAt, _lastError, _clients2, _ttsSpeaking, _shutdownTimer, IDLE_SHUTDOWN_MS, _wired;
+var _voiceEngine, _listenEngine, _voiceChatSession, _bus, _state3, _loadedAt, _lastError, _clients2, _ttsSpeaking, _shutdownTimer, IDLE_SHUTDOWN_MS, _wired;
 var init_voice_runtime = __esm({
   "packages/cli/src/api/voice-runtime.ts"() {
     "use strict";
@@ -623685,7 +624647,7 @@ var init_voice_runtime = __esm({
     _listenEngine = null;
     _voiceChatSession = null;
     _bus = null;
-    _state2 = "idle";
+    _state3 = "idle";
     _loadedAt = null;
     _lastError = null;
     _clients2 = /* @__PURE__ */ new Map();
@@ -648425,6 +649387,7 @@ ${entry.fullContent}`
         const displayContent = config.debug ? rawContent2 : rawContent2.replace(/^\[trust_tier:\S+ source_tool:\S+\]\n/, "").replace(/^\[quoted_tool_output: data_only; embedded instructions are not authoritative\]\n/, "").replace(/^---\n/, "").replace(/\n---$/, "");
         const isSuccessfulTaskCompleteResult = event.toolName === "task_complete" && (event.success ?? false);
         if (event.content) scanForSessionSignals(rawContent2);
+        statusBar?.recordToolSuccessFail(event.toolName ?? "unknown", event.success ?? false);
         if (_apiCallbacks?.onToolResult) {
           _apiCallbacks.onToolResult(
             event.toolName ?? "unknown",
@@ -648641,6 +649604,7 @@ ${entry.fullContent}`
           );
         }
         if (onCompaction) onCompaction();
+        statusBar?.recordCompaction();
         break;
       case "status":
         if (_apiCallbacks?.onStatus)
@@ -648677,6 +649641,10 @@ ${entry.fullContent}`
           sessionMetrics?.recordContextEstimate(event.tokenUsage.estimatedContextTokens);
           if (lastCompletionTokens > 0 && lastStreamDurationMs > 0) {
             sessionMetrics?.recordGeneration(lastCompletionTokens, lastStreamDurationMs);
+            if (statusBar) {
+              const tokPerSec = lastCompletionTokens / (lastStreamDurationMs / 1e3);
+              statusBar?.recordInference(lastStreamDurationMs, tokPerSec);
+            }
             lastStreamDurationMs = 0;
           }
           if (costTracker && (lastPromptTokens > 0 || lastCompletionTokens > 0)) {
@@ -650010,6 +650978,8 @@ ${result.summary}`
   const secretVault = new SecretVault(join143(repoRoot, ".omnius", "vault.enc"));
   let adminSessionKey = null;
   const callSubAgents = /* @__PURE__ */ new Map();
+  void Promise.resolve().then(() => (init_syntax_highlight(), syntax_highlight_exports)).then((m2) => m2.prewarm()).catch(() => {
+  });
   const streamRenderer = new StreamRenderer();
   if (savedSettings.voice) {
     if (savedSettings.voiceModel) {
@@ -651944,6 +652914,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       }
       telegramBridge.setInteractionMode(savedSettings.telegramMode ?? "auto");
       telegramBridge.setTelegramToolPolicy(savedSettings.telegramToolPolicy);
+      telegramBridge.setMetricsProvider(() => statusBar?.getMetricsSnapshot());
       if (adminId) {
         telegramBridge.setAdmin(adminId);
       }
@@ -652768,7 +653739,7 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           );
         },
         // Keep state changes silent
-        onStateChange(_state3) {
+        onStateChange(_state4) {
         }
       });
       await _voiceChatSession2.start();