omnius 1.0.136 → 1.0.138

package/dist/index.js

@@ -1337,29 +1337,36 @@ function ramSnapshotMB() {
   const free = Math.round(freemem() / (1024 * 1024));
   return { total, free, used: total - free };
 }
-async function vramSnapshotMB() {
+async function vramSnapshotPerDevice() {
   if (_nvSmiAvailable === false)
-    return null;
+    return [];
   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));
+      exec("nvidia-smi --query-gpu=index,uuid,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;
+    const devices = [];
     for (const line of out.trim().split("\n")) {
+      if (!line.trim())
+        continue;
       const parts = line.split(",").map((s2) => s2.trim());
-      if (parts.length < 3)
+      if (parts.length < 5)
         continue;
-      total += parseInt(parts[0] ?? "0", 10) || 0;
-      used += parseInt(parts[1] ?? "0", 10) || 0;
-      free += parseInt(parts[2] ?? "0", 10) || 0;
+      const index = parseInt(parts[0] ?? "-1", 10);
+      if (!Number.isFinite(index) || index < 0)
+        continue;
+      devices.push({
+        index,
+        uuid: parts[1] ?? "",
+        total: parseInt(parts[2] ?? "0", 10) || 0,
+        used: parseInt(parts[3] ?? "0", 10) || 0,
+        free: parseInt(parts[4] ?? "0", 10) || 0
+      });
     }
-    if (total <= 0)
-      return null;
-    return { total, used, free };
+    return devices;
   } catch {
     _nvSmiAvailable = false;
-    return null;
+    return [];
   }
 }
 function getModelBroker() {
@@ -1403,7 +1410,9 @@ 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). */
+      /** Inference slot capacity (shared pool aggregate; auto-tunes from Ollama
+       *  pool size when known). Per-device cap defaults to ceil(slotCapacity/N)
+       *  unless overridden via setPerGpuSlotCapacity. */
       slotCapacity = DEFAULT_SLOT_CAPACITY;
       /** Maximum queue depth before queue pressure is emitted. */
       queueCapacity = DEFAULT_QUEUE_CAPACITY;
@@ -1419,6 +1428,15 @@ var init_model_broker = __esm({
       _throughput = /* @__PURE__ */ new Map();
       /** Monotonic counter for slot ids. */
       _slotIdSeq = 0;
+      /** Per-GPU slot capacity override. When unset, broker derives a per-GPU
+       *  cap from slotCapacity / detected device count. */
+      _perGpuSlotCapacity = /* @__PURE__ */ new Map();
+      /** Cached per-device VRAM (refreshed by pollOnce). */
+      _vramByDevice = [];
+      /** Optional provider that maps an Ollama model name to its current GPU.
+       *  Wired by the CLI/orchestrator at startup so the broker can copy pool
+       *  affinity onto LoadedModel records without importing the pool directly. */
+      _ollamaAffinityProvider = null;
       static getInstance() {
         if (!_ModelBroker._instance)
           _ModelBroker._instance = new _ModelBroker();
@@ -1471,6 +1489,18 @@ var init_model_broker = __esm({
       setOllamaBaseUrl(url) {
         this._ollamaBaseUrl = url;
       }
+      /**
+       * Wire a function that resolves an Ollama model name to its current GPU
+       * affinity (from the Ollama pool's per-instance state). The CLI calls
+       * this at startup with a closure over `getOllamaPool().status()` so the
+       * broker can copy gpuIndex/gpuUuid onto LoadedModel records without
+       * importing from @omnius/orchestrator (which would create a circular dep).
+       *
+       * Pass null to clear.
+       */
+      setOllamaAffinityProvider(provider) {
+        this._ollamaAffinityProvider = provider;
+      }
       /** One poll cycle — refreshes /api/ps and emits snapshot. */
       async pollOnce() {
         await Promise.all([
@@ -1539,30 +1569,44 @@ var init_model_broker = __esm({
         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;
+        const devices = await vramSnapshotPerDevice();
+        this._vramByDevice = devices;
+        let chosenGpu = null;
+        let vramFitsAfter = devices.length === 0;
+        if (devices.length > 0) {
+          const candidates = devices.filter((d2) => spec.preferredGpuIndex === void 0 || d2.index === spec.preferredGpuIndex).filter((d2) => d2.free - estVram >= this.vramHeadroomMB).sort((a2, b) => b.free - a2.free);
+          if (candidates.length > 0) {
+            chosenGpu = candidates[0].index;
+            vramFitsAfter = true;
+          }
+        }
         if (ramFitsAfter && vramFitsAfter) {
-          const promise = Promise.resolve({ kind: "ok", effectiveNumCtx });
+          const decision2 = { kind: "ok", effectiveNumCtx, gpuIndex: chosenGpu };
+          const promise = Promise.resolve(decision2);
           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 };
+          return decision2;
         }
+        const targetGpu = chosenGpu ?? this.deviceWithMostPressureRelativeTo(devices, estVram);
+        const needVramMB = vramFitsAfter ? 0 : targetGpu !== null ? estVram + this.vramHeadroomMB - (devices.find((d2) => d2.index === targetGpu)?.free ?? 0) : estVram + this.vramHeadroomMB;
         const evictTargets = this.pickEvictionCandidates({
-          needVramMB: vramFitsAfter ? 0 : estVram + this.vramHeadroomMB - (vram?.free ?? 0),
+          needVramMB,
           needRamMB: ramFitsAfter ? 0 : estRam + this.ramHeadroomMB - ram.free,
           requestingPriority: spec.priority ?? 0,
-          requestingDomain: spec.domain
+          requestingDomain: spec.domain,
+          targetGpu
         });
         if (evictTargets.length > 0) {
-          return { kind: "evict", evictTargets, effectiveNumCtx };
+          return { kind: "evict", evictTargets, effectiveNumCtx, gpuIndex: targetGpu };
         }
         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`;
+        const perDeviceSummary = devices.length === 0 ? "no GPU" : devices.map((d2) => `gpu${d2.index}=${d2.free}MB`).join(", ");
+        const reason = `insufficient resources (need ~${estRam}MB RAM, ~${estVram}MB VRAM; free ${ram.free}MB RAM; VRAM ${perDeviceSummary}) and no evictable / fallback models`;
         this.emit("rejected", spec, reason);
         return { kind: "reject", reason };
       }
@@ -1638,10 +1682,22 @@ var init_model_broker = __esm({
             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));
+            let affinity = null;
+            try {
+              affinity = this._ollamaAffinityProvider ? this._ollamaAffinityProvider(m2.name) : null;
+            } catch {
+              affinity = null;
+            }
             const existing = this._loaded.get(key);
             if (existing) {
               existing.vramMB = vramMB || existing.vramMB;
               existing.ramMB = ramMB || existing.ramMB;
+              if (affinity) {
+                if (affinity.gpuIndex !== null)
+                  existing.gpuIndex = affinity.gpuIndex;
+                if (affinity.gpuUuid !== null)
+                  existing.gpuUuid = affinity.gpuUuid;
+              }
             } else {
               const tracked = this.registerLoaded({
                 key,
@@ -1653,7 +1709,9 @@ var init_model_broker = __esm({
                 ramMB,
                 priority: 0,
                 loadedAt: now,
-                lastUsedAt: now
+                lastUsedAt: now,
+                gpuIndex: affinity?.gpuIndex ?? null,
+                gpuUuid: affinity?.gpuUuid ?? null
               });
               void tracked;
             }
@@ -1746,7 +1804,8 @@ var init_model_broker = __esm({
           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 onTargetGpu = (m2) => req2.targetGpu === void 0 || req2.targetGpu === null ? true : m2.gpuIndex === req2.targetGpu;
+        const evictable = [...this._loaded.values()].filter((m2) => m2.priority <= req2.requestingPriority).filter(sameDomainOk).filter(onTargetGpu).sort((a2, b) => {
           const aIdle = idle(a2) ? 0 : 1;
           const bIdle = idle(b) ? 0 : 1;
           if (aIdle !== bIdle)
@@ -1767,6 +1826,24 @@ var init_model_broker = __esm({
           return targets;
         return [];
       }
+      /** Pick the GPU whose free-VRAM gap to the requested footprint is smallest
+       *  (i.e. closest to fitting). Used when no device cleanly fits — eviction
+       *  on this device has the best chance of opening room. Returns null when
+       *  no GPUs are detected. */
+      deviceWithMostPressureRelativeTo(devices, needMB) {
+        if (devices.length === 0)
+          return null;
+        let best = null;
+        let bestGap = Infinity;
+        for (const d2 of devices) {
+          const gap = needMB - d2.free;
+          if (gap < bestGap) {
+            bestGap = gap;
+            best = d2;
+          }
+        }
+        return best?.index ?? null;
+      }
       countByDomain(domain) {
         let n2 = 0;
         for (const m2 of this._loaded.values())
@@ -1897,17 +1974,31 @@ var init_model_broker = __esm({
           inflight: [...this._inflight.entries()].map(([key, v]) => ({ key, owner: v.owner, startedMs: v.startedMs })),
           ramMB: ram,
           vramMB: vram,
+          vramPerDevice: [...this._vramByDevice],
           lastPollAt: Date.now(),
           slots: this.buildSlotsSnapshot()
         };
       }
       buildSlotsSnapshot() {
         const byModel = {};
+        const byGpu = {};
         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;
+          if (slot.gpuIndex !== null && slot.gpuIndex !== void 0) {
+            if (!byGpu[slot.gpuIndex])
+              byGpu[slot.gpuIndex] = { inUse: 0, capacity: this.perGpuSlotCapacity(slot.gpuIndex), loadedMB: 0 };
+            byGpu[slot.gpuIndex].inUse += 1;
+          }
+        }
+        for (const m2 of this._loaded.values()) {
+          if (m2.gpuIndex !== null && m2.gpuIndex !== void 0) {
+            if (!byGpu[m2.gpuIndex])
+              byGpu[m2.gpuIndex] = { inUse: 0, capacity: this.perGpuSlotCapacity(m2.gpuIndex), loadedMB: 0 };
+            byGpu[m2.gpuIndex].loadedMB += m2.vramMB;
+          }
         }
         for (const [model, tp] of this._throughput) {
           if (!byModel[model])
@@ -1915,23 +2006,46 @@ var init_model_broker = __esm({
           byModel[model].tokensPerSec = tp.tokensPerSec;
           byModel[model].samples = tp.samples;
         }
+        for (const d2 of this._vramByDevice) {
+          if (!byGpu[d2.index])
+            byGpu[d2.index] = { inUse: 0, capacity: this.perGpuSlotCapacity(d2.index), loadedMB: 0 };
+        }
         return {
           inUse: this._activeSlots.size,
           capacity: this.slotCapacity,
           queueDepth: this._slotQueue.length,
           queueCapacity: this.queueCapacity,
-          byModel
+          byModel,
+          byGpu
         };
       }
+      /** Per-GPU slot capacity. Returns the override when set, else ceil(slotCapacity / deviceCount). */
+      perGpuSlotCapacity(gpuIndex) {
+        const override = this._perGpuSlotCapacity.get(gpuIndex);
+        if (override !== void 0)
+          return override;
+        const n2 = Math.max(1, this._vramByDevice.length);
+        return Math.max(1, Math.ceil(this.slotCapacity / n2));
+      }
       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 devices = await vramSnapshotPerDevice();
+        this._vramByDevice = devices;
+        if (devices.length > 0) {
+          let total = 0, used = 0, free = 0;
+          for (const d2 of devices) {
+            total += d2.total;
+            used += d2.used;
+            free += d2.free;
+          }
+          snap.vramMB = { total, used, free };
+          snap.vramPerDevice = devices;
+          for (const d2 of devices) {
+            if (d2.free < this.vramHeadroomMB) {
+              this.emit("pressure", "vram", d2.free, this.vramHeadroomMB);
+            }
           }
         }
         const queueThreshold = Math.floor(this.queueCapacity * 0.8);
@@ -1960,18 +2074,22 @@ var init_model_broker = __esm({
        * upstream callers (e.g. Telegram poll loop) should slow ingress.
        */
       acquireInferenceSlot(spec) {
-        if (this._activeSlots.size < this.slotCapacity) {
+        const chosenGpu = this.pickGpuForSlot(spec);
+        const gpuOk = chosenGpu === null || this.activeSlotsOnGpu(chosenGpu) < this.perGpuSlotCapacity(chosenGpu);
+        if (gpuOk && this._activeSlots.size < this.slotCapacity) {
           return Promise.resolve(this.admitSlot(
             spec,
             /*reserved*/
-            false
+            false,
+            chosenGpu
           ));
         }
         if (spec.sessionKey && !this._reservedBySession.has(spec.sessionKey) && this._activeSlots.size < this.slotCapacity + 1) {
           const slot = this.admitSlot(
             spec,
             /*reserved*/
-            true
+            true,
+            chosenGpu
           );
           this._reservedBySession.set(spec.sessionKey, slot.info.id);
           return Promise.resolve(slot);
@@ -2038,7 +2156,7 @@ var init_model_broker = __esm({
         });
       }
       /** Admit a slot — internal, called from acquire fast path and from drainQueue. */
-      admitSlot(spec, reserved) {
+      admitSlot(spec, reserved, gpuIndex = null) {
         const id = `slot-${++this._slotIdSeq}-${Date.now().toString(36)}`;
         const info = {
           id,
@@ -2048,7 +2166,8 @@ var init_model_broker = __esm({
           sessionKey: spec.sessionKey,
           acquiredAt: Date.now(),
           promptTokens: spec.promptTokens ?? 0,
-          reserved
+          reserved,
+          gpuIndex
         };
         this._activeSlots.set(id, info);
         this.emit("slotAcquired", info);
@@ -2064,6 +2183,35 @@ var init_model_broker = __esm({
           }
         };
       }
+      /** Count of active slots pinned to a given GPU. */
+      activeSlotsOnGpu(gpuIndex) {
+        let n2 = 0;
+        for (const s2 of this._activeSlots.values()) {
+          if (s2.gpuIndex === gpuIndex)
+            n2++;
+        }
+        return n2;
+      }
+      /**
+       * Pick a GPU for a new inference slot. Honors caller's preferredGpuIndex
+       * when set; otherwise picks the GPU with the highest free VRAM that has
+       * room for the estimated footprint and an open per-device slot.
+       *
+       * Returns null when no GPU is detected (CPU-only) or no device fits — in
+       * the latter case the slot is admitted unpinned and the underlying
+       * subprocess will pick whatever CUDA exposes by default.
+       */
+      pickGpuForSlot(spec) {
+        if (this._vramByDevice.length === 0)
+          return null;
+        const candidates = this._vramByDevice.filter((d2) => spec.preferredGpuIndex === void 0 || d2.index === spec.preferredGpuIndex).filter((d2) => this.activeSlotsOnGpu(d2.index) < this.perGpuSlotCapacity(d2.index)).filter((d2) => spec.estimatedVramMB === void 0 || d2.free >= spec.estimatedVramMB).sort((a2, b) => b.free - a2.free);
+        return candidates[0]?.index ?? null;
+      }
+      /** Configure per-GPU slot capacity. Overrides the slotCapacity-derived default. */
+      setPerGpuSlotCapacity(gpuIndex, capacity) {
+        this._perGpuSlotCapacity.set(gpuIndex, Math.max(1, Math.floor(capacity)));
+        this.drainSlotQueue();
+      }
       releaseSlot(info, outcome) {
         this._activeSlots.delete(info.id);
         if (info.sessionKey && this._reservedBySession.get(info.sessionKey) === info.id) {
@@ -2089,8 +2237,18 @@ var init_model_broker = __esm({
         this.drainSlotQueue();
       }
       drainSlotQueue() {
-        while (this._slotQueue.length > 0 && this._activeSlots.size < this.slotCapacity) {
-          const entry = this._slotQueue.shift();
+        const queueCopy = [...this._slotQueue];
+        for (const entry of queueCopy) {
+          if (this._activeSlots.size >= this.slotCapacity)
+            break;
+          const chosenGpu = this.pickGpuForSlot(entry.spec);
+          const gpuOk = chosenGpu === null || this.activeSlotsOnGpu(chosenGpu) < this.perGpuSlotCapacity(chosenGpu);
+          if (!gpuOk)
+            continue;
+          const idx = this._slotQueue.indexOf(entry);
+          if (idx < 0)
+            continue;
+          this._slotQueue.splice(idx, 1);
           if (entry.onSignalAbort && entry.spec.signal) {
             entry.spec.signal.removeEventListener("abort", entry.onSignalAbort);
           }
@@ -2104,7 +2262,8 @@ var init_model_broker = __esm({
           const slot = this.admitSlot(
             entry.spec,
             /*reserved*/
-            false
+            false,
+            chosenGpu
           );
           try {
             entry.resolve(slot);
@@ -19608,26 +19767,16 @@ function extractSkillForQuery(skill, content, query, budgetTokens = 900) {
 function buildSkillsSummary(skills) {
   if (skills.length === 0)
     return "";
-  const lines = [
-    "## Skills Index",
-    "",
-    `${skills.length} skills available. Call \`skill_list\` to search, \`skill_execute <name>\` to load full instructions.`,
-    ""
-  ];
   const bySource = /* @__PURE__ */ new Map();
   for (const s2 of skills) {
-    const group = bySource.get(s2.source) ?? [];
-    group.push(s2);
-    bySource.set(s2.source, group);
-  }
-  for (const [source, group] of bySource) {
-    const names = group.map((s2) => {
-      const t2 = s2.triggers[0];
-      return t2 ? `${s2.name}(${t2})` : s2.name;
-    });
-    lines.push(`**${source}** (${group.length}): ${names.join(", ")}`);
+    bySource.set(s2.source, (bySource.get(s2.source) ?? 0) + 1);
   }
-  return lines.join("\n");
+  const sourcesSummary = [...bySource.entries()].sort((a2, b) => b[1] - a2[1]).map(([source, count]) => `${source}=${count}`).join(", ");
+  return [
+    "## Skills Index",
+    `${skills.length} skills available across ${bySource.size} sources (${sourcesSummary}).`,
+    "Use `skill_list` (with optional `filter` or `source`) to search; `skill_execute <name>` to load full instructions."
+  ].join("\n");
 }
 function safeReaddir2(dir, dirsOnly = false) {
   try {
@@ -255439,6 +255588,11 @@ import sys
 import time
 from pathlib import Path
 
+# Broker-picked GPU pinning — MUST run before importing torch.
+_omnius_gpu = os.environ.get("OMNIUS_GPU_INDEX", "").strip()
+if _omnius_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
+    os.environ["CUDA_VISIBLE_DEVICES"] = _omnius_gpu
+
 def _progress(stage, message, percent=None):
     payload = {"omnius_progress": True, "stage": stage, "message": message}
     if percent is not None:
@@ -255597,9 +255751,15 @@ if __name__ == "__main__":
     SDCPP_RUNNER = String.raw`#!/usr/bin/env python3
 import argparse
 import json
+import os
 import time
 from pathlib import Path
 
+# Broker-picked GPU pinning — sd-cpp's CUDA backend honors CUDA_VISIBLE_DEVICES.
+_omnius_gpu = os.environ.get("OMNIUS_GPU_INDEX", "").strip()
+if _omnius_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
+    os.environ["CUDA_VISIBLE_DEVICES"] = _omnius_gpu
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model-path", required=True)
@@ -255713,6 +255873,9 @@ if __name__ == "__main__":
       defaultModel;
       defaultBackend;
       promptExpander = null;
+      /** Broker-chosen GPU pinning for the in-flight generation. Read by the
+       *  spawn path to set OMNIUS_GPU_INDEX in the subprocess env. */
+      _brokerGpuIndex = null;
       constructor(cwd4, ollamaUrl = "http://localhost:11434", defaults3 = {}) {
         this.cwd = cwd4;
         this.ollamaUrl = ollamaUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "");
@@ -255788,6 +255951,7 @@ if __name__ == "__main__":
         const candidates = imageGenerationFallbackCandidates(requestedModel, requestedBackend, generationFallbackEnabled(args));
         const broker = getModelBroker();
         const firstCandidate = candidates[0];
+        let brokerGpuIndex = null;
         if (firstCandidate) {
           const decision2 = await broker.ensureModelLoadable({
             name: firstCandidate.model,
@@ -255799,6 +255963,9 @@ if __name__ == "__main__":
             for (const target of decision2.evictTargets) {
               await broker.evict(target.host, target.name, "image-gen-needs-room");
             }
+            brokerGpuIndex = decision2.gpuIndex ?? null;
+          } else if (decision2.kind === "ok") {
+            brokerGpuIndex = decision2.gpuIndex ?? null;
           } else if (decision2.kind === "reject") {
             return {
               success: false,
@@ -255808,6 +255975,7 @@ if __name__ == "__main__":
             };
           }
         }
+        this._brokerGpuIndex = brokerGpuIndex;
         try {
           return await this.generateCandidateLadder({ candidates, prompt, args, seed, start: start2 });
         } catch (err) {
@@ -256310,10 +256478,14 @@ ${errText.slice(0, 800)}`,
         }
         ensureUnifiedCacheDirs();
         this.emitProgress({ stage: "load", message: `Starting image generation with ${args.model}` });
+        const runnerEnv = { ...python.env };
+        if (this._brokerGpuIndex !== null) {
+          runnerEnv["OMNIUS_GPU_INDEX"] = String(this._brokerGpuIndex);
+        }
         const result = await runProcess2(python.command, argv, {
           cwd: this.cwd,
           timeoutMs: 9e5,
-          env: python.env,
+          env: runnerEnv,
           progressLabel: `Downloading/loading ${args.model}`,
           onProgress: (event) => this.emitProgress(event)
         });
@@ -257609,9 +257781,14 @@ var init_audio_generate = __esm({
       DEFAULT_MUSIC_MODEL
     ];
     DIFFUSERS_AUDIO_RUNNER = String.raw`#!/usr/bin/env python3
-import argparse, json, sys, time
+import argparse, json, os, sys, time
 from pathlib import Path
 
+# Broker-picked GPU pinning — must run before importing torch.
+_omnius_gpu = os.environ.get("OMNIUS_GPU_INDEX", "").strip()
+if _omnius_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
+    os.environ["CUDA_VISIBLE_DEVICES"] = _omnius_gpu
+
 def _format_bytes(value):
     try:
         n = float(value)
@@ -257805,9 +257982,14 @@ if __name__ == "__main__":
     main()
 `;
     TRANSFORMERS_AUDIO_RUNNER = String.raw`#!/usr/bin/env python3
-import argparse, json, sys, time
+import argparse, json, os, sys, time
 from pathlib import Path
 
+# Broker-picked GPU pinning — must run before importing torch.
+_omnius_gpu = os.environ.get("OMNIUS_GPU_INDEX", "").strip()
+if _omnius_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
+    os.environ["CUDA_VISIBLE_DEVICES"] = _omnius_gpu
+
 def _format_bytes(value):
     try:
         n = float(value)
@@ -258033,6 +258215,8 @@ if __name__ == "__main__":
       progressHandler = null;
       lastProgressMessage = "";
       lastProgressAt = 0;
+      /** Broker-chosen GPU pinning for the in-flight generation. */
+      _brokerGpuIndex = null;
       constructor(cwd4, defaults3 = {}) {
         this.cwd = cwd4;
         this.defaults = defaults3;
@@ -258198,6 +258382,7 @@ if __name__ == "__main__":
         const playback = playbackRequested(args);
         const broker = getModelBroker();
         const firstCandidate = candidates[0];
+        let brokerGpuIndex = null;
         if (firstCandidate) {
           const decision2 = await broker.ensureModelLoadable({
             name: firstCandidate.model,
@@ -258209,6 +258394,9 @@ if __name__ == "__main__":
             for (const target of decision2.evictTargets) {
               await broker.evict(target.host, target.name, `${kind}-gen-needs-room`);
             }
+            brokerGpuIndex = decision2.gpuIndex ?? null;
+          } else if (decision2.kind === "ok") {
+            brokerGpuIndex = decision2.gpuIndex ?? null;
           } else if (decision2.kind === "reject") {
             return {
               success: false,
@@ -258218,6 +258406,7 @@ if __name__ == "__main__":
             };
           }
         }
+        this._brokerGpuIndex = brokerGpuIndex;
         try {
           return await this.generateCandidateLadder({ kind, candidates, prompt, args, seed, playback, start: start2 });
         } catch (err) {
@@ -258384,10 +258573,14 @@ if __name__ == "__main__":
         }
         ensureUnifiedCacheDirs();
         this.emitProgress({ stage: "load", message: `Starting ${args.kind} generation with ${args.model}` });
+        const runnerEnv = { ...python.env };
+        if (this._brokerGpuIndex !== null) {
+          runnerEnv["OMNIUS_GPU_INDEX"] = String(this._brokerGpuIndex);
+        }
         const result = await runProcess3(python.command, argv, {
           cwd: this.cwd,
           timeoutMs: 9e5,
-          env: python.env,
+          env: runnerEnv,
           progressLabel: `Downloading/loading ${args.model}`,
           onProgress: (event) => this.emitProgress(event)
         });
@@ -259157,7 +259350,7 @@ function parseRunnerJson3(stdout) {
   }
   return null;
 }
-var DEFAULT_DIFFUSERS_VIDEO_MODEL, SANA_VIDEO_480P_MODEL, SANA_VIDEO_720P_MODEL, WAN_TI2V_5B_MODEL, WAN_T2V_A14B_MODEL, WAN_I2V_A14B_MODEL, WAN_S2V_14B_MODEL, COGVIDEOX_5B_MODEL, COGVIDEOX_2B_MODEL, COGVIDEOX_5B_I2V_MODEL, MOCHI_PREVIEW_MODEL, LTX_VIDEO_MODEL, LTX_2_3_MODEL, HUNYUAN_VIDEO_MODEL, DIFFUSERS_VIDEO_PACKAGES, VIDEO_GENERATION_MODEL_PRESETS, VIDEO_GENERATION_QUALITY_LADDER, VIDEO_AUDIO_QUALITY_LADDER, DIFFUSERS_VIDEO_RUNNER, COMFY_BOOTSTRAP_SCRIPT, COMFY_DEFAULT_WORKFLOWS, VideoGenerateTool;
+var DEFAULT_DIFFUSERS_VIDEO_MODEL, SANA_VIDEO_480P_MODEL, SANA_VIDEO_720P_MODEL, SANA_WM_BIDIRECTIONAL_MODEL, WAN_TI2V_5B_MODEL, WAN_T2V_A14B_MODEL, WAN_I2V_A14B_MODEL, WAN_S2V_14B_MODEL, COGVIDEOX_5B_MODEL, COGVIDEOX_2B_MODEL, COGVIDEOX_5B_I2V_MODEL, MOCHI_PREVIEW_MODEL, LTX_VIDEO_MODEL, LTX_2_3_MODEL, HUNYUAN_VIDEO_MODEL, DIFFUSERS_VIDEO_PACKAGES, VIDEO_GENERATION_MODEL_PRESETS, VIDEO_GENERATION_QUALITY_LADDER, VIDEO_AUDIO_QUALITY_LADDER, DIFFUSERS_VIDEO_RUNNER, COMFY_BOOTSTRAP_SCRIPT, COMFY_DEFAULT_WORKFLOWS, VideoGenerateTool;
 var init_video_generate = __esm({
   "packages/execution/dist/tools/video-generate.js"() {
     "use strict";
@@ -259167,6 +259360,7 @@ var init_video_generate = __esm({
     DEFAULT_DIFFUSERS_VIDEO_MODEL = "Efficient-Large-Model/SANA-Video_2B_480p";
     SANA_VIDEO_480P_MODEL = "Efficient-Large-Model/SANA-Video_2B_480p";
     SANA_VIDEO_720P_MODEL = "Efficient-Large-Model/SANA-Video_2B_720p";
+    SANA_WM_BIDIRECTIONAL_MODEL = "Efficient-Large-Model/SANA-WM_bidirectional";
     WAN_TI2V_5B_MODEL = "Wan-AI/Wan2.2-TI2V-5B-Diffusers";
     WAN_T2V_A14B_MODEL = "Wan-AI/Wan2.2-T2V-A14B-Diffusers";
     WAN_I2V_A14B_MODEL = "Wan-AI/Wan2.2-I2V-A14B-Diffusers";
@@ -259460,6 +259654,41 @@ var init_video_generate = __esm({
         licenseNote: "Apache 2.0",
         note: "Premium Wan T2V; cloud GPU recommended."
       },
+      {
+        id: SANA_WM_BIDIRECTIONAL_MODEL,
+        label: "SANA-WM bidirectional (world-model i2v)",
+        kinds: ["i2v"],
+        backend: "diffusers",
+        // SANA-WM declares its concrete class in model_index.json; loaded via
+        // generic DiffusionPipeline.from_pretrained — the runner's auto path
+        // already does this for unknown model names.
+        pipelineClass: "DiffusionPipeline",
+        install: 'python3 .omnius/video-gen/diffusers_text2video.py --model Efficient-Large-Model/SANA-WM_bidirectional --mode i2v --num-frames 121 --fps 24 --width 704 --height 1280 --steps 30 --guidance 5.0 --image <input.png> --prompt "..." --output .omnius/videos/out.mp4',
+        category: "Premium quality",
+        sizeClass: "2.6B DiT + LTX-2 refiner (Sana World Model)",
+        quality: "Image-to-video world model with optional camera-trajectory control. Two-stage generation (Sana DiT + LTX-2 refiner); hybrid linear attention; 6-DoF camera support via .npy matrices or WASD/IJKL action DSL.",
+        output: "Up to ~13s 704×1280 (portrait 720p) MP4 at 24 fps; max 321 frames.",
+        bestUse: "World-model / camera-controlled video from a single first-frame image. Best on H100/A100-class hardware.",
+        minVramGB: 80,
+        recommendedVramGB: 100,
+        deployment: "Diffusers DiffusionPipeline.from_pretrained; bfloat16; aggressive CPU offload mandatory below 100 GB. Bundled LTX-2 refiner runs as stage 2.",
+        steps: 30,
+        guidance: 5,
+        numFrames: 121,
+        fps: 24,
+        width: 704,
+        height: 1280,
+        dtype: "bfloat16",
+        needsCpuOffload: true,
+        frameQuantum: 1,
+        pixelQuantum: 16,
+        // Apache 2.0 base; bundled LTX-2 refiner + VAE inherit the LTX-2
+        // non-commercial license. Surface that explicitly.
+        licenseNote: "Apache 2.0 (bundled LTX-2 refiner/VAE inherit LTX-2 non-commercial terms)",
+        approxDownloadGB: 99,
+        fallbackFor: [WAN_I2V_A14B_MODEL],
+        note: "Sana World Model bidirectional i2v; portrait 704×1280 fixed; camera control via --camera <matrices.npy> or --action <DSL> when the runner supports it."
+      },
       {
         id: WAN_I2V_A14B_MODEL,
         label: "Wan2.2 I2V A14B",
@@ -259588,6 +259817,9 @@ var init_video_generate = __esm({
       COGVIDEOX_5B_MODEL,
       MOCHI_PREVIEW_MODEL,
       COGVIDEOX_2B_MODEL,
+      // Heavy i2v / world-model tier — only attempted when an explicit model
+      // is requested or the consumer-VRAM tier above has failed for an i2v ask.
+      SANA_WM_BIDIRECTIONAL_MODEL,
       WAN_I2V_A14B_MODEL,
       WAN_T2V_A14B_MODEL,
       HUNYUAN_VIDEO_MODEL
@@ -259606,6 +259838,16 @@ import sys
 import time
 from pathlib import Path
 
+# ── GPU pinning ─────────────────────────────────────────────────────
+# The TS broker picks a GPU per generation via bin-packing across the
+# available CUDA devices. It passes the chosen index in OMNIUS_GPU_INDEX.
+# We MUST apply CUDA_VISIBLE_DEVICES BEFORE importing torch, otherwise
+# torch initializes the device list with all visible GPUs and the model
+# may land on a different device than the broker reserved capacity on.
+_omnius_gpu = os.environ.get("OMNIUS_GPU_INDEX", "").strip()
+if _omnius_gpu and "CUDA_VISIBLE_DEVICES" not in os.environ:
+    os.environ["CUDA_VISIBLE_DEVICES"] = _omnius_gpu
+
 def _progress(stage, message, percent=None):
     payload = {"omnius_progress": True, "stage": stage, "message": message}
     if percent is not None:
@@ -260412,6 +260654,9 @@ if __name__ == "__main__":
       defaultBackend;
       defaultKind;
       promptExpander = null;
+      /** GPU index chosen by the broker for the in-flight generation. Read
+       *  by the spawn path to set OMNIUS_GPU_INDEX in the subprocess env. */
+      _brokerGpuIndex = null;
       constructor(cwd4, defaults3 = {}) {
         this.cwd = cwd4;
         this.defaultModel = defaults3.model;
@@ -260501,17 +260746,23 @@ if __name__ == "__main__":
         const candidates = videoGenerationFallbackCandidates(requestedModel, requestedBackend, inferredKind, generationFallbackEnabled3(args), { preferNativeAudioVideo: withAudio || Boolean(audioInput) });
         const broker = getModelBroker();
         const firstCandidate = candidates[0];
+        let brokerGpuIndex = null;
         if (firstCandidate) {
+          const preset = firstCandidate.preset;
           const decision2 = await broker.ensureModelLoadable({
             name: firstCandidate.model,
             domain: "video-gen",
             host: firstCandidate.backend === "comfyui" ? "comfyui" : "diffusers-py",
-            owner: "video-generate-tool"
+            owner: "video-generate-tool",
+            estimatedVramMB: preset ? preset.minVramGB * 1024 : void 0
           });
           if (decision2.kind === "evict") {
             for (const target of decision2.evictTargets) {
               await broker.evict(target.host, target.name, "video-gen-needs-room");
             }
+            brokerGpuIndex = decision2.gpuIndex ?? null;
+          } else if (decision2.kind === "ok") {
+            brokerGpuIndex = decision2.gpuIndex ?? null;
           } else if (decision2.kind === "reject") {
             return {
               success: false,
@@ -260521,6 +260772,7 @@ if __name__ == "__main__":
             };
           }
         }
+        this._brokerGpuIndex = brokerGpuIndex;
         if (candidates.length === 0) {
           return {
             success: false,
@@ -260942,6 +261194,9 @@ ${llmAnnotation}` : result.llmContent;
           runnerEnv["HF_TOKEN"] = effectiveToken;
           runnerEnv["HUGGING_FACE_HUB_TOKEN"] = effectiveToken;
         }
+        if (this._brokerGpuIndex !== null) {
+          runnerEnv["OMNIUS_GPU_INDEX"] = String(this._brokerGpuIndex);
+        }
         const argv = [
           runner,
           "--model",
@@ -570291,18 +570546,6 @@ function formatReflection(notes2, scenario) {
   ];
   return lines.join("\n");
 }
-function formatMemory(input, state) {
-  const lines = [];
-  if (input.memoryContext) lines.push(input.memoryContext);
-  if (state.dynamicState && Object.keys(state.dynamicState).length > 0) {
-    const entries = Object.entries(state.dynamicState).slice(0, 12).map(([key, value2]) => `- ${key}: ${compactText(JSON.stringify(value2) ?? String(value2), 220)}`);
-    lines.push(`Dynamic state:
-${entries.join("\n")}`);
-  }
-  if (state.updatedAt) lines.push(`State updated: ${state.updatedAt}`);
-  if (lines.length === 0) return "No additional retrieved voice-soul memory beyond scoped personality and runtime state.";
-  return lines.join("\n\n");
-}
 function formatFinalVoice(input) {
   const voice = findProjectVoice(input.scope);
   const lines = [
@@ -570329,23 +570572,23 @@ function buildSoulContext(input) {
   const state = loadSoulRuntimeState(input);
   const scenario = resolveSoulScenario(input, state);
   const tree2 = resolveSoulDecisionTree(input, state, scenario);
-  return [
-    "## Voice Soul Context",
-    "### 1. Authority And Safety Scope",
+  const sections = ["## Voice Soul Context"];
+  const voiceAndScope = [
     formatAuthorityScope(input),
-    "### 2. Core Identity",
     formatCoreIdentity(input),
-    "### 3. Procedural Decision Tree",
-    formatProceduralConstraints(input, scenario, tree2, state),
-    "### 4. Relationship State",
-    formatRelationshipState(input),
-    "### 5. Current Reflection Notes",
-    formatReflection(input.currentReflection, scenario),
-    "### 6. Minimal Retrieved Memory",
-    formatMemory(input, state),
-    "### 7. Final Voice Guidance",
     formatFinalVoice(input)
-  ].join("\n\n");
+  ].filter(Boolean).join("\n\n");
+  sections.push("### Voice + Scope + Identity", voiceAndScope);
+  const decisionSubstrate = [
+    formatRelationshipState(input),
+    formatProceduralConstraints(input, scenario, tree2, state)
+  ].filter(Boolean).join("\n\n");
+  sections.push("### Active Relationship + Scenario", decisionSubstrate);
+  const reflection = formatReflection(input.currentReflection, scenario);
+  if (reflection && reflection.trim().length > 0) {
+    sections.push("### Current Reflection Notes", reflection);
+  }
+  return sections.join("\n\n");
 }
 var MAX_SOUL_CHARS, MAX_VOICE_CHARS, MAX_SCOPED_PERSONALITY_CHARS, UNCLASSIFIED_SCENARIO;
 var init_voice_soul = __esm({
@@ -577276,7 +577519,32 @@ var init_status_bar = __esm({
           if (this.active) this.renderFooterPreserveCursor();
         }, intervalMs);
         try {
-          getModelBroker().startPolling(Math.max(2e3, intervalMs * 2));
+          const broker = getModelBroker();
+          try {
+            Promise.resolve().then(() => (init_dist8(), dist_exports3)).then(({ getOllamaPool: getOllamaPool2, resolveDefaultPoolConfig: resolveDefaultPoolConfig2 }) => {
+              try {
+                const config = resolveDefaultPoolConfig2();
+                const pool3 = getOllamaPool2({ baseInstanceUrl: config.baseInstanceUrl });
+                broker.setOllamaAffinityProvider((modelName) => {
+                  try {
+                    const status = pool3.status?.();
+                    if (!status) return null;
+                    for (const inst of status.instances ?? []) {
+                      void modelName;
+                      return { gpuIndex: inst.gpuIndex, gpuUuid: inst.gpuUuid };
+                    }
+                    return null;
+                  } catch {
+                    return null;
+                  }
+                });
+              } catch {
+              }
+            }).catch(() => {
+            });
+          } catch {
+          }
+          broker.startPolling(Math.max(2e3, intervalMs * 2));
         } catch {
         }
       }
@@ -604379,14 +604647,22 @@ async function handleBroker(arg, _ctx) {
     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) {
+    if (snap.vramPerDevice.length > 0) {
+      safeLog(`  ${c3.bold("GPUs:")}`);
+      for (const d2 of snap.vramPerDevice) {
+        const gpuSlots = snap.slots.byGpu[d2.index];
+        const slotInfo = gpuSlots ? ` slots=${gpuSlots.inUse}/${gpuSlots.capacity}, loaded=${gpuSlots.loadedMB}MB` : "";
+        safeLog(`    gpu${d2.index} (${d2.uuid.slice(0, 12)}…)  ${d2.used} / ${d2.total} MB used (${d2.free} MB free)${slotInfo}`);
+      }
+    } else 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("VRAM headroom threshold:")} ${broker.vramHeadroomMB} MB (per-device)`);
     safeLog(`  ${c3.dim("Idle-evict threshold:")} ${Math.round(broker.idleEvictMs / 1e3)}s`);
+    safeLog(`  ${c3.dim("Slot capacity:")} ${snap.slots.inUse}/${snap.slots.capacity} active, queue ${snap.slots.queueDepth}/${snap.slots.queueCapacity}`);
     safeLog("");
     if (snap.loaded.length === 0) {
       safeLog(`  ${c3.dim("No loaded models tracked.")}`);
@@ -604397,7 +604673,8 @@ async function handleBroker(arg, _ctx) {
         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}`);
+        const gpu = m2.gpuIndex !== null && m2.gpuIndex !== void 0 ? c3.dim(` gpu=${m2.gpuIndex}`) : "";
+        safeLog(`    ${c3.cyan(m2.name)} (${m2.host}/${m2.domain})  vram=${m2.vramMB}MB ram=${m2.ramMB}MB${gpu}  idle=${idle}s${ctx3}${owner}`);
       }
     }
     if (snap.inflight.length > 0) {
@@ -618149,6 +618426,95 @@ function parseTelegramSilentReflectionNotes(text) {
   }
   return null;
 }
+function extractPartialTelegramReplyJson(buffer2) {
+  const stripped = stripTelegramHiddenThinking(buffer2).trimStart();
+  if (!stripped.startsWith("{")) {
+    return stripped || null;
+  }
+  const keyMatch = stripped.indexOf('"reply"');
+  if (keyMatch < 0) return null;
+  let i2 = keyMatch + '"reply"'.length;
+  while (i2 < stripped.length && stripped[i2] !== ":") i2++;
+  if (i2 >= stripped.length) return null;
+  i2++;
+  while (i2 < stripped.length && /\s/.test(stripped[i2])) i2++;
+  if (i2 >= stripped.length || stripped[i2] !== '"') return null;
+  i2++;
+  let out = "";
+  while (i2 < stripped.length) {
+    const ch = stripped[i2];
+    if (ch === "\\") {
+      const next = stripped[i2 + 1];
+      if (next === void 0) break;
+      if (next === '"') out += '"';
+      else if (next === "\\") out += "\\";
+      else if (next === "n") out += "\n";
+      else if (next === "t") out += "	";
+      else if (next === "r") out += "\r";
+      else if (next === "/") out += "/";
+      else if (next === "u") {
+        if (i2 + 5 >= stripped.length) break;
+        const hex = stripped.slice(i2 + 2, i2 + 6);
+        const code8 = parseInt(hex, 16);
+        if (Number.isFinite(code8)) out += String.fromCharCode(code8);
+        i2 += 4;
+      } else {
+        out += next;
+      }
+      i2 += 2;
+      continue;
+    }
+    if (ch === '"') {
+      return out;
+    }
+    out += ch;
+    i2++;
+  }
+  return out.length > 0 ? out : null;
+}
+function extractFinalTelegramReplyJson(buffer2) {
+  const stripped = stripTelegramHiddenThinking(buffer2).trim();
+  if (!stripped.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(stripped);
+    if (typeof parsed.reply === "string") return parsed.reply.trim();
+  } catch {
+  }
+  let depth = 0;
+  let inString = false;
+  let escape2 = false;
+  let end = -1;
+  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) {
+        end = i2;
+        break;
+      }
+    }
+  }
+  if (end > 0) {
+    try {
+      const parsed = JSON.parse(stripped.slice(0, end + 1));
+      if (typeof parsed.reply === "string") return parsed.reply.trim();
+    } catch {
+    }
+  }
+  const partial = extractPartialTelegramReplyJson(stripped);
+  return partial && partial.trim().length > 0 ? partial.trim() : null;
+}
 function estimatePromptTokensFromRequest(request) {
   let chars = 0;
   for (const m2 of request.messages ?? []) {
@@ -619636,7 +620002,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c3.dim("│")} ${c3.magenta("✘")} @${username}: ${c3.dim(preview)}
 `);
 }
-var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
+var TELEGRAM_TOOL_ACTION_GROUPS, TELEGRAM_TOOL_ACTION_GROUP, TELEGRAM_TOOL_MUTATING_GROUPS, DEFAULT_TELEGRAM_TOOL_GROUP_POLICY, TELEGRAM_TOOL_BUTTON_LABELS, TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, TELEGRAM_PUBLIC_SOUL_PROFILE, TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT, TELEGRAM_PUBLIC_MEMORY_SCOPE_CONTRACT, TELEGRAM_PUBLIC_VISION_STACK_CONTRACT, GROUP_REPLY_DISCRETION_PROMPT, TELEGRAM_CHAT_MODE_PROMPT, ADMIN_CHAT_PROFILE_PROMPT, TELEGRAM_ACTION_RESPONSE_CONTRACT, TELEGRAM_EXTERNAL_ACQUISITION_CONTRACT, TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT, TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT, TELEGRAM_STUCK_SELF_TALK_PREFIXES, TELEGRAM_CHAT_HISTORY_LIMIT, TELEGRAM_CONTEXT_RECENT_DEFAULT, TELEGRAM_CONTEXT_LINE_LIMIT, TELEGRAM_CONTEXT_SAMPLE_LIMIT, TELEGRAM_MEMORY_CARD_LIMIT, TELEGRAM_MEMORY_NOTE_LIMIT, TELEGRAM_ASSOCIATIVE_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_USER_FACT_LIMIT, TELEGRAM_ASSOCIATIVE_ACTION_LIMIT, TELEGRAM_ASSOCIATIVE_RELATION_LIMIT, TELEGRAM_MEMORY_STOPWORDS, TELEGRAM_MEMORY_GENERIC_QUERY_TOKENS, TELEGRAM_SUB_AGENT_BOUNDED_OPTIONS, TELEGRAM_SUB_AGENT_DEFAULT_LIMIT, TELEGRAM_SUB_AGENT_MAX_LIMIT, TELEGRAM_SUB_AGENT_BURST_CONTEXT_LIMIT, TELEGRAM_PUBLIC_HELP_COMMANDS2, TELEGRAM_REMINDER_SLASH_COMMANDS, TELEGRAM_REFLECTION_SLASH_COMMANDS, TELEGRAM_PUBLIC_BOT_COMMAND_NAMES, TELEGRAM_IMAGE_EXTENSIONS, MEDIA_CACHE_TTL_MS, TELEGRAM_CHANNEL_DMN_SWEEP_MS, TELEGRAM_CHANNEL_DMN_IDLE_AFTER_MS, TELEGRAM_CHANNEL_DMN_MIN_INTERVAL_MS, TELEGRAM_CHANNEL_DMN_MIN_MESSAGES, TELEGRAM_ALLOWED_UPDATES, TELEGRAM_PUBLIC_TOOL_QUOTAS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/src/tui/telegram-bridge.ts"() {
     "use strict";
@@ -619870,6 +620236,12 @@ Rules:
 7. Do not claim older chat is unavailable when the context stream contains it. If asked what you see, summarize the supplied transcript, speakers, and relationship/tone signals.
 8. Mirror the current sender's tone and directness while staying safe and clear.
 9. Never send router decisions, skip explanations, memory-stage notes, task-complete summaries, or "no_reply" as chat text.
+
+Output discipline (your assistant message is sent verbatim to Telegram, ALL of it):
+- Emit ONLY the final reply text. Do not narrate your reasoning, summarize what you found, organize bullet-point notes, or write phrases like "Let me summarize", "Let me send the reply", "Now I have enough", "Based on the research", "Here's my response:" before the actual reply. Those are scratch-pad phrases that leak when emitted as visible text.
+- Do not produce a draft followed by the final answer. The first character of your output should be the first character of the message the user will receive.
+- If you need to think, do it silently. Do not write your reasoning steps as visible prose. If you have an internal scratchpad, keep it internal.
+- A reply that begins by restating what you found, then says something like "Let me write the response" or "Here's the breakdown", then gives the answer, is wrong twice over: the user sees the restatement AND the answer, doubling the message. Skip the restatement.
 `.trim();
     ADMIN_CHAT_PROFILE_PROMPT = `
 You are replying to the authenticated Telegram admin in a private DM.
@@ -619902,6 +620274,24 @@ External acquisition contract:
     TELEGRAM_INTERACTION_DECISION_RESPONSE_FORMAT = {
       type: "json_object"
     };
+    TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT = {
+      type: "json_schema",
+      json_schema: {
+        name: "telegram_chat_reply",
+        strict: true,
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["reply"],
+          properties: {
+            reply: {
+              type: "string",
+              description: "The exact text to send to Telegram. No prefixes, no narration, no scratch reasoning, no bullet-point notes preceding the reply."
+            }
+          }
+        }
+      }
+    };
     TELEGRAM_STUCK_SELF_TALK_PREFIXES = [
       /^i'?ve been stuck for\b/i,
       /^i am (still |currently )?stuck\b/i,
@@ -622128,6 +622518,14 @@ ${mediaContext}` : ""
         if (state.lastFollowupAt && now - state.lastFollowupAt < 60 * 6e4) {
           return { sent: false, reason: "rate limit held public follow-up" };
         }
+        const cooldownEnv = Number.parseInt(process.env["OMNIUS_TG_FOLLOWUP_COOLDOWN_MS"] ?? "", 10);
+        const cooldownMs = Number.isFinite(cooldownEnv) && cooldownEnv >= 6e4 ? cooldownEnv : 10 * 6e4;
+        if (state.lastAssistantMessageAt && now - state.lastAssistantMessageAt < cooldownMs) {
+          return {
+            sent: false,
+            reason: `recent assistant reply suppresses follow-up (${Math.round((now - state.lastAssistantMessageAt) / 1e3)}s ago, cooldown ${Math.round(cooldownMs / 1e3)}s)`
+          };
+        }
         const candidateMessageIds = Array.from(new Set([
           ...artifact.curiosityThreads.flatMap((thread) => thread.sourceMessages ?? []),
           ...artifact.memoryProposals.flatMap((proposal) => proposal.sourceMessages ?? []),
@@ -622458,6 +622856,10 @@ ${mediaContext}` : ""
           chatTitle: msg.chatTitle
         };
         this.recordChatHistory(sessionKey, entry);
+        try {
+          this.reflectionStateForSession(sessionKey).lastAssistantMessageAt = Date.now();
+        } catch {
+        }
         this.persistTelegramAssistantMessage(
           msg,
           clean5,
@@ -623409,214 +623811,29 @@ ${lines.join("\n")}`);
         const cardCount = (this.chatMemoryCards.get(sessionKey) ?? []).length;
         const memory = this.chatAssociativeMemory.get(sessionKey);
         const factCount = memory?.facts.length ?? 0;
-        const relationshipCount = memory?.relationships.length ?? 0;
         const userMemoryCount = memory ? Object.keys(memory.users).length : 0;
         const historyCount = (this.chatHistory.get(sessionKey) ?? []).length;
-        let sqliteCount = 0;
-        let episodeCount2 = 0;
-        try {
-          const db = this.telegramDb();
-          if (db) {
-            const row = db.prepare("SELECT COUNT(*) AS n FROM telegram_messages WHERE session_key = ?").get(sessionKey);
-            sqliteCount = Number(row?.n) || 0;
-          }
-        } catch {
-        }
-        if (this.repoRoot) {
-          try {
-            const paths = omniusMemoryDbPaths(this.repoRoot);
-            if (existsSync117(paths.episodes)) {
-              const graph = new TemporalGraph(paths.knowledge);
-              const store2 = new EpisodeStore(paths.episodes, graph);
-              try {
-                const sample = store2.search({ sessionId: sessionKey, limit: 1 }) ?? [];
-                if (sample.length > 0) {
-                  const dbAny = store2.db;
-                  if (dbAny && typeof dbAny.prepare === "function") {
-                    const row = dbAny.prepare("SELECT COUNT(*) AS n FROM episodes WHERE session_id = ?").get(sessionKey);
-                    episodeCount2 = Number(row?.n) || 0;
-                  } else {
-                    episodeCount2 = 1;
-                  }
-                }
-              } finally {
-                try {
-                  store2.close();
-                } catch {
-                }
-                try {
-                  graph.close();
-                } catch {
-                }
-              }
-            }
-          } catch {
-          }
-        }
         const chatId = msg.chatId;
-        const topicFiles = [];
+        let topicCount = 0;
         if (this.repoRoot && chatId !== void 0) {
           try {
             const memDir = resolve46(this.repoRoot, ".omnius", "memory");
             if (existsSync117(memDir)) {
               const prefix = this.telegramScopedMemoryPrefix(chatId);
               for (const file of readdirSync41(memDir)) {
-                if (!file.endsWith(".json") || !file.startsWith(prefix)) continue;
-                const topic = file.slice(prefix.length, -".json".length);
-                if (topic) topicFiles.push(topic);
-              }
-            }
-          } catch {
-          }
-        }
-        const anyMemory = cardCount + factCount + relationshipCount + userMemoryCount + sqliteCount + episodeCount2 + topicFiles.length > 0;
-        if (!anyMemory && historyCount === 0) return "";
-        const lines = [
-          "### Scoped Memory Substrate (this chat - always present)",
-          "Persistent memory is available for this chat. The current turn's lexical scorers may",
-          "have surfaced 0 matches above - that does not mean the substrate is empty. Counts:",
-          `- Memory cards: ${cardCount}`,
-          `- Associative facts: ${factCount}`,
-          `- Associative relationships: ${relationshipCount}`,
-          `- Per-user memories: ${userMemoryCount}`,
-          `- Rolling history entries retained: ${historyCount}`,
-          `- Addressable conversation history rows: ${Math.max(historyCount, sqliteCount)}`,
-          `- SQLite mirror rows: ${sqliteCount}`,
-          `- Episodes (durable, day+ scope): ${episodeCount2}`
-        ];
-        if (topicFiles.length > 0) {
-          lines.push("");
-          lines.push("Per-topic memory files (call memory_read with one of these `topic` values):");
-          for (const topic of topicFiles.slice(0, 80)) {
-            lines.push(`  - ${topic}`);
-          }
-        }
-        const anchors = this.telegramHistoryAnchorsForSession(sessionKey, 3);
-        const fmtHistoryAnchor = (entry) => {
-          const when = entry.ts ? new Date(entry.ts).toISOString() : "(unknown ts)";
-          const speaker = telegramHistorySpeaker(entry);
-          const kind = entry.role === "assistant" || entry.isBot ? "bot" : "human";
-          const mode = entry.mode ? `/${entry.mode}` : "";
-          const messageId = entry.messageId ? ` msg:${entry.messageId}` : "";
-          return `${when} ${speaker} [${kind}]${mode}${messageId}: ${telegramContextJsonString(String(entry.text || ""), 320)}`;
-        };
-        const sameHistoryAnchor = (a2, b) => {
-          if (!a2 || !b) return false;
-          if (a2.messageId !== void 0 && b.messageId !== void 0) return a2.messageId === b.messageId && a2.role === b.role;
-          return a2.ts === b.ts && a2.role === b.role && a2.text === b.text;
-        };
-        if (anchors.earliest.length > 0 || anchors.latest) {
-          lines.push("");
-          lines.push("Chronological anchors - Telegram conversation history (SQLite mirror preferred; ground truth for 'oldest/newest memory' questions):");
-          if (anchors.earliest[0]) lines.push(`  Earliest turn: ${fmtHistoryAnchor(anchors.earliest[0])}`);
-          if (anchors.latest && !sameHistoryAnchor(anchors.earliest[0], anchors.latest)) {
-            lines.push(`  Latest turn:   ${fmtHistoryAnchor(anchors.latest)}`);
-          }
-          if (anchors.earliest[1]) {
-            lines.push(`  2nd earliest:  ${fmtHistoryAnchor(anchors.earliest[1])}`);
-          }
-          if (anchors.earliest[2]) {
-            lines.push(`  3rd earliest:  ${fmtHistoryAnchor(anchors.earliest[2])}`);
-          }
-        }
-        const activityStats = this.telegramParticipantActivityStats(sessionKey, { limit: 8 });
-        if (activityStats.length > 0) {
-          lines.push("");
-          lines.push("Activity anchors - participant message counts from the durable mirror/merged history:");
-          for (const stat7 of activityStats) {
-            const first2 = stat7.firstTs ? new Date(stat7.firstTs).toISOString() : "?";
-            const last2 = stat7.lastTs ? new Date(stat7.lastTs).toISOString() : "?";
-            lines.push(`  - ${stat7.speaker}: ${stat7.count} message${stat7.count === 1 ? "" : "s"} (first:${first2}, last:${last2})`);
-          }
-        }
-        if (this.repoRoot) {
-          try {
-            const paths = omniusMemoryDbPaths(this.repoRoot);
-            if (existsSync117(paths.episodes)) {
-              const graph = new TemporalGraph(paths.knowledge);
-              const store2 = new EpisodeStore(paths.episodes, graph);
-              try {
-                const dbAny = store2.db;
-                if (dbAny && typeof dbAny.prepare === "function") {
-                  const earliest = dbAny.prepare(
-                    "SELECT timestamp, modality, tool_name, content, gist FROM episodes WHERE session_id = ? ORDER BY timestamp ASC LIMIT 1"
-                  ).get(sessionKey);
-                  const latest = dbAny.prepare(
-                    "SELECT timestamp, modality, tool_name, content, gist FROM episodes WHERE session_id = ? ORDER BY timestamp DESC LIMIT 1"
-                  ).get(sessionKey);
-                  if (earliest || latest) {
-                    lines.push("");
-                    lines.push("Chronological anchors - episodes.db (durable, may reach further back than rolling history):");
-                    const fmtEp = (row) => {
-                      const when = row.timestamp ? new Date(row.timestamp).toISOString() : "(unknown ts)";
-                      const tag = `[${row.modality || "?"}${row.tool_name ? ":" + row.tool_name : ""}]`;
-                      const text = (row.gist || row.content || "").split("\n").filter((ln) => !/^(Telegram|session:|chat:|message_id:|thread_id:|speaker:|mode:)/i.test(ln.trim())).join(" ").replace(/\s+/g, " ").trim();
-                      return `${when} ${tag} ${telegramContextJsonString(text, 320)}`;
-                    };
-                    if (earliest) lines.push(`  Earliest episode: ${fmtEp(earliest)}`);
-                    if (latest && (!earliest || earliest.timestamp !== latest.timestamp)) lines.push(`  Latest episode:   ${fmtEp(latest)}`);
-                  }
-                }
-              } finally {
-                try {
-                  store2.close();
-                } catch {
-                }
-                try {
-                  graph.close();
-                } catch {
-                }
+                if (file.endsWith(".json") && file.startsWith(prefix)) topicCount++;
               }
             }
           } catch {
           }
         }
-        if (this.repoRoot && chatId !== void 0 && topicFiles.length > 0) {
-          try {
-            const memDir = resolve46(this.repoRoot, ".omnius", "memory");
-            const prefix = this.telegramScopedMemoryPrefix(chatId);
-            let earliestEntry = null;
-            let latestEntry = null;
-            for (const topic of topicFiles) {
-              const file = join131(memDir, `${prefix}${topic}.json`);
-              if (!existsSync117(file)) continue;
-              let parsed;
-              try {
-                parsed = JSON.parse(readFileSync96(file, "utf8"));
-              } catch {
-                continue;
-              }
-              for (const [key, entry] of Object.entries(parsed)) {
-                if (!entry || typeof entry !== "object") continue;
-                const rawTs = entry.timestamp;
-                const ts = typeof rawTs === "string" ? Date.parse(rawTs) : typeof rawTs === "number" ? rawTs : NaN;
-                if (!Number.isFinite(ts)) continue;
-                const value2 = String(entry.value ?? "");
-                if (!earliestEntry || ts < earliestEntry.ts) earliestEntry = { topic, key, value: value2, ts };
-                if (!latestEntry || ts > latestEntry.ts) latestEntry = { topic, key, value: value2, ts };
-              }
-            }
-            if (earliestEntry || latestEntry) {
-              lines.push("");
-              lines.push("Chronological anchors - memory_write entries (most-trusted, agent-asserted):");
-              const fmtMem = (e2) => {
-                const when = new Date(e2.ts).toISOString();
-                return `${when} topic="${e2.topic}" key="${e2.key}" → ${telegramContextJsonString(e2.value, 320)}`;
-              };
-              if (earliestEntry) lines.push(`  Earliest memory_write: ${fmtMem(earliestEntry)}`);
-              if (latestEntry && (!earliestEntry || earliestEntry.ts !== latestEntry.ts)) lines.push(`  Latest memory_write:   ${fmtMem(latestEntry)}`);
-            }
-          } catch {
-          }
-        }
-        lines.push("");
-        lines.push("Rules:");
-        lines.push("  1. Do not tell the user 'memory is empty' or 'nothing has been stored' for this chat without first calling memory_search and memory_read on a relevant topic from the list above.");
-        lines.push("  2. If the structured sections (cards/facts/sqlite/episodes) above did not surface what the user asked about, that is a scoring miss, not absence. Call memory_search with broader tokens or pick a topic above with memory_read.");
-        lines.push("  3. The rolling-history block is base context; the cards/facts/episodes are retrieval-augmented. Treat them as the same memory, surfaced different ways.");
-        lines.push("  4. For 'what is your oldest/earliest memory' or 'most recent memory' questions: answer directly from the 'Chronological anchors' lines above. Quote the timestamp and content. Do not call tools first and do not report 'empty'.");
-        lines.push("  5. memory_search accepts natural-language time phrases inside the `query` argument or explicit `since`/`until`/`bucket` args. Examples: query='what did manitcor say yesterday', query='last 3 hours', query='earlier today', query='2 days ago', query='since 2026-05-15', query='between 2026-05-15 and 2026-05-16', query='oldest memory about github', query='most recent flux discussion'. Use these for chronological/'how far back' style queries instead of guessing - the tool parses the phrase, filters by time, and returns the right window.");
-        return lines.join("\n");
+        const hasMemory = cardCount + factCount + userMemoryCount + topicCount > 0 || historyCount > 0;
+        if (!hasMemory) return "";
+        return [
+          "### Memory Substrate (this chat)",
+          `Available: ${cardCount} cards, ${factCount} facts, ${userMemoryCount} per-user memories, ${historyCount} rolling-history msgs, ${topicCount} memory_read topics.`,
+          "Recall via memory_search (semantic similarity / graph traversal / episodes). For exact reads: memory_read(topic, key). The substrate is associative — recall is by cue, not by date."
+        ].join("\n");
       }
       buildTelegramConversationContextStream(sessionKey, msg, maxRecent = TELEGRAM_CONTEXT_RECENT_DEFAULT, salienceSignals = []) {
         this.ensureTelegramConversationLoaded(sessionKey);
@@ -623685,32 +623902,16 @@ ${lines.join("\n")}`);
           sections.push(`### Participants And Relationship Signals${tierNote}
 ${participantLines.join("\n")}`);
         }
-        const associativeContext = this.relevantTelegramAssociativeMemoryContext(
-          sessionKey,
-          msg,
-          isGroup ? 14 : 8
-        );
-        if (associativeContext) {
-          sections.push(associativeContext);
-        }
-        const sqliteMirrorContext = this.relevantTelegramSqliteMirrorContext(
-          sessionKey,
-          msg,
-          isGroup ? 14 : 8
-        );
-        if (sqliteMirrorContext) {
-          sections.push(sqliteMirrorContext);
-        }
-        try {
-          const episodicContext = this.relevantTelegramEpisodicMemoryContext(
+        const ASSOCIATIVE_MIN_TURNS = isGroup ? 8 : 4;
+        if (retainedCount >= ASSOCIATIVE_MIN_TURNS) {
+          const associativeContext = this.relevantTelegramAssociativeMemoryContext(
             sessionKey,
             msg,
-            isGroup ? 10 : 6
+            isGroup ? 14 : 8
           );
-          if (episodicContext) {
-            sections.push(episodicContext);
+          if (associativeContext) {
+            sections.push(associativeContext);
           }
-        } catch {
         }
         const memoryCards = this.relevantTelegramMemoryCards(sessionKey, msg, isGroup ? 10 : 6);
         if (memoryCards.length > 0) {
@@ -623741,10 +623942,6 @@ ${notes2}`;
 ${cardLines.join("\n")}`);
           }
         }
-        const channelDaydream = this.formatLatestTelegramChannelDaydreamContext(sessionKey);
-        if (channelDaydream) {
-          sections.push(channelDaydream);
-        }
         const recentMedia = this.recentTelegramMediaEntries(msg.chatId, 10);
         if (recentMedia.length > 0) {
           const mediaLines = recentMedia.map((entry) => {
@@ -623763,26 +623960,33 @@ ${cardLines.join("\n")}`);
           ].join("\n"));
         }
         if (olderCount > 0) {
+          const halfLifeMs = (isGroup ? 24 : 48) * 60 * 60 * 1e3;
+          const now = Date.now();
           const older = history.slice(0, olderCount);
           const bySpeaker = /* @__PURE__ */ new Map();
           for (const entry of older) {
             if (!entry.text.trim()) continue;
             const speaker = telegramHistorySpeaker(entry);
+            const ageMs = Math.max(0, now - (entry.ts ?? 0));
+            const weight = Math.exp(-ageMs / halfLifeMs);
             const existing = bySpeaker.get(speaker);
             const text = truncateTelegramContextLine(entry.text, 180);
             if (existing) {
               existing.count += 1;
               existing.last = text;
+              existing.weightSum += weight;
+              existing.maxWeight = Math.max(existing.maxWeight, weight);
             } else {
-              bySpeaker.set(speaker, { count: 1, first: text, last: text });
+              bySpeaker.set(speaker, { count: 1, first: text, last: text, weightSum: weight, maxWeight: weight });
             }
           }
-          const olderLines = [...bySpeaker.entries()].slice(0, 10).map(([speaker, info]) => {
+          const olderLines = [...bySpeaker.entries()].sort(([, a2], [, b]) => b.maxWeight - a2.maxWeight).slice(0, 5).map(([speaker, info]) => {
             const range = info.first === info.last ? info.first : `${info.first} -> ${info.last}`;
-            return `- ${speaker}: ${info.count} earlier msg(s); digest=${telegramContextJsonString(range, 240)}`;
+            const decayLabel = info.maxWeight >= 0.5 ? "fresh" : info.maxWeight >= 0.1 ? "decayed" : "stale";
+            return `- ${speaker}: ${info.count} earlier msg(s) [${decayLabel}]; digest=${telegramContextJsonString(range, 200)}`;
           });
           if (olderLines.length > 0) {
-            sections.push(`### Earlier Retained Thread Digest
+            sections.push(`### Earlier Retained Thread Digest (recency-weighted)
 ${olderLines.join("\n")}`);
           }
         }
@@ -624096,7 +624300,8 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
         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({
+        const brokerBypass = process.env["OMNIUS_DISABLE_BROKER_ADMISSION"] === "1";
+        const slot = brokerBypass ? null : await broker.acquireInferenceSlot({
           model,
           domain: "chat",
           owner: `telegram-bridge/${kind}`,
@@ -624107,7 +624312,7 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
         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" : ""}`
+            `inference admitted [${kind}] model=${model} prompt~${promptTokens}t num_ctx=${targetCtx} slot=${slot ? slot.info.id : "bypass"}${slot?.info.reserved ? " reserved" : ""}`
           ));
         }
         const streamFn = backend.chatCompletionStream;
@@ -624136,10 +624341,10 @@ ${this.quoteTelegramContextBlock(msg.text, 1200)}`,
           }
           const usage = result.usage;
           completionTokens = usage?.completion_tokens ?? 0;
-          slot.release({ ok: true, completionTokens });
+          slot?.release({ ok: true, completionTokens });
           return result;
         } catch (err) {
-          slot.release({ ok: false, error: err instanceof Error ? err.message : String(err) });
+          slot?.release({ ok: false, error: err instanceof Error ? err.message : String(err) });
           throw err;
         } finally {
           this.deregisterTelegramInference(id);
@@ -625140,34 +625345,25 @@ ${list}` : "No shared group target is currently known for this sender. Ask in th
         return join131(this.repoRoot, ".omnius", "telegram-runner-state", safe);
       }
       buildTelegramAdminOverviewContext(currentSessionKey) {
-        const sections = [];
         this.ensureAllTelegramConversationsLoaded();
         const chatEntries = [...this.chatHistory.entries()].filter(([sessionKey, history]) => sessionKey !== currentSessionKey && history.length > 0).sort(([, a2], [, b]) => (b[b.length - 1]?.ts ?? 0) - (a2[a2.length - 1]?.ts ?? 0)).slice(0, 18);
+        if (chatEntries.length === 0) return "";
+        const indexLines = [];
         for (const [sessionKey, history] of chatEntries) {
           const latest = history[history.length - 1];
-          const participants = [...this.chatParticipants.get(sessionKey)?.values() ?? []].sort((a2, b) => b.lastSeenTs - a2.lastSeenTs).slice(0, 8).map((profile) => {
-            const label = profile.username && profile.username !== "unknown" ? `@${profile.username}` : profile.firstName || `user:${profile.fromUserId}`;
-            return `${label} (${profile.messageCount} msg)`;
-          }).join(", ");
-          const recent = history.slice(-5).map(
-            (entry) => `    - ${telegramHistorySpeaker(entry)}: ${truncateTelegramContextLine(entry.text, 180)}`
-          ).join("\n");
-          const cards = (this.chatMemoryCards.get(sessionKey) ?? []).slice(0, 4).map((card) => `    - ${card.title}: ${card.notes.slice(-1)[0] ?? ""}`).join("\n");
-          sections.push([
-            `- ${sessionKey} (chat_id ${String(latest.chatId ?? "unknown")}; ${latest.chatType || "chat"}${latest.chatTitle ? `: ${latest.chatTitle}` : ""})`,
-            participants ? `  Participants: ${participants}` : "",
-            `  Latest: ${telegramHistorySpeaker(latest)}: ${truncateTelegramContextLine(latest.text, 180)}`,
-            recent ? `  Recent:
-${recent}` : "",
-            cards ? `  Memory cards:
-${cards}` : ""
-          ].filter(Boolean).join("\n"));
-        }
-        if (sections.length === 0) return "";
+          const participantCount = this.chatParticipants.get(sessionKey)?.size ?? 0;
+          const ageMs = Date.now() - (latest.ts ?? 0);
+          const ageMin = Math.round(ageMs / 6e4);
+          const ageStr = ageMin < 60 ? `${ageMin}m ago` : ageMin < 24 * 60 ? `${Math.round(ageMin / 60)}h ago` : `${Math.round(ageMin / (24 * 60))}d ago`;
+          const label = latest.chatTitle ? `"${latest.chatTitle}"` : sessionKey;
+          indexLines.push(`- ${label} (chat_id ${String(latest.chatId ?? "?")}; ${latest.chatType || "chat"}): ${participantCount} participants; last ${ageStr}; ${history.length} retained msgs`);
+        }
         return [
-          "## Admin Telegram Omniscience",
-          "This section is one-way context for the authenticated admin private DM only. It summarizes public/group and other Telegram sessions the bot has observed. Never inject admin/private DM content into public groups.",
-          sections.join("\n")
+          "## Admin Telegram Omniscience (index only)",
+          "One-way context for the authenticated admin private DM. Other Telegram sessions the bot has observed are listed below with one line each.",
+          "For details on a specific chat, use memory_search (mode=episodes) with a topic keyword or chat_id — the always-loaded view is intentionally compact.",
+          "Never inject admin/private DM content into public groups.",
+          indexLines.join("\n")
         ].join("\n\n");
       }
       buildTelegramSessionContext(msg, toolContext, profile, modelTier) {
@@ -626287,8 +626483,9 @@ ${conversationStream}`
           messages: this.buildTelegramChatMessages(msg, toolContext, mediaContext),
           tools: [],
           temperature: 0.4,
-          maxTokens: 700,
-          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4)
+          maxTokens: 1500,
+          timeoutMs: Math.max(config.timeoutMs ?? 3e5, 12e4),
+          responseFormat: TELEGRAM_CHAT_REPLY_RESPONSE_FORMAT
         });
         let accumulated = "";
         let streamError;
@@ -626315,7 +626512,8 @@ ${conversationStream}`
                 } else {
                   this.bumpTelegramInferenceTokens(inferenceId, 1, 0);
                   accumulated += piece;
-                  await onToken(accumulated);
+                  const partial = extractPartialTelegramReplyJson(accumulated);
+                  if (partial !== null) await onToken(partial);
                 }
               }
             } catch (err) {
@@ -626337,11 +626535,14 @@ ${conversationStream}`
             }
             this.updateTelegramInferenceFinal(inferenceId, result);
             accumulated = result.choices[0]?.message?.content ?? "";
-            if (accumulated) await onToken(accumulated);
+            const fullExtracted = extractPartialTelegramReplyJson(accumulated);
+            if (fullExtracted) await onToken(fullExtracted);
           }
         } finally {
           this.deregisterTelegramInference(inferenceId);
         }
+        const extracted = extractFinalTelegramReplyJson(accumulated);
+        if (extracted) return extracted;
         return stripTelegramHiddenThinking(accumulated).trim();
       }
       retainTelegramVisibleReplyDraft(subAgent, draft, streamToolNames = subAgent.currentStreamToolNames) {