omnius 1.0.10 → 1.0.12

package/dist/index.js

@@ -181,7 +181,7 @@ function printWarning(message2) {
 `);
 }
 function printInfo(message2) {
-  process.stdout.write(`${c.cyan("ℹ")} ${message2}
+  process.stdout.write(`${c.cyan("i")} ${message2}
 `);
 }
 function printKeyValue(key, value2, indent = 0) {
@@ -229,7 +229,7 @@ var init_output = __esm({
     isStderrTTY = process.stderr.isTTY;
     c = {
       bold: (t2) => ansi("1", t2, isTTY),
-      dim: (t2) => ansi("2", t2, isTTY),
+      dim: (t2) => ansi("38;5;250", t2, isTTY),
       red: (t2) => ansi("31", t2, isTTY),
       green: (t2) => ansi("32", t2, isTTY),
       yellow: (t2) => ansi("33", t2, isTTY),
@@ -250335,6 +250335,36 @@ import { spawn as spawn9 } from "node:child_process";
 import { existsSync as existsSync23, statSync as statSync8 } from "node:fs";
 import { chmod as chmod3, mkdir as mkdir11, writeFile as writeFile16 } from "node:fs/promises";
 import { join as join36, resolve as resolve18 } from "node:path";
+function parsePercent(text) {
+  const match = text.match(/\b(\d{1,3})%\b/);
+  if (!match)
+    return void 0;
+  const value2 = Number(match[1]);
+  if (!Number.isFinite(value2))
+    return void 0;
+  return Math.max(0, Math.min(100, value2));
+}
+function cleanProgressText(text) {
+  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function parseStructuredProgress(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{"))
+    return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed["omnius_progress"] !== true)
+      return null;
+    const stage = String(parsed["stage"] ?? "process");
+    const message2 = String(parsed["message"] ?? "").trim();
+    const percent = typeof parsed["percent"] === "number" ? parsed["percent"] : void 0;
+    if (!message2)
+      return null;
+    return { stage, message: message2, percent };
+  } catch {
+    return null;
+  }
+}
 function numberArg(value2, fallback) {
   const n2 = Number(value2);
   return Number.isFinite(n2) && n2 > 0 ? n2 : fallback;
@@ -250430,6 +250460,7 @@ function imageGenerationSetupPlan(backend, repoRoot = ".", model) {
 }
 async function runProcess2(command, args, options2) {
   return new Promise((resolveProcess) => {
+    const startedAt2 = Date.now();
     const child = spawn9(command, args, {
       cwd: options2.cwd,
       env: { ...process.env, ...options2.env },
@@ -250437,22 +250468,66 @@ async function runProcess2(command, args, options2) {
     });
     let stdout = "";
     let stderr = "";
+    let lastProgress = "";
+    let lastProgressAt = 0;
+    const emitProgress = (stream, raw) => {
+      if (!options2.onProgress)
+        return;
+      const parts = raw.split(/[\r\n]+/).filter((part) => part.trim());
+      for (const part of parts.length > 0 ? parts : [raw]) {
+        const clean3 = cleanProgressText(part);
+        if (!clean3)
+          continue;
+        const now = Date.now();
+        const structured = parseStructuredProgress(clean3);
+        if (clean3 === lastProgress && now - lastProgressAt < 750)
+          continue;
+        lastProgress = clean3;
+        lastProgressAt = now;
+        if (structured) {
+          options2.onProgress({ ...structured, elapsedMs: now - startedAt2 });
+        } else {
+          options2.onProgress({
+            stage: stream === "stderr" ? "download" : "process",
+            message: clean3.length > 220 ? clean3.slice(0, 217) + "..." : clean3,
+            percent: parsePercent(clean3),
+            elapsedMs: now - startedAt2
+          });
+        }
+      }
+    };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
     }, options2.timeoutMs);
     timer.unref();
+    const heartbeat = setInterval(() => {
+      if (!options2.onProgress || !options2.progressLabel)
+        return;
+      options2.onProgress({
+        stage: "process",
+        message: `${options2.progressLabel} still running`,
+        elapsedMs: Date.now() - startedAt2
+      });
+    }, 5e3);
+    heartbeat.unref();
     child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
+      const text = chunk.toString();
+      stdout += text;
+      emitProgress("stdout", text);
     });
     child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
+      const text = chunk.toString();
+      stderr += text;
+      emitProgress("stderr", text);
     });
     child.on("error", (err) => {
       clearTimeout(timer);
+      clearInterval(heartbeat);
       resolveProcess({ code: 127, stdout, stderr: stderr + String(err.message || err) });
     });
     child.on("close", (code8) => {
       clearTimeout(timer);
+      clearInterval(heartbeat);
       resolveProcess({ code: code8, stdout, stderr });
     });
   });
@@ -250468,6 +250543,8 @@ function imageGenerationPythonEnv(repoRoot) {
   const hf = join36(root, "huggingface");
   return {
     PYTHONUNBUFFERED: "1",
+    HF_HUB_DISABLE_PROGRESS_BARS: "0",
+    TQDM_DISABLE: "0",
     HF_HOME: hf,
     HUGGINGFACE_HUB_CACHE: join36(hf, "hub"),
     TRANSFORMERS_CACHE: join36(hf, "transformers"),
@@ -250494,7 +250571,7 @@ 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) {
+async function ensurePythonFor(repoRoot, kind, explicit, onProgress) {
   const pythonEnv = imageGenerationPythonEnv(repoRoot);
   await ensureImageGenerationCacheDirs(repoRoot);
   if (explicit)
@@ -250505,7 +250582,14 @@ async function ensurePythonFor(repoRoot, kind, explicit) {
   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 });
+    onProgress?.({ stage: "setup", message: `Creating image-generation Python environment at ${venvDir}` });
+    const created = await runProcess2("python3", ["-m", "venv", venvDir], {
+      cwd: repoRoot,
+      timeoutMs: 18e4,
+      env: pythonEnv,
+      progressLabel: "Creating image-generation Python environment",
+      onProgress
+    });
     if (created.code !== 0) {
       throw new Error(`Failed to create image-generation venv at ${venvDir}.
 ${trimProcessText(created.stderr || created.stdout)}`);
@@ -250516,10 +250600,13 @@ ${trimProcessText(created.stderr || created.stdout)}`);
     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], {
+  onProgress?.({ stage: "setup", message: `Installing ${kind} image-generation Python packages` });
+  const pip = await runProcess2(command, ["-m", "pip", "install", "--progress-bar", "on", "-U", "pip", ...packages], {
     cwd: repoRoot,
     timeoutMs: 18e5,
-    env: pythonEnv
+    env: pythonEnv,
+    progressLabel: `Installing ${kind} image-generation Python packages`,
+    onProgress
   });
   if (pip.code !== 0) {
     throw new Error(`Failed to install ${kind} image-generation packages into ${venvDir}.
@@ -250893,9 +250980,16 @@ var init_image_generate = __esm({
 import argparse
 import json
 import os
+import sys
 import time
 from pathlib import Path
 
+def _progress(stage, message, percent=None):
+    payload = {"omnius_progress": True, "stage": stage, "message": message}
+    if percent is not None:
+        payload["percent"] = percent
+    print(json.dumps(payload), file=sys.stderr, flush=True)
+
 def _device():
     import torch
     if torch.cuda.is_available():
@@ -250943,12 +251037,15 @@ def main():
         kwargs["variant"] = args.variant
 
     try:
+        _progress("load", f"loading model {args.model}")
         pipeline_cls = _pipeline_class(args.model)
         pipe = pipeline_cls.from_pretrained(args.model, **kwargs)
     except Exception:
+        _progress("load", f"retrying model load without variant for {args.model}")
         kwargs.pop("variant", None)
         pipeline_cls = _pipeline_class(args.model)
         pipe = pipeline_cls.from_pretrained(args.model, **kwargs)
+    _progress("load", f"model loaded on {device}")
 
     if hasattr(pipe, "enable_attention_slicing"):
         try:
@@ -250976,14 +251073,17 @@ def main():
         "height": args.height,
     }
     try:
+        _progress("generate", f"generating {args.width}x{args.height} image with {args.steps} steps")
         image = pipe(**call_kwargs).images[0]
     except TypeError:
         call_kwargs.pop("width", None)
         call_kwargs.pop("height", None)
+        _progress("generate", f"generating image with model-native dimensions and {args.steps} steps")
         image = pipe(**call_kwargs).images[0]
 
     out = Path(args.output)
     out.parent.mkdir(parents=True, exist_ok=True)
+    _progress("save", f"saving image to {out}")
     image.save(out)
     print(json.dumps({
         "ok": True,
@@ -251094,10 +251194,27 @@ if __name__ == "__main__":
       cwd;
       ollamaUrl;
       cachedImageModel = null;
+      progressHandler = null;
+      lastProgressMessage = "";
+      lastProgressAt = 0;
       constructor(cwd4, ollamaUrl = "http://localhost:11434") {
         this.cwd = cwd4;
         this.ollamaUrl = ollamaUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "");
       }
+      setProgressCallback(handler) {
+        this.progressHandler = handler;
+      }
+      emitProgress(event) {
+        if (!this.progressHandler)
+          return;
+        const now = Date.now();
+        const key = `${event.stage}:${event.percent ?? ""}:${event.message}`;
+        if (key === this.lastProgressMessage && now - this.lastProgressAt < 750)
+          return;
+        this.lastProgressMessage = key;
+        this.lastProgressAt = now;
+        this.progressHandler(event);
+      }
       async execute(args) {
         const start2 = performance.now();
         const action = String(args["action"] ?? "generate");
@@ -251239,7 +251356,7 @@ ${errText.slice(0, 800)}`,
         const filepath = outputPath(this.cwd);
         let python;
         try {
-          python = await ensurePythonFor(this.cwd, "diffusers", typeof args.python === "string" ? args.python : void 0);
+          python = await ensurePythonFor(this.cwd, "diffusers", typeof args.python === "string" ? args.python : void 0, (event) => this.emitProgress(event));
         } catch (err) {
           const plan = imageGenerationSetupPlan("diffusers", this.cwd, args.model);
           return {
@@ -251273,7 +251390,14 @@ ${errText.slice(0, 800)}`,
         ];
         if (args.seed !== void 0)
           argv.push("--seed", String(args.seed));
-        const result = await runProcess2(python.command, argv, { cwd: this.cwd, timeoutMs: 9e5, env: python.env });
+        this.emitProgress({ stage: "load", message: `Starting image generation with ${args.model}` });
+        const result = await runProcess2(python.command, argv, {
+          cwd: this.cwd,
+          timeoutMs: 9e5,
+          env: python.env,
+          progressLabel: `Downloading/loading ${args.model}`,
+          onProgress: (event) => this.emitProgress(event)
+        });
         if (result.code !== 0 || !existsSync23(filepath)) {
           const plan = imageGenerationSetupPlan("diffusers", this.cwd, args.model);
           return {
@@ -535558,7 +535682,7 @@ Respond with EXACTLY this structure before your next tool call:
               this.emit({
                 type: "tool_result",
                 toolName: tc.name,
-                content: output.slice(0, 200),
+                content: this.toolResultEventContent(tc.name, output),
                 success: result.success,
                 turn,
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -536667,7 +536791,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 this.emit({
                   type: "tool_result",
                   toolName: tc.name,
-                  content: output.slice(0, 200),
+                  content: this.toolResultEventContent(tc.name, output),
                   success: result.success,
                   turn,
                   timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -537511,6 +537635,12 @@ ${marker}` : marker);
        *
        * This replaces scattered post-hoc truncation with a single normalization point.
        */
+      toolResultEventContent(toolName, output) {
+        if (toolName === "generate_image" || toolName === "screenshot" || toolName === "camera_capture" || /(?:Image generated|Screenshot saved|Saved to|Output saved to):?\s+/i.test(output)) {
+          return output.slice(0, 2e3);
+        }
+        return output.slice(0, 200);
+      }
       normalizeToolOutput(result, toolName, args, turn) {
         const { toolOutputMaxChars: maxLen } = this.contextLimits();
         const modelContent = result.llmContent ?? result.output;
@@ -545376,7 +545506,7 @@ var init_spinner = __esm({
       info(message2) {
         this.stop();
         const msg = message2 ?? this._text;
-        process.stdout.write(`\x1B[36mℹ\x1B[0m ${msg}
+        process.stdout.write(`\x1B[36mi\x1B[0m ${msg}
 `);
         return this;
       }
@@ -550194,8 +550324,8 @@ var init_theme = __esm({
         // terminal default foreground
         textPrimary: -1,
         // terminal default foreground
-        textDim: 245,
-        // slightly dim
+        textDim: 250,
+        // readable dim text without ANSI faint
         boxColor: -1
         // terminal default foreground
       },
@@ -550207,8 +550337,8 @@ var init_theme = __esm({
         // teal
         textPrimary: 37,
         // teal
-        textDim: 240,
-        // grey
+        textDim: 250,
+        // readable grey
         boxColor: 37
         // teal
       },
@@ -550217,7 +550347,7 @@ var init_theme = __esm({
         bg: -1,
         accent: 37,
         textPrimary: 252,
-        textDim: 245,
+        textDim: 250,
         boxColor: 252
       }
     };
@@ -551457,7 +551587,7 @@ ${icon} \x1B[38;5;198m${message2}\x1B[0m
 function renderInfo(message2) {
   const redir = _contentWriteHook?.redirect?.();
   const dim = dimFg();
-  const icon = `${dim}🛈\x1B[0m`;
+  const icon = `${dim}i\x1B[0m`;
   const text = `${icon} ${dim}${message2}\x1B[0m
 `;
   if (redir) {
@@ -551746,7 +551876,7 @@ var init_render = __esm({
     isTTY2 = process.stdout.isTTY ?? false;
     c3 = {
       bold: (t2) => ansi2("1", t2),
-      dim: (t2) => ansi2("2", t2),
+      dim: (t2) => isTTY2 ? `${dimFg()}${t2}\x1B[0m` : t2,
       italic: (t2) => ansi2("3", t2),
       red: (t2) => ansi2("31", t2),
       green: (t2) => ansi2("32", t2),
@@ -551761,10 +551891,10 @@ var init_render = __esm({
     ui = {
       /** Primary text — lighter grey (252) for main content */
       primary: (t2) => fg256(252, t2),
-      /** Sub-text — darker grey (245) for secondary info */
-      sub: (t2) => fg256(245, t2),
-      /** Dim text — very dark grey (240) for hints/placeholders */
-      hint: (t2) => fg256(240, t2),
+      /** Sub-text — readable grey for secondary info */
+      sub: (t2) => fg256(tuiTextDim(), t2),
+      /** Dim text — readable grey for hints/placeholders */
+      hint: (t2) => fg256(tuiTextDim(), t2),
       /** Error text — magenta (bright) for errors */
       error: (t2) => fg256(198, t2),
       /** Warning text — warm orange for warnings */
@@ -551801,14 +551931,14 @@ var init_render = __esm({
       // light peach
       link: 111,
       // periwinkle
-      blockquote: 245,
-      // grey
-      hr: 240,
-      // dark grey
-      listBullet: 245,
-      // grey
-      tableBar: 245
-      // grey
+      blockquote: 250,
+      // readable grey
+      hr: 250,
+      // readable grey
+      listBullet: 250,
+      // readable grey
+      tableBar: 250
+      // readable grey
     };
     TOOL_ICONS = {
       file_read: "📄",
@@ -559067,7 +559197,7 @@ var init_daemon_registry = __esm({
           bar += `${PANEL_BG} ${BTN_BG}\x1B[${fgColor}m ${label} \x1B[${dotColor}m●\x1B[${fgColor}m `;
         }
         if (!bar) {
-          return `${PANEL_BG} \x1B[38;5;240m⠀ no active daemons`;
+          return `${PANEL_BG} \x1B[38;5;250m⠀ no active daemons`;
         }
         return bar + PANEL_BG;
       }
@@ -562478,7 +562608,7 @@ ${CONTENT_BG_SEQ}`);
         if (fullLine.length <= availWidth) {
           let displayLine;
           if (ghost) {
-            displayLine = fullLine + `\x1B[7m\x1B[38;5;${TEXT_DIM}m${ghost[0]}\x1B[0m${PANEL_BG_SEQ}\x1B[2m\x1B[38;5;${TEXT_DIM}m${ghost.slice(1)}\x1B[0m${PANEL_BG_SEQ}`;
+            displayLine = fullLine + `\x1B[7m\x1B[38;5;${TEXT_DIM}m${ghost[0]}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${TEXT_DIM}m${ghost.slice(1)}\x1B[0m${PANEL_BG_SEQ}`;
           } else {
             displayLine = _StatusBar.insertVisualCursor(fullLine, cursorPos);
           }
@@ -563677,13 +563807,13 @@ var init_tui_select = __esm({
     selectColors = {
       orange: (t2) => fg2563(208, t2),
       green: (t2) => ansi3("32", t2),
-      dim: (t2) => ansi3("2", t2),
+      dim: (t2) => fg2563(tuiTextDim(), t2),
       bold: (t2) => ansi3("1", t2),
       cyan: (t2) => ansi3("36", t2),
       /** Lighter grey for filter matches (252 = near-white) */
       matchLight: (t2) => fg2563(252, t2),
-      /** Dark grey for non-matching items (240 = dark grey) */
-      matchDark: (t2) => fg2563(240, t2)
+      /** Readable grey for non-matching items */
+      matchDark: (t2) => fg2563(tuiTextDim(), t2)
     };
   }
 });
@@ -568228,7 +568358,7 @@ var init_drop_panel = __esm({
     isTTY4 = process.stdout.isTTY ?? false;
     dc = {
       bold: (t2) => ansi4("1", t2),
-      dim: (t2) => ansi4("2", t2),
+      dim: (t2) => ansi4("38;5;250", t2),
       cyan: (t2) => ansi4("36", t2),
       green: (t2) => ansi4("32", t2),
       red: (t2) => ansi4("31", t2),
@@ -570727,7 +570857,7 @@ async function connectRPC(state, neovimPkg, cols) {
     state.outputChanId = chanId;
     await nvim.request("nvim_chan_send", [
       chanId,
-      "\x1B[36m── Agent Output ──\x1B[0m\r\n\r\n\x1B[2mAgent activity will appear here.\x1B[0m\r\n\x1B[2mCtrl+N toggles focus to input.\x1B[0m\r\n"
+      "\x1B[36m── Agent Output ──\x1B[0m\r\n\r\n\x1B[38;5;250mAgent activity will appear here.\x1B[0m\r\n\x1B[38;5;250mCtrl+N toggles focus to input.\x1B[0m\r\n"
     ]);
     await nvim.request("nvim_win_set_option", [win.id, "number", false]);
     await nvim.request("nvim_win_set_option", [win.id, "relativenumber", false]);
@@ -572498,22 +572628,29 @@ function normalizeAscii(ascii2, width, height) {
   const lines = ascii2.replace(ANSI_PATTERN, "").replace(/\r/g, "").split("\n").map((line) => line.replace(/\s+$/g, "")).filter((line, idx, all2) => line.length > 0 || idx > 0 && idx < all2.length - 1);
   return lines.slice(0, height).map((line) => line.length > width ? line.slice(0, width) : line).join("\n").trimEnd();
 }
+function previewFailure(message2, width) {
+  const clean3 = message2.replace(/\s+/g, " ").trim();
+  const text = `[image-to-ascii preview failed: ${clean3 || "unknown error"}]`;
+  return text.length > width ? `${text.slice(0, Math.max(0, width - 1))}]` : text;
+}
 async function convertWithImageToAscii(imagePath, width, height, timeoutMs) {
   let imageToAscii;
   try {
     const require4 = createRequire4(import.meta.url);
     const mod2 = require4("image-to-ascii");
     imageToAscii = typeof mod2 === "function" ? mod2 : mod2.default;
-    if (typeof imageToAscii !== "function") return null;
-  } catch {
-    return null;
+    if (typeof imageToAscii !== "function") {
+      return { ascii: null, error: "module did not export a function" };
+    }
+  } catch (err) {
+    return { ascii: null, error: err instanceof Error ? err.message : String(err) };
   }
   return new Promise((resolvePreview) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (!settled) {
         settled = true;
-        resolvePreview(null);
+        resolvePreview({ ascii: null, error: `timed out after ${timeoutMs}ms` });
       }
     }, timeoutMs).unref();
     try {
@@ -572532,18 +572669,20 @@ async function convertWithImageToAscii(imagePath, width, height, timeoutMs) {
           settled = true;
           clearTimeout(timer);
           if (err || !converted) {
-            resolvePreview(null);
+            resolvePreview({ ascii: null, error: err?.message || "empty renderer output" });
             return;
           }
           const normalized = normalizeAscii(converted, width, height);
-          resolvePreview(normalized || null);
+          resolvePreview(
+            normalized ? { ascii: normalized } : { ascii: null, error: "empty normalized renderer output" }
+          );
         }
       );
-    } catch {
+    } catch (err) {
       if (!settled) {
         settled = true;
         clearTimeout(timer);
-        resolvePreview(null);
+        resolvePreview({ ascii: null, error: err instanceof Error ? err.message : String(err) });
       }
     }
   });
@@ -572607,8 +572746,15 @@ async function buildImageAsciiPreview(inputPath, options2 = {}) {
   const height = clamp5(options2.height ?? defaults3.height, 8, 60);
   const timeoutMs = clamp5(options2.timeoutMs ?? 5e3, 500, 3e4);
   if (options2.preferPackage !== false) {
-    const ascii2 = await convertWithImageToAscii(imagePath, width, height, timeoutMs);
-    if (ascii2) return { path: imagePath, ascii: ascii2, renderer: "image-to-ascii", width, height };
+    const result = await convertWithImageToAscii(imagePath, width, height, timeoutMs);
+    if (result.ascii) return { path: imagePath, ascii: result.ascii, renderer: "image-to-ascii", width, height };
+    return {
+      path: imagePath,
+      ascii: previewFailure(result.error || "renderer unavailable", width),
+      renderer: "image-to-ascii",
+      width,
+      height
+    };
   }
   const fallback = convertWithFfmpeg(imagePath, width, height, timeoutMs);
   if (fallback) return { path: imagePath, ascii: fallback, renderer: "ffmpeg", width, height };
@@ -572621,6 +572767,8 @@ ${preview.ascii}`;
 function extractSavedImagePath(text, repoRoot) {
   const patterns = [
     /Image generated:\s*([^\n\r]+)/i,
+    /Image generated at\s+([^\s\n\r]+\.(?:png|jpg|jpeg|webp|gif))/i,
+    /Output saved to\s+([^\s\n\r]+\.(?:png|jpg|jpeg|webp|gif))/i,
     /Screenshot saved:\s*([^\n\r]+)/i,
     /Screenshot:\s*([^\n\r]+)/i,
     /Saved to:\s*([^\n\r]+)/i,
@@ -583137,6 +583285,9 @@ async function handleImageCommand(ctx3, arg, hasLocal) {
   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;
+  tool.setProgressCallback((event) => {
+    renderInfo(formatImageGenerationProgress(event));
+  });
   renderInfo(`Generating image with ${model} (${backend})...`);
   const result = await tool.execute({
     prompt,
@@ -583159,13 +583310,31 @@ async function handleImageCommand(ctx3, arg, hasLocal) {
     if (imagePath) {
       const preview = await buildImageAsciiPreview2(imagePath);
       const displayPath = relative11(ctx3.repoRoot, imagePath).startsWith("..") ? imagePath : relative11(ctx3.repoRoot, imagePath);
-      if (preview) renderImageAsciiPreview("Generated image", displayPath, preview.ascii, preview.renderer);
+      if (preview) {
+        renderImageAsciiPreview("Generated image", displayPath, preview.ascii, preview.renderer);
+      } else {
+        renderWarning(`Generated image preview unavailable for ${displayPath}.`);
+      }
       renderInfo(`File: ${imagePath}`);
+    } else {
+      renderWarning("Generated image preview skipped: no saved image path was found in the tool output.");
     }
-  } catch {
+  } catch (err) {
+    renderWarning(`Generated image preview failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   return "handled";
 }
+function formatImageGenerationProgress(event) {
+  const pct = event.percent;
+  const elapsed = event.elapsedMs && event.elapsedMs > 1500 ? ` ${Math.round(event.elapsedMs / 1e3)}s` : "";
+  if (typeof pct === "number") {
+    const width = 20;
+    const filled = Math.max(0, Math.min(width, Math.round(pct / 100 * width)));
+    const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
+    return `Image ${event.stage}: [${bar}] ${pct}% ${event.message}${elapsed}`;
+  }
+  return `Image ${event.stage}: ${event.message}${elapsed}`;
+}
 async function showHelpMenu(ctx3) {
   const slashCommands = getSlashHelpEntries();
   const groups = /* @__PURE__ */ new Map();
@@ -589035,13 +589204,13 @@ function fg2564(code8, text) {
   return isTTY8 ? `\x1B[38;5;${code8}m${text}\x1B[0m` : text;
 }
 function dimText(text) {
-  return isTTY8 ? `\x1B[2m${text}\x1B[0m` : text;
+  return isTTY8 ? `\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
 }
 function italicText(text) {
   return isTTY8 ? `\x1B[3m${text}\x1B[0m` : text;
 }
 function dimItalic(text) {
-  return isTTY8 ? `\x1B[2;3m${text}\x1B[0m` : text;
+  return isTTY8 ? `\x1B[3m\x1B[38;5;${tuiTextDim()}m${text}\x1B[0m` : text;
 }
 function boldText(text) {
   return isTTY8 ? `\x1B[1m${text}\x1B[0m` : text;
@@ -589052,6 +589221,7 @@ var init_stream_renderer = __esm({
     "use strict";
     init_layout2();
     init_text_selection();
+    init_theme();
     isTTY8 = process.stdout.isTTY ?? false;
     PASTEL = {
       key: 222,
@@ -589066,14 +589236,14 @@ var init_stream_renderer = __esm({
       // grey-blue — null
       bracket: 75,
       // soft blue — { } [ ]
-      colon: 245,
-      // neutral grey — : ,
+      colon: 250,
+      // readable grey — : ,
       keyword: 117,
       // sky blue — function, return, if, else
-      comment: 243,
-      // dim grey — // comments
-      thinking: 245,
-      // neutral grey for thinking tokens
+      comment: 250,
+      // readable grey — // comments
+      thinking: 250,
+      // readable grey for thinking tokens
       toolArg: 111,
       // dim periwinkle for tool arg tokens
       // Markdown
@@ -589087,10 +589257,10 @@ var init_stream_renderer = __esm({
       // light peach — `code`
       link: 111,
       // periwinkle — [link](url)
-      blockquote: 245,
-      // grey — > quote
-      hr: 240,
-      // dark grey — ---
+      blockquote: 250,
+      // readable grey — > quote
+      hr: 250,
+      // readable grey — ---
       // Diff / patch
       diffAdded: 114,
       // mint green — + lines
@@ -589100,8 +589270,8 @@ var init_stream_renderer = __esm({
       // blue — @@ headers
       diffMeta: 222,
       // gold — --- +++ file headers
-      diffContext: 245,
-      // grey — context lines
+      diffContext: 250,
+      // readable grey — context lines
       // Shell
       shellVar: 222,
       // gold — $VAR
@@ -593417,7 +593587,7 @@ function formatTelegramCreativeWorkspacePrompt(root) {
     "Creative file tools are scoped to that folder only.",
     "Allowed: create new files, read/list files in this workspace, and edit/patch files already created in this workspace.",
     "Forbidden: delete files, access paths outside this workspace, mutate the project tree, run shell commands, or touch system state.",
-    "When you create an artifact for Telegram, the bridge attaches files recorded by tool results. Refer to the attachment naturally; do not expose filesystem paths unless the admin explicitly asks."
+    "When a user asks for an artifact to be sent, create it here and then call telegram_send_file. The bridge also auto-attaches recorded artifacts as a fallback. Refer to the attachment naturally; do not expose filesystem paths unless the admin explicitly asks."
   ].join("\n");
 }
 function collectGeneratedArtifactPathsFromText(text, root) {
@@ -594514,6 +594684,14 @@ function mimeForPath(path11, fallbackKind) {
   if (fallbackKind === "video") return "video/mp4";
   return "application/octet-stream";
 }
+function normalizeTelegramSendKind(rawKind, path11) {
+  const requested = typeof rawKind === "string" ? rawKind.trim().toLowerCase() : "auto";
+  if (requested === "photo") return "image";
+  if (requested === "image" || requested === "animation" || requested === "audio" || requested === "voice" || requested === "video" || requested === "document") {
+    return requested;
+  }
+  return classifyMedia(path11) ?? "document";
+}
 function renderTelegramStart(botUsername, adminId, mode = "auto") {
   process.stdout.write(`
   ${c3.cyan("✈")} ${c3.bold("Telegram Bridge")} connected as @${botUsername}
@@ -596427,7 +596605,7 @@ ${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.",
+            "If the user asks you to create or send a file, image, or audio artifact, create it with the scoped creative tools and call telegram_send_file to upload it. The bridge still auto-attaches generated files as a fallback 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");
@@ -596573,7 +596751,8 @@ ${creativeWorkspace}` : ""}`;
           new ImpactAnalysisTool(repoRoot),
           new CodeNeighborsTool(repoRoot),
           new ProcessHealthTool(),
-          fullSubAgentTool
+          fullSubAgentTool,
+          this.buildTelegramSendFileTool(context2, repoRoot, chatId)
         ];
         const allTools = context2 === "telegram-admin-dm" ? adminTools : sharedReadMemoryWebTools;
         if (this.contextWindowSize > 0) {
@@ -596606,9 +596785,122 @@ ${creativeWorkspace}` : ""}`;
             this.agentConfig?.backendUrl
           ).map((tool) => adaptTool5(tool, todoSessionId));
           adaptedTools.push(...creativeTools);
+          adaptedTools.push(adaptTool5(this.buildTelegramSendFileTool(context2, repoRoot, chatId), todoSessionId));
         }
         return [...adaptedTools, taskComplete];
       }
+      buildTelegramSendFileTool(context2, repoRoot, currentChatId) {
+        const bridge = this;
+        const adminDm = context2 === "telegram-admin-dm";
+        const scopedRoot = adminDm ? void 0 : telegramCreativeWorkspaceRoot(repoRoot, currentChatId);
+        return {
+          name: "telegram_send_file",
+          description: adminDm ? "Upload an existing local file to a Telegram chat. Admin DM scope may target the current chat, a numeric chat/user id, or a @username if the bot is allowed to message it. This only sends the file; it does not create, edit, or delete files." : `Upload an existing file from this chat's scoped creative workspace to the current Telegram chat. Public/group scope cannot target other chats and cannot send files outside ${scopedRoot}.`,
+          parameters: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: adminDm ? "Local file path to send. Relative paths resolve from the repo root; absolute paths are allowed for admin DM." : "File path inside the scoped creative workspace."
+              },
+              chat_id: {
+                type: "string",
+                description: "Admin DM only. Optional target chat/user id or @username. Defaults to the current Telegram chat."
+              },
+              user_id: {
+                type: "string",
+                description: "Admin DM only. Optional numeric Telegram user id to send to, if the bot can message that user."
+              },
+              kind: {
+                type: "string",
+                enum: ["auto", "image", "photo", "document", "audio", "voice", "video", "animation"],
+                description: "How Telegram should send the file. Defaults to auto based on extension."
+              },
+              caption: {
+                type: "string",
+                description: "Optional Telegram caption."
+              },
+              reply_to_message_id: {
+                type: "number",
+                description: "Optional Telegram message id to reply to."
+              }
+            },
+            required: ["path"]
+          },
+          async execute(args) {
+            const start2 = performance.now();
+            const rawPath = typeof args["path"] === "string" ? args["path"].trim() : "";
+            if (!rawPath) {
+              return { success: false, output: "", error: "path is required", durationMs: performance.now() - start2 };
+            }
+            const target = bridge.resolveTelegramFileTarget(args, currentChatId, adminDm);
+            if (!target.ok) {
+              return { success: false, output: "", error: target.error, durationMs: performance.now() - start2 };
+            }
+            const file = bridge.resolveTelegramFilePath(rawPath, repoRoot, scopedRoot);
+            if (!file.ok) {
+              return { success: false, output: "", error: file.error, durationMs: performance.now() - start2 };
+            }
+            const kind = normalizeTelegramSendKind(args["kind"], file.path);
+            const caption = typeof args["caption"] === "string" ? args["caption"].trim().slice(0, 1024) : void 0;
+            const replyTo = Number(args["reply_to_message_id"]);
+            try {
+              const messageId = await bridge.sendTelegramFileToChat(target.chatId, file.path, {
+                kind,
+                caption: caption || void 0,
+                replyToMessageId: Number.isFinite(replyTo) && replyTo > 0 ? Math.floor(replyTo) : void 0
+              });
+              return {
+                success: true,
+                output: `Sent Telegram file: ${basename22(file.path)} as ${kind} to ${String(target.chatId)}${messageId ? ` (message_id ${messageId})` : ""}`,
+                llmContent: `Sent ${basename22(file.path)} to Telegram as ${kind}.`,
+                durationMs: performance.now() - start2,
+                mutated: false,
+                mutatedFiles: []
+              };
+            } catch (err) {
+              return {
+                success: false,
+                output: "",
+                error: `Telegram file upload failed: ${err instanceof Error ? err.message : String(err)}`,
+                durationMs: performance.now() - start2
+              };
+            }
+          }
+        };
+      }
+      resolveTelegramFileTarget(args, currentChatId, adminDm) {
+        const rawTarget = args["chat_id"] ?? args["target_chat_id"] ?? args["user_id"] ?? args["username"];
+        if (!adminDm) {
+          if (rawTarget !== void 0 && String(rawTarget).trim() && String(rawTarget).trim() !== String(currentChatId)) {
+            return { ok: false, error: "Public/group telegram_send_file cannot target another chat. It may only send to the current chat." };
+          }
+          if (currentChatId === void 0) return { ok: false, error: "Current Telegram chat id is unavailable." };
+          return { ok: true, chatId: currentChatId };
+        }
+        if (rawTarget === void 0 || !String(rawTarget).trim()) {
+          if (currentChatId === void 0) return { ok: false, error: "No target chat_id/user_id provided and current chat id is unavailable." };
+          return { ok: true, chatId: currentChatId };
+        }
+        const target = String(rawTarget).trim();
+        if (/^-?\d+$/.test(target)) return { ok: true, chatId: target };
+        const cleanUsername = target.replace(/^@/, "");
+        if (/^[A-Za-z0-9_]{5,32}$/.test(cleanUsername)) {
+          return { ok: true, chatId: `@${cleanUsername}` };
+        }
+        return { ok: false, error: "Expected chat_id/user_id as digits, or a valid @username." };
+      }
+      resolveTelegramFilePath(rawPath, repoRoot, scopedRoot) {
+        const base3 = scopedRoot ? resolve39(scopedRoot) : resolve39(repoRoot);
+        const trimmed = rawPath.trim().replace(/^["']|["']$/g, "");
+        const abs = isAbsolute6(trimmed) ? resolve39(trimmed) : resolve39(base3, trimmed);
+        if (scopedRoot && !isPathInside(base3, abs)) {
+          return { ok: false, error: `Public/group telegram_send_file can only send files inside ${base3}.` };
+        }
+        if (!existsSync105(abs)) return { ok: false, error: `File does not exist: ${trimmed}` };
+        if (!statSync35(abs).isFile()) return { ok: false, error: `Path is not a file: ${trimmed}` };
+        return { ok: true, path: abs };
+      }
       /** Check if a message is from the admin user (uses fromUserId, NOT chatId) */
       isAdminUser(msg) {
         if (!this.adminUserId) return false;
@@ -596836,17 +597128,41 @@ ${visionContext}]`;
         }
         return options2.html ? this.sendMessageHTML(msg.chatId, text, options2.replyToMessageId) : this.sendMessage(msg.chatId, text);
       }
-      async sendMediaReference(chatId, media) {
+      async sendTelegramFileToChat(chatId, path11, options2) {
+        const abs = resolve39(path11);
+        if (!existsSync105(abs) || !statSync35(abs).isFile()) {
+          throw new Error(`File does not exist or is not a regular file: ${path11}`);
+        }
+        return this.sendMediaReferenceStrict(chatId, {
+          original: abs,
+          value: abs,
+          kind: options2.kind,
+          source: "file",
+          audioAsVoice: options2.kind === "voice"
+        }, options2);
+      }
+      async sendMediaReference(chatId, media, options2 = {}) {
+        try {
+          return await this.sendMediaReferenceStrict(chatId, media, options2);
+        } catch {
+          return null;
+        }
+      }
+      async sendMediaReferenceStrict(chatId, media, options2 = {}) {
         const { method, field } = mediaTelegramMethod(media.kind);
+        const caption = options2.caption?.trim();
         if (media.source === "url") {
           const result2 = await this.apiCall(method, {
             chat_id: chatId,
-            [field]: media.value
+            [field]: media.value,
+            ...caption ? { caption } : {},
+            ...options2.replyToMessageId ? { reply_to_message_id: options2.replyToMessageId } : {}
           });
+          if (result2.ok === false) throw new Error(String(result2.description || `Telegram ${method} failed`));
           this.state.messagesSent++;
           return result2.result?.message_id ?? null;
         }
-        if (!existsSync105(media.value)) return null;
+        if (!existsSync105(media.value)) throw new Error(`File does not exist: ${media.value}`);
         const buffer2 = readFileSync86(media.value);
         const boundary = `----omnius-media-${Date.now()}-${Math.random().toString(36).slice(2)}`;
         const filename = basename22(media.value);
@@ -596862,6 +597178,8 @@ ${visionContext}]`;
 `));
         };
         addField("chat_id", String(chatId));
+        if (caption) addField("caption", caption);
+        if (options2.replyToMessageId) addField("reply_to_message_id", String(options2.replyToMessageId));
         parts.push(Buffer.from(`--${boundary}\r
 `));
         parts.push(Buffer.from(
@@ -596888,7 +597206,7 @@ Content-Type: ${contentType}\r
           this.state.messagesSent++;
           return result.result?.message_id ?? null;
         }
-        return null;
+        throw new Error(String(result.description || `Telegram ${method} failed`));
       }
       async sendGeneratedArtifactsFromSubAgent(msg, subAgent, finalText, includeMentioned) {
         const root = subAgent.creativeWorkspaceRoot;
@@ -622407,23 +622725,44 @@ async function renderAsciiPreviewForImage(imagePath, displayPath, title, writer)
       formatImageAsciiContext: formatImageAsciiContext2
     } = await Promise.resolve().then(() => (init_image_ascii_preview(), image_ascii_preview_exports));
     const preview = await buildImageAsciiPreview2(imagePath);
-    if (!preview) return "";
+    if (!preview) {
+      writer(() => renderWarning(`Image ASCII preview unavailable for ${displayPath}.`));
+      return "";
+    }
     writer(() => renderImageAsciiPreview(title, displayPath, preview.ascii, preview.renderer));
     return formatImageAsciiContext2(preview, displayPath);
   } catch {
     return "";
   }
 }
+function formatImageGenerationProgress2(event) {
+  const elapsed = event.elapsedMs && event.elapsedMs > 1500 ? ` ${Math.round(event.elapsedMs / 1e3)}s` : "";
+  if (typeof event.percent === "number") {
+    const width = 20;
+    const filled = Math.max(0, Math.min(width, Math.round(event.percent / 100 * width)));
+    const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
+    return `Image ${event.stage}: [${bar}] ${event.percent}% ${event.message}${elapsed}`;
+  }
+  return `Image ${event.stage}: ${event.message}${elapsed}`;
+}
 async function renderAsciiPreviewForToolResult(toolName, output, repoRoot, writer) {
   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;
+    if (!imagePath) {
+      if (toolName === "generate_image") {
+        writer(() => renderWarning("Generated image preview skipped: no saved image path was found in the tool output."));
+      }
+      return;
+    }
     const displayPath = relative14(repoRoot, imagePath).startsWith("..") ? imagePath : relative14(repoRoot, imagePath);
     const title = toolName === "generate_image" ? "Generated image" : toolName === "screenshot" ? "Screenshot" : toolName === "camera_capture" ? "Camera frame" : "Image";
     await renderAsciiPreviewForImage(imagePath, displayPath, title, writer);
-  } catch {
+  } catch (err) {
+    if (toolName === "generate_image") {
+      writer(() => renderWarning(`Generated image preview failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
   }
 }
 async function runSelfImprovementCycle(repoRoot) {
@@ -623397,6 +623736,14 @@ ${entry.fullContent}`
       fn();
     }
   };
+  for (const tool of tools) {
+    const maybeProgressTool = tool;
+    if (typeof maybeProgressTool.setProgressCallback === "function") {
+      maybeProgressTool.setProgressCallback((event) => {
+        contentWrite(() => renderInfo(formatImageGenerationProgress2(event)));
+      });
+    }
+  }
   runner.onEvent((event) => {
     emotionEngine?.appraise(event);
     switch (event.type) {
@@ -623573,7 +623920,7 @@ ${entry.fullContent}`
             }
           });
         }
-        if (event.success) {
+        if (event.success || event.toolName === "generate_image") {
           void renderAsciiPreviewForToolResult(event.toolName, event.content ?? "", repoRoot, contentWrite);
         }
         if (voice?.enabled && voice.voiceMode === "voicechat" && _voiceChatSession2?.isActive && event.toolName === "task_complete") {
@@ -623702,7 +624049,7 @@ ${entry.fullContent}`
         if (_apiCallbacks?.onStatus)
           _apiCallbacks.onStatus(event.content ?? "");
         if (isNeovimActive()) {
-          writeToNeovimOutput(`\x1B[2m${event.content ?? ""}\x1B[0m\r
+          writeToNeovimOutput(`\x1B[38;5;250m${event.content ?? ""}\x1B[0m\r
 `);
         } else {
           contentWrite(() => renderInfo(event.content ?? ""));