omnius 1.0.357 → 1.0.358

package/dist/index.js

@@ -567542,6 +567542,27 @@ var init_completion_resolution_verifier = __esm({
 });
 
 // packages/orchestrator/dist/evidenceBranch.js
+function buildStructuralPreview2(lines, path12, query) {
+  const n2 = lines.length;
+  const clip3 = (l2) => l2.length > 180 ? l2.slice(0, 180) + "…" : l2;
+  const head = lines.slice(0, HEAD_LINES2).map((l2, i2) => `${i2 + 1}: ${clip3(l2)}`);
+  const isStructural = (l2) => /^\s*(<[A-Za-z!]|#{1,6}\s|def |class |function |export |interface |type |async |public |private |\[[^\]]+\]|[A-Za-z_][\w.]*\s*=)/.test(l2) && l2.trim().length > 0 && l2.trim().length <= 180;
+  const markers = [];
+  for (let i2 = HEAD_LINES2; i2 < n2; i2++) {
+    const l2 = lines[i2];
+    if (isStructural(l2))
+      markers.push(`${i2 + 1}: ${clip3(l2.trim())}`);
+  }
+  const MAX_MARKERS = 30;
+  const sampled = markers.length > MAX_MARKERS ? Array.from({ length: MAX_MARKERS }, (_, k) => markers[Math.floor(k * markers.length / MAX_MARKERS)]) : markers;
+  return [
+    `[STRUCTURAL PREVIEW] "${query}" was not directly located in ${path12} (${n2} lines). Navigate by the structure below and re-read a SPECIFIC region with offset/limit — do NOT re-read the whole file:`,
+    "Head:",
+    ...head,
+    sampled.length ? "Section markers (line: content):" : "(no clear section markers)",
+    ...sampled
+  ].filter(Boolean).join("\n").slice(0, 1600);
+}
 function queryTerms(query) {
   return [
     ...new Set(query.toLowerCase().replace(/[^a-z0-9_<>./-]+/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOPWORDS2.has(w)))
@@ -567692,17 +567713,20 @@ async function extractEvidence(opts) {
       const ends = kept.map((s2) => s2.end);
       const snippetLower = claim2.toLowerCase();
       const covered = terms2.filter((t2) => snippetLower.includes(t2)).length;
-      return {
-        path: path12,
-        query,
-        claim: claim2,
-        sourceStart: starts.length ? Math.min(...starts) : null,
-        sourceEnd: ends.length ? Math.max(...ends) : null,
-        fileVersion,
-        confidence: Math.min(1, covered / Math.max(1, terms2.length)),
-        exploredLines: lines.length,
-        injectedChars: claim2.length
-      };
+      const grepConfidence = Math.min(1, covered / Math.max(1, terms2.length));
+      if (grepConfidence >= EXTRACT_CONFIDENCE_FLOOR) {
+        return {
+          path: path12,
+          query,
+          claim: claim2,
+          sourceStart: starts.length ? Math.min(...starts) : null,
+          sourceEnd: ends.length ? Math.max(...ends) : null,
+          fileVersion,
+          confidence: grepConfidence,
+          exploredLines: lines.length,
+          injectedChars: claim2.length
+        };
+      }
     }
   }
   const windows = lines.length <= WINDOW_LINES * 2 ? [{ start: 1, end: lines.length, text: content, score: 1 }] : selectWindows(lines, terms2);
@@ -567725,7 +567749,7 @@ async function extractEvidence(opts) {
       parsed = null;
     }
   }
-  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : `No evidence for "${query}" found in the explored windows of ${path12}.`;
+  const claim = parsed && parsed.found && parsed.claim ? parsed.claim : buildStructuralPreview2(lines, path12, query);
   return {
     path: path12,
     query,
@@ -567743,7 +567767,7 @@ function shouldBranchRead(contentLength, lineCount, hasExplicitSmallRange, thres
     return false;
   return contentLength > thresholdChars || lineCount > 200;
 }
-var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, STOPWORDS2;
+var WINDOW_LINES, SNIPPET_CONTEXT, HEAD_LINES2, MAX_SNIPPET_LINES, EXTRACT_CONFIDENCE_FLOOR, STOPWORDS2;
 var init_evidenceBranch = __esm({
   "packages/orchestrator/dist/evidenceBranch.js"() {
     "use strict";
@@ -567751,6 +567775,7 @@ var init_evidenceBranch = __esm({
     SNIPPET_CONTEXT = 4;
     HEAD_LINES2 = 10;
     MAX_SNIPPET_LINES = 220;
+    EXTRACT_CONFIDENCE_FLOOR = 0.3;
     STOPWORDS2 = /* @__PURE__ */ new Set([
       "the",
       "and",
@@ -615029,35 +615054,105 @@ ${CONTENT_BG_SEQ}`);
           (seq) => seq.endsWith("m") ? seq : ""
         );
       }
-      reflowContentLines(livePartialLine, width) {
+      /** Resolve a dynamic-block sentinel line to its registered renderer's lines
+       *  at the given width, or null if it is not a (live) sentinel. */
+      dynamicBlockLines(line, maxWidth) {
+        if (!line.startsWith(this.DYNAMIC_BLOCK_MARK_PREFIX) || !line.endsWith(this.DYNAMIC_BLOCK_MARK_SUFFIX)) {
+          return null;
+        }
+        const id = line.slice(
+          this.DYNAMIC_BLOCK_MARK_PREFIX.length,
+          line.length - this.DYNAMIC_BLOCK_MARK_SUFFIX.length
+        );
+        const renderer = this._dynamicBlocks.get(id);
+        if (!renderer) return [];
+        try {
+          return renderer(maxWidth);
+        } catch {
+          return [];
+        }
+      }
+      /** Reflowed-row COUNT for one buffer line at width — dynamic-block aware.
+       *  Static lines are a cache-hit `.length` (no allocation), so the count pass
+       *  over the whole backlog is cheap. */
+      rowCountForSourceLine(line, maxWidth) {
+        const block = this.dynamicBlockLines(line, maxWidth);
+        if (block !== null) {
+          let n2 = 0;
+          for (const seg of block) n2 += this.reflowContentLine(seg, maxWidth).length;
+          return n2;
+        }
+        return this.reflowContentLine(line, maxWidth).length;
+      }
+      /** Reflowed rows (with bufferIdx) for one buffer line — built ONLY for the
+       *  lines actually inside the viewport window. */
+      rowsForSourceLine(line, idx, maxWidth) {
+        const block = this.dynamicBlockLines(line, maxWidth);
+        if (block !== null) {
+          return block.flatMap(
+            (seg) => this.reflowContentLine(seg, maxWidth).map((s2) => ({
+              line: s2,
+              bufferIdx: idx
+            }))
+          );
+        }
+        return this.reflowContentLine(line, maxWidth).map((segment) => ({
+          line: segment,
+          bufferIdx: idx
+        }));
+      }
+      /** Total reflowed row count at width (cheap — cache-hit counts, no big array
+       *  allocation). Used for scroll bounds. */
+      reflowedRowCount(livePartialLine, width) {
         const maxWidth = Math.max(16, width);
         const source = livePartialLine ? [...this._contentLines, livePartialLine] : this._contentLines;
-        return source.flatMap((line, idx) => {
-          if (line.startsWith(this.DYNAMIC_BLOCK_MARK_PREFIX) && line.endsWith(this.DYNAMIC_BLOCK_MARK_SUFFIX)) {
-            const id = line.slice(
-              this.DYNAMIC_BLOCK_MARK_PREFIX.length,
-              line.length - this.DYNAMIC_BLOCK_MARK_SUFFIX.length
-            );
-            const renderer = this._dynamicBlocks.get(id);
-            if (!renderer) return [];
-            let blockLines;
-            try {
-              blockLines = renderer(maxWidth);
-            } catch {
-              return [];
-            }
-            return blockLines.flatMap(
-              (segment) => this.reflowContentLine(segment, maxWidth).map((s2) => ({
-                line: s2,
-                bufferIdx: idx
-              }))
-            );
-          }
-          return this.reflowContentLine(line, maxWidth).map((segment) => ({
-            line: segment,
-            bufferIdx: idx
-          }));
-        });
+        let total = 0;
+        for (let i2 = 0; i2 < source.length; i2++) {
+          total += this.rowCountForSourceLine(source[i2], maxWidth);
+        }
+        return total;
+      }
+      /**
+       * VIRTUALIZED reflow — produce ONLY the viewport window's rows (the visible
+       * `viewportRows` reflowed rows at the given scroll offset). Repaint cost is
+       * O(viewport + dynamic blocks) instead of O(scrollback), so a long session
+       * never re-wraps the whole 10k-line backlog on every paint (the lag-after-
+       * thousands-of-lines stall). Returns the window rows IN ORDER (index 0 = top
+       * visible row), the total row count (for the scrollbar/bounds), and the
+       * clamped scroll offset.
+       */
+      reflowContentWindow(livePartialLine, width, viewportRows, scrollOffset) {
+        const maxWidth = Math.max(16, width);
+        const source = livePartialLine ? [...this._contentLines, livePartialLine] : this._contentLines;
+        const h = Math.max(0, viewportRows);
+        let totalRows = 0;
+        const counts = new Array(source.length);
+        for (let i2 = 0; i2 < source.length; i2++) {
+          const c8 = this.rowCountForSourceLine(source[i2], maxWidth);
+          counts[i2] = c8;
+          totalRows += c8;
+        }
+        const maxOffset = Math.max(0, totalRows - h);
+        const off = scrollOffset < 0 ? 0 : scrollOffset > maxOffset ? maxOffset : scrollOffset;
+        const startIdx = Math.max(0, totalRows - h - off);
+        const endIdx = startIdx + h;
+        const rows = [];
+        let cursor = 0;
+        for (let i2 = 0; i2 < source.length && cursor < endIdx; i2++) {
+          const c8 = counts[i2];
+          const lineStart = cursor;
+          cursor += c8;
+          if (cursor <= startIdx) continue;
+          if (lineStart >= endIdx) break;
+          const lr = this.rowsForSourceLine(source[i2], i2, maxWidth);
+          const from3 = Math.max(0, startIdx - lineStart);
+          const to = Math.min(c8, endIdx - lineStart);
+          for (let k = from3; k < to; k++) {
+            const r2 = lr[k];
+            if (r2) rows.push(r2);
+          }
+        }
+        return { rows, totalRows, startIdx, scrollOffset: off };
       }
       // Memoize per-line reflow: it is a PURE function of (line, width), and
       // reflowContentLines re-wraps the entire scrollback every repaint. Caching
@@ -615201,7 +615296,7 @@ ${CONTENT_BG_SEQ}`);
       maxContentScrollOffset(width = termCols(), livePartialLine = this.getLiveBufferedLine()) {
         return Math.max(
           0,
-          this.reflowContentLines(livePartialLine, width).length - this.contentHeight
+          this.reflowedRowCount(livePartialLine, width) - this.contentHeight
         );
       }
       clampContentScrollOffset(width = termCols()) {
@@ -615330,26 +615425,30 @@ ${CONTENT_BG_SEQ}`);
         const w = termCols();
         const _perfOn = process.env["OMNIUS_TUI_PERF"] === "1";
         const _t0 = _perfOn ? performance.now() : 0;
-        const reflowedLines = this.reflowContentLines(livePartialLine, w);
+        const win = this.reflowContentWindow(
+          livePartialLine,
+          w,
+          h,
+          this._contentScrollOffset
+        );
+        const reflowedLines = win.rows;
         if (_perfOn) {
           const _ms = performance.now() - _t0;
           if (_ms > 8) {
             try {
               process.stderr.write(
-                `[TUI-PERF] reflow ${_ms.toFixed(1)}ms (lines=${reflowedLines.length}, w=${w})
+                `[TUI-PERF] reflow ${_ms.toFixed(1)}ms (window=${win.rows.length}/${win.totalRows} rows, w=${w})
 `
               );
             } catch {
             }
           }
         }
-        const totalLines = reflowedLines.length;
-        const maxOffset = Math.max(0, totalLines - h);
-        if (this._contentScrollOffset > maxOffset) {
-          this._contentScrollOffset = maxOffset;
+        if (win.scrollOffset !== this._contentScrollOffset) {
+          this._contentScrollOffset = win.scrollOffset;
           if (this._contentScrollOffset === 0) this._autoScroll = true;
         }
-        const startIdx = Math.max(0, totalLines - h - this._contentScrollOffset);
+        const startIdx = 0;
         this._lastPaintReflow = reflowedLines;
         this._lastPaintStartIdx = startIdx;
         const headerSafeFloor = layout().headerBottom + 1;
@@ -615402,8 +615501,8 @@ ${CONTENT_BG_SEQ}`);
           }
         }
         if (this._contentScrollOffset > 0) {
-          const linesAbove = startIdx;
-          const pct = totalLines > 0 ? Math.round((startIdx + h) / totalLines * 100) : 100;
+          const linesAbove = win.startIdx;
+          const pct = win.totalRows > 0 ? Math.round((win.startIdx + h) / win.totalRows * 100) : 100;
           const indicator = ` ↑ ${linesAbove} lines above · ${pct}% · PgDn/End to return `;
           const pad = Math.max(0, w - indicator.length);
           buf += `\x1B[${this.scrollRegionTop};1H\x1B[7m${indicator}${" ".repeat(pad)}\x1B[0m`;
@@ -662307,18 +662406,27 @@ function deriveVisualEvidencePlan(request) {
   const needsText = /\b(text|read|ocr|extract|label|word|number|what does it say|transcript|character|letter|digit|spell|transcribe|copy|quote|type|what is written)\b/i.test(prompt);
   const needsScene = /\b(what|who|where|describe|scene|object|person|identify|tell me about|explain|see|show|happening|look like|recogniz)\b/i.test(prompt) && !needsText;
   const needsUI = /\b(ui|button|menu|dialog|window|interface|screen|dashboard|form|field|input|select|option|dropdown)\b/i.test(prompt);
+  const comprehensive = (reason) => ({
+    stages: [
+      { kind: "low_fidelity_observation", required: false },
+      { kind: "ocr", required: true },
+      { kind: "auxiliary_vision", required: true }
+    ],
+    reason
+  });
   switch (detail) {
     case "low":
-      return { stages: [{ kind: "low_fidelity_observation", required: true }], reason: "low detail requested" };
+      return { stages: [{ kind: "low_fidelity_observation", required: true }], reason: "low detail explicitly requested" };
     case "text":
-      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: true }, { kind: "auxiliary_vision", required: false }], reason: "text extraction requested" };
+      return comprehensive("text extraction requested — full vision still runs for classification");
+    case "visual":
+      return comprehensive("visual analysis requested");
     case "full":
-      return { stages: [{ kind: "low_fidelity_observation", required: false }, { kind: "ocr", required: needsText || needsUI }, { kind: "auxiliary_vision", required: true }], reason: "full detail requested" };
+      return comprehensive("full detail requested");
     default:
-      const stages = [{ kind: "low_fidelity_observation", required: false }];
-      if (needsText || needsUI) stages.push({ kind: "ocr", required: true });
-      if (needsScene || needsUI) stages.push({ kind: "auxiliary_vision", required: !needsText && !needsUI });
-      return { stages, reason: needsText ? "text evidence needed" : needsScene ? "scene analysis needed" : needsUI ? "UI/document analysis needed" : "auto" };
+      return comprehensive(
+        needsText ? "comprehensive (text emphasis)" : needsScene ? "comprehensive (scene emphasis)" : needsUI ? "comprehensive (UI/document emphasis)" : "comprehensive (full vision + OCR on all media)"
+      );
   }
 }
 async function executeVisualEvidencePlan(resolution, plan, executor) {
@@ -662362,6 +662470,7 @@ __export(vision_ingress_exports, {
   isTesseractAvailable: () => isTesseractAvailable,
   isVisionModel: () => isVisionModel,
   queryVisionModel: () => queryVisionModel,
+  resolveVisionModel: () => resolveVisionModel,
   runVisionIngress: () => runVisionIngress
 });
 import { execFileSync as execFileSync10 } from "node:child_process";
@@ -662490,25 +662599,32 @@ async function queryVisionModel(modelName, imagePath, prompt = "Describe what yo
     return "";
   }
 }
+function resolveVisionModel(currentModel) {
+  if (currentModel && isVisionModel(currentModel)) return currentModel;
+  const env2 = (process.env["OMNIUS_VISION_MODEL"] || "").trim();
+  if (env2) return env2;
+  return "moondream";
+}
 async function runVisionIngress(image, currentModel) {
   const ocrText = advancedOcr(image.path);
   let visionDescription = "";
   let visionUsed = false;
-  if (currentModel && isVisionModel(currentModel)) {
-    visionDescription = await queryVisionModel(currentModel, image.path);
+  const visionModel = resolveVisionModel(currentModel);
+  if (visionModel) {
+    visionDescription = await queryVisionModel(visionModel, image.path);
     visionUsed = visionDescription.length > 0;
   }
   const parts = [];
   if (ocrText.length > 0) {
-    parts.push(`[OCR Text from pasted image]
+    parts.push(`[OCR Text from image]
 ${ocrText}`);
   }
   if (visionDescription.length > 0) {
-    parts.push(`[Vision analysis of pasted image (model: ${currentModel})]
+    parts.push(`[Vision analysis of image (model: ${visionModel})]
 ${visionDescription}`);
   }
   if (parts.length === 0) {
-    parts.push(`[Image pasted at ${image.path} — no text detected by OCR, no vision model available for analysis]`);
+    parts.push(`[Image at ${image.path} — OCR found no text and the vision model (${visionModel}) returned no description; treat as UNCOMPREHENDED and re-run telegram_image_analyze with detail='full' before answering.]`);
   }
   const contextBlock = parts.join("\n\n");
   return {
@@ -665197,7 +665313,7 @@ Public Telegram vision and media stack
 
 Public Telegram runs have the full scoped media-analysis stack for media posted in this chat:
 - Use telegram_media_recent to find recent scoped media, then use path/media aliases 'reply' and 'latest' instead of exposing local paths to users.
-- For image questions, prefer telegram_image_analyze first. It resolves omitted/reply/latest media, starts with low-fidelity image intake, uses basic OCR as the text extraction probe, escalates to advanced OCR when text is dense or under-extracted, and escalates to Moondream vision when visual QA/captioning is needed.
+- MANDATORY: whenever one or more images are present (posted, replied-to, or recent), run a FULL comprehension pass on EVERY image BEFORE responding — telegram_image_analyze with detail='full' (advanced OCR + Moondream vision) on each; if a burst of images was posted, enumerate them with telegram_media_recent and analyze ALL of them. Base the answer ONLY on the extracted content (objects, scene, any text). NEVER answer from metadata alone (count, size, timestamp, caption), never claim you can't say what's pictured without running vision, and never offer to analyze only "the ones you care about" — full vision on all of them IS the job. Do not stop until every image is fully comprehended.
 - Use ocr for quick image text extraction, ocr_image_advanced when basic OCR shows dense or degraded text, image_read for image metadata + multimodal image payload, and vision for direct Moondream captioning, visual QA, object detection, or pointing.
 - Use pdf_to_text for embedded-text PDFs and ocr_pdf for scanned PDFs.
 - Use video_understand and transcribe_file for video/audio media posted in this chat.
@@ -675910,7 +676026,7 @@ ${currentTelegramPrompt}`;
             TELEGRAM_LINK_INTEGRITY_CONTRACT,
             "If a user explicitly states a durable preference for reply cadence/order, call telegram_preference_set. Do not infer or classify reply-mode preferences from keywords, style, tone, or task type.",
             TELEGRAM_EVIDENCE_SUFFICIENCY_CONTRACT,
-            "You have the full scoped Telegram media-analysis stack by default: telegram_image_analyze, telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. For image questions, prefer telegram_image_analyze first; it resolves omitted/reply/latest media, starts with low-fidelity image intake, uses basic OCR as the text extraction probe, escalates to advanced OCR when text is dense or under-extracted, and escalates to Moondream vision when visual QA/captioning is needed.",
+            "You have the full scoped Telegram media-analysis stack by default: telegram_image_analyze, telegram_media_recent, image_read, ocr, ocr_image_advanced, vision, pdf_to_text, ocr_pdf, transcribe_file, video_understand, audio_analyze, and identity_memory. MANDATORY image handling: whenever one or more images are present in the message (or a referenced/recent message), you MUST run a FULL comprehension pass on EVERY image before you respond — call telegram_image_analyze with detail='full' (advanced OCR + Moondream vision) on each, and if multiple images were sent in a burst, analyze ALL of them (use telegram_media_recent to enumerate them). Base your answer ONLY on the actual extracted content (objects, scene, and any text). NEVER answer from metadata alone (count, file size, timestamp, caption) and NEVER say you 'can't say what's pictured without running vision' or offer to analyze 'the ones you care about' — running full vision on all of them IS your job. Do not stop until every image is fully comprehended; if a pass returns nothing, retry with detail='full' or image_read+ocr_image_advanced+vision before concluding.",
             formatIdentityMemoryContext(chatLabel || "Telegram private chat"),
             reminderToolContract,
             "If the user asks you to create an image, audio file, video, 3D/CAD model, or document artifact, create it with the scoped creative tools. Freshly generated artifacts are recorded and automatically attached to this Telegram chat when the turn completes, so do not call telegram_send_file for those same artifacts unless the user asked for a specific caption, existing/unrecorded file, or non-default target.",
@@ -679750,7 +679866,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
        * Downloads the file, runs it through the appropriate pipeline,
        * caches it, and returns a text description for the agent.
        */
-      async processMedia(msg, source = "message") {
+      async processMedia(msg, source = "message", eager = false) {
         const media = source === "reply" ? msg.replyToMedia : msg.media;
         if (!media) return "";
         const { type, fileId, fileUniqueId, mimeType, caption } = media;
@@ -679759,6 +679875,12 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
         const sourceLabel = source === "reply" ? "replied-to " : "";
         const mediaAlias = sourceMessageId ? `message_id:${sourceMessageId}` : source === "reply" ? "reply" : "latest";
         const safeCaption = caption ? ` — caption: ${telegramContextJsonString(caption, 220)}` : "";
+        const cacheKey = `${String(msg.chatId)}:${String(sourceMessageId ?? 0)}:${fileUniqueId}`;
+        const existingEntry = this.mediaCache.get(cacheKey);
+        if (existingEntry && existsSync146(existingEntry.localPath)) {
+          existingEntry.cachedAt = Date.now();
+          return existingEntry.extractedContent || `[${sourceLabel}${type} received: path_alias=${mediaAlias}${safeCaption}]`;
+        }
         let ext = ".bin";
         if (isImageMedia) ext = telegramImageExtension(media);
         else if (type === "audio" || type === "voice") ext = ".ogg";
@@ -679782,10 +679904,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
           caption,
           cachedAt: Date.now()
         };
-        this.mediaCache.set(
-          `${String(msg.chatId)}:${String(sourceMessageId ?? 0)}:${fileUniqueId}`,
-          cacheEntry
-        );
+        this.mediaCache.set(cacheKey, cacheEntry);
         const metadataKey = String(msg.chatId);
         if (!this.mediaMetadata.has(metadataKey)) {
           this.mediaMetadata.set(metadataKey, []);
@@ -679798,7 +679917,7 @@ ${knownList}` : "Private-user telegram_send_file target must be this DM or a kno
           username: msg.username
         });
         let description = `[${type}${caption ? `: ${caption}` : ""}]`;
-        if (isImageMedia) {
+        if (isImageMedia && !eager) {
           let visionContext = "";
           try {
             const { runVisionIngress: runVisionIngress2, formatImageContextPrefix: formatImageContextPrefix2 } = await Promise.resolve().then(() => (init_vision_ingress(), vision_ingress_exports));
@@ -680897,6 +681016,10 @@ ${caption}\r
                 if (this.adminUserId && !this.agentConfig) {
                   if (!isAdmin) continue;
                 }
+                if (msg.media) {
+                  void this.processMedia(msg, "message", true).catch(() => {
+                  });
+                }
                 if (this.agentConfig && this.repoRoot) {
                   this.handleMessageWithSubAgent(msg).catch((err) => {
                     this.tuiWrite(

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.357",
+  "version": "1.0.358",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.357",
+      "version": "1.0.358",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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