omnius 1.0.134 → 1.0.136

package/dist/index.js

@@ -1365,7 +1365,7 @@ async function vramSnapshotMB() {
 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, ModelBroker, _nvSmiAvailable;
+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";
@@ -1374,6 +1374,11 @@ var init_model_broker = __esm({
     DEFAULT_IDLE_EVICT_MS = 5 * 60 * 1e3;
     DEFAULT_POLL_MS = 4e3;
     DEFAULT_INFLIGHT_WAIT_MS = 6e4;
+    DEFAULT_SLOT_CAPACITY = 8;
+    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}`. */
@@ -1398,6 +1403,22 @@ var init_model_broker = __esm({
       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();
@@ -1876,7 +1897,30 @@ var init_model_broker = __esm({
           inflight: [...this._inflight.entries()].map(([key, v]) => ({ key, owner: v.owner, startedMs: v.startedMs })),
           ramMB: ram,
           vramMB: vram,
-          lastPollAt: Date.now()
+          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) {
@@ -1890,6 +1934,196 @@ var init_model_broker = __esm({
             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) => {
+          if (this._slotQueue.length >= this.queueCapacity) {
+            const newPrio = spec.priority ?? 0;
+            let victim = -1;
+            let victimPrio = Infinity;
+            for (let i2 = this._slotQueue.length - 1; i2 >= 0; i2--) {
+              const p2 = this._slotQueue[i2].spec.priority ?? 0;
+              if (p2 < victimPrio) {
+                victimPrio = p2;
+                victim = i2;
+              }
+              if (victimPrio === 0)
+                break;
+            }
+            if (victim >= 0 && victimPrio < newPrio) {
+              const dropped = this._slotQueue.splice(victim, 1)[0];
+              if (dropped.onSignalAbort && dropped.spec.signal) {
+                dropped.spec.signal.removeEventListener("abort", dropped.onSignalAbort);
+              }
+              try {
+                dropped.reject(new Error("broker queue shed: capacity reached, lower-priority entry displaced"));
+              } catch {
+              }
+            } else {
+              reject(new Error(`broker queue full (capacity=${this.queueCapacity}); caller priority ${newPrio} insufficient to displace`));
+              return;
+            }
+          }
+          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}`;
@@ -1899,6 +2133,115 @@ var init_model_broker = __esm({
   }
 });
 
+// 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) {
@@ -525416,6 +525759,7 @@ __export(dist_exports, {
   videoGenerationQualityLadder: () => videoGenerationQualityLadder,
   videoGenerationSetupPlan: () => videoGenerationSetupPlan,
   worktreeHasChanges: () => worktreeHasChanges,
+  wrapWithBroker: () => wrapWithBroker,
   writeProvenanceFile: () => writeProvenanceFile,
   writeTodos: () => writeTodos
 });
@@ -525424,6 +525768,7 @@ var init_dist5 = __esm({
     "use strict";
     init_tool_executor();
     init_model_broker();
+    init_broker_mediated_backend();
     init_security_classifier();
     init_tool_manifest();
     init_provenance();
@@ -555275,6 +555620,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;
@@ -615178,6 +615530,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";
@@ -615276,7 +615922,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));
 }
@@ -615287,7 +615933,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;
@@ -615362,7 +616008,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)) {
@@ -615382,7 +616028,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);
@@ -615456,7 +616102,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;
@@ -615468,7 +616114,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);
@@ -616571,7 +617217,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) {
@@ -616718,8 +617364,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) : [],
@@ -616738,7 +617384,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)
@@ -616796,7 +617442,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),
@@ -616808,7 +617454,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) : [],
@@ -616826,7 +617472,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()),
@@ -616883,7 +617529,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),
@@ -616895,7 +617541,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),
@@ -616919,7 +617565,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,
@@ -616929,7 +617575,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;
@@ -617069,8 +617715,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;
@@ -617112,7 +617758,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
@@ -617503,9 +618149,57 @@ 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 isLikelyTruncatedRouterJson(text) {
+  if (typeof text !== "string") return false;
+  const stripped = text.replace(/^\s*<think>[\s\S]*?<\/think>\s*/i, "").trim();
+  if (!stripped.startsWith("{")) return false;
+  let depth = 0;
+  let inString = false;
+  let escape2 = false;
+  for (let i2 = 0; i2 < stripped.length; i2++) {
+    const ch = stripped[i2];
+    if (escape2) {
+      escape2 = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\") escape2 = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+  }
+  if (depth <= 0) return false;
+  const hits = (stripped.includes('"route"') ? 1 : 0) + (stripped.includes('"should_reply"') ? 1 : 0) + (stripped.includes('"confidence"') ? 1 : 0) + (stripped.includes('"reason"') ? 1 : 0) + (stripped.includes('"silent_disposition"') ? 1 : 0) + (stripped.includes('"mental_note"') ? 1 : 0);
+  return hits >= 3;
+}
+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() : [];
@@ -618960,6 +619654,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();
@@ -622925,6 +623622,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);
@@ -622958,14 +623661,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(
@@ -622997,16 +623714,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) {
@@ -623079,6 +623812,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) {
@@ -623141,6 +623875,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({
@@ -623249,7 +624002,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
               ],
               tools: [],
               temperature: 0,
-              maxTokens: 650,
+              // Reflection has 12 string fields; 650 was tight enough to truncate.
+              maxTokens: 1500,
               timeoutMs: telegramRouterTimeoutMs(timeoutMs),
               think: false
             },
@@ -623335,30 +624089,58 @@ ${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 completionHeadroom = 4096;
+        const targetCtx = trainCtx && trainCtx > 0 ? Math.min(trainCtx, Math.max(2048, promptTokens + completionHeadroom)) : Math.max(2048, promptTokens + completionHeadroom);
+        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
+        });
+        if (process.env["OMNIUS_BROKER_TRACE"] === "1") {
+          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);
         }
@@ -623549,7 +624331,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
       getTelegramThinkingVisible() {
         return this.telegramThinkingVisible;
       }
-      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs, diagnostics) {
+      async repairTelegramInteractionDecision(backend, rawOutput, forcedRoute, timeoutMs, diagnostics, sessionKey = "__router__") {
         const rawPreview = telegramRouterRawPreview(rawOutput, 4e3);
         if (!rawPreview || telegramDecisionOutputHasDanglingJson(rawOutput)) {
           if (diagnostics) {
@@ -623584,10 +624366,10 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 500,
+            maxTokens: 1500,
             timeoutMs: telegramRouterTimeoutMs(timeoutMs, 8e3, 2e4),
             think: false
-          });
+          }, diagnostics, "router-repair", sessionKey);
           const repairedText = result.choices[0]?.message?.content ?? "";
           if (telegramDecisionRecoverableFlag(repairedText) === false) {
             if (diagnostics) diagnostics.repairStatus = "no-recoverable-output";
@@ -623619,7 +624401,7 @@ ${repairedText}`,
           return null;
         }
       }
-      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs, diagnostics) {
+      async retryTelegramInteractionDecisionStrict(backend, userPrompt, rawOutput, forcedRoute, timeoutMs, diagnostics, sessionKey = "__router__") {
         const invalidPreview = telegramRouterRawPreview(rawOutput, 1200) ?? "(empty assistant content)";
         const routeInstruction = forcedRoute ? `The operator selected Telegram mode "${forcedRoute}". The route field must be "${forcedRoute}", but should_reply must still be inferred from context.` : `Infer route live from context.`;
         const trimmedUserPrompt = userPrompt.length > 4e3 ? `…
@@ -623651,10 +624433,10 @@ ${userPrompt.slice(-4e3)}` : userPrompt;
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 1200,
+            maxTokens: 2400,
             timeoutMs: telegramRouterTimeoutMs(timeoutMs, 1e4, 3e4),
             think: false
-          });
+          }, diagnostics, "router-strict-retry", sessionKey);
           const retryText = result.choices[0]?.message?.content ?? "";
           if (diagnostics) diagnostics.strictRetryPreview = telegramRouterRawPreview(retryText, 320);
           const parsed = parseTelegramInteractionDecision(retryText, forcedRoute, {
@@ -623718,33 +624500,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;
@@ -623765,11 +624529,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
@@ -623965,30 +624724,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.`,
@@ -624020,10 +624801,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: [
@@ -624035,23 +624819,70 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             ],
             tools: [],
             temperature: 0,
-            maxTokens: 1e3,
+            // Router JSON schema has ~18 string-valued fields when reflection is
+            // embedded (consolidated mode). 1000 tokens was the documented cause
+            // of truncated JSON → repair → strict-retry cascade. 2400 is enough
+            // for normal verbose values without slowing the call appreciably.
+            maxTokens: 2400,
             timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
             think: false
-          }, diagnostics);
+          }, diagnostics, "router", sessionKey);
           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
           });
           if (parsed) {
             return this.applyTelegramSilentReflectionNotes(parsed, reflectionNotes);
           }
+          if (isLikelyTruncatedRouterJson(text)) {
+            if (diagnostics) diagnostics.repairStatus = "skipped-truncation-rerun";
+            try {
+              const reissued = await this.telegramRouterJsonCompletion(backend, {
+                messages: [
+                  {
+                    role: "system",
+                    content: "You perform live Telegram route and stimulation inference. Output strict JSON only."
+                  },
+                  { role: "user", content: userPrompt }
+                ],
+                tools: [],
+                temperature: 0,
+                maxTokens: 4096,
+                timeoutMs: telegramRouterTimeoutMs(config.timeoutMs),
+                think: false
+              }, diagnostics, "router", sessionKey);
+              const reissuedText = reissued.choices[0]?.message?.content ?? "";
+              const reparsed = parseTelegramInteractionDecision(reissuedText, forcedRoute, {
+                defaultShouldReply: false
+              });
+              if (reparsed) {
+                return this.applyTelegramSilentReflectionNotes(reparsed, reflectionNotes);
+              }
+            } catch {
+            }
+          }
           const repaired = await this.repairTelegramInteractionDecision(
             backend,
             text,
             forcedRoute,
             config.timeoutMs ?? 3e4,
-            diagnostics
+            diagnostics,
+            sessionKey
           );
           if (repaired) {
             return this.applyTelegramSilentReflectionNotes(repaired, reflectionNotes);
@@ -624062,7 +624893,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`
             text,
             forcedRoute,
             config.timeoutMs ?? 3e4,
-            diagnostics
+            diagnostics,
+            sessionKey
           );
           if (strictRetry) {
             return this.applyTelegramSilentReflectionNotes(strictRetry, reflectionNotes);
@@ -628274,11 +629106,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 };
@@ -628288,8 +629127,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()
+                });
+              }
             }
           }
         }
@@ -630726,7 +631589,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter13 } from "node:events";
-function clamp0110(x) {
+function clamp0111(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -630765,9 +631628,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) + "…";
@@ -631037,7 +631900,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);