omnius 1.0.5 → 1.0.7

package/dist/index.js

@@ -250369,10 +250369,19 @@ function inferImageGenerationBackend(model, requested) {
     return "sdcpp";
   return "diffusers";
 }
+function imageGenerationDir(repoRoot = ".") {
+  return join36(repoRoot, ".omnius", "image-gen");
+}
+function diffusersVenvDir(repoRoot = ".") {
+  return join36(imageGenerationDir(repoRoot), ".venv");
+}
+function sdcppVenvDir(repoRoot = ".") {
+  return join36(imageGenerationDir(repoRoot), ".venv-sdcpp");
+}
 function imageGenerationSetupPlan(backend, repoRoot = ".", model) {
-  const imageDir = join36(repoRoot, ".omnius", "image-gen");
+  const imageDir = imageGenerationDir(repoRoot);
   if (backend === "ollama") {
-    const chosen = model && model !== "auto" ? model : "x/z-image-turbo";
+    const chosen = model && model !== "auto" ? model : DEFAULT_OLLAMA_IMAGE_MODEL;
     return {
       backend,
       title: "Ollama image generation",
@@ -250387,26 +250396,30 @@ function imageGenerationSetupPlan(backend, repoRoot = ".", model) {
     };
   }
   if (backend === "diffusers") {
+    const venvDir2 = diffusersVenvDir(repoRoot);
+    const chosen = model && model !== "auto" ? model : DEFAULT_DIFFUSERS_IMAGE_MODEL;
     return {
       backend,
       title: "Python Diffusers image generation",
       commands: [
-        `python3 -m venv ${join36(imageDir, "venv")}`,
-        `${join36(imageDir, "venv", "bin", "python")} -m pip install -U pip torch diffusers transformers accelerate safetensors pillow`,
-        `omnius /image "a compact robot painter" --backend diffusers --model ${model && model !== "auto" ? model : "segmind/tiny-sd"}`
+        `python3 -m venv ${venvDir2}`,
+        `${venvPython(venvDir2)} -m pip install -U pip ${DIFFUSERS_PYTHON_PACKAGES.join(" ")}`,
+        `omnius /image "a compact robot painter" --backend diffusers --model ${chosen}`
       ],
       notes: [
-        "Good lightweight candidates: segmind/tiny-sd, nota-ai/bk-sdm-tiny-2m, SimianLuo/LCM_Dreamshaper_v7, stabilityai/sd-turbo.",
+        `Default first-run model: ${DEFAULT_DIFFUSERS_IMAGE_MODEL}. Good lighter candidates: stabilityai/sd-turbo, segmind/tiny-sd, nota-ai/bk-sdm-tiny-2m.`,
+        "The venv, Hugging Face cache, Torch cache, and pip cache stay under .omnius/image-gen.",
         "The runner script is created automatically at .omnius/image-gen/diffusers_text2image.py."
       ]
     };
   }
+  const venvDir = sdcppVenvDir(repoRoot);
   return {
     backend,
     title: "stable-diffusion.cpp Python image generation",
     commands: [
-      `python3 -m venv ${join36(imageDir, "venv-sdcpp")}`,
-      `${join36(imageDir, "venv-sdcpp", "bin", "python")} -m pip install -U pip stable-diffusion-cpp-python pillow`,
+      `python3 -m venv ${venvDir}`,
+      `${venvPython(venvDir)} -m pip install -U pip ${SDCPP_PYTHON_PACKAGES.join(" ")}`,
       `omnius /image "a compact robot painter" --backend sdcpp --model /absolute/path/to/model.gguf`
     ],
     notes: [
@@ -250450,17 +250463,75 @@ function trimProcessText(text, max = 1800) {
     return clean3;
   return clean3.slice(0, max - 20) + "\n... (truncated)";
 }
-function pythonFor(repoRoot, kind, explicit) {
+function imageGenerationPythonEnv(repoRoot) {
+  const root = imageGenerationDir(repoRoot);
+  const hf = join36(root, "huggingface");
+  return {
+    PYTHONUNBUFFERED: "1",
+    HF_HOME: hf,
+    HUGGINGFACE_HUB_CACHE: join36(hf, "hub"),
+    TRANSFORMERS_CACHE: join36(hf, "transformers"),
+    DIFFUSERS_CACHE: join36(hf, "diffusers"),
+    TORCH_HOME: join36(root, "torch"),
+    XDG_CACHE_HOME: join36(root, "cache"),
+    PIP_CACHE_DIR: join36(root, "pip-cache")
+  };
+}
+async function ensureImageGenerationCacheDirs(repoRoot) {
+  const env2 = imageGenerationPythonEnv(repoRoot);
+  await Promise.all([
+    imageGenerationDir(repoRoot),
+    env2["HF_HOME"],
+    env2["HUGGINGFACE_HUB_CACHE"],
+    env2["TRANSFORMERS_CACHE"],
+    env2["DIFFUSERS_CACHE"],
+    env2["TORCH_HOME"],
+    env2["XDG_CACHE_HOME"],
+    env2["PIP_CACHE_DIR"]
+  ].filter((value2) => Boolean(value2)).map((dir) => mkdir11(dir, { recursive: true })));
+}
+async function pythonCanImport(command, code8, repoRoot, env2) {
+  const result = await runProcess2(command, ["-c", code8], { cwd: repoRoot, timeoutMs: 6e4, env: env2 });
+  return result.code === 0;
+}
+async function ensurePythonFor(repoRoot, kind, explicit) {
+  const pythonEnv = imageGenerationPythonEnv(repoRoot);
+  await ensureImageGenerationCacheDirs(repoRoot);
   if (explicit)
-    return explicit;
-  const env2 = process.env["OMNIUS_IMAGE_PYTHON"];
-  if (env2)
-    return env2;
-  const venv = kind === "diffusers" ? join36(repoRoot, ".omnius", "image-gen", "venv", "bin", "python") : join36(repoRoot, ".omnius", "image-gen", "venv-sdcpp", "bin", "python");
-  return existsSync23(venv) ? venv : "python3";
+    return { command: explicit, env: pythonEnv };
+  const configuredPython = process.env["OMNIUS_IMAGE_PYTHON"];
+  if (configuredPython)
+    return { command: configuredPython, env: pythonEnv };
+  const venvDir = kind === "diffusers" ? diffusersVenvDir(repoRoot) : sdcppVenvDir(repoRoot);
+  const command = venvPython(venvDir);
+  if (!existsSync23(command)) {
+    const created = await runProcess2("python3", ["-m", "venv", venvDir], { cwd: repoRoot, timeoutMs: 18e4, env: pythonEnv });
+    if (created.code !== 0) {
+      throw new Error(`Failed to create image-generation venv at ${venvDir}.
+${trimProcessText(created.stderr || created.stdout)}`);
+    }
+  }
+  const importCheck = kind === "diffusers" ? "import torch, diffusers, PIL\nfrom diffusers import AutoPipelineForText2Image\n" : "import stable_diffusion_cpp, PIL\n";
+  if (await pythonCanImport(command, importCheck, repoRoot, pythonEnv)) {
+    return { command, env: pythonEnv };
+  }
+  const packages = kind === "diffusers" ? DIFFUSERS_PYTHON_PACKAGES : SDCPP_PYTHON_PACKAGES;
+  const pip = await runProcess2(command, ["-m", "pip", "install", "-U", "pip", ...packages], {
+    cwd: repoRoot,
+    timeoutMs: 18e5,
+    env: pythonEnv
+  });
+  if (pip.code !== 0) {
+    throw new Error(`Failed to install ${kind} image-generation packages into ${venvDir}.
+${trimProcessText(pip.stderr || pip.stdout)}`);
+  }
+  if (!await pythonCanImport(command, importCheck, repoRoot, pythonEnv)) {
+    throw new Error(`Image-generation Python environment at ${venvDir} was created, but required ${kind} imports still fail.`);
+  }
+  return { command, env: pythonEnv };
 }
 async function ensureRunner(repoRoot, kind) {
-  const dir = join36(repoRoot, ".omnius", "image-gen");
+  const dir = imageGenerationDir(repoRoot);
   await mkdir11(dir, { recursive: true });
   const script = kind === "diffusers" ? join36(dir, "diffusers_text2image.py") : join36(dir, "sdcpp_text2image.py");
   await writeFile16(script, kind === "diffusers" ? DIFFUSERS_RUNNER : SDCPP_RUNNER, "utf8");
@@ -250494,16 +250565,39 @@ function parseRunnerJson(stdout) {
   }
   return null;
 }
-var IMAGE_GENERATION_MODEL_PRESETS, OLLAMA_IMAGE_MODELS, DIFFUSERS_RUNNER, SDCPP_RUNNER, ImageGenerateTool;
+var DEFAULT_DIFFUSERS_IMAGE_MODEL, DEFAULT_OLLAMA_IMAGE_MODEL, DIFFUSERS_PYTHON_PACKAGES, SDCPP_PYTHON_PACKAGES, IMAGE_GENERATION_MODEL_PRESETS, OLLAMA_IMAGE_MODELS, DIFFUSERS_RUNNER, SDCPP_RUNNER, ImageGenerateTool;
 var init_image_generate = __esm({
   "packages/execution/dist/tools/image-generate.js"() {
     "use strict";
+    init_venv_paths();
+    DEFAULT_DIFFUSERS_IMAGE_MODEL = "stabilityai/sdxl-turbo";
+    DEFAULT_OLLAMA_IMAGE_MODEL = "x/z-image-turbo";
+    DIFFUSERS_PYTHON_PACKAGES = [
+      "torch",
+      "diffusers",
+      "transformers",
+      "accelerate",
+      "safetensors",
+      "pillow",
+      "sentencepiece",
+      "protobuf"
+    ];
+    SDCPP_PYTHON_PACKAGES = [
+      "stable-diffusion-cpp-python",
+      "pillow"
+    ];
     IMAGE_GENERATION_MODEL_PRESETS = [
       {
-        id: "x/z-image-turbo",
+        id: DEFAULT_OLLAMA_IMAGE_MODEL,
         label: "Z-Image Turbo",
         backend: "ollama",
         install: "ollama pull x/z-image-turbo",
+        category: "Modern deployable",
+        sizeClass: "6B-class efficient image model",
+        quality: "Modern high-quality output with a practical inference footprint; below FLUX.1 dev/SD3.5 Large for peak photorealism.",
+        minVramGB: 16,
+        recommendedVramGB: 24,
+        deployment: "Ollama model path; good high-end consumer GPU target.",
         steps: 8,
         width: 1024,
         height: 1024,
@@ -250514,16 +250608,161 @@ var init_image_generate = __esm({
         label: "FLUX.2 Klein",
         backend: "ollama",
         install: "ollama pull x/flux2-klein",
+        category: "Modern deployable",
+        sizeClass: "4B compact FLUX-family",
+        quality: "Modern FLUX-family quality in a smaller package; useful when full FLUX.1 is too heavy.",
+        minVramGB: 12,
+        recommendedVramGB: 16,
+        deployment: "Ollama model path for practical local experimentation.",
         steps: 8,
         width: 1024,
         height: 1024,
         note: "Compact FLUX-family Ollama path for interactive local generation."
       },
+      {
+        id: "black-forest-labs/FLUX.1-dev",
+        label: "FLUX.1 dev",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model black-forest-labs/FLUX.1-dev --steps 28 --guidance 3.5 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Primary hyper-realistic baseline",
+        sizeClass: "12B rectified-flow transformer",
+        quality: "Top-tier open-weight photorealism, prompt adherence, texture detail, composition, and typography.",
+        minVramGB: 24,
+        recommendedVramGB: 48,
+        deployment: "Heavy. Best with Diffusers CPU offload, FP8/quantized variants, ComfyUI, multi-GPU, or cloud GPU workers.",
+        steps: 28,
+        guidance: 3.5,
+        width: 1024,
+        height: 1024,
+        note: "Primary serious-generation baseline for maximum photorealism."
+      },
+      {
+        id: "stabilityai/stable-diffusion-3.5-large",
+        label: "Stable Diffusion 3.5 Large",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model stabilityai/stable-diffusion-3.5-large --steps 28 --guidance 4.5 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Primary hyper-realistic baseline",
+        sizeClass: "8B MMDiT",
+        quality: "Serious open Stable Diffusion ecosystem baseline with strong realism, complex prompt understanding, typography, and controllability.",
+        minVramGB: 24,
+        recommendedVramGB: 40,
+        deployment: "Best local candidate for SD/LoRA/ControlNet-style workflows; use offload or quantization below high-VRAM GPUs.",
+        steps: 28,
+        guidance: 4.5,
+        width: 1024,
+        height: 1024,
+        note: "Primary serious-generation baseline for the Stable Diffusion ecosystem."
+      },
+      {
+        id: "black-forest-labs/FLUX.1-schnell",
+        label: "FLUX.1 schnell",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model black-forest-labs/FLUX.1-schnell --steps 4 --guidance 0 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Fast large-model iteration",
+        sizeClass: "12B rectified-flow transformer",
+        quality: "FLUX-style output with fewer steps; better for rapid iteration than absolute peak quality.",
+        minVramGB: 16,
+        recommendedVramGB: 24,
+        deployment: "Use for fast prompt iteration; verify current license terms before commercial use.",
+        steps: 4,
+        guidance: 0,
+        width: 1024,
+        height: 1024,
+        note: "Fast FLUX-family iteration path."
+      },
+      {
+        id: "stabilityai/stable-diffusion-3.5-large-turbo",
+        label: "SD3.5 Large Turbo",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model stabilityai/stable-diffusion-3.5-large-turbo --steps 4 --guidance 0 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Fast large-model iteration",
+        sizeClass: "8B distilled MMDiT",
+        quality: "SD3.5-family quality optimized for fewer inference steps; throughput over peak fidelity.",
+        minVramGB: 16,
+        recommendedVramGB: 24,
+        deployment: "Good for interactive SD3.5-family concepting with offload/quantization when needed.",
+        steps: 4,
+        guidance: 0,
+        width: 1024,
+        height: 1024,
+        note: "Fast SD3.5-family iteration path."
+      },
+      {
+        id: "Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers",
+        label: "HunyuanDiT v1.2",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model Tencent-Hunyuan/HunyuanDiT-v1.2-Diffusers --steps 30 --guidance 7.5 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Large multilingual diffusion",
+        sizeClass: "Large DiT text-to-image",
+        quality: "Strong bilingual English/Chinese prompt understanding with detailed, realistic multi-resolution output.",
+        minVramGB: 24,
+        recommendedVramGB: 40,
+        deployment: "Significant GPU memory requirements; prefer Diffusers-compatible variants and offload on smaller GPUs.",
+        steps: 30,
+        guidance: 7.5,
+        width: 1024,
+        height: 1024,
+        note: "Large DiT option for bilingual and detailed realism workflows."
+      },
+      {
+        id: "Tongyi-MAI/Z-Image-Turbo",
+        label: "Z-Image-Turbo",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model Tongyi-MAI/Z-Image-Turbo --steps 8 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Modern deployable",
+        sizeClass: "6B image generation model",
+        quality: "Efficient newer large-model quality; useful below full FLUX/SD3.5 hardware budgets.",
+        minVramGB: 16,
+        recommendedVramGB: 24,
+        deployment: "Candidate for high-end consumer GPUs and optimized runtimes.",
+        steps: 8,
+        width: 1024,
+        height: 1024,
+        note: "Efficient modern large image model."
+      },
+      {
+        id: "black-forest-labs/FLUX.2-klein-4B",
+        label: "FLUX.2 Klein 4B",
+        backend: "diffusers",
+        install: 'python .omnius/image-gen/diffusers_text2image.py --model black-forest-labs/FLUX.2-klein-4B --steps 8 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Modern deployable",
+        sizeClass: "4B compact FLUX-family",
+        quality: "Bridge between practical deployment and modern FLUX-family visual quality.",
+        minVramGB: 12,
+        recommendedVramGB: 16,
+        deployment: "Better fit for consumer GPU experimentation than 8B-12B baselines.",
+        steps: 8,
+        width: 1024,
+        height: 1024,
+        note: "More deployable compact FLUX-family model."
+      },
+      {
+        id: "deepseek-ai/Janus-Pro-7B",
+        label: "Janus-Pro-7B",
+        backend: "diffusers",
+        install: "experimental research model; use a dedicated Janus pipeline/runtime rather than the generic Diffusers text-to-image runner",
+        category: "Experimental multimodal research",
+        sizeClass: "7B multimodal image generation model",
+        quality: "Relevant research model, but not a classic diffusion baseline for production image pipelines.",
+        minVramGB: 16,
+        recommendedVramGB: 24,
+        deployment: "Experimental/non-classic diffusion-adjacent; list for awareness, not a default production path.",
+        steps: 20,
+        width: 1024,
+        height: 1024,
+        note: "Experimental multimodal generation research model."
+      },
       {
         id: "segmind/tiny-sd",
         label: "Segmind Tiny-SD",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model segmind/tiny-sd --prompt "..." --output .omnius/images/out.png',
+        category: "Lightweight smoke test",
+        sizeClass: "Small SD-compatible",
+        quality: "Fast validation model; not a serious photorealism baseline.",
+        minVramGB: 4,
+        recommendedVramGB: 8,
+        deployment: "Use to verify the local Diffusers stack works before pulling large models.",
         steps: 20,
         guidance: 7,
         width: 512,
@@ -250535,6 +250774,12 @@ var init_image_generate = __esm({
         label: "BK-SDM Tiny 2M",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model nota-ai/bk-sdm-tiny-2m --prompt "..." --output .omnius/images/out.png',
+        category: "Lightweight smoke test",
+        sizeClass: "Compressed SD-compatible",
+        quality: "Very small and practical; quality is mainly for tests and rough drafts.",
+        minVramGB: 4,
+        recommendedVramGB: 8,
+        deployment: "Low-friction compressed Stable Diffusion-style model.",
         steps: 20,
         guidance: 7,
         width: 512,
@@ -250546,6 +250791,12 @@ var init_image_generate = __esm({
         label: "BK-SDM Small 2M",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model nota-ai/bk-sdm-small-2m --prompt "..." --output .omnius/images/out.png',
+        category: "Lightweight smoke test",
+        sizeClass: "Compressed SD-compatible",
+        quality: "Slightly better compressed-SD quality than tiny variants; still not a high-fidelity baseline.",
+        minVramGB: 4,
+        recommendedVramGB: 8,
+        deployment: "Small quality/size tradeoff for weak hardware.",
         steps: 20,
         guidance: 7,
         width: 512,
@@ -250557,6 +250808,12 @@ var init_image_generate = __esm({
         label: "LCM DreamShaper v7",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model SimianLuo/LCM_Dreamshaper_v7 --steps 4 --prompt "..." --output .omnius/images/out.png',
+        category: "Fast iteration",
+        sizeClass: "Few-step SD-compatible",
+        quality: "Good for low-latency concepting; below SDXL/SD3.5/FLUX for photoreal detail.",
+        minVramGB: 6,
+        recommendedVramGB: 8,
+        deployment: "Few-step latent-consistency route.",
         steps: 4,
         guidance: 8,
         width: 512,
@@ -250568,6 +250825,12 @@ var init_image_generate = __esm({
         label: "SD-Turbo",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model stabilityai/sd-turbo --steps 1 --guidance 0 --prompt "..." --output .omnius/images/out.png',
+        category: "Fast iteration",
+        sizeClass: "One-to-four-step SD",
+        quality: "Fast SD-family output; useful for iteration but lower ceiling than SDXL Turbo and large baselines.",
+        minVramGB: 6,
+        recommendedVramGB: 8,
+        deployment: "Check Stability license for your use case.",
         steps: 1,
         guidance: 0,
         width: 512,
@@ -250575,10 +250838,16 @@ var init_image_generate = __esm({
         note: "One-to-four-step Stable Diffusion family model; check Stability license."
       },
       {
-        id: "stabilityai/sdxl-turbo",
+        id: DEFAULT_DIFFUSERS_IMAGE_MODEL,
         label: "SDXL-Turbo",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model stabilityai/sdxl-turbo --steps 1 --guidance 0 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Default local generation",
+        sizeClass: "Few-step SDXL",
+        quality: "Strong fast default for local image generation; not as realistic as FLUX.1 dev or SD3.5 Large, but much more practical.",
+        minVramGB: 8,
+        recommendedVramGB: 12,
+        deployment: "Auto-installed first-run Diffusers default.",
         steps: 1,
         guidance: 0,
         width: 1024,
@@ -250590,6 +250859,12 @@ var init_image_generate = __esm({
         label: "Sana Sprint 0.6B",
         backend: "diffusers",
         install: 'python .omnius/image-gen/diffusers_text2image.py --model Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers --steps 4 --guidance 0 --width 1024 --height 1024 --prompt "..." --output .omnius/images/out.png',
+        category: "Modern efficient",
+        sizeClass: "0.6B efficient diffusion",
+        quality: "Modern efficient output under smaller compute budgets; below primary large baselines.",
+        minVramGB: 8,
+        recommendedVramGB: 12,
+        deployment: "Efficient Diffusers path for consumer VRAM.",
         steps: 4,
         guidance: 0,
         width: 1024,
@@ -250601,6 +250876,12 @@ var init_image_generate = __esm({
         label: "stable-diffusion.cpp local checkpoint",
         backend: "sdcpp",
         install: 'python .omnius/image-gen/sdcpp_text2image.py --model-path /path/to/model.gguf --prompt "..." --output .omnius/images/out.png',
+        category: "Local checkpoint/GGUF",
+        sizeClass: "Depends on checkpoint",
+        quality: "Quality depends entirely on the local checkpoint or GGUF variant.",
+        minVramGB: 0,
+        recommendedVramGB: 8,
+        deployment: "CPU/GGUF/checkpoint route for custom local workflows.",
         steps: 20,
         width: 512,
         height: 512,
@@ -250623,6 +250904,21 @@ def _device():
         return "mps"
     return "cpu"
 
+def _pipeline_class(model):
+    lowered = model.lower()
+    if "flux" in lowered:
+        from diffusers import FluxPipeline
+        return FluxPipeline
+    if "stable-diffusion-3.5" in lowered or "stable_diffusion_3" in lowered or "sd3" in lowered:
+        from diffusers import StableDiffusion3Pipeline
+        return StableDiffusion3Pipeline
+    from diffusers import AutoPipelineForText2Image
+    return AutoPipelineForText2Image
+
+def _large_model(model):
+    lowered = model.lower()
+    return any(token in lowered for token in ["flux.1", "flux.2", "stable-diffusion-3.5", "hunyuan", "z-image", "janus"])
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--model", required=True)
@@ -250639,7 +250935,6 @@ def main():
 
     t0 = time.perf_counter()
     import torch
-    from diffusers import AutoPipelineForText2Image
 
     device = _device() if args.device == "auto" else args.device
     dtype = torch.float16 if device == "cuda" else torch.float32
@@ -250648,17 +250943,25 @@ def main():
         kwargs["variant"] = args.variant
 
     try:
-        pipe = AutoPipelineForText2Image.from_pretrained(args.model, **kwargs)
+        pipeline_cls = _pipeline_class(args.model)
+        pipe = pipeline_cls.from_pretrained(args.model, **kwargs)
     except Exception:
         kwargs.pop("variant", None)
-        pipe = AutoPipelineForText2Image.from_pretrained(args.model, **kwargs)
+        pipeline_cls = _pipeline_class(args.model)
+        pipe = pipeline_cls.from_pretrained(args.model, **kwargs)
 
     if hasattr(pipe, "enable_attention_slicing"):
         try:
             pipe.enable_attention_slicing()
         except Exception:
             pass
-    pipe = pipe.to(device)
+    if device == "cuda" and _large_model(args.model) and hasattr(pipe, "enable_model_cpu_offload"):
+        try:
+            pipe.enable_model_cpu_offload()
+        except Exception:
+            pipe = pipe.to(device)
+    else:
+        pipe = pipe.to(device)
 
     generator = None
     if args.seed is not None:
@@ -250739,7 +251042,7 @@ if __name__ == "__main__":
 `;
     ImageGenerateTool = class {
       name = "generate_image";
-      description = "Generate an image from a text prompt using a local image-generation backend. Supports Ollama image models (x/z-image-turbo, x/flux2-klein), Python Diffusers models (Tiny-SD, BK-SDM, LCM, SD-Turbo, Sana Sprint), and stable-diffusion.cpp local checkpoints/GGUF. Saves a PNG under .omnius/images and returns the file path.";
+      description = "Generate an image from a text prompt using a local image-generation backend. Supports Ollama image models (x/z-image-turbo, x/flux2-klein), Python Diffusers models (SDXL Turbo default, FLUX.1 dev, SD3.5 Large, Tiny-SD, LCM, Sana Sprint), and stable-diffusion.cpp local checkpoints/GGUF. Saves a PNG under .omnius/images and returns the file path.";
       parameters = {
         type: "object",
         properties: {
@@ -250838,11 +251141,11 @@ if __name__ == "__main__":
           let backend = inferImageGenerationBackend(requestedModel, requestedBackend);
           let model = requestedModel;
           if (backend === "auto") {
-            model = await this.findImageGenModel() ?? void 0;
-            backend = model ? "ollama" : "diffusers";
+            backend = "diffusers";
+            model = DEFAULT_DIFFUSERS_IMAGE_MODEL;
           }
           if (!model) {
-            model = backend === "diffusers" ? "segmind/tiny-sd" : "x/z-image-turbo";
+            model = backend === "diffusers" ? DEFAULT_DIFFUSERS_IMAGE_MODEL : DEFAULT_OLLAMA_IMAGE_MODEL;
           }
           if (backend === "ollama") {
             return await this.generateWithOllama({ prompt, model, width, height, steps, start: start2 });
@@ -250934,7 +251237,23 @@ ${errText.slice(0, 800)}`,
         const runner = await ensureRunner(this.cwd, "diffusers");
         await mkdir11(join36(this.cwd, ".omnius", "images"), { recursive: true });
         const filepath = outputPath(this.cwd);
-        const command = pythonFor(this.cwd, "diffusers", typeof args.python === "string" ? args.python : void 0);
+        let python;
+        try {
+          python = await ensurePythonFor(this.cwd, "diffusers", typeof args.python === "string" ? args.python : void 0);
+        } catch (err) {
+          const plan = imageGenerationSetupPlan("diffusers", this.cwd, args.model);
+          return {
+            success: false,
+            output: [
+              `Diffusers setup failed before image generation.`,
+              err instanceof Error ? err.message : String(err),
+              "",
+              "Setup path:",
+              ...plan.commands.map((cmd) => `  ${cmd}`)
+            ].filter(Boolean).join("\n"),
+            durationMs: performance.now() - args.start
+          };
+        }
         const argv = [
           runner,
           "--model",
@@ -250954,7 +251273,7 @@ ${errText.slice(0, 800)}`,
         ];
         if (args.seed !== void 0)
           argv.push("--seed", String(args.seed));
-        const result = await runProcess2(command, argv, { cwd: this.cwd, timeoutMs: 9e5 });
+        const result = await runProcess2(python.command, argv, { cwd: this.cwd, timeoutMs: 9e5, env: python.env });
         if (result.code !== 0 || !existsSync23(filepath)) {
           const plan = imageGenerationSetupPlan("diffusers", this.cwd, args.model);
           return {
@@ -251008,7 +251327,23 @@ ${errText.slice(0, 800)}`,
         const runner = await ensureRunner(this.cwd, "sdcpp");
         await mkdir11(join36(this.cwd, ".omnius", "images"), { recursive: true });
         const filepath = outputPath(this.cwd);
-        const command = pythonFor(this.cwd, "sdcpp", typeof args.python === "string" ? args.python : void 0);
+        let python;
+        try {
+          python = await ensurePythonFor(this.cwd, "sdcpp", typeof args.python === "string" ? args.python : void 0);
+        } catch (err) {
+          const plan = imageGenerationSetupPlan("sdcpp", this.cwd, args.model);
+          return {
+            success: false,
+            output: [
+              `stable-diffusion.cpp setup failed before image generation.`,
+              err instanceof Error ? err.message : String(err),
+              "",
+              "Setup path:",
+              ...plan.commands.map((cmd) => `  ${cmd}`)
+            ].filter(Boolean).join("\n"),
+            durationMs: performance.now() - args.start
+          };
+        }
         const argv = [
           runner,
           "--model-path",
@@ -251026,7 +251361,7 @@ ${errText.slice(0, 800)}`,
         ];
         if (args.seed !== void 0)
           argv.push("--seed", String(args.seed));
-        const result = await runProcess2(command, argv, { cwd: this.cwd, timeoutMs: 9e5 });
+        const result = await runProcess2(python.command, argv, { cwd: this.cwd, timeoutMs: 9e5, env: python.env });
         if (result.code !== 0 || !existsSync23(filepath)) {
           const plan = imageGenerationSetupPlan("sdcpp", this.cwd, args.model);
           return {
@@ -512881,6 +513216,8 @@ __export(dist_exports, {
   CreateToolTool: () => CreateToolTool,
   CronAgentTool: () => CronAgentTool,
   CustomTool: () => CustomTool,
+  DEFAULT_DIFFUSERS_IMAGE_MODEL: () => DEFAULT_DIFFUSERS_IMAGE_MODEL,
+  DEFAULT_OLLAMA_IMAGE_MODEL: () => DEFAULT_OLLAMA_IMAGE_MODEL,
   DESKTOP_DEPS: () => DESKTOP_DEPS,
   DebateTool: () => DebateTool,
   DesktopClickTool: () => DesktopClickTool,
@@ -513002,6 +513339,7 @@ __export(dist_exports, {
   deleteTodos: () => deleteTodos,
   detectElevationMethod: () => detectElevationMethod,
   detectSearchProvider: () => detectSearchProvider,
+  diffusersVenvDir: () => diffusersVenvDir,
   discoverPlugins: () => discoverPlugins,
   discoverSkills: () => discoverSkills,
   emitIndexed: () => emitIndexed,
@@ -513034,6 +513372,7 @@ __export(dist_exports, {
   getWorkingNotesSummary: () => getWorkingNotesSummary,
   getWorktreeSession: () => getWorktreeSession,
   hashGeneratedArtifactContent: () => hashGeneratedArtifactContent,
+  imageGenerationDir: () => imageGenerationDir,
   imageGenerationSetupPlan: () => imageGenerationSetupPlan,
   inferImageGenerationBackend: () => inferImageGenerationBackend,
   isFortemiAvailable: () => isFortemiAvailable,
@@ -513084,6 +513423,7 @@ __export(dist_exports, {
   saveCustomToolDefinition: () => saveCustomToolDefinition,
   saveMcpServerToConfig: () => saveMcpServerToConfig,
   savePacket: () => savePacket,
+  sdcppVenvDir: () => sdcppVenvDir,
   serializeMap: () => serializeMap,
   setChangeLogSession: () => setChangeLogSession,
   setSudoPassword: () => setSudoPassword,
@@ -550222,7 +550562,7 @@ var init_command_registry = __esm({
       ["/image <prompt>", "Generate an image from a prompt and show an ASCII preview"],
       ["/image --model <model> <prompt>", "Generate with an explicit image model"],
       ["/image setup <ollama|diffusers|sdcpp>", "Show setup commands for an image-generation backend"],
-      ["/image models", "List known lightweight/local image-generation model presets"],
+      ["/image list", "List image models by category, quality, size, and hardware fit"],
       ["/call", "Start voice call session (cloudflared tunnel + ASR/TTS)"],
       ["/hangup", "End active call session"],
       ["/queue <prompt>", "Queue a prompt for the next turn without interrupting the current run"],
@@ -572281,14 +572621,16 @@ ${preview.ascii}`;
 function extractSavedImagePath(text, repoRoot) {
   const patterns = [
     /Image generated:\s*([^\n\r]+)/i,
+    /Screenshot saved:\s*([^\n\r]+)/i,
+    /Screenshot:\s*([^\n\r]+)/i,
     /Saved to:\s*([^\n\r]+)/i,
     /Image attached:\s*([^\n\r]+)/i,
-    /image saved at\s+([^\n\r.]+)/i
+    /image saved at\s+([^\n\r]+)/i
   ];
   for (const pattern of patterns) {
     const match = text.match(pattern);
     if (!match?.[1]) continue;
-    const raw = match[1].trim().replace(/^["']|["']$/g, "");
+    const raw = match[1].trim().replace(/\s+\([^)]+\)\s*$/g, "").replace(/^["']|["']$/g, "");
     const candidate = raw.startsWith("/") ? raw : resolve37(repoRoot, raw);
     if (existsSync93(candidate)) return candidate;
   }
@@ -582626,18 +582968,123 @@ function parseImageNumber(value2) {
   const n2 = Number(value2);
   return Number.isFinite(n2) ? n2 : void 0;
 }
+function rateImagePresetForHardware(preset, specs) {
+  const min = preset.minVramGB ?? (preset.backend === "sdcpp" ? 0 : 8);
+  const recommended = preset.recommendedVramGB ?? Math.max(min, 12);
+  const vram = specs.gpuVramGB;
+  const ram = Math.max(specs.availableRamGB, specs.totalRamGB * 0.65);
+  if (preset.id === "deepseek-ai/Janus-Pro-7B") {
+    const base3 = vram >= recommended ? 65 : vram >= min ? 50 : 25;
+    return {
+      score: base3,
+      label: base3 >= 60 ? "experimental" : "not turnkey",
+      note: "Experimental multimodal model; use a dedicated Janus runtime, not the generic Diffusers runner."
+    };
+  }
+  if (min <= 0) {
+    const score2 = vram >= recommended ? 85 : vram > 0 ? 70 : ram >= 32 ? 45 : 25;
+    return {
+      score: score2,
+      label: score2 >= 80 ? "comfortable" : score2 >= 60 ? "workable" : "checkpoint-dependent",
+      note: vram > 0 ? "Fit depends on the local checkpoint/GGUF size and runtime flags." : "CPU/GGUF path is possible but will be slow; choose small quantized checkpoints."
+    };
+  }
+  let score;
+  let label;
+  let note;
+  if (vram >= recommended) {
+    score = Math.min(100, Math.round(90 + Math.min(10, (vram - recommended) / Math.max(1, recommended) * 10)));
+    label = "excellent";
+    note = `Runs well on ${vram.toFixed(0)}GB VRAM; enough headroom for ${preset.sizeClass ?? "this model"}.`;
+  } else if (vram >= min) {
+    score = Math.round(70 + (vram - min) / Math.max(1, recommended - min) * 18);
+    label = "comfortable";
+    note = `Fits the stated ${min.toFixed(0)}GB minimum; expect lower batching/headroom than the ${recommended.toFixed(0)}GB target.`;
+  } else if (vram > 0 && ram >= recommended * 1.5) {
+    score = 52;
+    label = "offload";
+    note = `Below ${min.toFixed(0)}GB VRAM; may work with CPU offload or quantization, but latency and reliability will suffer.`;
+  } else if (ram >= recommended * 2) {
+    score = 35;
+    label = "cloud/quant";
+    note = "System RAM is large enough for experiments, but VRAM is below target; prefer quantized runtimes or cloud GPU.";
+  } else {
+    score = 18;
+    label = "too heavy";
+    note = `Needs roughly ${min.toFixed(0)}GB VRAM minimum and ${recommended.toFixed(0)}GB recommended.`;
+  }
+  return { score, label, note };
+}
+function imageFitIcon(score) {
+  if (score >= 85) return c3.green("✔");
+  if (score >= 60) return c3.green("◐");
+  if (score >= 40) return c3.yellow("△");
+  return c3.red("✖");
+}
+function wrapImageListText(text, width = 94) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = "";
+  for (const word2 of words) {
+    if (!line) line = word2;
+    else if (line.length + 1 + word2.length <= width) line += ` ${word2}`;
+    else {
+      lines.push(line);
+      line = word2;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.length > 0 ? lines : [""];
+}
+function renderImagePresetDetail(prefix, text) {
+  const [first2, ...rest] = wrapImageListText(text, 92);
+  renderInfo(`${prefix}${first2}`);
+  for (const line of rest) renderInfo(`${" ".repeat(prefix.length)}${line}`);
+}
+function renderImageModelList() {
+  const specs = detectSystemSpecs();
+  const hardware = `${specs.totalRamGB.toFixed(0)}GB RAM` + (specs.gpuVramGB > 0 ? ` + ${specs.gpuVramGB.toFixed(0)}GB VRAM (${specs.gpuName || "NVIDIA GPU"})` : " + no NVIDIA VRAM detected");
+  renderInfo(`Image models for this hardware: ${hardware}`);
+  renderInfo("Fit legend: 85+ excellent, 60+ comfortable, 40+ offload/quantized, below 40 heavy/cloud.");
+  renderInfo("Primary hyper-realistic baselines: FLUX.1 dev and Stable Diffusion 3.5 Large.");
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const preset of IMAGE_GENERATION_MODEL_PRESETS) {
+    const category = preset.category ?? "Other";
+    const list = byCategory.get(category) ?? [];
+    list.push(preset);
+    byCategory.set(category, list);
+  }
+  for (const [category, presets] of byCategory) {
+    renderInfo("");
+    renderInfo(c3.bold(category));
+    for (const preset of presets) {
+      const fit2 = rateImagePresetForHardware(preset, specs);
+      const primary = category === "Primary hyper-realistic baseline" ? c3.cyan(" ★") : "";
+      renderInfo(`${imageFitIcon(fit2.score)} ${String(fit2.score).padStart(3)}/100 ${c3.bold(preset.label)}${primary}`);
+      renderInfo(`    id: ${preset.id}`);
+      renderInfo(`    type: ${preset.backend} · ${preset.sizeClass ?? "unknown size"} · ${fit2.label}`);
+      renderImagePresetDetail("    quality: ", preset.quality ?? preset.note);
+      renderImagePresetDetail("    fit: ", fit2.note);
+      if (preset.deployment) renderImagePresetDetail("    deploy: ", preset.deployment);
+    }
+  }
+}
 async function showImageModelsMenu(ctx3, hasLocal) {
   const settings = resolveSettings(ctx3.repoRoot);
+  const specs = detectSystemSpecs();
   const items = [
     { key: "setup:ollama", label: "Setup Ollama", detail: "Pull x/z-image-turbo or x/flux2-klein" },
-    { key: "setup:diffusers", label: "Setup Diffusers", detail: "Python venv for Tiny-SD, BK-SDM, SD-Turbo, Sana" },
+    { key: "setup:diffusers", label: "Setup Diffusers", detail: "Auto-installs SDXL Turbo under .omnius/image-gen/.venv" },
     { key: "setup:sdcpp", label: "Setup stable-diffusion.cpp", detail: "CPU/GGUF/checkpoint route" },
     { key: "hdr:models", label: selectColors.dim("─── Models ───") },
-    ...IMAGE_GENERATION_MODEL_PRESETS.map((preset) => ({
-      key: `model:${preset.id}`,
-      label: preset.label,
-      detail: `${preset.backend} · ${preset.id} · ${preset.note}`
-    }))
+    ...IMAGE_GENERATION_MODEL_PRESETS.map((preset) => {
+      const fit2 = rateImagePresetForHardware(preset, specs);
+      return {
+        key: `model:${preset.id}`,
+        label: preset.label,
+        detail: `${fit2.score}/100 ${fit2.label} · ${preset.category ?? preset.backend} · ${preset.sizeClass ?? preset.id}`
+      };
+    })
   ];
   const result = await tuiSelect({
     items,
@@ -582673,10 +583120,8 @@ async function handleImageCommand(ctx3, arg, hasLocal) {
     await showImageModelsMenu(ctx3, hasLocal);
     return "handled";
   }
-  if (parsed.subcommand === "models") {
-    for (const preset of IMAGE_GENERATION_MODEL_PRESETS) {
-      renderInfo(`${preset.id} [${preset.backend}] ${preset.note}`);
-    }
+  if (parsed.subcommand === "models" || parsed.subcommand === "list") {
+    renderImageModelList();
     return "handled";
   }
   if (parsed.subcommand === "setup") {
@@ -582688,7 +583133,7 @@ async function handleImageCommand(ctx3, arg, hasLocal) {
     for (const note of plan.notes) renderInfo(`- ${note}`);
     return "handled";
   }
-  const model = String(parsed.flags["model"] ?? settings.imageModel ?? "auto");
+  const model = String(parsed.flags["model"] ?? settings.imageModel ?? DEFAULT_DIFFUSERS_IMAGE_MODEL);
   const backend = String(parsed.flags["backend"] ?? settings.imageBackend ?? inferImageGenerationBackend(model, void 0));
   const tool = new ImageGenerateTool(ctx3.repoRoot, ctx3.config.backendUrl);
   const prompt = parsed.prompt;
@@ -593167,11 +593612,11 @@ function runProcess3(command, args, cwd4, timeoutMs) {
     child.stderr?.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    child.on("error", (err) => {
+    onChildError(child, (err) => {
       clearTimeout(timer);
       resolveProcess({ code: 127, stdout, stderr: stderr + String(err.message || err) });
     });
-    child.on("close", (code8) => {
+    onChildClose(child, (code8) => {
       clearTimeout(timer);
       resolveProcess({ code: code8, stdout, stderr });
     });
@@ -593181,6 +593626,7 @@ var MANIFEST_FILE, PATH_KEYS, MEDIA_PATH_RE, CreativeAudioFileTool;
 var init_telegram_creative_tools = __esm({
   "packages/cli/src/tui/telegram-creative-tools.ts"() {
     "use strict";
+    init_typed_node_events();
     init_dist5();
     MANIFEST_FILE = ".omnius-creative-manifest.json";
     PATH_KEYS = ["path", "file", "file_path", "filename", "filepath", "filePath"];
@@ -593477,6 +593923,13 @@ function sanitizeTelegramProgressText(text, maxLength) {
 function compactTelegramVisibleText(text) {
   return stripTelegramHiddenThinking(text).replace(/\s+/g, " ").trim();
 }
+function stableTelegramValueKey(value2) {
+  if (value2 === void 0) return "undefined";
+  if (value2 === null || typeof value2 !== "object") return JSON.stringify(value2) ?? String(value2);
+  if (Array.isArray(value2)) return `[${value2.map(stableTelegramValueKey).join(",")}]`;
+  const record = value2;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableTelegramValueKey(record[key])}`).join(",")}}`;
+}
 function isTelegramPotentialNoReplyPrefix(text) {
   const lower = compactTelegramVisibleText(text).toLowerCase();
   return Boolean(lower) && "no_reply".startsWith(lower);
@@ -593507,7 +593960,39 @@ function cleanTelegramVisibleReply(text, options2 = {}) {
   if (!clean3) return "";
   if (options2.suppressPotentialNoReplyPrefix && isTelegramPotentialNoReplyPrefix(clean3)) return "";
   if (isTelegramInternalStatusText(clean3)) return "";
-  return clean3;
+  return dedupeTelegramVisibleReply(clean3);
+}
+function dedupeTelegramVisibleReply(text) {
+  const paragraphs = text.split(/\n{2,}/);
+  const seenParagraphs = /* @__PURE__ */ new Set();
+  const collapsedParagraphs = [];
+  for (const paragraph of paragraphs) {
+    const clean3 = paragraph.trim();
+    if (!clean3) continue;
+    const key = compactTelegramVisibleText(clean3).toLowerCase();
+    if (seenParagraphs.has(key)) continue;
+    seenParagraphs.add(key);
+    collapsedParagraphs.push(clean3);
+  }
+  const paragraphCollapsed = collapsedParagraphs.join("\n\n");
+  const sentenceLike = paragraphCollapsed.match(/[^.!?]+[.!?]+|[^.!?]+$/g);
+  if (!sentenceLike || sentenceLike.length < 3) return paragraphCollapsed;
+  const seenSentences = /* @__PURE__ */ new Set();
+  const out = [];
+  let duplicates = 0;
+  for (const raw of sentenceLike) {
+    const sentence = raw.trim();
+    if (!sentence) continue;
+    const key = sentence.replace(/\s+/g, " ").toLowerCase();
+    if (seenSentences.has(key)) {
+      duplicates++;
+      continue;
+    }
+    seenSentences.add(key);
+    out.push(sentence);
+  }
+  if (duplicates === 0) return paragraphCollapsed;
+  return out.join(" ").trim();
 }
 function truncateTelegramContext(text, maxLength) {
   const trimmed = text.trim();
@@ -593631,9 +594116,7 @@ function selectTelegramFinalResponse(args) {
     args.assistantText
   ].map((candidate) => cleanTelegramVisibleReply(candidate || "")).filter(Boolean);
   if (visibleCandidates.length > 0) {
-    return visibleCandidates.reduce(
-      (best, current) => current.length > best.length ? current : best
-    );
+    return visibleCandidates[0];
   }
   void args.summary;
   return "";
@@ -593925,6 +594408,26 @@ function telegramImageMime(media) {
   if (ext === ".tif" || ext === ".tiff") return "image/tiff";
   return "image/jpeg";
 }
+function extractTelegramMentionedUsernames(message2, text) {
+  const usernames = /* @__PURE__ */ new Set();
+  const entities = [
+    ...Array.isArray(message2.entities) ? message2.entities : [],
+    ...Array.isArray(message2.caption_entities) ? message2.caption_entities : []
+  ];
+  for (const entity of entities) {
+    if (!entity || typeof entity !== "object") continue;
+    if (entity.type === "mention") {
+      const offset = Number(entity.offset);
+      const length4 = Number(entity.length);
+      if (!Number.isFinite(offset) || !Number.isFinite(length4) || length4 <= 1) continue;
+      const mention = text.slice(offset, offset + length4).replace(/^@/, "").trim();
+      if (mention) usernames.add(mention);
+    } else if (entity.type === "text_mention" && typeof entity.user?.username === "string") {
+      usernames.add(entity.user.username);
+    }
+  }
+  return [...usernames];
+}
 function normalizeTelegramUpdate(update2) {
   const sourceUpdateType = update2.guest_message ? "guest_message" : update2.message ? "message" : null;
   if (!sourceUpdateType) return null;
@@ -593957,6 +594460,9 @@ function normalizeTelegramUpdate(update2) {
     isDirectMessages: Boolean(message2.chat?.is_direct_messages),
     parentChatId: message2.chat?.parent_chat?.id ?? message2.direct_messages_topic?.parent_topic?.id,
     replyToMessageId: message2.reply_to_message?.message_id,
+    replyToUsername: message2.reply_to_message?.from?.username ?? message2.reply_to_message?.sender_chat?.username,
+    replyToBot: Boolean(message2.reply_to_message?.from?.is_bot),
+    mentionedUsernames: extractTelegramMentionedUsernames(message2, text),
     sourceUpdateType
   };
 }
@@ -594015,10 +594521,10 @@ function renderTelegramStart(botUsername, adminId, mode = "auto") {
   if (adminId) {
     process.stdout.write(`    ${c3.dim(`Admin: ${adminId} (full memory + tools)`)}
 `);
-    process.stdout.write(`    ${c3.dim("Public users: light memory + web search only")}
+    process.stdout.write(`    ${c3.dim("Public users: scoped memory + web + per-chat creative file/image/audio tools")}
 `);
   }
-  process.stdout.write(`    ${c3.dim("Safety filter: ACTIVE — public channel mode")}
+  process.stdout.write(`    ${c3.dim("Safety filter: ACTIVE — public channel mode; creative writes are sandboxed under .omnius/telegram-creative/<chat>")}
 `);
   process.stdout.write(`    ${c3.dim("Use /telegram to toggle off, or /telegram stop")}
 
@@ -594858,16 +595364,27 @@ ${lines.join("\n")}`);
         this.groupSkipLogAt.set(sessionKey, now);
         this.tuiWrite(() => renderTelegramSubAgentEvent(msg.username, `${reason} (context retained)`));
       }
+      telegramMessageAddressesBot(msg) {
+        const bot = this.state.botUsername.trim().replace(/^@/, "").toLowerCase();
+        if (!bot) return false;
+        const mentioned = (msg.mentionedUsernames ?? []).some(
+          (name10) => name10.trim().replace(/^@/, "").toLowerCase() === bot
+        );
+        if (mentioned) return true;
+        if (msg.replyToUsername && msg.replyToUsername.trim().replace(/^@/, "").toLowerCase() === bot) return true;
+        return false;
+      }
       async inferTelegramInteractionDecision(msg, toolContext) {
         const config = this.agentConfig;
         const forcedRoute = this.interactionMode === "chat" || this.interactionMode === "action" ? this.interactionMode : null;
         const isGroup = msg.chatType !== "private";
+        const addressesBot = this.telegramMessageAddressesBot(msg);
         if (!config) {
           return {
-            route: forcedRoute ?? "action",
-            shouldReply: !isGroup,
+            route: forcedRoute ?? (isGroup ? "action" : "chat"),
+            shouldReply: !isGroup || addressesBot,
             confidence: 0,
-            reason: isGroup ? "router inference unavailable; public group fails closed without keyword heuristics" : "router inference unavailable; private chat defaults to reply",
+            reason: isGroup ? addressesBot ? "router inference unavailable; Telegram message directly addresses the bot" : "router inference unavailable; public group fails closed without keyword heuristics" : "router inference unavailable; private chat defaults to quick reply",
             source: "inference-unavailable"
           };
         }
@@ -594888,6 +595405,7 @@ ${lines.join("\n")}`);
           `Route meanings:`,
           `- chat: a short conversational answer can be produced without tools.`,
           `- action: tools, workspace context, media processing, web lookup, delegation, or a multi-step agent loop may be needed.`,
+          `Route discipline: greetings, acknowledgements, casual tone/style discussion, and simple conversational questions are chat. Use action only when the message asks you to inspect, create, change, send, remember, search, analyze media, or otherwise do tool-backed work.`,
           ``,
           `Reply discretion: infer from the live thread, speaker relationships, direct mentions, replies, tone, and current message. Do not use static keyword rules.`,
           `Private chats: should_reply is normally true.`,
@@ -594896,9 +595414,12 @@ ${lines.join("\n")}`);
           ``,
           `Tool context: ${toolContext}`,
           `Bot username: ${this.state.botUsername || "unknown"}`,
+          `Current message directly addresses this bot: ${addressesBot ? "yes" : "no"}`,
           `Current chat type: ${msg.chatType}`,
           `Current sender: ${telegramSpeakerLabel(msg)}`,
           msg.replyToMessageId ? `Current message replies to message_id ${msg.replyToMessageId}` : "",
+          msg.replyToUsername ? `Current message replies to @${msg.replyToUsername}` : "",
+          (msg.mentionedUsernames ?? []).length > 0 ? `Current message mentions: ${(msg.mentionedUsernames ?? []).map((name10) => `@${name10}`).join(", ")}` : "",
           msg.media ? `Current message has media: ${summarizeTelegramMessageAttachments(msg)}` : "",
           ``,
           context2,
@@ -594929,10 +595450,10 @@ ${msg.text}`
         } catch {
         }
         return {
-          route: forcedRoute ?? "action",
-          shouldReply: !isGroup,
+          route: forcedRoute ?? (isGroup ? "action" : "chat"),
+          shouldReply: !isGroup || addressesBot,
           confidence: 0,
-          reason: isGroup ? "router inference failed; public group fails closed without keyword heuristics" : "router inference failed; private chat defaults to reply",
+          reason: isGroup ? addressesBot ? "router inference failed; Telegram message directly addresses the bot" : "router inference failed; public group fails closed without keyword heuristics" : "router inference failed; private chat defaults to quick reply",
           source: "inference-unavailable"
         };
       }
@@ -595407,7 +595928,8 @@ ${mediaContext}`;
           toolContext,
           pendingMessages: [],
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(msg, toolContext),
-          generatedArtifacts: []
+          generatedArtifacts: [],
+          surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
         this.refreshActiveTelegramInteractionCount();
@@ -595504,7 +596026,8 @@ ${mediaContext}`;
           toolContext,
           pendingMessages: [],
           creativeWorkspaceRoot: this.creativeWorkspaceRootForMessage(msg, toolContext),
-          generatedArtifacts: []
+          generatedArtifacts: [],
+          surfacedToolCallFingerprints: /* @__PURE__ */ new Set()
         };
         this.subAgents.set(sessionKey, subAgent);
         this.refreshActiveTelegramInteractionCount();
@@ -595807,8 +596330,20 @@ ${mediaContext}` : ""}`
         runner.registerTools(tools);
         runner.onEvent((event) => {
           if (subAgent.aborted) return;
-          this.onSubAgentEvent?.(msg.chatId, msg.username, event);
+          let suppressExternalEvent = false;
+          if (event.type === "tool_call" && event.toolName) {
+            const fp = `${event.toolName}:${stableTelegramValueKey(event.toolArgs ?? {})}`;
+            if (subAgent.surfacedToolCallFingerprints.has(fp)) {
+              suppressExternalEvent = true;
+            } else {
+              subAgent.surfacedToolCallFingerprints.add(fp);
+            }
+          }
+          if (!suppressExternalEvent) {
+            this.onSubAgentEvent?.(msg.chatId, msg.username, event);
+          }
           if (event.type === "tool_call" && event.toolName) {
+            if (suppressExternalEvent) return;
             const argsPreview = event.toolArgs ? JSON.stringify(event.toolArgs).slice(0, 100) : "";
             this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `tool: ${event.toolName}(${argsPreview})`);
           } else if (event.type === "tool_result" && event.toolName) {
@@ -595823,6 +596358,9 @@ ${mediaContext}` : ""}`
             this.subAgentViewCallbacks?.onWrite(subAgent.viewId, `status: ${event.content}`);
           } else if (event.type === "assistant_text" && event.content && event.source !== "task_complete_summary") {
             subAgent.assistantText = event.content;
+          } else if (event.type === "stream_start") {
+            subAgent.accumulated = "";
+            subAgent.streamText = "";
           } else if (event.type === "stream_end" && event.content) {
             subAgent.streamText = event.content;
           }
@@ -595885,6 +596423,8 @@ ${msg.text}`;
           const toolHint = [
             "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation.",
             "You can remember facts about users and retrieve them later. You also have web_search and web_fetch to look up information.",
+            "If the user asks you to create or send a file, image, or audio artifact, use the scoped creative tools. The bridge will attach generated files back to Telegram when tool results record them.",
+            "For image generation requests, decide from the conversation whether generate_image is appropriate; do not ask the user to use a hardcoded shortcut when the request is clear.",
             creativeWorkspace
           ].filter(Boolean).join("\n\n");
           userPrompt = `${systemPrompt}${discretionPrompt}
@@ -621869,13 +622409,14 @@ async function renderAsciiPreviewForImage(imagePath, displayPath, title, writer)
   }
 }
 async function renderAsciiPreviewForToolResult(toolName, output, repoRoot, writer) {
-  if (toolName !== "camera_capture" || !output) return;
+  if (!output) return;
   try {
     const { extractSavedImagePath: extractSavedImagePath2 } = await Promise.resolve().then(() => (init_image_ascii_preview(), image_ascii_preview_exports));
     const imagePath = extractSavedImagePath2(output, repoRoot);
     if (!imagePath) return;
     const displayPath = relative13(repoRoot, imagePath).startsWith("..") ? imagePath : relative13(repoRoot, imagePath);
-    await renderAsciiPreviewForImage(imagePath, displayPath, "Camera frame", writer);
+    const title = toolName === "generate_image" ? "Generated image" : toolName === "screenshot" ? "Screenshot" : toolName === "camera_capture" ? "Camera frame" : "Image";
+    await renderAsciiPreviewForImage(imagePath, displayPath, title, writer);
   } catch {
   }
 }
@@ -623026,7 +623567,7 @@ ${entry.fullContent}`
             }
           });
         }
-        if (event.success && event.toolName === "camera_capture") {
+        if (event.success) {
           void renderAsciiPreviewForToolResult(event.toolName, event.content ?? "", repoRoot, contentWrite);
         }
         if (voice?.enabled && voice.voiceMode === "voicechat" && _voiceChatSession2?.isActive && event.toolName === "task_complete") {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.5",
+      "version": "1.0.7",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",