omnius 1.0.133 → 1.0.135

package/dist/index.js

@@ -1328,6 +1328,893 @@ var init_tool_executor = __esm({
   }
 });
 
+// packages/execution/dist/model-broker.js
+import { EventEmitter } from "node:events";
+import { totalmem, freemem } from "node:os";
+import { exec } from "node:child_process";
+function ramSnapshotMB() {
+  const total = Math.round(totalmem() / (1024 * 1024));
+  const free = Math.round(freemem() / (1024 * 1024));
+  return { total, free, used: total - free };
+}
+async function vramSnapshotMB() {
+  if (_nvSmiAvailable === false)
+    return null;
+  try {
+    const out = await new Promise((resolve55, reject) => {
+      exec("nvidia-smi --query-gpu=memory.total,memory.used,memory.free --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve55(stdout));
+    });
+    _nvSmiAvailable = true;
+    let total = 0, used = 0, free = 0;
+    for (const line of out.trim().split("\n")) {
+      const parts = line.split(",").map((s2) => s2.trim());
+      if (parts.length < 3)
+        continue;
+      total += parseInt(parts[0] ?? "0", 10) || 0;
+      used += parseInt(parts[1] ?? "0", 10) || 0;
+      free += parseInt(parts[2] ?? "0", 10) || 0;
+    }
+    if (total <= 0)
+      return null;
+    return { total, used, free };
+  } catch {
+    _nvSmiAvailable = false;
+    return null;
+  }
+}
+function getModelBroker() {
+  return ModelBroker.getInstance();
+}
+var DEFAULT_RAM_HEADROOM_MB, DEFAULT_VRAM_HEADROOM_MB, DEFAULT_IDLE_EVICT_MS, DEFAULT_POLL_MS, DEFAULT_INFLIGHT_WAIT_MS, DEFAULT_SLOT_CAPACITY, DEFAULT_QUEUE_CAPACITY, THROUGHPUT_EMA_ALPHA, THROUGHPUT_INITIAL_TPS, STUCK_INFLIGHT_DIAGNOSTIC_MS, ModelBroker, _nvSmiAvailable;
+var init_model_broker = __esm({
+  "packages/execution/dist/model-broker.js"() {
+    "use strict";
+    DEFAULT_RAM_HEADROOM_MB = 2048;
+    DEFAULT_VRAM_HEADROOM_MB = 1024;
+    DEFAULT_IDLE_EVICT_MS = 5 * 60 * 1e3;
+    DEFAULT_POLL_MS = 4e3;
+    DEFAULT_INFLIGHT_WAIT_MS = 6e4;
+    DEFAULT_SLOT_CAPACITY = 4;
+    DEFAULT_QUEUE_CAPACITY = 50;
+    THROUGHPUT_EMA_ALPHA = 0.2;
+    THROUGHPUT_INITIAL_TPS = 25;
+    STUCK_INFLIGHT_DIAGNOSTIC_MS = 5 * 60 * 1e3;
+    ModelBroker = class _ModelBroker {
+      static _instance = null;
+      /** Loaded model registry keyed by `${host}:${name}`. */
+      _loaded = /* @__PURE__ */ new Map();
+      /** In-flight load promises keyed by `${host}:${name}`. */
+      _inflight = /* @__PURE__ */ new Map();
+      /** Fallback chains keyed by domain. */
+      _fallbacks = /* @__PURE__ */ new Map();
+      /** Cached n_ctx_train per Ollama model. */
+      _ctxTrainCache = /* @__PURE__ */ new Map();
+      /** Cached "model exists in Ollama" probes (true / false). */
+      _ollamaModelExists = /* @__PURE__ */ new Map();
+      /** Event emitter — typed via `on<K>(event: K, listener: BrokerEvents[K])`. */
+      _events = new EventEmitter();
+      /** Poll timer. */
+      _pollTimer = null;
+      /** Last full snapshot. */
+      _lastSnapshot = null;
+      /** Configured Ollama base URL. */
+      _ollamaBaseUrl = process.env["OLLAMA_HOST"] || "http://127.0.0.1:11434";
+      /** Configured thresholds (mutable for /broker tuning). */
+      ramHeadroomMB = DEFAULT_RAM_HEADROOM_MB;
+      vramHeadroomMB = DEFAULT_VRAM_HEADROOM_MB;
+      idleEvictMs = DEFAULT_IDLE_EVICT_MS;
+      /** Inference slot capacity (auto-tunes from Ollama pool size when known). */
+      slotCapacity = DEFAULT_SLOT_CAPACITY;
+      /** Maximum queue depth before queue pressure is emitted. */
+      queueCapacity = DEFAULT_QUEUE_CAPACITY;
+      // ── Inference slot tracking ─────────────────────────────────────────
+      /** Active slots keyed by slot id. */
+      _activeSlots = /* @__PURE__ */ new Map();
+      /** Reserved slots per sessionKey (1 reserved slot per active chat). */
+      _reservedBySession = /* @__PURE__ */ new Map();
+      // sessionKey -> slot id
+      /** Shared (non-reserved) queue. FIFO with priority insertion. */
+      _slotQueue = [];
+      /** Per-model throughput tracking. */
+      _throughput = /* @__PURE__ */ new Map();
+      /** Monotonic counter for slot ids. */
+      _slotIdSeq = 0;
+      static getInstance() {
+        if (!_ModelBroker._instance)
+          _ModelBroker._instance = new _ModelBroker();
+        return _ModelBroker._instance;
+      }
+      /** Reset (test-only). */
+      static resetInstance() {
+        if (_ModelBroker._instance?._pollTimer)
+          clearInterval(_ModelBroker._instance._pollTimer);
+        _ModelBroker._instance = null;
+      }
+      constructor() {
+        this.registerDefaultFallbacks();
+      }
+      // ------------------------------------------------------------------
+      // Public API — events
+      // ------------------------------------------------------------------
+      on(event, listener) {
+        this._events.on(event, listener);
+        return this;
+      }
+      off(event, listener) {
+        this._events.off(event, listener);
+        return this;
+      }
+      emit(event, ...args) {
+        this._events.emit(event, ...args);
+      }
+      // ------------------------------------------------------------------
+      // Public API — polling
+      // ------------------------------------------------------------------
+      /** Start background polling of Ollama /api/ps and nvidia-smi. */
+      startPolling(intervalMs = DEFAULT_POLL_MS) {
+        if (this._pollTimer)
+          return;
+        this._pollTimer = setInterval(() => {
+          this.pollOnce().catch(() => {
+          });
+        }, intervalMs);
+        this.pollOnce().catch(() => {
+        });
+      }
+      stopPolling() {
+        if (this._pollTimer) {
+          clearInterval(this._pollTimer);
+          this._pollTimer = null;
+        }
+      }
+      /** Configure Ollama base URL (called from cli config wiring). */
+      setOllamaBaseUrl(url) {
+        this._ollamaBaseUrl = url;
+      }
+      /** One poll cycle — refreshes /api/ps and emits snapshot. */
+      async pollOnce() {
+        await Promise.all([
+          this.refreshOllamaPs().catch(() => {
+          })
+          // VRAM total/free comes from system-metrics; broker computes its own snapshot
+        ]);
+        const snapshot = this.buildSnapshot();
+        this._lastSnapshot = snapshot;
+        this.emit("snapshot", snapshot);
+        this.checkPressure(snapshot);
+        return snapshot;
+      }
+      /** Best-known current snapshot. */
+      snapshot() {
+        return this._lastSnapshot ?? this.buildSnapshot();
+      }
+      // ------------------------------------------------------------------
+      // Public API — fallback registry
+      // ------------------------------------------------------------------
+      /** Register a fallback chain for a domain. Later entries are tried later. */
+      setFallbackChain(domain, chain) {
+        this._fallbacks.set(domain, [...chain]);
+      }
+      getFallbackChain(domain) {
+        return this._fallbacks.get(domain) ?? [];
+      }
+      // ------------------------------------------------------------------
+      // Public API — load decisioning
+      // ------------------------------------------------------------------
+      /**
+       * Pre-flight a model-load request. Always call this before allocating a model.
+       *
+       * Decisions:
+       *   - ok:                 proceed; use `effectiveNumCtx` if returned
+       *   - wait-for-inflight:  another caller is loading the same model; await `promise`
+       *   - evict:              caller should free `evictTargets` (broker calls evict
+       *                         hooks itself when possible) then retry
+       *   - degrade:            caller should reissue with `fallback`
+       *   - reject:             nothing viable — caller should error out
+       */
+      async ensureModelLoadable(spec) {
+        const key = this.keyOf(spec);
+        const inflight = this._inflight.get(key);
+        if (inflight) {
+          return { kind: "wait-for-inflight", promise: inflight.promise };
+        }
+        const existing = this._loaded.get(key);
+        if (existing) {
+          existing.lastUsedAt = Date.now();
+          return { kind: "ok", effectiveNumCtx: existing.numCtx, note: "already-loaded" };
+        }
+        let effectiveNumCtx;
+        if (spec.host === "ollama" && spec.requestedNumCtx) {
+          const trainCtx = await this.getNctxTrain(spec.name);
+          if (trainCtx && spec.requestedNumCtx > trainCtx) {
+            effectiveNumCtx = trainCtx;
+          } else {
+            effectiveNumCtx = spec.requestedNumCtx;
+          }
+        } else if (spec.host === "ollama") {
+          const trainCtx = await this.getNctxTrain(spec.name);
+          if (trainCtx)
+            effectiveNumCtx = trainCtx;
+        }
+        const estVram = spec.estimatedVramMB ?? this.estimateFootprintVramMB(spec);
+        const estRam = spec.estimatedRamMB ?? this.estimateFootprintRamMB(spec);
+        const ram = ramSnapshotMB();
+        const vram = await vramSnapshotMB();
+        const ramFitsAfter = ram.free - estRam >= this.ramHeadroomMB;
+        const vramFitsAfter = vram ? vram.free - estVram >= this.vramHeadroomMB : true;
+        if (ramFitsAfter && vramFitsAfter) {
+          const promise = Promise.resolve({ kind: "ok", effectiveNumCtx });
+          this._inflight.set(key, { startedMs: Date.now(), owner: spec.owner, promise });
+          setTimeout(() => this._inflight.delete(key), spec.loadTimeoutMs ?? DEFAULT_INFLIGHT_WAIT_MS).unref?.();
+          return { kind: "ok", effectiveNumCtx };
+        }
+        const evictTargets = this.pickEvictionCandidates({
+          needVramMB: vramFitsAfter ? 0 : estVram + this.vramHeadroomMB - (vram?.free ?? 0),
+          needRamMB: ramFitsAfter ? 0 : estRam + this.ramHeadroomMB - ram.free,
+          requestingPriority: spec.priority ?? 0,
+          requestingDomain: spec.domain
+        });
+        if (evictTargets.length > 0) {
+          return { kind: "evict", evictTargets, effectiveNumCtx };
+        }
+        const fallback = await this.findRunnableFallback(spec);
+        if (fallback) {
+          this.emit("degraded", spec, fallback, "insufficient-memory-no-evictable");
+          return { kind: "degrade", fallback, reason: "insufficient-memory-no-evictable" };
+        }
+        const reason = `insufficient resources (need ~${estRam}MB RAM, ~${estVram}MB VRAM; free ${ram.free}MB RAM, ${vram ? vram.free : "?"}MB VRAM) and no evictable / fallback models`;
+        this.emit("rejected", spec, reason);
+        return { kind: "reject", reason };
+      }
+      /**
+       * Register a model that has been successfully loaded.
+       * Callers MUST call this after a successful load so the broker can track LRU.
+       */
+      registerLoaded(model) {
+        const now = Date.now();
+        const m2 = {
+          ...model,
+          loadedAt: model.loadedAt ?? now,
+          lastUsedAt: model.lastUsedAt ?? now
+        };
+        this._loaded.set(m2.key, m2);
+        this._inflight.delete(m2.key);
+        this.emit("loaded", m2);
+        return m2;
+      }
+      /** Update last-used timestamp on every successful inference. */
+      touch(host, name10) {
+        const m2 = this._loaded.get(`${host}:${name10}`);
+        if (m2)
+          m2.lastUsedAt = Date.now();
+      }
+      /** Unregister a model (called when caller knows it has unloaded). */
+      unregisterLoaded(host, name10, reason = "caller-unloaded") {
+        const key = `${host}:${name10}`;
+        const m2 = this._loaded.get(key);
+        if (m2) {
+          this._loaded.delete(key);
+          this.emit("evicted", m2, reason);
+        }
+      }
+      /** Clear an inflight marker without registering a load (failed/aborted). */
+      clearInflight(host, name10) {
+        this._inflight.delete(`${host}:${name10}`);
+      }
+      /**
+       * Best-effort eviction of a tracked model. Returns true if the broker was
+       * able to actively unload (e.g. Ollama keep_alive=0); false if it just
+       * unregistered (caller must clean up its own subprocess).
+       */
+      async evict(host, name10, reason = "broker-evict") {
+        const key = `${host}:${name10}`;
+        const m2 = this._loaded.get(key);
+        if (!m2)
+          return false;
+        let actively = false;
+        if (host === "ollama") {
+          actively = await this.ollamaUnload(name10).catch(() => false);
+        }
+        this._loaded.delete(key);
+        this.emit("evicted", m2, reason);
+        return actively;
+      }
+      // ------------------------------------------------------------------
+      // Internal — Ollama
+      // ------------------------------------------------------------------
+      /** Fetch Ollama's runtime model list and reconcile against our registry. */
+      async refreshOllamaPs() {
+        try {
+          const res = await fetch(`${this._ollamaBaseUrl}/api/ps`, {
+            signal: AbortSignal.timeout(3e3)
+          });
+          if (!res.ok)
+            return;
+          const data = await res.json();
+          const seen = /* @__PURE__ */ new Set();
+          const now = Date.now();
+          for (const m2 of data.models ?? []) {
+            const key = `ollama:${m2.name}`;
+            seen.add(key);
+            const vramMB = Math.round((m2.size_vram ?? 0) / (1024 * 1024));
+            const ramMB = Math.round(((m2.size ?? 0) - (m2.size_vram ?? 0)) / (1024 * 1024));
+            const existing = this._loaded.get(key);
+            if (existing) {
+              existing.vramMB = vramMB || existing.vramMB;
+              existing.ramMB = ramMB || existing.ramMB;
+            } else {
+              const tracked = this.registerLoaded({
+                key,
+                name: m2.name,
+                domain: this.guessOllamaDomain(m2.name),
+                host: "ollama",
+                owner: "external-ollama",
+                vramMB,
+                ramMB,
+                priority: 0,
+                loadedAt: now,
+                lastUsedAt: now
+              });
+              void tracked;
+            }
+          }
+          for (const [key, m2] of this._loaded) {
+            if (m2.host === "ollama" && !seen.has(key)) {
+              this._loaded.delete(key);
+              this.emit("evicted", m2, "ollama-unloaded");
+            }
+          }
+        } catch {
+        }
+      }
+      /** Force Ollama to unload a model by calling /api/generate keep_alive=0. */
+      async ollamaUnload(modelName) {
+        try {
+          const res = await fetch(`${this._ollamaBaseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: modelName, keep_alive: 0 }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          return res.ok;
+        } catch {
+          return false;
+        }
+      }
+      /** Pull n_ctx_train for an Ollama model via /api/show; cached. */
+      async getNctxTrain(modelName) {
+        if (this._ctxTrainCache.has(modelName))
+          return this._ctxTrainCache.get(modelName);
+        try {
+          const res = await fetch(`${this._ollamaBaseUrl}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: modelName }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok)
+            return null;
+          const data = await res.json();
+          const info = data.model_info ?? {};
+          const arch3 = info["general.architecture"];
+          let trainCtx;
+          if (arch3 && typeof info[`${arch3}.context_length`] === "number") {
+            trainCtx = info[`${arch3}.context_length`];
+          } else {
+            for (const [k, v] of Object.entries(info)) {
+              if (k.endsWith(".context_length") && typeof v === "number") {
+                trainCtx = v;
+                break;
+              }
+            }
+          }
+          if (trainCtx && Number.isFinite(trainCtx) && trainCtx > 0) {
+            this._ctxTrainCache.set(modelName, trainCtx);
+            return trainCtx;
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      /** Probe whether a model exists in Ollama (cached). */
+      async ollamaModelExists(modelName) {
+        if (this._ollamaModelExists.has(modelName))
+          return this._ollamaModelExists.get(modelName);
+        try {
+          const res = await fetch(`${this._ollamaBaseUrl}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: modelName }),
+            signal: AbortSignal.timeout(3e3)
+          });
+          const exists2 = res.ok;
+          this._ollamaModelExists.set(modelName, exists2);
+          return exists2;
+        } catch {
+          this._ollamaModelExists.set(modelName, false);
+          return false;
+        }
+      }
+      // ------------------------------------------------------------------
+      // Internal — LRU eviction selection
+      // ------------------------------------------------------------------
+      pickEvictionCandidates(req2) {
+        const now = Date.now();
+        const sameDomainOk = (m2) => (
+          // never evict the requesting domain's only loaded model unless multiple exist
+          m2.domain !== req2.requestingDomain || this.countByDomain(req2.requestingDomain) > 1
+        );
+        const idle = (m2) => now - m2.lastUsedAt > this.idleEvictMs;
+        const evictable = [...this._loaded.values()].filter((m2) => m2.priority <= req2.requestingPriority).filter(sameDomainOk).sort((a2, b) => {
+          const aIdle = idle(a2) ? 0 : 1;
+          const bIdle = idle(b) ? 0 : 1;
+          if (aIdle !== bIdle)
+            return aIdle - bIdle;
+          return a2.lastUsedAt - b.lastUsedAt;
+        });
+        const targets = [];
+        let vramFreed = 0;
+        let ramFreed = 0;
+        for (const m2 of evictable) {
+          if (vramFreed >= req2.needVramMB && ramFreed >= req2.needRamMB)
+            break;
+          targets.push(m2);
+          vramFreed += m2.vramMB;
+          ramFreed += m2.ramMB;
+        }
+        if (vramFreed >= req2.needVramMB && ramFreed >= req2.needRamMB)
+          return targets;
+        return [];
+      }
+      countByDomain(domain) {
+        let n2 = 0;
+        for (const m2 of this._loaded.values())
+          if (m2.domain === domain)
+            n2++;
+        return n2;
+      }
+      // ------------------------------------------------------------------
+      // Internal — fallback resolution
+      // ------------------------------------------------------------------
+      async findRunnableFallback(original) {
+        const chain = this._fallbacks.get(original.domain) ?? [];
+        for (const entry of chain) {
+          if (entry.spec.host === original.host && entry.spec.name === original.name)
+            continue;
+          const ok3 = entry.available ? await Promise.resolve(entry.available()).catch(() => false) : true;
+          if (!ok3)
+            continue;
+          return { ...entry.spec, owner: original.owner };
+        }
+        return null;
+      }
+      registerDefaultFallbacks() {
+        this.setFallbackChain("vision", [
+          { spec: { name: "moondream2", domain: "vision", host: "moondream-station" }, note: "local Moondream Station REST" },
+          { spec: { name: "moondream", domain: "vision", host: "ollama", estimatedVramMB: 1800 }, note: "ollama moondream (small VRAM)" },
+          { spec: { name: "tesseract-ocr-fallback", domain: "ocr", host: "subprocess", estimatedVramMB: 0, estimatedRamMB: 100 }, note: "OCR-only — no visual reasoning" }
+        ]);
+        this.setFallbackChain("image-gen", [
+          { spec: { name: "flux1-schnell", domain: "image-gen", host: "diffusers-py", estimatedVramMB: 12e3 } },
+          { spec: { name: "sdxl-turbo", domain: "image-gen", host: "diffusers-py", estimatedVramMB: 8e3 } },
+          { spec: { name: "sd-turbo", domain: "image-gen", host: "diffusers-py", estimatedVramMB: 4e3 } }
+        ]);
+        this.setFallbackChain("music", [
+          { spec: { name: "facebook/musicgen-medium", domain: "music", host: "audiocraft", estimatedVramMB: 6e3 } },
+          { spec: { name: "facebook/musicgen-small", domain: "music", host: "audiocraft", estimatedVramMB: 3e3 } }
+        ]);
+        this.setFallbackChain("sound", [
+          { spec: { name: "cvssp/audioldm-s-full-v2", domain: "sound", host: "diffusers-py", estimatedVramMB: 4e3 } },
+          { spec: { name: "facebook/audiogen-medium", domain: "sound", host: "audiocraft", estimatedVramMB: 3e3 } }
+        ]);
+        this.setFallbackChain("asr", [
+          { spec: { name: "base", domain: "asr", host: "whisper-cli", estimatedRamMB: 800 } },
+          { spec: { name: "tiny", domain: "asr", host: "whisper-cli", estimatedRamMB: 300 } }
+        ]);
+        this.setFallbackChain("tts", [
+          { spec: { name: "piper-default", domain: "tts", host: "piper", estimatedRamMB: 200 } }
+        ]);
+      }
+      // ------------------------------------------------------------------
+      // Internal — footprint estimation
+      // ------------------------------------------------------------------
+      estimateFootprintVramMB(spec) {
+        if (spec.estimatedVramMB !== void 0)
+          return spec.estimatedVramMB;
+        switch (spec.domain) {
+          case "embedding":
+            return 300;
+          case "vision":
+            return spec.host === "moondream-station" ? 2e3 : 2500;
+          case "image-gen":
+            return 8e3;
+          case "video-gen":
+            return 12e3;
+          case "music":
+            return 4e3;
+          case "sound":
+            return 3e3;
+          case "asr":
+            return 1e3;
+          case "tts":
+            return 300;
+          case "subagent":
+            return 4e3;
+          case "ocr":
+            return 0;
+          case "chat":
+          default:
+            return 5e3;
+        }
+      }
+      estimateFootprintRamMB(spec) {
+        if (spec.estimatedRamMB !== void 0)
+          return spec.estimatedRamMB;
+        switch (spec.domain) {
+          case "ocr":
+            return 100;
+          case "tts":
+            return 200;
+          case "embedding":
+            return 500;
+          case "asr":
+            return 800;
+          case "music":
+          case "sound":
+            return 2e3;
+          case "vision":
+            return 1500;
+          case "image-gen":
+            return 4e3;
+          case "video-gen":
+            return 6e3;
+          case "subagent":
+            return 1500;
+          case "chat":
+          default:
+            return 2e3;
+        }
+      }
+      guessOllamaDomain(name10) {
+        const n2 = name10.toLowerCase();
+        if (/embed|nomic|bge|e5/.test(n2))
+          return "embedding";
+        if (/moondream|llava|vlm|vision|qwen.*vl|minicpm-v|gemma3|pixtral|cogvlm|internvl/.test(n2))
+          return "vision";
+        if (/flux|stable.diffusion|sdxl|z-image/.test(n2))
+          return "image-gen";
+        return "chat";
+      }
+      // ------------------------------------------------------------------
+      // Internal — snapshot + pressure
+      // ------------------------------------------------------------------
+      buildSnapshot() {
+        const ram = ramSnapshotMB();
+        const vram = this._lastSnapshot?.vramMB ?? null;
+        return {
+          loaded: [...this._loaded.values()],
+          inflight: [...this._inflight.entries()].map(([key, v]) => ({ key, owner: v.owner, startedMs: v.startedMs })),
+          ramMB: ram,
+          vramMB: vram,
+          lastPollAt: Date.now(),
+          slots: this.buildSlotsSnapshot()
+        };
+      }
+      buildSlotsSnapshot() {
+        const byModel = {};
+        for (const slot of this._activeSlots.values()) {
+          const k = slot.model;
+          if (!byModel[k])
+            byModel[k] = { inUse: 0, tokensPerSec: 0, samples: 0 };
+          byModel[k].inUse += 1;
+        }
+        for (const [model, tp] of this._throughput) {
+          if (!byModel[model])
+            byModel[model] = { inUse: 0, tokensPerSec: 0, samples: 0 };
+          byModel[model].tokensPerSec = tp.tokensPerSec;
+          byModel[model].samples = tp.samples;
+        }
+        return {
+          inUse: this._activeSlots.size,
+          capacity: this.slotCapacity,
+          queueDepth: this._slotQueue.length,
+          queueCapacity: this.queueCapacity,
+          byModel
+        };
+      }
+      async checkPressure(snap) {
+        if (snap.ramMB.free < this.ramHeadroomMB) {
+          this.emit("pressure", "ram", snap.ramMB.free, this.ramHeadroomMB);
+        }
+        const v = await vramSnapshotMB();
+        if (v) {
+          snap.vramMB = v;
+          if (v.free < this.vramHeadroomMB) {
+            this.emit("pressure", "vram", v.free, this.vramHeadroomMB);
+          }
+        }
+        const queueThreshold = Math.floor(this.queueCapacity * 0.8);
+        if (this._slotQueue.length >= queueThreshold) {
+          this.emit("pressure", "queue", this._slotQueue.length, queueThreshold);
+        }
+        const now = Date.now();
+        for (const slot of this._activeSlots.values()) {
+          if (now - slot.acquiredAt > STUCK_INFLIGHT_DIAGNOSTIC_MS) {
+          }
+        }
+      }
+      // ------------------------------------------------------------------
+      // Inference slot admission control (replaces timeouts)
+      // ------------------------------------------------------------------
+      /**
+       * Acquire an inference slot. Blocks (queues with backpressure) until a slot
+       * is available. Never times out — work either completes or is cancelled
+       * via the caller-provided AbortSignal before admission.
+       *
+       * Two-tier admission:
+       *   1. Reserved: 1 slot per sessionKey kept warm even when shared pool full
+       *   2. Shared: queue with FIFO+priority ordering; size-bounded by queueCapacity
+       *
+       * Backpressure: when queue exceeds 80% capacity, emit `pressure: "queue"` —
+       * upstream callers (e.g. Telegram poll loop) should slow ingress.
+       */
+      acquireInferenceSlot(spec) {
+        if (this._activeSlots.size < this.slotCapacity) {
+          return Promise.resolve(this.admitSlot(
+            spec,
+            /*reserved*/
+            false
+          ));
+        }
+        if (spec.sessionKey && !this._reservedBySession.has(spec.sessionKey) && this._activeSlots.size < this.slotCapacity + 1) {
+          const slot = this.admitSlot(
+            spec,
+            /*reserved*/
+            true
+          );
+          this._reservedBySession.set(spec.sessionKey, slot.info.id);
+          return Promise.resolve(slot);
+        }
+        return new Promise((resolve55, reject) => {
+          const entry = { spec, resolve: resolve55, reject, enqueuedAt: Date.now() };
+          if (spec.signal) {
+            const onAbort = () => {
+              const idx = this._slotQueue.indexOf(entry);
+              if (idx >= 0)
+                this._slotQueue.splice(idx, 1);
+              reject(new Error("inference slot acquisition aborted by caller signal"));
+            };
+            if (spec.signal.aborted) {
+              onAbort();
+              return;
+            }
+            spec.signal.addEventListener("abort", onAbort, { once: true });
+            entry.onSignalAbort = onAbort;
+          }
+          const prio = spec.priority ?? 0;
+          let insertAt = this._slotQueue.length;
+          for (let i2 = this._slotQueue.length - 1; i2 >= 0; i2--) {
+            const p2 = this._slotQueue[i2].spec.priority ?? 0;
+            if (p2 >= prio) {
+              insertAt = i2 + 1;
+              break;
+            }
+            if (i2 === 0)
+              insertAt = 0;
+          }
+          this._slotQueue.splice(insertAt, 0, entry);
+          const threshold = Math.floor(this.queueCapacity * 0.8);
+          if (this._slotQueue.length === threshold) {
+            this.emit("pressure", "queue", this._slotQueue.length, threshold);
+          }
+        });
+      }
+      /** Admit a slot — internal, called from acquire fast path and from drainQueue. */
+      admitSlot(spec, reserved) {
+        const id = `slot-${++this._slotIdSeq}-${Date.now().toString(36)}`;
+        const info = {
+          id,
+          model: spec.model,
+          domain: spec.domain,
+          owner: spec.owner,
+          sessionKey: spec.sessionKey,
+          acquiredAt: Date.now(),
+          promptTokens: spec.promptTokens ?? 0,
+          reserved
+        };
+        this._activeSlots.set(id, info);
+        this.emit("slotAcquired", info);
+        let released = false;
+        const broker = this;
+        return {
+          info,
+          release(outcome) {
+            if (released)
+              return;
+            released = true;
+            broker.releaseSlot(info, outcome);
+          }
+        };
+      }
+      releaseSlot(info, outcome) {
+        this._activeSlots.delete(info.id);
+        if (info.sessionKey && this._reservedBySession.get(info.sessionKey) === info.id) {
+          this._reservedBySession.delete(info.sessionKey);
+        }
+        if (outcome.ok && (outcome.completionTokens ?? 0) > 0) {
+          const wallMs = Date.now() - info.acquiredAt;
+          if (wallMs > 100) {
+            const tps = outcome.completionTokens * 1e3 / wallMs;
+            const cur = this._throughput.get(info.model) ?? {
+              tokensPerSec: THROUGHPUT_INITIAL_TPS,
+              samples: 0,
+              lastReleaseAt: 0
+            };
+            cur.tokensPerSec = cur.samples === 0 ? tps : cur.tokensPerSec * (1 - THROUGHPUT_EMA_ALPHA) + tps * THROUGHPUT_EMA_ALPHA;
+            cur.samples += 1;
+            cur.lastReleaseAt = Date.now();
+            this._throughput.set(info.model, cur);
+            this.emit("throughputUpdated", info.model, cur.tokensPerSec);
+          }
+        }
+        this.emit("slotReleased", info, outcome);
+        this.drainSlotQueue();
+      }
+      drainSlotQueue() {
+        while (this._slotQueue.length > 0 && this._activeSlots.size < this.slotCapacity) {
+          const entry = this._slotQueue.shift();
+          if (entry.onSignalAbort && entry.spec.signal) {
+            entry.spec.signal.removeEventListener("abort", entry.onSignalAbort);
+          }
+          if (entry.spec.signal?.aborted) {
+            try {
+              entry.reject(new Error("aborted before admission"));
+            } catch {
+            }
+            continue;
+          }
+          const slot = this.admitSlot(
+            entry.spec,
+            /*reserved*/
+            false
+          );
+          try {
+            entry.resolve(slot);
+          } catch {
+          }
+        }
+      }
+      /** Snapshot of throughput EMAs (for /broker and debugging). */
+      throughputByModel() {
+        const out = {};
+        for (const [model, tp] of this._throughput) {
+          out[model] = { tokensPerSec: tp.tokensPerSec, samples: tp.samples };
+        }
+        return out;
+      }
+      /** Tune the shared slot capacity at runtime (e.g. when Ollama pool resizes). */
+      setSlotCapacity(n2) {
+        this.slotCapacity = Math.max(1, Math.floor(n2));
+        this.drainSlotQueue();
+      }
+      keyOf(spec) {
+        return `${spec.host}:${spec.name}`;
+      }
+    };
+    _nvSmiAvailable = null;
+  }
+});
+
+// packages/execution/dist/broker-mediated-backend.js
+function wrapWithBroker(backend, options2) {
+  const broker = getModelBroker();
+  const clamp7 = options2.clampNumCtx !== false;
+  const wrapped = Object.create(backend);
+  wrapped.chatCompletion = async (request) => {
+    const model = backend.model || request.model || "unknown";
+    let effectiveRequest = request;
+    if (clamp7) {
+      const trainCtx = await broker.getNctxTrain(model).catch(() => null);
+      const requestedNumCtx = request.numCtx;
+      if (trainCtx && trainCtx > 0) {
+        const target = requestedNumCtx ? Math.min(requestedNumCtx, trainCtx) : Math.min(trainCtx, estimateContextNeed(request));
+        if (target > 0) {
+          effectiveRequest = { ...request, numCtx: target };
+        }
+      }
+    }
+    const promptTokens = estimatePromptTokens(request);
+    const slot = await broker.acquireInferenceSlot({
+      model,
+      domain: options2.domain,
+      owner: options2.owner,
+      sessionKey: options2.sessionKey,
+      promptTokens,
+      priority: options2.priority ?? 0
+    });
+    try {
+      const result = await backend.chatCompletion(effectiveRequest);
+      const usage = result.usage;
+      slot.release({ ok: true, completionTokens: usage?.completion_tokens ?? 0 });
+      return result;
+    } catch (err) {
+      slot.release({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      throw err;
+    }
+  };
+  if (typeof backend.chatCompletionStream === "function") {
+    const streamFn = backend.chatCompletionStream.bind(backend);
+    wrapped.chatCompletionStream = async function* (request) {
+      const model = backend.model || request.model || "unknown";
+      let effectiveRequest = request;
+      if (clamp7) {
+        const trainCtx = await broker.getNctxTrain(model).catch(() => null);
+        const requestedNumCtx = request.numCtx;
+        if (trainCtx && trainCtx > 0) {
+          const target = requestedNumCtx ? Math.min(requestedNumCtx, trainCtx) : Math.min(trainCtx, estimateContextNeed(request));
+          if (target > 0)
+            effectiveRequest = { ...request, numCtx: target };
+        }
+      }
+      const promptTokens = estimatePromptTokens(request);
+      const slot = await broker.acquireInferenceSlot({
+        model,
+        domain: options2.domain,
+        owner: options2.owner,
+        sessionKey: options2.sessionKey,
+        promptTokens,
+        priority: options2.priority ?? 0
+      });
+      let completionTokens = 0;
+      try {
+        for await (const chunk of streamFn(effectiveRequest)) {
+          const usage = chunk.usage;
+          if (usage?.completion_tokens)
+            completionTokens = usage.completion_tokens;
+          yield chunk;
+        }
+        slot.release({ ok: true, completionTokens });
+      } catch (err) {
+        slot.release({ ok: false, error: err instanceof Error ? err.message : String(err) });
+        throw err;
+      }
+    };
+  }
+  return wrapped;
+}
+function estimatePromptTokens(request) {
+  let chars = 0;
+  if (Array.isArray(request?.messages)) {
+    for (const m2 of request.messages) {
+      if (typeof m2.content === "string")
+        chars += m2.content.length;
+      else if (Array.isArray(m2.content)) {
+        for (const part of m2.content) {
+          if (typeof part?.text === "string")
+            chars += part.text.length;
+        }
+      }
+      chars += 8;
+    }
+  }
+  if (Array.isArray(request?.tools) && request.tools.length > 0) {
+    chars += request.tools.length * 600;
+  }
+  return Math.ceil(chars / 4);
+}
+function estimateContextNeed(request) {
+  const promptTokens = estimatePromptTokens(request);
+  const maxTokens = request?.maxTokens ?? 1024;
+  return Math.max(2048, promptTokens + maxTokens + 512);
+}
+var init_broker_mediated_backend = __esm({
+  "packages/execution/dist/broker-mediated-backend.js"() {
+    "use strict";
+    init_model_broker();
+  }
+});
+
 // packages/execution/dist/tools/security-classifier.js
 function classifyTool(name10) {
   for (const rule of RULES) {
@@ -19513,6 +20400,20 @@ import { existsSync as existsSync25, mkdirSync as mkdirSync10, writeFileSync as
 import { join as join28, basename as basename5, extname as extname3, resolve as resolve16 } from "node:path";
 import { homedir as homedir9 } from "node:os";
 import { execFileSync as execFileSync3, execSync as execSync15 } from "node:child_process";
+function whisperRamEstimate(model) {
+  const m2 = model.toLowerCase();
+  if (m2.includes("large"))
+    return 3200;
+  if (m2.includes("medium"))
+    return 1700;
+  if (m2.includes("small"))
+    return 800;
+  if (m2.includes("base"))
+    return 400;
+  if (m2.includes("tiny"))
+    return 200;
+  return 800;
+}
 function isTranscribable(path12) {
   const ext = extname3(path12).toLowerCase();
   return AUDIO_EXTS.has(ext) || VIDEO_EXTS.has(ext);
@@ -19582,6 +20483,7 @@ var AUDIO_EXTS, VIDEO_EXTS, MAX_TRANSCRIBE_URL_BYTES, _tcModule, _tcChecked, Tra
 var init_transcribe_tool = __esm({
   "packages/execution/dist/tools/transcribe-tool.js"() {
     "use strict";
+    init_model_broker();
     init_network_egress_policy();
     AUDIO_EXTS = /* @__PURE__ */ new Set([
       ".mp3",
@@ -19636,7 +20538,7 @@ var init_transcribe_tool = __esm({
       async execute(args) {
         const start2 = performance.now();
         const filePath = resolve16(this.workingDir, String(args["path"] ?? ""));
-        const model = String(args["model"] ?? "base");
+        let model = String(args["model"] ?? "base");
         const diarize = Boolean(args["diarize"] ?? false);
         if (!existsSync25(filePath)) {
           return {
@@ -19654,6 +20556,32 @@ var init_transcribe_tool = __esm({
             durationMs: performance.now() - start2
           };
         }
+        const broker = getModelBroker();
+        const askedModel = model;
+        let effectiveModel = model;
+        const whisperDecision = await broker.ensureModelLoadable({
+          name: askedModel,
+          domain: "asr",
+          host: "whisper-cli",
+          owner: "transcribe-file-tool",
+          estimatedRamMB: whisperRamEstimate(askedModel)
+        });
+        if (whisperDecision.kind === "degrade") {
+          effectiveModel = whisperDecision.fallback.name;
+        } else if (whisperDecision.kind === "evict") {
+          for (const target of whisperDecision.evictTargets) {
+            await broker.evict(target.host, target.name, "asr-needs-room");
+          }
+        } else if (whisperDecision.kind === "reject") {
+          return {
+            success: false,
+            output: "",
+            error: `Transcription blocked by resource broker: ${whisperDecision.reason}`,
+            durationMs: performance.now() - start2
+          };
+        }
+        if (effectiveModel !== askedModel)
+          model = effectiveModel;
         const tc = await loadTranscribeCli();
         if (!tc) {
           return this.execViaCli(filePath, model, diarize, start2);
@@ -46186,11 +47114,11 @@ var require_eventemitter3 = __commonJS({
       if (--emitter._eventsCount === 0) emitter._events = new Events();
       else delete emitter._events[evt];
     }
-    function EventEmitter14() {
+    function EventEmitter15() {
       this._events = new Events();
       this._eventsCount = 0;
     }
-    EventEmitter14.prototype.eventNames = function eventNames() {
+    EventEmitter15.prototype.eventNames = function eventNames() {
       var names = [], events, name10;
       if (this._eventsCount === 0) return names;
       for (name10 in events = this._events) {
@@ -46201,7 +47129,7 @@ var require_eventemitter3 = __commonJS({
       }
       return names;
     };
-    EventEmitter14.prototype.listeners = function listeners(event) {
+    EventEmitter15.prototype.listeners = function listeners(event) {
       var evt = prefix ? prefix + event : event, handlers = this._events[evt];
       if (!handlers) return [];
       if (handlers.fn) return [handlers.fn];
@@ -46210,13 +47138,13 @@ var require_eventemitter3 = __commonJS({
       }
       return ee;
     };
-    EventEmitter14.prototype.listenerCount = function listenerCount(event) {
+    EventEmitter15.prototype.listenerCount = function listenerCount(event) {
       var evt = prefix ? prefix + event : event, listeners = this._events[evt];
       if (!listeners) return 0;
       if (listeners.fn) return 1;
       return listeners.length;
     };
-    EventEmitter14.prototype.emit = function emit2(event, a1, a2, a3, a4, a5) {
+    EventEmitter15.prototype.emit = function emit2(event, a1, a2, a3, a4, a5) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return false;
       var listeners = this._events[evt], len = arguments.length, args, i2;
@@ -46267,13 +47195,13 @@ var require_eventemitter3 = __commonJS({
       }
       return true;
     };
-    EventEmitter14.prototype.on = function on2(event, fn, context2) {
+    EventEmitter15.prototype.on = function on2(event, fn, context2) {
       return addListener2(this, event, fn, context2, false);
     };
-    EventEmitter14.prototype.once = function once(event, fn, context2) {
+    EventEmitter15.prototype.once = function once(event, fn, context2) {
       return addListener2(this, event, fn, context2, true);
     };
-    EventEmitter14.prototype.removeListener = function removeListener2(event, fn, context2, once) {
+    EventEmitter15.prototype.removeListener = function removeListener2(event, fn, context2, once) {
       var evt = prefix ? prefix + event : event;
       if (!this._events[evt]) return this;
       if (!fn) {
@@ -46296,7 +47224,7 @@ var require_eventemitter3 = __commonJS({
       }
       return this;
     };
-    EventEmitter14.prototype.removeAllListeners = function removeAllListeners(event) {
+    EventEmitter15.prototype.removeAllListeners = function removeAllListeners(event) {
       var evt;
       if (event) {
         evt = prefix ? prefix + event : event;
@@ -46307,12 +47235,12 @@ var require_eventemitter3 = __commonJS({
       }
       return this;
     };
-    EventEmitter14.prototype.off = EventEmitter14.prototype.removeListener;
-    EventEmitter14.prototype.addListener = EventEmitter14.prototype.on;
-    EventEmitter14.prefixed = prefix;
-    EventEmitter14.EventEmitter = EventEmitter14;
+    EventEmitter15.prototype.off = EventEmitter15.prototype.removeListener;
+    EventEmitter15.prototype.addListener = EventEmitter15.prototype.on;
+    EventEmitter15.prefixed = prefix;
+    EventEmitter15.EventEmitter = EventEmitter15;
     if ("undefined" !== typeof module) {
-      module.exports = EventEmitter14;
+      module.exports = EventEmitter15;
     }
   }
 });
@@ -119084,10 +120012,10 @@ var require_wrap_handler = __commonJS({
 var require_dispatcher = __commonJS({
   "../node_modules/undici/lib/dispatcher/dispatcher.js"(exports, module) {
     "use strict";
-    var EventEmitter14 = __require("node:events");
+    var EventEmitter15 = __require("node:events");
     var WrapHandler = require_wrap_handler();
     var wrapInterceptor = (dispatch) => (opts, handler) => dispatch(opts, WrapHandler.wrap(handler));
-    var Dispatcher2 = class extends EventEmitter14 {
+    var Dispatcher2 = class extends EventEmitter15 {
       dispatch() {
         throw new Error("not implemented");
       }
@@ -126370,7 +127298,7 @@ var require_socks5_utils = __commonJS({
 var require_socks5_client = __commonJS({
   "../node_modules/undici/lib/core/socks5-client.js"(exports, module) {
     "use strict";
-    var { EventEmitter: EventEmitter14 } = __require("node:events");
+    var { EventEmitter: EventEmitter15 } = __require("node:events");
     var { Buffer: Buffer7 } = __require("node:buffer");
     var { InvalidArgumentError, Socks5ProxyError } = require_errors2();
     var { debuglog } = __require("node:util");
@@ -126413,7 +127341,7 @@ var require_socks5_client = __commonJS({
       ERROR: "error",
       CLOSED: "closed"
     };
-    var Socks5Client = class extends EventEmitter14 {
+    var Socks5Client = class extends EventEmitter15 {
       constructor(socket, options2 = {}) {
         super();
         if (!socket) {
@@ -132798,9 +133726,9 @@ var require_memory_cache_store = __commonJS({
   "../node_modules/undici/lib/cache/memory-cache-store.js"(exports, module) {
     "use strict";
     var { Writable } = __require("node:stream");
-    var { EventEmitter: EventEmitter14 } = __require("node:events");
+    var { EventEmitter: EventEmitter15 } = __require("node:events");
     var { assertCacheKey, assertCacheValue } = require_cache();
-    var MemoryCacheStore = class extends EventEmitter14 {
+    var MemoryCacheStore = class extends EventEmitter15 {
       #maxCount = 1024;
       #maxSize = 104857600;
       // 100MB
@@ -229661,7 +230589,7 @@ var init_send_ssdp_message = __esm({
 });
 
 // ../node_modules/@achingbrain/ssdp/dist/src/ssdp.js
-import { EventEmitter as EventEmitter2, on } from "node:events";
+import { EventEmitter as EventEmitter3, on } from "node:events";
 import { createRequire } from "node:module";
 var req, name8, version2, DEFAULT_SSDP_SIGNATURE, SSDP;
 var init_ssdp = __esm({
@@ -229679,7 +230607,7 @@ var init_ssdp = __esm({
     req = createRequire(import.meta.url);
     ({ name: name8, version: version2 } = req("../../package.json"));
     DEFAULT_SSDP_SIGNATURE = `node.js/${process.version.substring(1)} UPnP/1.1 ${name8}/${version2}`;
-    SSDP = class extends EventEmitter2 {
+    SSDP = class extends EventEmitter3 {
       udn;
       signature;
       sockets;
@@ -236837,7 +237765,7 @@ var require_extension2 = __commonJS({
 var require_websocket2 = __commonJS({
   "../node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter14 = __require("events");
+    var EventEmitter15 = __require("events");
     var https4 = __require("https");
     var http6 = __require("http");
     var net5 = __require("net");
@@ -236869,7 +237797,7 @@ var require_websocket2 = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket6 = class _WebSocket extends EventEmitter14 {
+    var WebSocket6 = class _WebSocket extends EventEmitter15 {
       /**
        * Create a new `WebSocket`.
        *
@@ -237866,7 +238794,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "../node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter14 = __require("events");
+    var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
     var { createHash: createHash31 } = __require("crypto");
@@ -237879,7 +238807,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer4 = class extends EventEmitter14 {
+    var WebSocketServer4 = class extends EventEmitter15 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -254016,6 +254944,7 @@ var DEFAULT_DIFFUSERS_IMAGE_MODEL, DEFAULT_OLLAMA_IMAGE_MODEL, LEGACY_SDXL_TURBO
 var init_image_generate = __esm({
   "packages/execution/dist/tools/image-generate.js"() {
     "use strict";
+    init_model_broker();
     init_venv_paths();
     init_model_store();
     DEFAULT_DIFFUSERS_IMAGE_MODEL = "Efficient-Large-Model/SANA1.5_1.6B_1024px_diffusers";
@@ -254830,6 +255759,28 @@ if __name__ == "__main__":
         const requestedBackend = args["backend"] ? String(args["backend"]) : this.defaultBackend;
         const seed = optionalNumberArg(args["seed"]);
         const candidates = imageGenerationFallbackCandidates(requestedModel, requestedBackend, generationFallbackEnabled(args));
+        const broker = getModelBroker();
+        const firstCandidate = candidates[0];
+        if (firstCandidate) {
+          const decision2 = await broker.ensureModelLoadable({
+            name: firstCandidate.model,
+            domain: "image-gen",
+            host: firstCandidate.backend === "ollama" ? "ollama" : "diffusers-py",
+            owner: "image-generate-tool"
+          });
+          if (decision2.kind === "evict") {
+            for (const target of decision2.evictTargets) {
+              await broker.evict(target.host, target.name, "image-gen-needs-room");
+            }
+          } else if (decision2.kind === "reject") {
+            return {
+              success: false,
+              output: "",
+              error: `Image generation blocked by resource broker: ${decision2.reason}`,
+              durationMs: performance.now() - start2
+            };
+          }
+        }
         try {
           return await this.generateCandidateLadder({ candidates, prompt, args, seed, start: start2 });
         } catch (err) {
@@ -256270,6 +257221,7 @@ var DEFAULT_SOUND_MODEL, DEFAULT_MUSIC_MODEL, DIFFUSERS_AUDIO_PACKAGES, TRANSFOR
 var init_audio_generate = __esm({
   "packages/execution/dist/tools/audio-generate.js"() {
     "use strict";
+    init_model_broker();
     init_venv_paths();
     init_model_store();
     DEFAULT_SOUND_MODEL = "cvssp/audioldm-s-full-v2";
@@ -257217,6 +258169,28 @@ if __name__ == "__main__":
         const candidates = audioGenerationFallbackCandidates(kind, requestedModel, requestedBackend, generationFallbackEnabled2(args));
         const seed = optionalNumberArg2(args["seed"]);
         const playback = playbackRequested(args);
+        const broker = getModelBroker();
+        const firstCandidate = candidates[0];
+        if (firstCandidate) {
+          const decision2 = await broker.ensureModelLoadable({
+            name: firstCandidate.model,
+            domain: kind === "music" ? "music" : "sound",
+            host: firstCandidate.backend === "audiocraft" ? "audiocraft" : firstCandidate.backend === "tangoflux" ? "tangoflux" : firstCandidate.backend === "transformers" ? "diffusers-py" : "diffusers-py",
+            owner: `audio-generate-tool/${kind}`
+          });
+          if (decision2.kind === "evict") {
+            for (const target of decision2.evictTargets) {
+              await broker.evict(target.host, target.name, `${kind}-gen-needs-room`);
+            }
+          } else if (decision2.kind === "reject") {
+            return {
+              success: false,
+              output: "",
+              error: `${kind === "music" ? "Music" : "Sound"} generation blocked by resource broker: ${decision2.reason}`,
+              durationMs: performance.now() - start2
+            };
+          }
+        }
         try {
           return await this.generateCandidateLadder({ kind, candidates, prompt, args, seed, playback, start: start2 });
         } catch (err) {
@@ -258160,6 +259134,7 @@ var DEFAULT_DIFFUSERS_VIDEO_MODEL, SANA_VIDEO_480P_MODEL, SANA_VIDEO_720P_MODEL,
 var init_video_generate = __esm({
   "packages/execution/dist/tools/video-generate.js"() {
     "use strict";
+    init_model_broker();
     init_venv_paths();
     init_model_store();
     DEFAULT_DIFFUSERS_VIDEO_MODEL = "Efficient-Large-Model/SANA-Video_2B_480p";
@@ -259497,6 +260472,28 @@ if __name__ == "__main__":
         const withAudio = booleanArg3(args["with_audio"], false);
         const audioInput = typeof args["audio_input"] === "string" && args["audio_input"].trim() ? String(args["audio_input"]).trim() : void 0;
         const candidates = videoGenerationFallbackCandidates(requestedModel, requestedBackend, inferredKind, generationFallbackEnabled3(args), { preferNativeAudioVideo: withAudio || Boolean(audioInput) });
+        const broker = getModelBroker();
+        const firstCandidate = candidates[0];
+        if (firstCandidate) {
+          const decision2 = await broker.ensureModelLoadable({
+            name: firstCandidate.model,
+            domain: "video-gen",
+            host: firstCandidate.backend === "comfyui" ? "comfyui" : "diffusers-py",
+            owner: "video-generate-tool"
+          });
+          if (decision2.kind === "evict") {
+            for (const target of decision2.evictTargets) {
+              await broker.evict(target.host, target.name, "video-gen-needs-room");
+            }
+          } else if (decision2.kind === "reject") {
+            return {
+              success: false,
+              output: "",
+              error: `Video generation blocked by resource broker: ${decision2.reason}`,
+              durationMs: performance.now() - start2
+            };
+          }
+        }
         if (candidates.length === 0) {
           return {
             success: false,
@@ -261097,6 +262094,7 @@ var moondreamClient, moondreamError, stationProcess, hfPointUnavailable, IMAGE_E
 var init_vision = __esm({
   "packages/execution/dist/tools/vision.js"() {
     "use strict";
+    init_model_broker();
     moondreamClient = null;
     moondreamError = null;
     stationProcess = null;
@@ -261195,14 +262193,43 @@ var init_vision = __esm({
               };
             }
           }
+          const broker = getModelBroker();
+          const moondreamDecision = await broker.ensureModelLoadable({
+            name: "moondream2",
+            domain: "vision",
+            host: "moondream-station",
+            owner: "vision-tool"
+          });
+          const forceDegradeToOllama = moondreamDecision.kind === "degrade" && moondreamDecision.fallback.host === "ollama";
+          const forceReject = moondreamDecision.kind === "reject" && this._activeModelHasVision !== true;
           let client = null;
-          try {
-            client = await getMoondreamClient();
-          } catch {
+          if (!forceDegradeToOllama) {
+            try {
+              client = await getMoondreamClient();
+            } catch {
+            }
           }
           if (client) {
+            broker.registerLoaded({
+              key: "moondream-station:moondream2",
+              name: "moondream2",
+              domain: "vision",
+              host: "moondream-station",
+              owner: "vision-tool",
+              vramMB: 2e3,
+              ramMB: 1500,
+              priority: 1
+            });
             return await this.runMoondream(client, buffer2, filename, action, prompt, length4, start2);
           }
+          if (forceReject) {
+            return {
+              success: false,
+              output: "",
+              error: `Vision blocked by resource broker: ${moondreamDecision.kind === "reject" ? moondreamDecision.reason : "insufficient memory"}`,
+              durationMs: performance.now() - start2
+            };
+          }
           const ollamaResult = await this.tryOllamaVision(buffer2, filename, action, prompt, length4, start2);
           if (ollamaResult)
             return ollamaResult;
@@ -261300,7 +262327,41 @@ Coordinates are normalized (0-1). Multiply by image width/height for pixel value
       async tryOllamaVision(buffer2, filename, action, prompt, length4, start2) {
         const ollamaHost = process.env["OLLAMA_HOST"] || "http://127.0.0.1:11434";
         const envModel = process.env["OLLAMA_VISION_MODEL"];
-        const model = envModel || (this._activeModelHasVision && this._activeModel ? this._activeModel : "moondream");
+        let model = envModel || (this._activeModelHasVision && this._activeModel ? this._activeModel : "moondream");
+        const broker = getModelBroker();
+        const decision2 = await broker.ensureModelLoadable({
+          name: model,
+          domain: "vision",
+          host: "ollama",
+          owner: "vision-tool/ollama",
+          requestedNumCtx: 2048,
+          estimatedVramMB: 2e3
+        });
+        let numCtx;
+        if (decision2.kind === "reject")
+          return null;
+        if (decision2.kind === "degrade") {
+          model = decision2.fallback.name;
+        } else if (decision2.kind === "evict") {
+          for (const target of decision2.evictTargets) {
+            await broker.evict(target.host, target.name, "vision-needs-room");
+          }
+          numCtx = decision2.effectiveNumCtx;
+        } else if (decision2.kind === "ok") {
+          numCtx = decision2.effectiveNumCtx;
+        } else if (decision2.kind === "wait-for-inflight") {
+          const inner = await decision2.promise;
+          if (inner.kind === "ok")
+            numCtx = inner.effectiveNumCtx;
+          else if (inner.kind === "degrade")
+            model = inner.fallback.name;
+          else if (inner.kind === "reject")
+            return null;
+        }
+        if (numCtx === void 0) {
+          const trainCtx = await broker.getNctxTrain(model);
+          numCtx = trainCtx && trainCtx > 0 ? Math.min(trainCtx, 4096) : 2048;
+        }
         const imageBase64 = buffer2.toString("base64");
         let ollamaPrompt;
         switch (action) {
@@ -261323,7 +262384,7 @@ Coordinates are normalized (0-1). Multiply by image width/height for pixel value
           let res = await fetch(`${ollamaHost}/api/generate`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ model, prompt: ollamaPrompt, images: [imageBase64], stream: false }),
+            body: JSON.stringify({ model, prompt: ollamaPrompt, images: [imageBase64], stream: false, options: { num_ctx: numCtx } }),
             signal: AbortSignal.timeout(6e4)
           });
           if (!res.ok && model === "moondream") {
@@ -261335,15 +262396,18 @@ Coordinates are normalized (0-1). Multiply by image width/height for pixel value
                 res = await fetch(`${ollamaHost}/api/generate`, {
                   method: "POST",
                   headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({ model, prompt: ollamaPrompt, images: [imageBase64], stream: false }),
+                  body: JSON.stringify({ model, prompt: ollamaPrompt, images: [imageBase64], stream: false, options: { num_ctx: numCtx } }),
                   signal: AbortSignal.timeout(6e4)
                 });
               } catch {
               }
             }
           }
-          if (!res.ok)
+          if (!res.ok) {
+            broker.clearInflight("ollama", model);
             return null;
+          }
+          broker.touch("ollama", model);
           const data = await res.json();
           const response = data.response || "";
           if (!response)
@@ -513030,7 +514094,7 @@ var init_dist4 = __esm({
 });
 
 // packages/execution/dist/tools/code-graph-events.js
-import { EventEmitter as EventEmitter3 } from "node:events";
+import { EventEmitter as EventEmitter4 } from "node:events";
 function emitIndexed(payload) {
   codeGraphEvents.publish({ type: "indexed", timestamp: Date.now(), ...payload });
 }
@@ -513048,7 +514112,7 @@ var init_code_graph_events = __esm({
   "packages/execution/dist/tools/code-graph-events.js"() {
     "use strict";
     MAX_RECENT = 256;
-    CodeGraphEventBus = class extends EventEmitter3 {
+    CodeGraphEventBus = class extends EventEmitter4 {
       ring = [];
       constructor() {
         super();
@@ -519570,6 +520634,7 @@ var init_full_sub_agent = __esm({
   "packages/execution/dist/tools/full-sub-agent.js"() {
     "use strict";
     init_process_kill();
+    init_model_broker();
     _activeSubProcesses = /* @__PURE__ */ new Map();
     FullSubAgentTool = class {
       name = "full_sub_agent";
@@ -519631,10 +520696,45 @@ var init_full_sub_agent = __esm({
             if (!task)
               return { success: false, output: "", error: "task is required", durationMs: performance.now() - start2 };
             const model = String(args["model"] ?? this.model);
+            const broker = getModelBroker();
+            const decision2 = await broker.ensureModelLoadable({
+              name: model || "default",
+              domain: "subagent",
+              host: model ? "ollama" : "subprocess",
+              owner: "full-sub-agent-tool",
+              estimatedVramMB: 4e3,
+              estimatedRamMB: 1500,
+              priority: 1
+              // sub-agents are higher priority than idle background models
+            });
+            if (decision2.kind === "evict") {
+              for (const target of decision2.evictTargets) {
+                await broker.evict(target.host, target.name, "sub-agent-spawn-needs-room");
+              }
+            } else if (decision2.kind === "reject") {
+              return {
+                success: false,
+                output: "",
+                error: `Sub-agent spawn blocked by resource broker: ${decision2.reason}`,
+                durationMs: performance.now() - start2
+              };
+            }
             const entry = spawnFullSubAgent(task, { model, backendUrl: this.backendUrl, workingDir: this.workingDir }, (text) => this.onViewWrite?.(entry.id, text), (id, exitCode, output) => {
               this.onViewStatus?.(id, exitCode === 0 ? "completed" : "failed");
+              broker.unregisterLoaded("subprocess", id, "sub-agent-exited");
               this.onComplete?.(id, task, exitCode, output);
             });
+            broker.registerLoaded({
+              key: `subprocess:${entry.id}`,
+              name: entry.id,
+              domain: "subagent",
+              host: "subprocess",
+              owner: "full-sub-agent-tool",
+              vramMB: 4e3,
+              ramMB: 1500,
+              pid: entry.pid,
+              priority: 1
+            });
             this.onViewRegister?.(entry.id, entry.id, "full");
             return {
               success: true,
@@ -519708,6 +520808,7 @@ var _idCounter, AgentTool;
 var init_agent_tool = __esm({
   "packages/execution/dist/tools/agent-tool.js"() {
     "use strict";
+    init_model_broker();
     _idCounter = 0;
     AgentTool = class {
       name = "agent";
@@ -519798,6 +520899,31 @@ var init_agent_tool = __esm({
         }
         const model = modelOverride ?? this.config.model;
         const agentId = generateAgentId(subagentType);
+        {
+          const broker = getModelBroker();
+          const decision2 = await broker.ensureModelLoadable({
+            name: model || "default",
+            domain: "subagent",
+            host: "ollama",
+            owner: `agent-tool/${subagentType}`,
+            estimatedVramMB: 2500,
+            estimatedRamMB: 1e3,
+            priority: 1
+          });
+          if (decision2.kind === "evict") {
+            for (const target of decision2.evictTargets) {
+              await broker.evict(target.host, target.name, "agent-tool-needs-room");
+            }
+          } else if (decision2.kind === "reject") {
+            return {
+              success: false,
+              output: "",
+              error: `Agent spawn blocked by resource broker: ${decision2.reason}`,
+              durationMs: performance.now() - start2
+            };
+          }
+          broker.touch("ollama", model);
+        }
         const label = description ?? `${subagentType}: ${prompt.slice(0, 40)}`;
         const preloadedFiles = [];
         if (relevantFilePaths.length > 0) {
@@ -522473,13 +523599,13 @@ var init_notebook_edit = __esm({
 
 // packages/execution/dist/tools/environment-snapshot.js
 import { execSync as execSync42 } from "node:child_process";
-import { cpus, totalmem, freemem, hostname as hostname2, platform as platform2, arch, uptime } from "node:os";
+import { cpus, totalmem as totalmem2, freemem as freemem2, hostname as hostname2, platform as platform2, arch, uptime } from "node:os";
 import { statfsSync as statfsSync2 } from "node:fs";
 function collectSnapshot(workingDir) {
   const now = /* @__PURE__ */ new Date();
   const cpuInfo = cpus();
-  const totalRAM = totalmem();
-  const freeRAM = freemem();
+  const totalRAM = totalmem2();
+  const freeRAM = freemem2();
   let load1 = 0, load5 = 0, load15 = 0;
   try {
     const loadavg4 = __require("node:os").loadavg();
@@ -522674,6 +523800,7 @@ var VideoUnderstandTool;
 var init_video_understand = __esm({
   "packages/execution/dist/tools/video-understand.js"() {
     "use strict";
+    init_model_broker();
     VideoUnderstandTool = class {
       name = "video_understand";
       description = "Analyze a video from URL or local file. Produces timestamped transcript aligned with keyframe descriptions. Supports YouTube URLs and direct video files. Pipeline: download → transcribe (Whisper) → extract keyframes (scene detection) → describe frames → align timestamps → save structured output.";
@@ -522704,6 +523831,36 @@ var init_video_understand = __esm({
         if (!url && !localPath) {
           return { success: false, output: "", error: "url or path required", durationMs: performance.now() - start2 };
         }
+        const broker = getModelBroker();
+        const asrDecision = await broker.ensureModelLoadable({
+          name: whisperModel,
+          domain: "asr",
+          host: "whisper-cli",
+          owner: "video-understand-tool"
+        });
+        if (asrDecision.kind === "evict") {
+          for (const target of asrDecision.evictTargets) {
+            await broker.evict(target.host, target.name, "video-understand-needs-asr-room");
+          }
+        } else if (asrDecision.kind === "reject") {
+          return {
+            success: false,
+            output: "",
+            error: `Video understanding blocked by resource broker (ASR): ${asrDecision.reason}`,
+            durationMs: performance.now() - start2
+          };
+        }
+        const visionDecision = await broker.ensureModelLoadable({
+          name: "moondream2",
+          domain: "vision",
+          host: "moondream-station",
+          owner: "video-understand-tool"
+        });
+        if (visionDecision.kind === "evict") {
+          for (const target of visionDecision.evictTargets) {
+            await broker.evict(target.host, target.name, "video-understand-needs-vision-room");
+          }
+        }
         const outDir = join71(this.workingDir, ".omnius", "video-analysis");
         mkdirSync28(outDir, { recursive: true });
         const tmpDir = join71(outDir, `tmp-${Date.now()}`);
@@ -524314,6 +525471,7 @@ __export(dist_exports, {
   MemorySearchTool: () => MemorySearchTool,
   MemoryWriteTool: () => MemoryWriteTool,
   MeshtasticTool: () => MeshtasticTool,
+  ModelBroker: () => ModelBroker,
   MultimodalMemoryTool: () => MultimodalMemoryTool,
   NetworkEgressPolicyError: () => NetworkEgressPolicyError,
   NexusTool: () => NexusTool,
@@ -524451,6 +525609,7 @@ __export(dist_exports, {
   getFileNotes: () => getFileNotes,
   getFullSubAgent: () => getFullSubAgent,
   getImageGenerationPreset: () => getImageGenerationPreset,
+  getModelBroker: () => getModelBroker,
   getModelStoreDiskInfo: () => getModelStoreDiskInfo,
   getRecentChangesSummary: () => getRecentChangesSummary,
   getSecretsFilePath: () => getSecretsFilePath,
@@ -524573,6 +525732,7 @@ __export(dist_exports, {
   videoGenerationQualityLadder: () => videoGenerationQualityLadder,
   videoGenerationSetupPlan: () => videoGenerationSetupPlan,
   worktreeHasChanges: () => worktreeHasChanges,
+  wrapWithBroker: () => wrapWithBroker,
   writeProvenanceFile: () => writeProvenanceFile,
   writeTodos: () => writeTodos
 });
@@ -524580,6 +525740,8 @@ var init_dist5 = __esm({
   "packages/execution/dist/index.js"() {
     "use strict";
     init_tool_executor();
+    init_model_broker();
+    init_broker_mediated_backend();
     init_security_classifier();
     init_tool_manifest();
     init_provenance();
@@ -527339,12 +528501,12 @@ var init_ollama_pool_cleanup = __esm({
 });
 
 // packages/orchestrator/dist/ollama-pool.js
-import { spawn as spawn23, exec } from "node:child_process";
+import { spawn as spawn23, exec as exec2 } from "node:child_process";
 import { existsSync as existsSync63, readFileSync as readFileSync50, readdirSync as readdirSync20, statfsSync as statfsSync3, statSync as statSync25 } from "node:fs";
 import { homedir as homedir28 } from "node:os";
 import { join as join77 } from "node:path";
 import { createServer as createServer3 } from "node:net";
-import { EventEmitter as EventEmitter4 } from "node:events";
+import { EventEmitter as EventEmitter5 } from "node:events";
 function discoverSystemOllamaModelStore() {
   const fromEnv = process.env["OLLAMA_MODELS"]?.trim();
   if (fromEnv && isDirectory(fromEnv))
@@ -527436,7 +528598,7 @@ async function detectGpus() {
   if (_nvidiaSmiAvailable === false)
     return [];
   return new Promise((resolve55) => {
-    exec("nvidia-smi --query-gpu=index,uuid,name,memory.total,memory.free,utilization.gpu --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => {
+    exec2("nvidia-smi --query-gpu=index,uuid,name,memory.total,memory.free,utilization.gpu --format=csv,noheader,nounits 2>/dev/null", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => {
       if (err) {
         _nvidiaSmiAvailable = false;
         resolve55([]);
@@ -527465,7 +528627,7 @@ async function detectGpus() {
   });
 }
 async function getHardwareSnapshot() {
-  const { totalmem: totalmem7, freemem: freemem6, cpus: cpus5 } = await import("node:os");
+  const { totalmem: totalmem8, freemem: freemem7, cpus: cpus5 } = await import("node:os");
   const gpus = await detectGpus();
   const diskPath = discoverSystemOllamaModelStore() ?? homedir28();
   const disk = snapshotDisk(diskPath);
@@ -527473,8 +528635,8 @@ async function getHardwareSnapshot() {
   return {
     gpus,
     cpuCores: cpus5().length,
-    ramTotalMB: Math.round(totalmem7() / (1024 * 1024)),
-    ramFreeMB: Math.round(freemem6() / (1024 * 1024)),
+    ramTotalMB: Math.round(totalmem8() / (1024 * 1024)),
+    ramFreeMB: Math.round(freemem7() / (1024 * 1024)),
     disk,
     network,
     takenAtMs: Date.now()
@@ -527741,7 +528903,7 @@ var init_ollama_pool = __esm({
       return { proc, ready };
     };
     _gpuCursor = 0;
-    OllamaPool = class extends EventEmitter4 {
+    OllamaPool = class extends EventEmitter5 {
       config;
       instances = [];
       reaperHandle = null;
@@ -540331,8 +541493,8 @@ var init_streaming_executor = __esm({
       startExecution(entry) {
         entry.state = "executing";
         entry.startedAt = Date.now();
-        const exec5 = this.executeFn;
-        entry.promise = exec5(entry.name, entry.args).then((result) => {
+        const exec6 = this.executeFn;
+        entry.promise = exec6(entry.name, entry.args).then((result) => {
           entry.state = "completed";
           entry.result = result;
           entry.completedAt = Date.now();
@@ -540621,7 +541783,7 @@ __export(preflightSnapshot_exports, {
 });
 import { existsSync as existsSync79, readFileSync as readFileSync62, statSync as statSync31 } from "node:fs";
 import { execSync as execSync46 } from "node:child_process";
-import { homedir as homedir29, platform as platform3, arch as arch2, totalmem as totalmem2, freemem as freemem2, hostname as hostname3 } from "node:os";
+import { homedir as homedir29, platform as platform3, arch as arch2, totalmem as totalmem3, freemem as freemem3, hostname as hostname3 } from "node:os";
 import { join as join92 } from "node:path";
 import { createHash as createHash17 } from "node:crypto";
 function capturePreflightSnapshot(workingDir) {
@@ -540668,8 +541830,8 @@ function capturePreflightSnapshot(workingDir) {
       platform: platform3(),
       arch: arch2(),
       nodeVersion: process.version,
-      totalMemBytes: totalmem2(),
-      freeMemBytes: freemem2(),
+      totalMemBytes: totalmem3(),
+      freeMemBytes: freemem3(),
       hostname: hostname3()
     },
     toolchain: captureToolchainVersions(),
@@ -554431,6 +555593,13 @@ ${description}`
         if (responseFormat !== void 0) {
           body["response_format"] = responseFormat;
         }
+        const reqNumCtx = request.numCtx;
+        if (Number.isFinite(reqNumCtx) && (reqNumCtx ?? 0) > 0) {
+          const opts = body["options"] ?? {};
+          opts["num_ctx"] = reqNumCtx;
+          body["options"] = opts;
+          body["num_ctx"] = reqNumCtx;
+        }
         let poolSlot = shouldUseOllamaPoolForBaseUrl(this.baseUrl) ? await getOllamaPool({ baseInstanceUrl: this.baseUrl }).acquire({
           model: this.model
         }) : null;
@@ -559212,7 +560381,7 @@ import { existsSync as existsSync85, mkdirSync as mkdirSync46, writeFileSync as
 import { join as join100, dirname as dirname27 } from "node:path";
 import { homedir as homedir32 } from "node:os";
 import { fileURLToPath as fileURLToPath11 } from "node:url";
-import { EventEmitter as EventEmitter5 } from "node:events";
+import { EventEmitter as EventEmitter6 } from "node:events";
 import { createInterface as createInterface2 } from "node:readline";
 function isAudioPath(path12) {
   const ext = path12.toLowerCase().split(".").pop();
@@ -559451,9 +560620,9 @@ function ensureTranscribeCliBackground() {
     } catch {
     }
     try {
-      const { exec: exec5 } = await import("node:child_process");
+      const { exec: exec6 } = await import("node:child_process");
       return new Promise((resolve55) => {
-        exec5("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
+        exec6("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
           resolve55(!err);
         });
       });
@@ -559501,7 +560670,7 @@ var init_listen = __esm({
       ".m4v",
       ".ts"
     ]);
-    WhisperFallbackTranscriber = class extends EventEmitter5 {
+    WhisperFallbackTranscriber = class extends EventEmitter6 {
       constructor(model, scriptPath2) {
         super();
         this.model = model;
@@ -559610,7 +560779,7 @@ var init_listen = __esm({
         this._ready = false;
       }
     };
-    ListenEngine = class extends EventEmitter5 {
+    ListenEngine = class extends EventEmitter6 {
       config;
       micProcess = null;
       liveTranscriber = null;
@@ -562355,7 +563524,7 @@ var require_extension3 = __commonJS({
 var require_websocket3 = __commonJS({
   "node_modules/.pnpm/ws@8.20.1/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter14 = __require("events");
+    var EventEmitter15 = __require("events");
     var https4 = __require("https");
     var http6 = __require("http");
     var net5 = __require("net");
@@ -562387,7 +563556,7 @@ var require_websocket3 = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket6 = class _WebSocket extends EventEmitter14 {
+    var WebSocket6 = class _WebSocket extends EventEmitter15 {
       /**
        * Create a new `WebSocket`.
        *
@@ -563384,7 +564553,7 @@ var require_subprotocol2 = __commonJS({
 var require_websocket_server2 = __commonJS({
   "node_modules/.pnpm/ws@8.20.1/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter14 = __require("events");
+    var EventEmitter15 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
     var { createHash: createHash31 } = __require("crypto");
@@ -563397,7 +564566,7 @@ var require_websocket_server2 = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer4 = class extends EventEmitter14 {
+    var WebSocketServer4 = class extends EventEmitter15 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -564285,6 +565454,9 @@ var init_command_registry = __esm({
       ["/wizard", "Alias for /setup"],
       ["/parallel", "Show current Ollama parallel inference slots"],
       ["/parallel <1-15>", "Set parallel slots (restarts Ollama, max 15)"],
+      ["/broker", "Show resource broker status — loaded models, in-flight loads, RAM/VRAM headroom"],
+      ["/broker evict <host>:<name>", "Force eviction of a tracked model (e.g. /broker evict ollama:moondream)"],
+      ["/broker threshold <ram|vram|idle> <v>", "Tune broker thresholds (RAM/VRAM in MB, idle in seconds)"],
       ["/ollama cleanup", "Dry-run stale Ollama pool process cleanup"],
       ["/ollama cleanup --execute", "Terminate guarded stale Ollama pool runners"],
       ["/mcp", "Show MCP server/tool status and controls"],
@@ -564554,6 +565726,7 @@ var init_command_registry = __esm({
       endpoint: "network",
       provider: "network",
       parallel: "runtime",
+      broker: "runtime",
       setup: "runtime",
       wizard: "runtime",
       mcp: "tools",
@@ -564695,6 +565868,7 @@ var init_command_registry = __esm({
       "model",
       "endpoint",
       "parallel",
+      "broker",
       "commands",
       "cmds",
       "selfmodify",
@@ -565588,7 +566762,7 @@ var init_task_complete_box = __esm({
 });
 
 // packages/cli/src/tui/model-picker.ts
-import { totalmem as totalmem3 } from "node:os";
+import { totalmem as totalmem4 } from "node:os";
 function isImageGenModel(name10, family) {
   return IMAGE_GEN_PATTERNS.some((p2) => p2.test(name10) || family && p2.test(family));
 }
@@ -565977,7 +567151,7 @@ async function queryModelContextSize(baseUrl, modelName) {
   }
 }
 function estimateRealisticContext(kvBytesPerToken, archMax, modelSizeGB2) {
-  const totalMemGB = totalmem3() / 1024 ** 3;
+  const totalMemGB = totalmem4() / 1024 ** 3;
   const usableBytes = totalMemGB * 0.7 * 1024 ** 3;
   const maxTokens = Math.floor(usableBytes / kvBytesPerToken);
   let numCtx = Math.max(2048, Math.floor(maxTokens / 1024) * 1024);
@@ -567316,7 +568490,7 @@ var init_render = __esm({
 // packages/cli/src/tui/voice-session.ts
 import { createServer as createServer4 } from "node:http";
 import { spawn as spawn25, execSync as execSync49 } from "node:child_process";
-import { EventEmitter as EventEmitter6 } from "node:events";
+import { EventEmitter as EventEmitter7 } from "node:events";
 function generateFrontendHTML() {
   return `<!DOCTYPE html>
 <html lang="en">
@@ -568051,7 +569225,7 @@ var init_voice_session = __esm({
     init_wrapper2();
     init_render();
     init_typed_node_events();
-    VoiceSession = class extends EventEmitter6 {
+    VoiceSession = class extends EventEmitter7 {
       state;
       server = null;
       wss = null;
@@ -569166,11 +570340,11 @@ var init_voice_soul = __esm({
 
 // packages/cli/src/tui/expose.ts
 import { createServer as createServer5, request as httpRequest } from "node:http";
-import { spawn as spawn26, exec as exec2 } from "node:child_process";
-import { EventEmitter as EventEmitter7 } from "node:events";
+import { spawn as spawn26, exec as exec3 } from "node:child_process";
+import { EventEmitter as EventEmitter8 } from "node:events";
 import { randomBytes as randomBytes19, timingSafeEqual } from "node:crypto";
 import { URL as URL2 } from "node:url";
-import { loadavg, cpus as cpus2, totalmem as totalmem4, freemem as freemem3 } from "node:os";
+import { loadavg, cpus as cpus2, totalmem as totalmem5, freemem as freemem4 } from "node:os";
 import { existsSync as existsSync88, readFileSync as readFileSync70, writeFileSync as writeFileSync44, unlinkSync as unlinkSync14, mkdirSync as mkdirSync48, readdirSync as readdirSync29, statSync as statSync34, statfsSync as statfsSync4 } from "node:fs";
 import { join as join103 } from "node:path";
 function cleanForwardHeaders(raw, targetHost) {
@@ -569276,8 +570450,8 @@ function parseRateLimitHeaders(headers) {
 async function collectSystemMetricsAsync() {
   const [l1, l5, l15] = loadavg();
   const cores = cpus2().length;
-  const totalMem = totalmem4();
-  const freeMem = freemem3();
+  const totalMem = totalmem5();
+  const freeMem = freemem4();
   const usedMem = totalMem - freeMem;
   let disk = {
     path: process.cwd(),
@@ -569310,7 +570484,7 @@ async function collectSystemMetricsAsync() {
   };
   try {
     const smi = await new Promise((resolve55, reject) => {
-      exec2(
+      exec3(
         "nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null",
         { encoding: "utf8", timeout: 3e3 },
         (err, stdout) => err ? reject(err) : resolve55(stdout)
@@ -569398,7 +570572,7 @@ var init_expose = __esm({
       custom: "http://127.0.0.1:11434"
     };
     STATE_FILE_NAME = "expose-state.json";
-    ExposeGateway = class _ExposeGateway extends EventEmitter7 {
+    ExposeGateway = class _ExposeGateway extends EventEmitter8 {
       constructor(options2) {
         super();
         this.options = options2;
@@ -570277,7 +571451,7 @@ ${this.formatConnectionInfo()}`);
       }
     };
     P2P_STATE_FILE_NAME = "expose-p2p-state.json";
-    ExposeP2PGateway = class _ExposeP2PGateway extends EventEmitter7 {
+    ExposeP2PGateway = class _ExposeP2PGateway extends EventEmitter8 {
       _nexusTool;
       // NexusTool instance
       _kind;
@@ -571048,7 +572222,7 @@ var init_secret_vault = __esm({
 });
 
 // packages/cli/src/tui/p2p/peer-mesh.ts
-import { EventEmitter as EventEmitter8 } from "node:events";
+import { EventEmitter as EventEmitter9 } from "node:events";
 import { createServer as createServer6 } from "node:http";
 import { randomBytes as randomBytes21, createHash as createHash21, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
@@ -571060,7 +572234,7 @@ var init_peer_mesh = __esm({
     PEER_TIMEOUT_MS = 9e4;
     GOSSIP_INTERVAL_MS = 6e4;
     MAX_PEERS = 50;
-    PeerMesh = class extends EventEmitter8 {
+    PeerMesh = class extends EventEmitter9 {
       constructor(options2) {
         super();
         this.options = options2;
@@ -571506,7 +572680,7 @@ var init_peer_mesh = __esm({
 });
 
 // packages/cli/src/tui/p2p/inference-router.ts
-import { EventEmitter as EventEmitter9 } from "node:events";
+import { EventEmitter as EventEmitter10 } from "node:events";
 var TRUST_WEIGHTS, InferenceRouter;
 var init_inference_router = __esm({
   "packages/cli/src/tui/p2p/inference-router.ts"() {
@@ -571518,7 +572692,7 @@ var init_inference_router = __esm({
       verified: 5,
       public: 2
     };
-    InferenceRouter = class extends EventEmitter9 {
+    InferenceRouter = class extends EventEmitter10 {
       mesh;
       vault;
       defaultTimeoutMs;
@@ -571716,7 +572890,7 @@ var init_p2p = __esm({
 });
 
 // packages/cli/src/tui/call-agent.ts
-import { EventEmitter as EventEmitter10 } from "node:events";
+import { EventEmitter as EventEmitter11 } from "node:events";
 import crypto13 from "node:crypto";
 function adaptTool(tool) {
   return {
@@ -571774,7 +572948,7 @@ var init_call_agent = __esm({
       }
     };
     _globalFeed = null;
-    CallSubAgent = class extends EventEmitter10 {
+    CallSubAgent = class extends EventEmitter11 {
       tier;
       clientId;
       runner = null;
@@ -573876,8 +575050,8 @@ __export(system_metrics_exports, {
   getInstantSnapshot: () => getInstantSnapshot,
   instantaneousCpuPct: () => instantaneousCpuPct
 });
-import { loadavg as loadavg2, cpus as cpus3, totalmem as totalmem5, freemem as freemem4, platform as platform4 } from "node:os";
-import { exec as exec3 } from "node:child_process";
+import { loadavg as loadavg2, cpus as cpus3, totalmem as totalmem6, freemem as freemem5, platform as platform4 } from "node:os";
+import { exec as exec4 } from "node:child_process";
 import { readFile as readFile22 } from "node:fs/promises";
 function formatRate(bytesPerSec) {
   if (bytesPerSec < 1024) return `${Math.round(bytesPerSec)}B`;
@@ -573924,7 +575098,7 @@ async function collectNetworkMetrics() {
   if (plat === "darwin") {
     try {
       const output = await new Promise((resolve55, reject) => {
-        exec3("netstat -ib 2>/dev/null | head -30", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve55(stdout));
+        exec4("netstat -ib 2>/dev/null | head -30", { encoding: "utf8", timeout: 3e3 }, (err, stdout) => err ? reject(err) : resolve55(stdout));
       });
       let rxBytes = 0, txBytes = 0;
       for (const line of output.split("\n")) {
@@ -573967,7 +575141,7 @@ async function collectGpuMetrics() {
   if (_nvidiaSmiAvailable2 === false) return noGpu;
   try {
     const smi = await new Promise((resolve55, reject) => {
-      exec3(
+      exec4(
         "nvidia-smi --query-gpu=index,uuid,utilization.gpu,memory.used,memory.total,name --format=csv,noheader,nounits 2>/dev/null",
         { encoding: "utf8", timeout: 3e3 },
         (err, stdout) => err ? reject(err) : resolve55(stdout)
@@ -574066,8 +575240,8 @@ function instantaneousCpuPct() {
 function collectCpuRam() {
   const cores = cpus3().length;
   const cpuModel = cpus3()[0]?.model ?? "";
-  const totalMem = totalmem5();
-  const usedMem = totalMem - freemem4();
+  const totalMem = totalmem6();
+  const usedMem = totalMem - freemem5();
   let cpuUtil = instantaneousCpuPct();
   if (cpuUtil < 0) {
     const [l1] = loadavg2();
@@ -574862,6 +576036,7 @@ var init_status_bar = __esm({
     init_text_selection();
     init_daemon_registry();
     init_overlay_lock();
+    init_dist5();
     init_theme();
     init_layout2();
     EXPERT_TOOL_BASELINES = {
@@ -576073,6 +577248,10 @@ var init_status_bar = __esm({
           this._unifiedMetrics = m2;
           if (this.active) this.renderFooterPreserveCursor();
         }, intervalMs);
+        try {
+          getModelBroker().startPolling(Math.max(2e3, intervalMs * 2));
+        } catch {
+        }
       }
       /** Stop all metrics collection (local and remote) */
       stopAllMetrics() {
@@ -580498,7 +581677,7 @@ __export(setup_exports, {
   updateOllama: () => updateOllama
 });
 import * as readline from "node:readline";
-import { execSync as execSync51, spawn as spawn28, exec as exec4 } from "node:child_process";
+import { execSync as execSync51, spawn as spawn28, exec as exec5 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 import { existsSync as existsSync95, writeFileSync as writeFileSync49, readFileSync as readFileSync78, appendFileSync as appendFileSync6, mkdirSync as mkdirSync53 } from "node:fs";
 import { join as join111 } from "node:path";
@@ -583250,7 +584429,7 @@ var init_setup = __esm({
     init_dist();
     init_tui_select();
     init_listen();
-    execAsync2 = promisify6(exec4);
+    execAsync2 = promisify6(exec5);
     OMNIUS_FIRST_RUN_BANNER = [
       " ░▒▓██████▓▒░░▒▓██████████████▓▒░░▒▓███████▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░░▒▓███████▓▒░ ",
       "░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░        ",
@@ -595704,6 +596883,9 @@ async function handleSlashCommand(input, ctx3) {
     case "parallel":
       await handleParallel(arg, ctx3);
       return "handled";
+    case "broker":
+      await handleBroker(arg, ctx3);
+      return "handled";
     case "ollama":
       await handleOllama(arg, ctx3);
       return "handled";
@@ -603161,6 +604343,83 @@ async function handlePeerEndpoint(peerId, authKey, ctx3, local) {
     );
   }
 }
+async function handleBroker(arg, _ctx) {
+  const broker = getModelBroker();
+  const sub = (arg || "").trim().toLowerCase();
+  const snap = await broker.pollOnce();
+  if (!sub || sub === "status" || sub === "list" || sub === "ls") {
+    safeLog("");
+    safeLog(`  ${c3.bold("Resource Broker")}`);
+    safeLog("");
+    safeLog(`  ${c3.dim("RAM:")}  ${snap.ramMB.used} / ${snap.ramMB.total} MB used (${snap.ramMB.free} MB free)`);
+    if (snap.vramMB) {
+      safeLog(`  ${c3.dim("VRAM:")} ${snap.vramMB.used} / ${snap.vramMB.total} MB used (${snap.vramMB.free} MB free)`);
+    } else {
+      safeLog(`  ${c3.dim("VRAM:")} ${c3.dim("(no GPU detected)")}`);
+    }
+    safeLog(`  ${c3.dim("RAM headroom threshold:")}  ${broker.ramHeadroomMB} MB`);
+    safeLog(`  ${c3.dim("VRAM headroom threshold:")} ${broker.vramHeadroomMB} MB`);
+    safeLog(`  ${c3.dim("Idle-evict threshold:")} ${Math.round(broker.idleEvictMs / 1e3)}s`);
+    safeLog("");
+    if (snap.loaded.length === 0) {
+      safeLog(`  ${c3.dim("No loaded models tracked.")}`);
+    } else {
+      safeLog(`  ${c3.bold("Loaded models:")}`);
+      const now = Date.now();
+      for (const m2 of snap.loaded) {
+        const idle = Math.round((now - m2.lastUsedAt) / 1e3);
+        const owner = m2.owner ? c3.dim(` [owner=${m2.owner}]`) : "";
+        const ctx3 = m2.numCtx ? c3.dim(` n_ctx=${m2.numCtx}`) : "";
+        safeLog(`    ${c3.cyan(m2.name)} (${m2.host}/${m2.domain})  vram=${m2.vramMB}MB ram=${m2.ramMB}MB  idle=${idle}s${ctx3}${owner}`);
+      }
+    }
+    if (snap.inflight.length > 0) {
+      safeLog("");
+      safeLog(`  ${c3.bold("In-flight loads:")}`);
+      for (const f2 of snap.inflight) {
+        const age = Math.round((Date.now() - f2.startedMs) / 1e3);
+        safeLog(`    ${c3.yellow(f2.key)}  owner=${f2.owner}  ${age}s ago`);
+      }
+    }
+    safeLog("");
+    safeLog(`  ${c3.dim("Subcommands: /broker [status|evict <key>|threshold ram|vram|idle <value>]")}`);
+    safeLog("");
+    return;
+  }
+  const parts = (arg || "").trim().split(/\s+/);
+  const op = parts[0]?.toLowerCase();
+  if (op === "evict") {
+    const key = parts[1];
+    if (!key || !key.includes(":")) {
+      renderWarning("Usage: /broker evict <host>:<name>  e.g. /broker evict ollama:moondream");
+      return;
+    }
+    const [host, ...rest] = key.split(":");
+    const name10 = rest.join(":");
+    const ok3 = await broker.evict(host, name10, "user-requested");
+    if (ok3) renderInfo(`Evicted ${key} (actively unloaded)`);
+    else renderInfo(`Unregistered ${key} (could not actively unload; subprocess may need manual cleanup)`);
+    return;
+  }
+  if (op === "threshold") {
+    const which3 = parts[1]?.toLowerCase();
+    const value2 = parts[2] ? Number(parts[2]) : NaN;
+    if (!which3 || !Number.isFinite(value2) || value2 < 0) {
+      renderWarning("Usage: /broker threshold <ram|vram|idle> <value>  (ram/vram in MB, idle in seconds)");
+      return;
+    }
+    if (which3 === "ram") broker.ramHeadroomMB = value2;
+    else if (which3 === "vram") broker.vramHeadroomMB = value2;
+    else if (which3 === "idle") broker.idleEvictMs = value2 * 1e3;
+    else {
+      renderWarning("Unknown threshold; use ram|vram|idle");
+      return;
+    }
+    renderInfo(`Updated broker threshold ${which3} = ${value2}`);
+    return;
+  }
+  renderWarning("Unknown /broker subcommand. Try: status | evict <host>:<name> | threshold <ram|vram|idle> <value>");
+}
 async function handleParallel(arg, ctx3) {
   const { execSync: execSync61 } = await import("node:child_process");
   const baseUrl = ctx3.config.backendUrl || "http://localhost:11434";
@@ -604173,9 +605432,9 @@ async function handleUpdate(subcommand, ctx3) {
       }
     };
   }
-  const { exec: exec5, spawn: spawn34, execSync: es2 } = await import("node:child_process");
+  const { exec: exec6, spawn: spawn34, execSync: es2 } = await import("node:child_process");
   const execA = (cmd, opts) => new Promise(
-    (res, rej) => exec5(
+    (res, rej) => exec6(
       cmd,
       {
         encoding: "utf8",
@@ -604869,7 +606128,7 @@ async function handleUpdate(subcommand, ctx3) {
     installOverlay.setPhase("Native Modules");
     installOverlay.setStatus("Rebuilding native modules...");
     await new Promise((resolve55) => {
-      const child = exec5(
+      const child = exec6(
         `${sudoPrefix}npm rebuild -g omnius 2>/dev/null || true`,
         { timeout: 12e4 },
         () => resolve55(true)
@@ -604911,7 +606170,7 @@ async function handleUpdate(subcommand, ctx3) {
     if (fsExists(venvPip2)) {
       installOverlay.setStatus("Upgrading Python packages...");
       await new Promise((resolve55) => {
-        const child = exec5(
+        const child = exec6(
           `"${venvPip2}" install --upgrade moondream-station pytesseract Pillow opencv-python-headless numpy 2>/dev/null || true`,
           { timeout: 3e5 },
           (err) => resolve55(!err)
@@ -610886,6 +612145,9 @@ var init_bless_engine = __esm({
       async pingModel() {
         try {
           const url = `${this.config.backendUrl}/api/chat`;
+          const broker = getModelBroker();
+          const trainCtx = await broker.getNctxTrain(this.config.model);
+          const numCtx = trainCtx && trainCtx > 0 ? Math.min(trainCtx, 8192) : void 0;
           await fetch(url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -610893,11 +612155,12 @@ var init_bless_engine = __esm({
               model: this.config.model,
               messages: [{ role: "user", content: "." }],
               stream: false,
-              options: { num_predict: 1 },
+              options: numCtx ? { num_predict: 1, num_ctx: numCtx } : { num_predict: 1 },
               keep_alive: "30m"
             }),
             signal: AbortSignal.timeout(15e3)
           });
+          broker.touch("ollama", this.config.model);
           this.state.keepAlivePings++;
         } catch {
         }
@@ -614240,6 +615503,300 @@ var init_stimulation = __esm({
   }
 });
 
+// packages/cli/src/tui/pid-controller.ts
+function clamp018(x) {
+  if (!Number.isFinite(x)) return 0;
+  if (x < 0) return 0;
+  if (x > 1) return 1;
+  return x;
+}
+function getPidRegistry() {
+  if (!_registry2) _registry2 = new PidRegistry();
+  return _registry2;
+}
+var DEFAULT_PID_CONFIG, PidRegistry, _registry2;
+var init_pid_controller = __esm({
+  "packages/cli/src/tui/pid-controller.ts"() {
+    "use strict";
+    DEFAULT_PID_CONFIG = {
+      kp: 1e-4,
+      ki: 1e-5,
+      kd: 0,
+      setpointMs: 8e3,
+      initialOutput: 1,
+      pvEmaAlpha: 0.3,
+      integralClamp: 5e3
+      // ms*s — bounds integral term contribution
+    };
+    PidRegistry = class {
+      _controllers = /* @__PURE__ */ new Map();
+      /** Get or create a controller. */
+      get(key, configOverride) {
+        let st = this._controllers.get(key);
+        if (!st) {
+          const config = { ...DEFAULT_PID_CONFIG, ...configOverride ?? {} };
+          st = {
+            output: config.initialOutput,
+            pv: config.setpointMs,
+            // assume on-target at startup
+            integral: 0,
+            lastError: 0,
+            lastSampleAt: 0,
+            samples: 0,
+            config
+          };
+          this._controllers.set(key, st);
+        }
+        return st;
+      }
+      /** Read-only current output (inclusion ratio in [0,1]). */
+      output(key) {
+        return this._controllers.get(key)?.output ?? DEFAULT_PID_CONFIG.initialOutput;
+      }
+      /**
+       * Record a new latency sample (in ms) and update the controller.
+       * Returns the new output value.
+       */
+      sample(key, latencyMs, configOverride) {
+        const st = this.get(key, configOverride);
+        const now = Date.now();
+        st.pv = st.samples === 0 ? latencyMs : st.pv * (1 - st.config.pvEmaAlpha) + latencyMs * st.config.pvEmaAlpha;
+        const error = st.config.setpointMs - st.pv;
+        st.integral += error;
+        if (st.integral > st.config.integralClamp) st.integral = st.config.integralClamp;
+        if (st.integral < -st.config.integralClamp) st.integral = -st.config.integralClamp;
+        const dt = st.lastSampleAt > 0 ? now - st.lastSampleAt : 1e3;
+        const derivative = dt > 0 ? (error - st.lastError) / dt : 0;
+        const u = st.config.kp * error + st.config.ki * st.integral + st.config.kd * derivative;
+        st.output = clamp018(st.output + u);
+        st.lastError = error;
+        st.lastSampleAt = now;
+        st.samples += 1;
+        return st.output;
+      }
+      /** All controller snapshots — for /broker debug surface. */
+      snapshot() {
+        return [...this._controllers.entries()].map(([key, st]) => ({
+          key,
+          output: st.output,
+          pv: st.pv,
+          setpoint: st.config.setpointMs,
+          samples: st.samples
+        }));
+      }
+      /** Reset (test-only). */
+      reset() {
+        this._controllers.clear();
+      }
+    };
+    _registry2 = null;
+  }
+});
+
+// packages/cli/src/tui/component-benefit.ts
+function getComponentBenefitRegistry() {
+  if (!_registry3) _registry3 = new ComponentBenefitRegistry();
+  return _registry3;
+}
+var EMA_ALPHA, MIN_SAMPLES_TO_TRUST, ComponentBenefitRegistry, _registry3;
+var init_component_benefit = __esm({
+  "packages/cli/src/tui/component-benefit.ts"() {
+    "use strict";
+    EMA_ALPHA = 0.2;
+    MIN_SAMPLES_TO_TRUST = 3;
+    ComponentBenefitRegistry = class {
+      /** Two-tier map: chatKey → componentKey → state. */
+      _byChat = /* @__PURE__ */ new Map();
+      /** Score for a component in a chat. Returns 0.5 (neutral) when not enough samples. */
+      score(chatKey, componentKey) {
+        const st = this._byChat.get(chatKey)?.get(componentKey);
+        if (!st || st.samples < MIN_SAMPLES_TO_TRUST) return 0.5;
+        return st.score;
+      }
+      /** Record one batch — for each sampled component, did the decision text reference its needle? */
+      recordOutcome(chatKey, samples, decisionText) {
+        const haystack = decisionText.toLowerCase();
+        let map2 = this._byChat.get(chatKey);
+        if (!map2) {
+          map2 = /* @__PURE__ */ new Map();
+          this._byChat.set(chatKey, map2);
+        }
+        const now = Date.now();
+        for (const sample of samples) {
+          const needle = sample.needle.toLowerCase();
+          const hit = needle.length >= 3 && haystack.includes(needle);
+          let st = map2.get(sample.key);
+          if (!st) {
+            st = { score: 0.5, samples: 0, hits: 0, lastSeenAt: now };
+            map2.set(sample.key, st);
+          }
+          const newScore = hit ? 1 : 0;
+          st.score = st.samples === 0 ? newScore : st.score * (1 - EMA_ALPHA) + newScore * EMA_ALPHA;
+          st.samples += 1;
+          st.hits += hit ? 1 : 0;
+          st.lastSeenAt = now;
+        }
+      }
+      /** Snapshot for /broker debug surface. */
+      snapshot(chatKey) {
+        const out = [];
+        const iterate = chatKey ? [[chatKey, this._byChat.get(chatKey)]].filter((e2) => !!e2[1]) : [...this._byChat.entries()];
+        for (const [cKey, map2] of iterate) {
+          for (const [comp, st] of map2) {
+            out.push({ chatKey: cKey, componentKey: comp, score: st.score, samples: st.samples, hits: st.hits });
+          }
+        }
+        return out;
+      }
+      reset() {
+        this._byChat.clear();
+      }
+    };
+    _registry3 = null;
+  }
+});
+
+// packages/cli/src/tui/soul-observations.ts
+function getSoulObservationStream() {
+  if (!_stream) {
+    _stream = new SoulObservationStream();
+    subscribeBrokerEvents(_stream);
+  }
+  return _stream;
+}
+function subscribeBrokerEvents(stream) {
+  if (_brokerSubscribed) return;
+  _brokerSubscribed = true;
+  const broker = getModelBroker();
+  broker.on("slotReleased", (info, outcome) => {
+    if (outcome.ok) {
+      stream.emit({
+        kind: "inference.completed",
+        model: info.model,
+        sessionKey: info.sessionKey,
+        latencyMs: Date.now() - info.acquiredAt,
+        promptTokens: info.promptTokens,
+        completionTokens: outcome.completionTokens ?? 0,
+        ts: Date.now()
+      });
+    } else {
+      stream.emit({
+        kind: "inference.degraded",
+        model: info.model,
+        sessionKey: info.sessionKey,
+        reason: outcome.error ?? "unknown",
+        ts: Date.now()
+      });
+    }
+  });
+  broker.on("pressure", (kind, value2, threshold) => {
+    stream.emit({ kind: "broker.pressure", pressure: kind, value: value2, threshold, ts: Date.now() });
+  });
+  broker.on("evicted", (m2, reason) => {
+    stream.emit({ kind: "model.evicted", host: m2.host, name: m2.name, reason, ts: Date.now() });
+  });
+}
+function formatSystemObservations(sessionKey) {
+  const stream = getSoulObservationStream();
+  const broker = getModelBroker();
+  const snap = broker.snapshot();
+  const pidSnap = getPidRegistry().snapshot();
+  const lines = [];
+  const slots = snap.slots;
+  const utilPct = slots.capacity > 0 ? Math.round(slots.inUse / slots.capacity * 100) : 0;
+  const tpsByModel = Object.entries(slots.byModel).filter(([, m2]) => m2.samples > 0).map(([model, m2]) => `${model}=${m2.tokensPerSec.toFixed(1)}t/s (${m2.samples}s)`).join(", ");
+  if (slots.inUse > 0 || slots.queueDepth > 0 || tpsByModel) {
+    lines.push(`Capacity: ${slots.inUse}/${slots.capacity} slots in use (${utilPct}%), queue=${slots.queueDepth}/${slots.queueCapacity}${tpsByModel ? `; throughput: ${tpsByModel}` : ""}.`);
+  }
+  if (snap.ramMB.free < (broker.ramHeadroomMB ?? 0)) {
+    lines.push(`RAM pressure: ${snap.ramMB.free}MB free (below ${broker.ramHeadroomMB}MB headroom).`);
+  }
+  if (snap.vramMB && snap.vramMB.free < (broker.vramHeadroomMB ?? 0)) {
+    lines.push(`VRAM pressure: ${snap.vramMB.free}MB free (below ${broker.vramHeadroomMB}MB headroom).`);
+  }
+  const queueThreshold = Math.floor(snap.slots.queueCapacity * 0.8);
+  if (snap.slots.queueDepth >= queueThreshold) {
+    lines.push(`Queue pressure: ${snap.slots.queueDepth}/${snap.slots.queueCapacity} entries — prefer brief replies or single-emoji reactions to keep the queue draining.`);
+  }
+  const interesting = pidSnap.filter((p2) => p2.samples >= 3 && (p2.output < 0.95 || p2.output > 1.05));
+  if (interesting.length > 0) {
+    const pidLines = interesting.slice(0, 4).map((p2) => `${p2.key}: u=${p2.output.toFixed(2)} (pv=${Math.round(p2.pv)}ms, sp=${p2.setpoint}ms)`).join(", ");
+    lines.push(`Context tier PID state: ${pidLines}.`);
+  }
+  if (sessionKey) {
+    const recent = stream.recentForSession(sessionKey, 15);
+    if (recent.length > 0) {
+      const sends = recent.filter((e2) => e2.kind.startsWith("telegram.send."));
+      const reactions = recent.filter((e2) => e2.kind.startsWith("emoji."));
+      const forbidden = sends.filter((e2) => e2.kind === "telegram.send.forbidden").length;
+      const rateLimited = sends.filter((e2) => e2.kind === "telegram.send.rate_limited").length;
+      if (forbidden > 0) lines.push(`This chat has refused ${forbidden} recent send attempt(s) (e.g. no rights to post). Treat as a strong silence signal.`);
+      if (rateLimited > 0) lines.push(`This chat rate-limited ${rateLimited} recent send(s). Slow cadence.`);
+      if (reactions.length > 0) {
+        const reactSummary = reactions.filter((e2) => e2.kind === "emoji.reaction.received").map((e2) => e2.emoji).join("");
+        if (reactSummary) lines.push(`Recent inbound reactions in this chat: ${reactSummary}`);
+      }
+    }
+  }
+  if (lines.length === 0) return "";
+  return ["## System Observations (broker, PID, capacity, send outcomes)", ...lines].join("\n");
+}
+var PER_SESSION_BUFFER, GLOBAL_BUFFER, SoulObservationStream, _stream, _brokerSubscribed;
+var init_soul_observations = __esm({
+  "packages/cli/src/tui/soul-observations.ts"() {
+    "use strict";
+    init_dist5();
+    init_pid_controller();
+    PER_SESSION_BUFFER = 60;
+    GLOBAL_BUFFER = 200;
+    SoulObservationStream = class {
+      _bySession = /* @__PURE__ */ new Map();
+      _global = [];
+      _listeners = /* @__PURE__ */ new Set();
+      /** Record an event. */
+      emit(event) {
+        if ("sessionKey" in event && event.sessionKey) {
+          let buf = this._bySession.get(event.sessionKey);
+          if (!buf) {
+            buf = [];
+            this._bySession.set(event.sessionKey, buf);
+          }
+          buf.push(event);
+          if (buf.length > PER_SESSION_BUFFER) buf.shift();
+        }
+        this._global.push(event);
+        if (this._global.length > GLOBAL_BUFFER) this._global.shift();
+        for (const listener of this._listeners) {
+          try {
+            listener(event);
+          } catch {
+          }
+        }
+      }
+      /** Subscribe to all events (live tail). */
+      subscribe(listener) {
+        this._listeners.add(listener);
+        return () => this._listeners.delete(listener);
+      }
+      /** Read recent events for a session (most recent last). */
+      recentForSession(sessionKey, limit = 20) {
+        const buf = this._bySession.get(sessionKey) ?? [];
+        return buf.slice(-limit);
+      }
+      /** Read recent global events. */
+      recentGlobal(limit = 30) {
+        return this._global.slice(-limit);
+      }
+      reset() {
+        this._bySession.clear();
+        this._global.length = 0;
+      }
+    };
+    _stream = null;
+    _brokerSubscribed = false;
+  }
+});
+
 // packages/cli/src/tui/telegram-channel-dmn.ts
 import { existsSync as existsSync115, mkdirSync as mkdirSync65, readdirSync as readdirSync40, readFileSync as readFileSync94, writeFileSync as writeFileSync59 } from "node:fs";
 import { join as join129 } from "node:path";
@@ -614338,7 +615895,7 @@ function buildReplyOpportunities(input, openQuestions) {
 function daydreamOpportunityId(input, trigger) {
   return createHash23("sha1").update(`${input.sessionKey}:${input.generatedAtMs}:${trigger}`).digest("hex").slice(0, 16);
 }
-function clamp018(value2) {
+function clamp019(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
 }
@@ -614349,7 +615906,7 @@ function pushStimulationSignal(signals, signal, source, weight) {
   const cleanSignal = compactLine2(signal, 120);
   const cleanSource = compactLine2(source, 180);
   if (!cleanSignal || signals.some((entry) => entry.signal === cleanSignal && entry.source === cleanSource)) return;
-  signals.push({ signal: cleanSignal, source: cleanSource, weight: clamp018(weight) });
+  signals.push({ signal: cleanSignal, source: cleanSource, weight: clamp019(weight) });
 }
 function buildMetaAnalysisSignals(input) {
   const chatLabel = input.chatTitle || input.chatId;
@@ -614424,7 +615981,7 @@ function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
       question: text.endsWith("?") || text.endsWith("？") ? text : `What should be learned or clarified from: ${text || entry.mediaSummary || "recent media"}?`,
       rationale: "Human curiosity, uncertainty, or multimodal content makes this a useful idle exploration target.",
       sourceMessages: messageId,
-      intensity: clamp018(0.5 + replyBoost + mediaBoost + questionBoost)
+      intensity: clamp019(0.5 + replyBoost + mediaBoost + questionBoost)
     });
   }
   for (const question of openQuestions.slice(-4)) {
@@ -614444,7 +616001,7 @@ function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
       question: `Is there a useful clarification or memory consolidation around ${strongest.source}?`,
       rationale: "Strongest stimulation signal can seed a low-intrusion reflection target.",
       sourceMessages: [],
-      intensity: clamp018(strongest.weight * 0.72)
+      intensity: clamp019(strongest.weight * 0.72)
     });
   }
   return threads.sort((a2, b) => b.intensity - a2.intensity).slice(0, 8);
@@ -614518,7 +616075,7 @@ function buildOutreachPlans(input, curiosityThreads) {
       purpose: "Continue the public thread only when the live model judges that the group would benefit from a concise follow-up.",
       draftIntent: "Ask one concrete clarification, offer one useful synthesis, or stay silent if the room has moved on.",
       gate: "model_decision",
-      confidence: clamp018(thread.intensity * 0.86)
+      confidence: clamp019(thread.intensity * 0.86)
     });
     const participant = participantForThread(input, thread);
     if (!participant) continue;
@@ -614530,7 +616087,7 @@ function buildOutreachPlans(input, curiosityThreads) {
       purpose: "Offer a one-to-one follow-up only if private contact is allowed and the issue is personal, unresolved, or better handled outside the group.",
       draftIntent: "Reference the public thread briefly, ask permission to continue privately, and do not reveal hidden meta-analysis.",
       gate: "admin_review",
-      confidence: clamp018(thread.intensity * 0.58)
+      confidence: clamp019(thread.intensity * 0.58)
     });
   }
   return plans.slice(0, 8);
@@ -615633,7 +617190,7 @@ function numberOr(value2, fallback) {
 function isNumber(value2) {
   return typeof value2 === "number" && Number.isFinite(value2);
 }
-function clamp019(value2) {
+function clamp0110(value2) {
   return Math.max(0, Math.min(1, Number.isFinite(value2) ? value2 : 0));
 }
 function iso(ts) {
@@ -615780,8 +617337,8 @@ function normalizeRelationship(raw) {
     kind: value2.kind,
     fromKey: String(value2.fromKey),
     toKey: String(value2.toKey),
-    confidence: clamp019(numberOr(value2.confidence, 0)),
-    weight: clamp019(numberOr(value2.weight, 0)),
+    confidence: clamp0110(numberOr(value2.confidence, 0)),
+    weight: clamp0110(numberOr(value2.weight, 0)),
     firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
     lastSeenAt: numberOr(value2.lastSeenAt, Date.now()),
     evidenceMessageIds: Array.isArray(value2.evidenceMessageIds) ? value2.evidenceMessageIds.filter(isNumber).slice(-40) : [],
@@ -615800,7 +617357,7 @@ function normalizePreferences(raw) {
       if (!evidence || typeof evidence !== "object") continue;
       out[actorKey][key] = {
         value: Math.max(-1, Math.min(1, numberOr(evidence.value, 0))),
-        confidence: clamp019(numberOr(evidence.confidence, 0)),
+        confidence: clamp0110(numberOr(evidence.confidence, 0)),
         updatedAt: numberOr(evidence.updatedAt, Date.now()),
         evidenceMessageIds: Array.isArray(evidence.evidenceMessageIds) ? evidence.evidenceMessageIds.filter(isNumber).slice(-12) : [],
         note: compactOptional(evidence.note, 220)
@@ -615858,7 +617415,7 @@ function normalizeOutcome(raw) {
     replyToMessageId: typeof value2.replyToMessageId === "number" ? value2.replyToMessageId : void 0,
     route: value2.route === "action" ? "action" : "chat",
     shouldReply: value2.shouldReply === true,
-    confidence: clamp019(numberOr(value2.confidence, 0)),
+    confidence: clamp0110(numberOr(value2.confidence, 0)),
     reason: compact2(value2.reason || "", 280),
     source: compact2(value2.source || "unknown", 80),
     silentDisposition: compactOptional(value2.silentDisposition, 280),
@@ -615870,7 +617427,7 @@ function normalizeOutcome(raw) {
     scenarioNote: compactOptional(value2.scenarioNote, 360),
     scenarioId: compactOptional(value2.scenarioId, 160),
     scenarioLabel: compactOptional(value2.scenarioLabel, 160),
-    scenarioConfidence: typeof value2.scenarioConfidence === "number" && Number.isFinite(value2.scenarioConfidence) ? clamp019(value2.scenarioConfidence) : void 0,
+    scenarioConfidence: typeof value2.scenarioConfidence === "number" && Number.isFinite(value2.scenarioConfidence) ? clamp0110(value2.scenarioConfidence) : void 0,
     scenarioObjective: compactOptional(value2.scenarioObjective, 360),
     scenarioStateLoop: compactOptional(value2.scenarioStateLoop, 360),
     salienceSignals: Array.isArray(value2.salienceSignals) ? value2.salienceSignals.map(String).slice(0, 16) : [],
@@ -615888,7 +617445,7 @@ function normalizeDaydreamOpportunity(raw) {
     artifactId: String(value2.artifactId || "unknown"),
     generatedAt: String(value2.generatedAt || (/* @__PURE__ */ new Date()).toISOString()),
     trigger: compact2(value2.trigger || "", 240),
-    confidence: clamp019(numberOr(value2.confidence, 0)),
+    confidence: clamp0110(numberOr(value2.confidence, 0)),
     lifecycle,
     firstSeenAt: numberOr(value2.firstSeenAt, Date.now()),
     updatedAt: numberOr(value2.updatedAt, Date.now()),
@@ -615945,7 +617502,7 @@ function commitTelegramSocialDecision(state, input) {
     replyToMessageId: input.replyToMessageId,
     route: input.route,
     shouldReply: input.shouldReply,
-    confidence: clamp019(input.confidence),
+    confidence: clamp0110(input.confidence),
     reason: compact2(input.reason, 280),
     source: compact2(input.source, 80),
     silentDisposition: compactOptional(input.silentDisposition, 280),
@@ -615957,7 +617514,7 @@ function commitTelegramSocialDecision(state, input) {
     scenarioNote: compactOptional(input.scenarioNote, 360),
     scenarioId: compactOptional(input.scenarioId, 160),
     scenarioLabel: compactOptional(input.scenarioLabel, 160),
-    scenarioConfidence: input.scenarioConfidence === void 0 ? void 0 : clamp019(input.scenarioConfidence),
+    scenarioConfidence: input.scenarioConfidence === void 0 ? void 0 : clamp0110(input.scenarioConfidence),
     scenarioObjective: compactOptional(input.scenarioObjective, 360),
     scenarioStateLoop: compactOptional(input.scenarioStateLoop, 360),
     salienceSignals: [...new Set((input.salienceSignals ?? []).map(String))].slice(0, 16),
@@ -615981,7 +617538,7 @@ function registerDaydreamOpportunities(state, opportunities, now = Date.now()) {
       artifactId: opportunity.artifactId || "unknown",
       generatedAt: opportunity.generatedAt || new Date(now).toISOString(),
       trigger: compact2(opportunity.trigger, 240),
-      confidence: clamp019(opportunity.confidence),
+      confidence: clamp0110(opportunity.confidence),
       lifecycle: "proposed",
       firstSeenAt: now,
       updatedAt: now,
@@ -615991,7 +617548,7 @@ function registerDaydreamOpportunities(state, opportunities, now = Date.now()) {
     };
     if (existing) {
       item.trigger = compact2(opportunity.trigger, 240) || item.trigger;
-      item.confidence = clamp019(opportunity.confidence);
+      item.confidence = clamp0110(opportunity.confidence);
       item.updatedAt = now;
     }
     state.daydreamOpportunities[id] = item;
@@ -616131,8 +617688,8 @@ function upsertRelationship(state, kind, fromKey, toKey, messageId, confidence2,
     evidenceMessageIds: [],
     source
   };
-  edge.confidence = Math.max(edge.confidence, clamp019(confidence2));
-  edge.weight = Math.min(1, edge.weight + 0.12 + clamp019(confidence2) * 0.2);
+  edge.confidence = Math.max(edge.confidence, clamp0110(confidence2));
+  edge.weight = Math.min(1, edge.weight + 0.12 + clamp0110(confidence2) * 0.2);
   edge.lastSeenAt = now;
   edge.evidenceMessageIds = appendUnique(edge.evidenceMessageIds, messageId, 40);
   edge.note = compactOptional(note, 260) || edge.note;
@@ -616174,7 +617731,7 @@ function setPreference(vector, key, value2, confidence2, messageId, now, note) {
   const existing = vector[key];
   vector[key] = {
     value: existing ? existing.value * 0.7 + value2 * 0.3 : value2,
-    confidence: Math.max(existing?.confidence ?? 0, clamp019(confidence2)),
+    confidence: Math.max(existing?.confidence ?? 0, clamp0110(confidence2)),
     updatedAt: now,
     evidenceMessageIds: appendUnique(existing?.evidenceMessageIds ?? [], messageId, 12),
     note
@@ -616279,19 +617836,51 @@ async function queryVisionModel(modelName, imagePath, prompt = "Describe what yo
   if (!existsSync116(imagePath)) return "";
   const imageBuffer = readFileSync95(imagePath);
   const base64Image = imageBuffer.toString("base64");
+  const broker = getModelBroker();
+  const decision2 = await broker.ensureModelLoadable({
+    name: modelName,
+    domain: "vision",
+    host: "ollama",
+    owner: "vision-ingress",
+    requestedNumCtx: 2048
+  });
+  let effectiveModel = modelName;
+  let numCtx;
+  if (decision2.kind === "reject") {
+    return "";
+  } else if (decision2.kind === "degrade") {
+    effectiveModel = decision2.fallback.name;
+  } else if (decision2.kind === "evict") {
+    for (const target of decision2.evictTargets) {
+      await broker.evict(target.host, target.name, "make-room-for-vision");
+    }
+    numCtx = decision2.effectiveNumCtx;
+  } else if (decision2.kind === "ok") {
+    numCtx = decision2.effectiveNumCtx;
+  } else if (decision2.kind === "wait-for-inflight") {
+    const inner = await decision2.promise;
+    if (inner.kind === "ok") numCtx = inner.effectiveNumCtx;
+    else if (inner.kind === "degrade") effectiveModel = inner.fallback.name;
+    else if (inner.kind === "reject") return "";
+  }
+  if (numCtx === void 0) {
+    const trainCtx = await broker.getNctxTrain(effectiveModel);
+    numCtx = trainCtx && trainCtx > 0 ? Math.min(trainCtx, 4096) : 2048;
+  }
   try {
     const response = await fetch("http://localhost:11434/api/generate", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        model: modelName,
+        model: effectiveModel,
         prompt,
         images: [base64Image],
         stream: false,
-        options: { temperature: 0.3, num_predict: 1024 }
+        options: { temperature: 0.3, num_predict: 1024, num_ctx: numCtx }
       })
     });
     if (!response.ok) return "";
+    broker.touch("ollama", effectiveModel);
     const data = await response.json();
     return (data.response || "").trim();
   } catch {
@@ -616344,6 +617933,7 @@ function formatImageContextPrefix(result) {
 var init_vision_ingress = __esm({
   "packages/cli/src/tui/vision-ingress.ts"() {
     "use strict";
+    init_dist5();
   }
 });
 
@@ -616532,9 +618122,31 @@ function parseTelegramSilentReflectionNotes(text) {
   }
   return null;
 }
-function telegramRouterTimeoutMs(configTimeoutMs, minMs = 12e4, _legacyMaxMs) {
-  const configured = Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) > 0 ? configTimeoutMs : 3e5;
-  return Math.max(configured, minMs, 12e4);
+function estimatePromptTokensFromRequest(request) {
+  let chars = 0;
+  for (const m2 of request.messages ?? []) {
+    if (typeof m2.content === "string") chars += m2.content.length;
+    else if (Array.isArray(m2.content)) {
+      for (const part of m2.content) {
+        if (typeof part?.text === "string") chars += part.text.length;
+      }
+    }
+    chars += 8;
+  }
+  if (Array.isArray(request.tools) && request.tools.length > 0) {
+    chars += request.tools.length * 600;
+  }
+  return Math.ceil(chars / 4);
+}
+function telegramRouterTimeoutMs(configTimeoutMs, _minMs, _legacyMaxMs) {
+  void _minMs;
+  void _legacyMaxMs;
+  const envRaw = Number.parseInt(process.env["OMNIUS_TG_INFERENCE_LIVENESS_MS"] ?? "", 10);
+  const livenessMs = Number.isFinite(envRaw) && envRaw >= 1e4 ? envRaw : 6e5;
+  if (Number.isFinite(configTimeoutMs) && (configTimeoutMs ?? 0) >= livenessMs) {
+    return configTimeoutMs;
+  }
+  return livenessMs;
 }
 function telegramThinkSuppressedRequest(request) {
   const messages2 = Array.isArray(request.messages) ? request.messages.slice() : [];
@@ -617989,6 +619601,9 @@ var init_telegram_bridge = __esm({
     init_telegram_creative_tools();
     init_omnius_directory();
     init_stimulation();
+    init_pid_controller();
+    init_component_benefit();
+    init_soul_observations();
     init_identity_memory_tool();
     init_visual_identity_association();
     init_telegram_channel_dmn();
@@ -621954,6 +623569,12 @@ ${lines.join("\n")}`);
         this.ensureTelegramConversationLoaded(sessionKey);
         const history = this.chatHistory.get(sessionKey) ?? [];
         const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].sort((a2, b) => b.lastSeenTs - a2.lastSeenTs);
+        const modelKey = this.agentConfig?.model ?? "?";
+        const pidReg = getPidRegistry();
+        const tier1Ratio = pidReg.output(`tier1.${modelKey}`);
+        const tier2Ratio = pidReg.output(`tier2.${modelKey}`);
+        const benefitReg = getComponentBenefitRegistry();
+        const sampledComponents = [];
         const isGroup = msg.chatType !== "private";
         const retainedCount = history.length;
         const olderCount = Math.max(0, retainedCount - maxRecent);
@@ -621987,14 +623608,28 @@ ${lines.join("\n")}`);
           sections.push(socialStateContext);
         }
         if (participants.length > 0) {
-          const participantLines = participants.slice(0, 12).map((profile) => {
+          const fullCount = Math.min(12, participants.length);
+          const tier1Count = Math.max(1, Math.round(fullCount * tier1Ratio));
+          const sortedByBenefit = participants.slice(0, fullCount).sort((a2, b) => {
+            const scoreA = benefitReg.score(sessionKey, `tier1.participant.${a2.username ?? a2.fromUserId}`);
+            const scoreB = benefitReg.score(sessionKey, `tier1.participant.${b.username ?? b.fromUserId}`);
+            return scoreB - scoreA;
+          });
+          const selected = sortedByBenefit.slice(0, tier1Count);
+          const participantLines = selected.map((profile) => {
             const label = profile.username && profile.username !== "unknown" ? `@${profile.username}` : profile.firstName || `user:${profile.fromUserId}`;
             const tones = [...profile.toneTags].slice(0, 5).join(", ") || "neutral";
             const direct = profile.directAddressCount ? `, direct-addresses:${profile.directAddressCount}` : "";
             const replies = profile.replyCount ? `, replies:${profile.replyCount}` : "";
+            sampledComponents.push({
+              key: `tier1.participant.${profile.username ?? profile.fromUserId}`,
+              needle: profile.username ?? String(profile.fromUserId)
+            });
             return `- ${label} [${telegramActorKindLabel(profile)}]: messages:${profile.messageCount}${direct}${replies}; tone:${tones}; last=${telegramContextJsonString(profile.lastMessage, 180)}`;
           });
-          sections.push(`### Participants And Relationship Signals
+          const shed = fullCount - tier1Count;
+          const tierNote = shed > 0 ? ` (tier1 u=${tier1Ratio.toFixed(2)}; ${shed} participants shed by benefit)` : "";
+          sections.push(`### Participants And Relationship Signals${tierNote}
 ${participantLines.join("\n")}`);
         }
         const associativeContext = this.relevantTelegramAssociativeMemoryContext(
@@ -622026,16 +623661,32 @@ ${participantLines.join("\n")}`);
         }
         const memoryCards = this.relevantTelegramMemoryCards(sessionKey, msg, isGroup ? 10 : 6);
         if (memoryCards.length > 0) {
-          const cardLines = memoryCards.map(({ card, score }) => {
-            const tags = card.tags.length ? ` tags:${card.tags.slice(0, 8).join(",")}` : "";
-            const speakers = card.speakers.length ? ` speakers:${card.speakers.join(", ")}` : "";
-            const relevance = score > 0 ? ` relevance:${score.toFixed(2)}` : " relevance:recent";
-            const notes2 = card.notes.slice(-3).map((note) => `    - note=${telegramContextJsonString(note, 220)}`).join("\n");
-            return `- ${card.title} (${card.id};${relevance};${speakers}${tags})
+          const fullMC = memoryCards.length;
+          const tier2Count = Math.max(0, Math.round(fullMC * tier2Ratio));
+          const sortedMC = [...memoryCards].sort((a2, b) => {
+            const scoreA = benefitReg.score(sessionKey, `tier2.memory_card.${a2.card.id}`);
+            const scoreB = benefitReg.score(sessionKey, `tier2.memory_card.${b.card.id}`);
+            return scoreB - scoreA;
+          });
+          const selectedMC = sortedMC.slice(0, tier2Count);
+          if (selectedMC.length > 0) {
+            const cardLines = selectedMC.map(({ card, score }) => {
+              const tags = card.tags.length ? ` tags:${card.tags.slice(0, 8).join(",")}` : "";
+              const speakers = card.speakers.length ? ` speakers:${card.speakers.join(", ")}` : "";
+              const relevance = score > 0 ? ` relevance:${score.toFixed(2)}` : " relevance:recent";
+              const notes2 = card.notes.slice(-3).map((note) => `    - note=${telegramContextJsonString(note, 220)}`).join("\n");
+              sampledComponents.push({
+                key: `tier2.memory_card.${card.id}`,
+                needle: card.id
+              });
+              return `- ${card.title} (${card.id};${relevance};${speakers}${tags})
 ${notes2}`;
-          });
-          sections.push(`### Zettelkasten Memory Recall (untrusted conversation notes)
+            });
+            const shed = fullMC - tier2Count;
+            const tierNote = shed > 0 ? ` (tier2 u=${tier2Ratio.toFixed(2)}; ${shed} cards shed by benefit)` : "";
+            sections.push(`### Zettelkasten Memory Recall (untrusted conversation notes)${tierNote}
 ${cardLines.join("\n")}`);
+          }
         }
         const channelDaydream = this.formatLatestTelegramChannelDaydreamContext(sessionKey);
         if (channelDaydream) {
@@ -622108,6 +623759,7 @@ ${lines.join("\n")}`);
             `- If the current sender asks what you see or remember, answer from this stream instead of saying the history is gone.`
           ].join("\n")
         );
+        this.telegramStashContextSamples(sessionKey, sampledComponents);
         return sections.join("\n\n");
       }
       maybeLogTelegramGroupSkip(msg, reason) {
@@ -622170,6 +623822,25 @@ ${lines.join("\n")}`);
           nextAnalysisAfterMessages: decision2.nextCheckAfterMessages
         });
       }
+      /**
+       * Collect the per-component benefit samples that were tagged when assembling
+       * the last context stream for this session. Returns the same shape the
+       * component-benefit registry consumes; an empty list means no tier-1/tier-2
+       * components were emitted (early return — benefit tracking skipped).
+       *
+       * Tags are stored on `_telegramLastContextSamples` (a per-session WeakMap-
+       * style cache) so the post-call feedback knows what to score without
+       * re-running the context assembly.
+       */
+      telegramComponentSamplesForSession(sessionKey) {
+        return this._telegramLastContextSamples.get(sessionKey) ?? [];
+      }
+      /** Per-session cache of last emitted context-component samples. */
+      _telegramLastContextSamples = /* @__PURE__ */ new Map();
+      /** Stash samples for the next post-call feedback cycle. */
+      telegramStashContextSamples(sessionKey, samples) {
+        this._telegramLastContextSamples.set(sessionKey, samples);
+      }
       buildTelegramRouterPersonaContext(sessionKey, msg, toolContext, selfIdentityContext) {
         const baseContract = toolContext === "telegram-admin-dm" ? ADMIN_DM_PROMPT : toolContext === "telegram-admin-group" ? ADMIN_GROUP_PROMPT : TELEGRAM_SAFETY_PROMPT;
         return buildSoulContext({
@@ -622364,30 +624035,55 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
        *      hard-deadline retire path becomes diagnosable instead of opaque
        */
       async telegramObservableInference(backend, request, kind, sessionKey) {
+        const model = this.agentConfig?.model ?? "?";
+        const promptTokens = estimatePromptTokensFromRequest(request);
+        const broker = getModelBroker();
+        const trainCtx = await broker.getNctxTrain(model).catch(() => null);
+        const targetCtx = trainCtx && trainCtx > 0 ? Math.min(trainCtx, Math.max(2048, promptTokens + 1024)) : Math.max(2048, promptTokens + 1024);
+        const requestWithCtx = { ...request, numCtx: targetCtx };
+        const slot = await broker.acquireInferenceSlot({
+          model,
+          domain: "chat",
+          owner: `telegram-bridge/${kind}`,
+          sessionKey,
+          promptTokens,
+          priority: kind === "router" || kind === "router-repair" || kind === "router-strict-retry" ? 1 : 0
+        });
+        this.tuiWrite(() => renderTelegramSubAgentEvent(
+          sessionKey,
+          `inference admitted [${kind}] model=${model} prompt~${promptTokens}t num_ctx=${targetCtx} slot=${slot.info.id}${slot.info.reserved ? " reserved" : ""}`
+        ));
         const streamFn = backend.chatCompletionStream;
-        const id = this.registerTelegramInference(kind, sessionKey, this.agentConfig?.model ?? "?");
+        const id = this.registerTelegramInference(kind, sessionKey, model);
+        let completionTokens = 0;
         try {
+          let result;
           if (typeof streamFn !== "function") {
-            const r2 = await backend.chatCompletion(request);
-            this.updateTelegramInferenceFinal(id, r2);
-            return r2;
-          }
-          try {
-            const result = await this.streamTelegramInferenceToCompletion(
-              streamFn.bind(backend),
-              request,
-              id
-            );
-            return result;
-          } catch (streamErr) {
-            const r2 = await backend.chatCompletion(request);
-            this.updateTelegramInferenceFinal(id, r2);
-            this.tuiWrite(() => renderTelegramSubAgentEvent(
-              sessionKey,
-              `inference ${id}: stream errored (${streamErr instanceof Error ? streamErr.message : String(streamErr)}); fell back to non-stream`
-            ));
-            return r2;
+            result = await backend.chatCompletion(requestWithCtx);
+            this.updateTelegramInferenceFinal(id, result);
+          } else {
+            try {
+              result = await this.streamTelegramInferenceToCompletion(
+                streamFn.bind(backend),
+                requestWithCtx,
+                id
+              );
+            } catch (streamErr) {
+              result = await backend.chatCompletion(requestWithCtx);
+              this.updateTelegramInferenceFinal(id, result);
+              this.tuiWrite(() => renderTelegramSubAgentEvent(
+                sessionKey,
+                `inference ${id}: stream errored (${streamErr instanceof Error ? streamErr.message : String(streamErr)}); fell back to non-stream`
+              ));
+            }
           }
+          const usage = result.usage;
+          completionTokens = usage?.completion_tokens ?? 0;
+          slot.release({ ok: true, completionTokens });
+          return result;
+        } catch (err) {
+          slot.release({ ok: false, error: err instanceof Error ? err.message : String(err) });
+          throw err;
         } finally {
           this.deregisterTelegramInference(id);
         }
@@ -622747,33 +624443,15 @@ ${retryText}`,
       /**
        * Internal: start an actual router inference for a sessionKey, store its
        * in-flight promise, and on completion fire any queued trailing call.
+       *
+       * No watchdog timeout — the broker's admission control guarantees the
+       * inference fits available compute. Inflight work always completes; new
+       * work waits in the broker's bounded queue with backpressure to upstream.
+       * Only the fetch-level I/O liveness AbortSignal can interrupt, and only
+       * on TCP-dead.
        */
       startCoalescedTelegramRouterCall(sessionKey, msg, toolContext) {
-        const HARD_DEADLINE_MS = this.telegramRouterHardDeadlineMs();
-        const inner = this.inferTelegramInteractionDecision(msg, toolContext);
-        const promise = new Promise((resolve55, reject) => {
-          let settled = false;
-          const guard = setTimeout(() => {
-            if (settled) return;
-            settled = true;
-            reject(new Error(`router-coalescer: hard deadline exceeded (${Math.round(HARD_DEADLINE_MS / 1e3)}s); inner inference did not settle`));
-          }, HARD_DEADLINE_MS);
-          if (typeof guard.unref === "function") guard.unref();
-          inner.then(
-            (v) => {
-              if (settled) return;
-              settled = true;
-              clearTimeout(guard);
-              resolve55(v);
-            },
-            (e2) => {
-              if (settled) return;
-              settled = true;
-              clearTimeout(guard);
-              reject(e2);
-            }
-          );
-        });
+        const promise = this.inferTelegramInteractionDecision(msg, toolContext);
         this.telegramRouterSessionState.set(sessionKey, { inFlight: promise });
         const onSettled = () => {
           let state;
@@ -622794,11 +624472,6 @@ ${retryText}`,
         promise.then(onSettled, onSettled);
         return promise;
       }
-      telegramRouterHardDeadlineMs() {
-        const raw = Number.parseInt(process.env["OMNIUS_TG_ROUTER_HARD_DEADLINE_MS"] ?? "", 10);
-        if (Number.isFinite(raw) && raw >= 5e3 && raw <= 18e4) return raw;
-        return 6e4;
-      }
       /**
        * Forcibly cancel every in-flight + trailing router-coalescer entry.
        * Used on bridge stop() and by the watchdog if it detects the coalescer
@@ -622994,30 +624667,52 @@ ${stimulationProbe.context}`,
           "",
           context2
         ].filter(Boolean).join("\n");
-        const reflectionNotes = await this.inferTelegramSilentReflectionNotes(
-          backend,
-          sessionKey,
-          msg,
-          toolContext,
-          personaContext,
-          observationContext,
-          config.timeoutMs
-        );
-        const reflectionContext = [
-          "## Silent Reflection Deliverables (must inform the attention decision)",
-          `silent_disposition: ${reflectionNotes.silentDisposition ?? "heard and retained"}`,
-          `mental_note: ${reflectionNotes.mentalNote ?? "no additional observation"}`,
-          `memory_note: ${reflectionNotes.memoryNote ?? "message retained in scoped memory"}`,
-          `relationship_note: ${reflectionNotes.relationshipNote ?? "no relationship change inferred"}`,
-          `procedure_note: ${reflectionNotes.procedureNote ?? "active voice-soul tree loaded; no procedure change inferred"}`,
-          `voice_note: ${reflectionNotes.voiceNote ?? "final voice unchanged unless reply is emitted"}`,
-          `scenario_note: ${reflectionNotes.scenarioNote ?? "scenario classification unavailable"}`,
-          `scenario_id: ${reflectionNotes.scenarioId ?? "unclassified"}`,
-          `scenario_label: ${reflectionNotes.scenarioLabel ?? "Unclassified"}`,
-          `scenario_confidence: ${reflectionNotes.scenarioConfidence !== void 0 ? reflectionNotes.scenarioConfidence.toFixed(2) : "0.00"}`,
-          `scenario_objective: ${reflectionNotes.scenarioObjective ?? "pending model-derived classifier output"}`,
-          `scenario_state_loop: ${reflectionNotes.scenarioStateLoop ?? "pending model-derived classifier output"}`
-        ].join("\n");
+        const brokerSnap = getModelBroker().snapshot();
+        const idleSlotRatio = brokerSnap.slots.capacity > 0 ? 1 - brokerSnap.slots.inUse / brokerSnap.slots.capacity : 1;
+        const consolidatedMode = idleSlotRatio < 0.5 || process.env["OMNIUS_TG_FORCE_CONSOLIDATED"] === "1";
+        let reflectionNotes;
+        let reflectionContext;
+        if (consolidatedMode) {
+          reflectionNotes = this.fallbackTelegramSilentReflectionNotes(msg, "consolidated mode: reflection computed inline by router");
+          reflectionContext = [
+            "## Consolidated Reflection (you produce these fields as part of the same JSON)",
+            "Before emitting your final decision, internally reflect on:",
+            "  silent_disposition: what happens silently with this message",
+            "  mental_note: concise observation of the turn",
+            "  memory_note: what scoped memory should retain or connect",
+            "  relationship_note: relationship/thread implication",
+            "  procedure_note: active tree/branch/abort implication",
+            "  voice_note: final voice implication if a reply happens",
+            "  scenario_note: identified scenario and transition state",
+            "  scenario_id / scenario_label / scenario_confidence / scenario_objective / scenario_state_loop",
+            "Use these as your attention substrate, then decide route/should_reply/confidence. Return all fields in ONE JSON."
+          ].join("\n");
+        } else {
+          reflectionNotes = await this.inferTelegramSilentReflectionNotes(
+            backend,
+            sessionKey,
+            msg,
+            toolContext,
+            personaContext,
+            observationContext,
+            config.timeoutMs
+          );
+          reflectionContext = [
+            "## Silent Reflection Deliverables (must inform the attention decision)",
+            `silent_disposition: ${reflectionNotes.silentDisposition ?? "heard and retained"}`,
+            `mental_note: ${reflectionNotes.mentalNote ?? "no additional observation"}`,
+            `memory_note: ${reflectionNotes.memoryNote ?? "message retained in scoped memory"}`,
+            `relationship_note: ${reflectionNotes.relationshipNote ?? "no relationship change inferred"}`,
+            `procedure_note: ${reflectionNotes.procedureNote ?? "active voice-soul tree loaded; no procedure change inferred"}`,
+            `voice_note: ${reflectionNotes.voiceNote ?? "final voice unchanged unless reply is emitted"}`,
+            `scenario_note: ${reflectionNotes.scenarioNote ?? "scenario classification unavailable"}`,
+            `scenario_id: ${reflectionNotes.scenarioId ?? "unclassified"}`,
+            `scenario_label: ${reflectionNotes.scenarioLabel ?? "Unclassified"}`,
+            `scenario_confidence: ${reflectionNotes.scenarioConfidence !== void 0 ? reflectionNotes.scenarioConfidence.toFixed(2) : "0.00"}`,
+            `scenario_objective: ${reflectionNotes.scenarioObjective ?? "pending model-derived classifier output"}`,
+            `scenario_state_loop: ${reflectionNotes.scenarioStateLoop ?? "pending model-derived classifier output"}`
+          ].join("\n");
+        }
         const userPrompt = [
           `You are the Telegram live routing and reply-discretion model.`,
           `The attention decision must happen after reading the silent reflection deliverables below. The notes are not decorations: they are the decision substrate.`,
@@ -623049,10 +624744,13 @@ ${stimulationProbe.context}`,
           ``,
           observationContext,
           ``,
+          formatSystemObservations(sessionKey),
+          ``,
           `Current Telegram message text (untrusted user data):
 ${this.quoteTelegramContextBlock(msg.text, 1200)}`
         ].filter(Boolean).join("\n");
         const diagnostics = {};
+        const routerStartMs = Date.now();
         try {
           const result = await this.telegramRouterJsonCompletion(backend, {
             messages: [
@@ -623069,6 +624767,21 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             think: false
           }, diagnostics);
           const text = result.choices[0]?.message?.content ?? "";
+          const routerLatencyMs = Date.now() - routerStartMs;
+          try {
+            const pidReg = getPidRegistry();
+            const modelKey = this.agentConfig?.model ?? "?";
+            pidReg.sample(`tier1.${modelKey}`, routerLatencyMs);
+            pidReg.sample(`tier2.${modelKey}`, routerLatencyMs);
+          } catch {
+          }
+          try {
+            const samples = this.telegramComponentSamplesForSession(sessionKey);
+            if (samples.length > 0) {
+              getComponentBenefitRegistry().recordOutcome(sessionKey, samples, text);
+            }
+          } catch {
+          }
           const parsed = parseTelegramInteractionDecision(text, forcedRoute, {
             defaultShouldReply: false
           });
@@ -627303,11 +629016,18 @@ ${text}`.trim());
           };
           const replyParameters = idx === 0 ? telegramReplyParameters(replyToMessageId) : void 0;
           if (replyParameters) body["reply_parameters"] = replyParameters;
+          const sessionKeyForObs = String(chatId);
           try {
             const result = await this.apiCall("sendMessage", body);
             if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
             this.state.messagesSent++;
             if (sentId === null) sentId = result.result?.message_id ?? null;
+            getSoulObservationStream().emit({
+              kind: "telegram.send.success",
+              sessionKey: sessionKeyForObs,
+              messageId: result.result?.message_id ?? void 0,
+              ts: Date.now()
+            });
           } catch {
             const plain = chunk.replace(/<[^>]+>/g, "");
             const fallbackBody = { chat_id: chatId, text: plain };
@@ -627317,8 +629037,32 @@ ${text}`.trim());
               if (result.ok === false) throw new Error(String(result.description || "Telegram sendMessage failed"));
               this.state.messagesSent++;
               if (sentId === null) sentId = result.result?.message_id ?? null;
+              getSoulObservationStream().emit({
+                kind: "telegram.send.success",
+                sessionKey: sessionKeyForObs,
+                messageId: result.result?.message_id ?? void 0,
+                ts: Date.now()
+              });
             } catch (err) {
               this.tuiWrite(() => renderWarning(`Failed to send Telegram message: ${err instanceof Error ? err.message : String(err)}`));
+              const errStr = err instanceof Error ? err.message : String(err);
+              const lc = errStr.toLowerCase();
+              if (/(not enough rights|forbidden|chat_write_forbidden|user_banned|kicked|chat_admin_required)/.test(lc)) {
+                getSoulObservationStream().emit({
+                  kind: "telegram.send.forbidden",
+                  sessionKey: sessionKeyForObs,
+                  reason: errStr,
+                  ts: Date.now()
+                });
+              } else if (/too many requests|retry after/.test(lc)) {
+                const m2 = lc.match(/retry after (\d+)/);
+                getSoulObservationStream().emit({
+                  kind: "telegram.send.rate_limited",
+                  sessionKey: sessionKeyForObs,
+                  retryAfterSec: m2 ? parseInt(m2[1], 10) : void 0,
+                  ts: Date.now()
+                });
+              }
             }
           }
         }
@@ -629030,12 +630774,12 @@ var direct_input_exports = {};
 __export(direct_input_exports, {
   DirectInput: () => DirectInput
 });
-import { EventEmitter as EventEmitter11 } from "node:events";
+import { EventEmitter as EventEmitter12 } from "node:events";
 var DirectInput;
 var init_direct_input = __esm({
   "packages/cli/src/tui/direct-input.ts"() {
     "use strict";
-    DirectInput = class extends EventEmitter11 {
+    DirectInput = class extends EventEmitter12 {
       /** Current input line text */
       line = "";
       /** Cursor position within .line (0-based) */
@@ -629754,8 +631498,8 @@ var voicechat_exports = {};
 __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
-import { EventEmitter as EventEmitter12 } from "node:events";
-function clamp0110(x) {
+import { EventEmitter as EventEmitter13 } from "node:events";
+function clamp0111(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -629794,9 +631538,9 @@ function computeSignalFromText(text, confidence2) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
-    score = 0.7 * score + 0.3 * clamp0110(confidence2);
+    score = 0.7 * score + 0.3 * clamp0111(confidence2);
   }
-  return clamp0110(score);
+  return clamp0111(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -629864,7 +631608,7 @@ Rules:
 - Prefer tools for factual queries; otherwise, answer directly with a short reply.`;
     MIN_SIGNAL_SCORE = 0.4;
     NOISE_ONLY_RE = /^(?:[.·…\s,;:!?\-–—_()\[\]{}"'`]+|(?:uh|um|erm|hmm|mm+|uhh+|umm+)[\s.!?]*)+$/i;
-    VoiceChatSession = class extends EventEmitter12 {
+    VoiceChatSession = class extends EventEmitter13 {
       voice;
       listen;
       backendUrl;
@@ -630066,7 +631810,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0110(snr) : computeSignalFromText(text, confidence2);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp0111(snr) : computeSignalFromText(text, confidence2);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -630393,7 +632137,7 @@ __export(voice_runtime_exports, {
   synthesizeToWav: () => synthesizeToWav,
   unregisterClient: () => unregisterClient
 });
-import { EventEmitter as EventEmitter13 } from "node:events";
+import { EventEmitter as EventEmitter14 } from "node:events";
 function getVoiceEngine() {
   if (!_voiceEngine) {
     _voiceEngine = new VoiceEngine();
@@ -630405,7 +632149,7 @@ function getDaemonListenEngine() {
   return _listenEngine;
 }
 function getVoiceBus() {
-  if (!_bus) _bus = new EventEmitter13();
+  if (!_bus) _bus = new EventEmitter14();
   return _bus;
 }
 function getRuntimeStatus() {
@@ -661368,8 +663112,8 @@ NEW TASK: ${fullInput}`;
         const updateInfo = await checkForUpdate(version4);
         if (updateInfo) {
           _autoUpdatedThisSession = true;
-          const { exec: exec5 } = await import("node:child_process");
-          exec5(
+          const { exec: exec6 } = await import("node:child_process");
+          exec6(
             `npm install -g omnius@latest --prefer-online`,
             { timeout: 18e4 },
             (err) => {