omnius 1.0.641 → 1.0.642

package/dist/index.js

@@ -345959,6 +345959,13 @@ function assessAdvancedOcrEvidence(input) {
     alnum_ratio: Number(alnumRatio2.toFixed(3))
   };
 }
+function isTerminalSmallCropOcrRejection(evidence) {
+  if (evidence.state !== "rejected")
+    return false;
+  if (evidence.reason === "high_volume_low_confidence_text")
+    return true;
+  return evidence.chars >= TERMINAL_SYMBOL_GARBAGE_CHARS && (evidence.alnum_ratio ?? 1) < TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO;
+}
 function ocrDiagnostic(code8, message2, extra = {}) {
   return {
     schema: "omnius.ocr-diagnostic.v1",
@@ -345977,7 +345984,7 @@ function parsePipelineDiagnostic(error) {
     return null;
   }
 }
-var OCR_PIPELINE_TIMEOUT_MS, OCR_PROCESS_DRAIN_MS, MIN_ACCEPTED_OCR_CONFIDENCE, MIN_SUBSTANTIVE_OCR_CHARS, HIGH_VOLUME_GARBAGE_CHARS, HIGH_VOLUME_GARBAGE_CONFIDENCE, OcrImageAdvancedTool;
+var OCR_PIPELINE_TIMEOUT_MS, OCR_PROCESS_DRAIN_MS, MIN_ACCEPTED_OCR_CONFIDENCE, MIN_SUBSTANTIVE_OCR_CHARS, HIGH_VOLUME_GARBAGE_CHARS, HIGH_VOLUME_GARBAGE_CONFIDENCE, TERMINAL_SYMBOL_GARBAGE_CHARS, TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO, OcrImageAdvancedTool;
 var init_ocr_image_advanced = __esm({
   "packages/execution/dist/tools/ocr-image-advanced.js"() {
     "use strict";
@@ -345989,6 +345996,8 @@ var init_ocr_image_advanced = __esm({
     MIN_SUBSTANTIVE_OCR_CHARS = 12;
     HIGH_VOLUME_GARBAGE_CHARS = 64;
     HIGH_VOLUME_GARBAGE_CONFIDENCE = 35;
+    TERMINAL_SYMBOL_GARBAGE_CHARS = 24;
+    TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO = 0.2;
     OcrImageAdvancedTool = class {
       workingDir;
       name = "ocr_image_advanced";
@@ -346184,7 +346193,9 @@ var init_ocr_image_advanced = __esm({
                 deadline_ms: result.diagnostic?.deadline_ms ?? OCR_PIPELINE_TIMEOUT_MS,
                 attempts_completed: result.diagnostic?.attempts_completed ?? null,
                 attempts_planned: result.diagnostic?.attempts_planned ?? null,
-                evidence: result.diagnostic?.evidence ?? null
+                evidence: result.diagnostic?.evidence ?? null,
+                terminal_small_crop_rejection: result.diagnostic?.terminal_small_crop_rejection ?? null,
+                attempt_cap_seconds: result.diagnostic?.attempt_cap_seconds ?? null
               })
             };
           }
@@ -346220,7 +346231,8 @@ var init_ocr_image_advanced = __esm({
               error: "OCR evidence rejected: low-confidence text was suppressed and is not presented as extracted evidence.",
               durationMs: performance.now() - start2,
               data: ocrDiagnostic("ocr_evidence_rejected", "OCR output did not meet evidence-quality requirements.", {
-                evidence: boundaryEvidence
+                evidence: boundaryEvidence,
+                terminal_small_crop_rejection: isTerminalSmallCropOcrRejection(boundaryEvidence)
               })
             };
           }
@@ -688747,6 +688759,11 @@ function updateListenLiveState(patch) {
 function getListenLiveState() {
   return listenLiveState;
 }
+function childProcessIsRunning(process4) {
+  return Boolean(
+    process4 && process4.exitCode === null && process4.signalCode === null && !process4.killed
+  );
+}
 function clamp0112(value2) {
   if (!Number.isFinite(value2)) return 0;
   return Math.max(0, Math.min(1, value2));
@@ -689408,7 +689425,7 @@ var init_listen = __esm({
       lastVisibleVadAt = 0;
       stderrTail = "";
       get ready() {
-        return this._ready;
+        return this._ready && childProcessIsRunning(this.process);
       }
       async start() {
         let pyPath = "python3";
@@ -689547,17 +689564,32 @@ ${text3}`.slice(-2e3);
           });
           onChildError(this.process, (err) => {
             clearTimeout(timeout2);
-            reject(err);
+            const wasReady = this._ready;
+            this._ready = false;
+            this.process = null;
+            if (wasReady) {
+              updateListenLiveState({ phase: "error", lastStatus: err.message.slice(0, 160) });
+              this.emit("error", err);
+            } else {
+              reject(err);
+            }
           });
           onChildClose(this.process, (code8) => {
             this.unregisterBrokerModel();
-            if (!this._ready) {
+            const wasReady = this._ready;
+            this._ready = false;
+            this.process = null;
+            if (!wasReady) {
               clearTimeout(timeout2);
               reject(
                 new Error(
                   `${this.engineId} worker exited with code ${code8} before ready` + (this.stderrTail ? `: ${this.stderrTail.trim()}` : "")
                 )
               );
+            } else {
+              const message2 = `${this.engineId} worker exited with code ${code8}` + (this.stderrTail ? `: ${this.stderrTail.trim()}` : "");
+              updateListenLiveState({ phase: "error", lastStatus: message2.slice(0, 160) });
+              this.emit("error", new Error(message2));
             }
           });
         });
@@ -689622,6 +689654,10 @@ ${text3}`.slice(-2e3);
       liveTranscriber = null;
       // TranscribeLive from transcribe-cli or WhisperFallbackTranscriber
       active = false;
+      /** Set only after the selected worker has emitted/finished its ready signal. */
+      liveWorkerReady = false;
+      /** Identity captured when that worker became ready; never infer it from a later selection. */
+      runningSelection = null;
       paused = false;
       // Pause state for voicechat (stops mic but keeps transcriber)
       silenceTimer = null;
@@ -689664,6 +689700,27 @@ ${text3}`.slice(-2e3);
       get currentMode() {
         return this.config.mode;
       }
+      /**
+       * Runtime truth for a resident live ASR pipeline.  This does not claim that
+       * a selected-but-unstarted model is ready, and it verifies fallback worker
+       * process liveness rather than trusting an old `ready` event.
+       */
+      get liveRuntimeReadiness() {
+        const fallbackHealthy = !(this.liveTranscriber instanceof WhisperFallbackTranscriber) || this.liveTranscriber.ready === true;
+        const workerReady = Boolean(
+          this.active && this.liveWorkerReady && this.runningSelection && this.liveTranscriber && fallbackHealthy
+        );
+        return {
+          // Keep the captured identity while reporting a failed worker so the
+          // daemon can surface its error against the exact selection rather than
+          // silently falling back to persisted weights state.
+          engineId: this.runningSelection?.engineId ?? null,
+          modelId: this.runningSelection?.modelId ?? null,
+          workerReady,
+          micActive: workerReady && !this.paused && childProcessIsRunning(this.micProcess),
+          paused: this.paused
+        };
+      }
       get pendingTranscript() {
         return this.pendingText;
       }
@@ -689934,6 +689991,8 @@ ${text3}`.slice(-2e3);
        */
       async start() {
         if (this.active) return "Already listening.";
+        this.liveWorkerReady = false;
+        this.runningSelection = null;
         const unavailableReason = getAsrEngineUnavailableReason(this.config.engineId);
         if (unavailableReason) return unavailableReason;
         if (this.config.engineId === "vibevoice-transformers") {
@@ -690063,6 +690122,8 @@ ${text3}`.slice(-2e3);
                   }
                 );
                 this.liveTranscriber.on("error", (err) => {
+                  this.liveWorkerReady = false;
+                  updateListenLiveState({ phase: "error", lastStatus: err.message.slice(0, 160) });
                   this.emit("error", err);
                 });
                 await new Promise((resolve90, reject) => {
@@ -690121,6 +690182,8 @@ ${text3}`.slice(-2e3);
               if (this.config.mode === "auto") this.resetSilenceTimer();
             });
             fallback.on("error", (err) => {
+              this.liveWorkerReady = false;
+              updateListenLiveState({ phase: "error", lastStatus: err.message.slice(0, 160) });
               this.emit("error", err);
             });
             this.liveTranscriber = fallback;
@@ -690133,6 +690196,11 @@ transcribe-cli error: ${transcribeCliError}` : "";
           }
         }
         this.active = true;
+        this.liveWorkerReady = true;
+        this.runningSelection = {
+          engineId: this.config.engineId,
+          modelId: this.config.modelId
+        };
         this.paused = false;
         this.spawnMicProcess(micCmd);
         this.blinkState = true;
@@ -690159,6 +690227,8 @@ transcribe-cli error: ${transcribeCliError}` : "";
       async stop() {
         if (!this.active) return "Not listening.";
         this.active = false;
+        this.liveWorkerReady = false;
+        this.runningSelection = null;
         this.owners.clear();
         this.blinkState = false;
         this.micWaterfall = [];
@@ -793053,6 +793123,12 @@ function getRuntimeStatus() {
   const persisted = _listenEngine ? null : loadGlobalSettings();
   const asrEngineId = _listenEngine?.currentEngine ?? persisted?.asrEngine ?? "openai-whisper";
   const asrModelId = _listenEngine?.currentModel ?? persisted?.asrModel ?? "medium";
+  const liveAsr = _listenEngine?.liveRuntimeReadiness ?? null;
+  const selectedLivePipeline = Boolean(
+    liveAsr?.engineId === asrEngineId && liveAsr?.modelId === asrModelId
+  );
+  const selectedLiveWorker = selectedLivePipeline && liveAsr?.workerReady === true;
+  const selectedLiveMic = selectedLiveWorker && liveAsr?.micActive === true;
   const managedAsr = asrEngineId === "openai-whisper" || asrEngineId === "nemotron-streaming" || asrEngineId === "voxtral-transformers" ? getManagedAsrReadiness(asrEngineId, asrModelId) : null;
   const vibePhase = vibe.active ? "ready" : vibe.lastError ? "error" : vibe.weightsReady ? "weights-ready" : vibe.installed ? "runtime-installed" : "not-installed";
   return {
@@ -793066,8 +793142,8 @@ function getRuntimeStatus() {
     asrEngineId,
     asrModelId,
     asrBackend: asrEngineId === "vibevoice-transformers" ? "vibevoice-transformers" : managedAsr ? asrEngineId : listenState.backend,
-    asrPhase: asrEngineId === "vibevoice-transformers" ? vibePhase : managedAsr?.active ? "ready" : managedAsr?.lastError ? "error" : managedAsr?.weightsReady ? "weights-ready" : listenState.phase,
-    asrReady: asrEngineId === "vibevoice-transformers" ? vibe.active : managedAsr ? managedAsr.active : Boolean(_listenEngine?.isActive),
+    asrPhase: asrEngineId === "vibevoice-transformers" ? vibePhase : selectedLiveMic ? "listening" : selectedLiveWorker && liveAsr?.paused && listenState.phase === "paused" ? "paused" : selectedLivePipeline && listenState.phase === "error" ? "error" : managedAsr?.active ? "ready" : managedAsr?.lastError ? "error" : managedAsr?.weightsReady ? "weights-ready" : "not-started",
+    asrReady: asrEngineId === "vibevoice-transformers" ? vibe.active : managedAsr ? managedAsr.active || selectedLiveMic : Boolean(_listenEngine?.isActive),
     micDevice: listenState.micDevice || null,
     micSourceKind: listenState.micSourceKind,
     micSourceChannels: listenState.micSourceChannels,
@@ -828376,8 +828452,9 @@ function getOpenApiSpec() {
             daemon_tool_names: { type: "array", items: { type: "string" }, description: "Optional exact allowlist of daemon tool names. Use this to keep local-model tool prompts small." },
             agent_timeout_s: { type: "number", minimum: 5, maximum: 600, default: 45, description: "Total server-side agent-loop deadline. Distinct from per-backend timeout_s." },
             agent_max_tool_rounds: { type: "integer", minimum: 1, maximum: 8, default: 1, description: "Maximum daemon-tool planning rounds. The default executes one tool round, then removes daemon schemas for lower-latency final synthesis." },
+            agent_prefetch_web_search: { type: "boolean", default: false, description: "Explicitly execute authorized web_search with the latest user text before one backend synthesis. factual-first enables this automatically." },
             max_turns: { type: "integer", description: "Q2 — agent_loop max iterations (default 8, max 64)." },
-            prompt_template: { type: "string", enum: ["factual-first"], description: "Q8 — prepended system policy template. 'factual-first' instructs model to call web_search FIRST for any factual question." }
+            prompt_template: { type: "string", enum: ["factual-first"], description: "Factual-first prefetches authorized web_search from the latest user turn and performs one grounded synthesis generation." }
           } } } } },
           responses: { 200: { description: "OpenAI chat.completion shape, SSE if stream=true. agent_loop responses include _agent_loop:{turns,log,done,reason,elapsed_ms,backend_transport}." }, 504: { description: "Backend round or total agent-loop deadline expired" }, 508: { description: "The model repeated an identical daemon tool call" }, ...ErrorResponses }
         }
@@ -833272,6 +833349,76 @@ ${messages2[firstSystemIdx].content}`
     const turnsLog = [];
     const seenDaemonCalls = /* @__PURE__ */ new Set();
     let daemonToolRoundsExecuted = 0;
+    const prefetchWebSearch = (promptTemplate === "factual-first" || requestBody["agent_prefetch_web_search"] === true) && advertisedDaemonNames.has("web_search") && callerTools.length === 0 && !messages2.some((message2) => message2.role === "tool" || (message2.tool_calls?.length ?? 0) > 0);
+    const latestUserQuery = [...messages2].reverse().find((message2) => message2.role === "user" && typeof message2.content === "string")?.content?.trim().slice(0, 1e3);
+    if (prefetchWebSearch && latestUserQuery) {
+      const meta = daemonTools.get("web_search");
+      let tool = null;
+      if (meta) {
+        try {
+          tool = new meta.ToolClass(process.cwd());
+        } catch {
+          try {
+            tool = new meta.ToolClass();
+          } catch {
+            tool = null;
+          }
+        }
+      }
+      if (tool) {
+        const callId = `prefetch_web_search_${randomBytes30(6).toString("hex")}`;
+        const args = { query: latestUserQuery };
+        const fingerprint3 = `web_search:${JSON.stringify(args)}`;
+        messages2.push({
+          role: "assistant",
+          content: "",
+          tool_calls: [{
+            id: callId,
+            type: "function",
+            function: { name: "web_search", arguments: JSON.stringify(args) }
+          }]
+        });
+        let toolResult;
+        try {
+          activeTool = tool;
+          const remainingMs = totalDeadline - Date.now();
+          if (remainingMs <= 0) throw new Error("agent loop deadline expired before factual-first search");
+          const execution = await executeAgentLoopToolBounded(
+            tool,
+            args,
+            Math.min(getAgentLoopToolTimeoutMs(), remainingMs),
+            clientDisconnect
+          );
+          if (execution.clientDisconnected || isClientDisconnected()) return;
+          toolResult = execution.result;
+        } catch (error) {
+          if (isClientDisconnected()) return;
+          toolResult = {
+            success: false,
+            output: "",
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: 0
+          };
+        } finally {
+          activeTool = null;
+        }
+        messages2.push({
+          role: "tool",
+          tool_call_id: callId,
+          name: "web_search",
+          content: compactAgentLoopToolResult(toolResult)
+        });
+        seenDaemonCalls.add(fingerprint3);
+        daemonToolRoundsExecuted = 1;
+        turnsLog.push({
+          turn: 0,
+          tool_calls: 1,
+          daemon_executed: 1,
+          client_yielded: 0,
+          prefetched: true
+        });
+      }
+    }
     for (let turn = 1; turn <= maxTurns; turn++) {
       if (isClientDisconnected()) return;
       if (Date.now() > totalDeadline) {
@@ -833326,6 +833473,7 @@ ${messages2[firstSystemIdx].content}`
         daemon_tool_names: void 0,
         agent_timeout_s: void 0,
         agent_max_tool_rounds: void 0,
+        agent_prefetch_web_search: void 0,
         max_turns: void 0,
         timeout_s: void 0,
         realtime: void 0,

package/dist/scripts/ocr-advanced.py

@@ -179,11 +179,17 @@ SMALL_CROP_AREA_PX = 512_000
 MEDIUM_IMAGE_AREA_PX = 2_000_000
 MAX_PIPELINE_DEADLINE_MS = 80_000
 MAX_TESSERACT_ATTEMPT_SECONDS = 12.0
+# Small conditioned crops normally complete in well under a second. A
+# six-second cap still permits a busy Tesseract child, while keeping a failed
+# recovery pair from consuming most of the REST deadline.
+SMALL_CROP_TESSERACT_ATTEMPT_SECONDS = 6.0
 MIN_TESSERACT_ATTEMPT_SECONDS = 0.25
 MIN_ACCEPTED_CONFIDENCE = 50.0
 MIN_SUBSTANTIVE_TEXT_CHARS = 12
 HIGH_VOLUME_GARBAGE_CHARS = 64
 HIGH_VOLUME_GARBAGE_CONFIDENCE = 35.0
+TERMINAL_SYMBOL_GARBAGE_CHARS = 24
+TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO = 0.20
 ACTIVE_DEADLINE = None
 
 
@@ -211,11 +217,11 @@ class OcrDeadline:
         if self.remaining_seconds() <= 0:
             raise OcrPipelineTimeout(f"OCR deadline exceeded during {stage}")
 
-    def tesseract_timeout_seconds(self):
+    def tesseract_timeout_seconds(self, attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS):
         self.check("Tesseract scheduling")
         return max(
             MIN_TESSERACT_ATTEMPT_SECONDS,
-            min(MAX_TESSERACT_ATTEMPT_SECONDS, self.remaining_seconds()),
+            min(attempt_cap_seconds, self.remaining_seconds()),
         )
 
 
@@ -251,7 +257,8 @@ def text_from_tesseract_data(data):
     return "\n".join(" ".join(words) for words in lines.values()).strip()
 
 
-def run_tesseract(binary_img, deadline, language="eng", psm=6):
+def run_tesseract(binary_img, deadline, language="eng", psm=6,
+                  attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS):
     """Run one bounded Tesseract TSV pass and derive text plus confidence."""
     deadline.check("Tesseract")
     pil_img = Image.fromarray(binary_img)
@@ -261,7 +268,7 @@ def run_tesseract(binary_img, deadline, language="eng", psm=6):
         lang=language,
         config=config,
         output_type=pytesseract.Output.DICT,
-        timeout=deadline.tesseract_timeout_seconds(),
+        timeout=deadline.tesseract_timeout_seconds(attempt_cap_seconds),
     )
     text = text_from_tesseract_data(data)
     confs = []
@@ -331,6 +338,24 @@ def assess_ocr_evidence(text, confidence, line_count):
     }
 
 
+def is_terminal_small_crop_rejection(evidence):
+    """Whether a first small-crop pass proves another recovery pass is futile.
+
+    Blanks and plausible alphanumeric low-confidence text remain recoverable
+    through the second variant. A large very-low-confidence transcript or a
+    distinctly symbol-heavy stream cannot become safe evidence through another
+    PSM6 pass, and should not make callers wait for one.
+    """
+    if evidence.get("state") != "rejected":
+        return False
+    if evidence.get("reason") == "high_volume_low_confidence_text":
+        return True
+    return (
+        evidence.get("chars", 0) >= TERMINAL_SYMBOL_GARBAGE_CHARS
+        and evidence.get("alnum_ratio", 1.0) < TERMINAL_SYMBOL_GARBAGE_ALNUM_RATIO
+    )
+
+
 def compute_score(text, confidence, line_count, evidence=None):
     """Combined scoring heuristic:
       - confidence * sqrt(char_count)  — rewards quality and coverage
@@ -451,15 +476,18 @@ def write_all_outputs(text, base_name, output_dir):
 # Main pipeline
 # ---------------------------------------------------------------------------
 
-def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefix="full"):
+def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefix="full",
+                     attempt_cap_seconds=MAX_TESSERACT_ATTEMPT_SECONDS,
+                     stop_on_terminal_rejection=False):
     """Run a bounded plan, stopping early once a legible result is proven."""
     all_results = {}
     ocr_errors = []
     best_key = None
     best_score = -1
     early_exit = False
+    terminal_rejection = False
 
-    for vname, psm in plan:
+    for attempt_index, (vname, psm) in enumerate(plan):
         deadline.check("preprocessing")
         key = f"{vname}_psm{psm}"
         try:
@@ -471,7 +499,9 @@ def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefi
             os.makedirs(debug_dir, exist_ok=True)
             cv2.imwrite(os.path.join(debug_dir, f"{debug_prefix}_{vname}.png"), binary)
         try:
-            text, confidence, line_count = run_tesseract(binary, deadline, language, psm)
+            text, confidence, line_count = run_tesseract(
+                binary, deadline, language, psm, attempt_cap_seconds
+            )
         except OcrPipelineTimeout:
             raise
         except OcrPipelineCancelled:
@@ -496,8 +526,15 @@ def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefi
         if has_sufficient_evidence(text, confidence, line_count):
             early_exit = True
             break
+        if (
+            stop_on_terminal_rejection
+            and attempt_index == 0
+            and is_terminal_small_crop_rejection(evidence)
+        ):
+            terminal_rejection = True
+            break
 
-    return all_results, ocr_errors, best_key, early_exit
+    return all_results, ocr_errors, best_key, early_exit, terminal_rejection
 
 
 def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_dir=None,
@@ -522,10 +559,22 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
     deadline.check("image conditioning")
     gray_2x = upscale_2x(gray)
     plan = build_ocr_plan(effective_area, single_psm)
+    is_small_crop = effective_area <= SMALL_CROP_AREA_PX
+    attempt_cap_seconds = (
+        SMALL_CROP_TESSERACT_ATTEMPT_SECONDS
+        if is_small_crop
+        else MAX_TESSERACT_ATTEMPT_SECONDS
+    )
     attempts_completed = 0
     try:
-        all_results, ocr_errors, best_key, early_exit = run_variant_plan(
-            gray_2x, plan, deadline, language, debug_dir
+        all_results, ocr_errors, best_key, early_exit, terminal_rejection = run_variant_plan(
+            gray_2x,
+            plan,
+            deadline,
+            language,
+            debug_dir,
+            attempt_cap_seconds=attempt_cap_seconds,
+            stop_on_terminal_rejection=is_small_crop,
         )
         attempts_completed = len(all_results)
         if not best_key:
@@ -545,6 +594,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                     "diagnostic": {
                         **diagnostic("ocr_evidence_rejected", message, deadline, "evidence_quality", attempts_completed, len(plan)),
                         "evidence": evidence,
+                        "terminal_small_crop_rejection": terminal_rejection,
+                        "attempt_cap_seconds": attempt_cap_seconds,
                     },
                 }
             # Empty or tiny non-substantive detections are valid observations:
@@ -579,6 +630,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                     "attempts_planned": len(plan),
                     "attempts_completed": attempts_completed,
                     "early_exit": False,
+                    "terminal_small_crop_rejection": terminal_rejection,
+                    "attempt_cap_seconds": attempt_cap_seconds,
                     "deadline_ms": deadline.deadline_ms,
                 },
             }
@@ -615,6 +668,8 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                 "attempts_planned": len(plan),
                 "attempts_completed": attempts_completed,
                 "early_exit": early_exit,
+                "terminal_small_crop_rejection": terminal_rejection,
+                "attempt_cap_seconds": attempt_cap_seconds,
                 "deadline_ms": deadline.deadline_ms,
             },
         }
@@ -627,9 +682,22 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
                 region_gray = extract_region(gray_2x, y_start, y_end)
                 # Region requests use at most two high-yield attempts. The
                 # main result already provides full-frame coverage.
-                region_plan = build_ocr_plan(region_gray.shape[0] * region_gray.shape[1], single_psm)[:2]
-                region_results, _errors, region_best_key, _early_exit = run_variant_plan(
-                    region_gray, region_plan, deadline, language, debug_dir, f"region_{rname}"
+                region_area = region_gray.shape[0] * region_gray.shape[1]
+                region_plan = build_ocr_plan(region_area, single_psm)[:2]
+                region_is_small = region_area <= SMALL_CROP_AREA_PX
+                region_results, _errors, region_best_key, _early_exit, _terminal_rejection = run_variant_plan(
+                    region_gray,
+                    region_plan,
+                    deadline,
+                    language,
+                    debug_dir,
+                    f"region_{rname}",
+                    attempt_cap_seconds=(
+                        SMALL_CROP_TESSERACT_ATTEMPT_SECONDS
+                        if region_is_small
+                        else MAX_TESSERACT_ATTEMPT_SECONDS
+                    ),
+                    stop_on_terminal_rejection=region_is_small,
                 )
                 regions[rname] = region_results[region_best_key]["text"] if region_best_key else ""
             result["regions"] = regions

package/docs/DISCOVERY.json

@@ -6163,6 +6163,11 @@
                       "default": 1,
                       "description": "Maximum daemon-tool planning rounds. The default executes one tool round, then removes daemon schemas for lower-latency final synthesis."
                     },
+                    "agent_prefetch_web_search": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Explicitly execute authorized web_search with the latest user text before one backend synthesis. factual-first enables this automatically."
+                    },
                     "max_turns": {
                       "type": "integer",
                       "description": "Q2 — agent_loop max iterations (default 8, max 64)."
@@ -6172,7 +6177,7 @@
                       "enum": [
                         "factual-first"
                       ],
-                      "description": "Q8 — prepended system policy template. 'factual-first' instructs model to call web_search FIRST for any factual question."
+                      "description": "Factual-first prefetches authorized web_search from the latest user turn and performs one grounded synthesis generation."
                     }
                   }
                 }

package/docs/rest/endpoints/chat.md

@@ -47,6 +47,7 @@ Important body fields:
 | `daemon_tool_names` | array | Exact daemon-tool allowlist; recommended for local models |
 | `agent_timeout_s` | number | Whole-loop deadline, default 45 seconds and maximum 600 |
 | `agent_max_tool_rounds` | integer | Daemon tool rounds before forced final synthesis; default 1 |
+| `agent_prefetch_web_search` | boolean | Explicit one-generation web-search prefetch; factual-first enables it automatically |
 | `max_turns` | integer | Server-side agent loop turn cap |
 | `prompt_template` | string | Optional template such as `factual-first` |
 
@@ -130,4 +131,4 @@ For ASR/TTS systems that only need the text brain, use `/realtime` or `/v1/realt
 
 `/v1/chat/completions` can run an internal tool loop when `agent_loop: true`. This lets clients collapse multiple model/tool round trips into one daemon request. Daemon tool calls execute inline; client-owned tool calls can still be yielded in OpenAI-compatible shape.
 
-Ollama-backed loops use its native `/api/chat` tool protocol. `timeout_s` applies to each backend round, while `agent_timeout_s` bounds the complete loop and defaults to 45 seconds. The planning turn is capped at 96 output tokens. By default Omnius executes one daemon-tool round, then removes daemon schemas for the final synthesis; set `agent_max_tool_rounds` only when a workflow genuinely needs deeper tool chaining. Omnius returns a typed HTTP 504 when the total budget expires and HTTP 508 when a model repeats the same daemon tool with identical arguments. Tool results are capped at 6,000 characters before the next prompt. Without `daemon_tool_names`, Omnius offers only a compact core catalog permitted by `include_daemon_tools`; `prompt_template: "factual-first"` narrows it further to `web_search` and `web_fetch`.
+Ollama-backed loops use its native `/api/chat` tool protocol. `timeout_s` applies to each backend round, while `agent_timeout_s` bounds the complete loop and defaults to 45 seconds. For a normal loop, the planning turn is capped at 96 output tokens; one daemon-tool round is the default, after which Omnius removes daemon schemas for final synthesis. `prompt_template: "factual-first"` skips that model-planning round entirely: Omnius executes the already-mandated, authorized `web_search` using the latest user turn, inserts the protocol-correct tool evidence, and performs one grounded synthesis generation. `agent_prefetch_web_search: true` opts into the same path directly. Generic/deeper tool workflows remain available through `agent_max_tool_rounds`. Omnius returns typed HTTP 504/508 failures, caps tool evidence at 6,000 characters, and limits the implicit catalog unless `daemon_tool_names` requests exact additions.

package/docs/rest/endpoints/voice-vision.md

@@ -128,9 +128,12 @@ needs `run` scope because optional
 
 The managed pipeline is bounded: it starts with high-yield preprocessing and
 expands variants only for low-evidence or larger images. Small crops avoid the
-former all-variant/all-PSM explosion. The REST default is 90 seconds (maximum
-180 seconds), while the worker has an 80-second internal deadline so it can
-return diagnostics. A timeout or cancellation returns
+former all-variant/all-PSM explosion and use a six-second cap per Tesseract
+attempt. If the first small-crop pass proves high-volume very-low-confidence or
+distinctly symbol-heavy garbage, recovery stops immediately; blanks and
+plausibly recoverable text still receive the second high-yield attempt. The
+REST default is 90 seconds (maximum 180 seconds), while the worker has an
+80-second internal deadline so it can return diagnostics. A timeout or cancellation returns
 `result.data.schema=omnius.ocr-diagnostic.v1` with code `ocr_timeout` or
 `ocr_cancelled`; cancellation terminates the Python/Tesseract process group
 with TERM followed by KILL.

package/npm-shrinkwrap.json

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

package/package.json

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