omnius 1.0.640 → 1.0.642

package/dist/scripts/audio-speaker-embedding-worker.py

@@ -37,10 +37,11 @@ MIN_RMS = 0.003
 MIN_PEAK = 0.01
 MAX_CLIPPED_FRACTION = 0.01
 FBANK_IMPLEMENTATION = "kaldi-fbank-numpy-v1"
-# SHA-256 over the rounded deterministic 2-second calibration fbank after
-# utterance CMN. This protects the source implementation from silent feature
-# drift while avoiding irrelevant last-bit FFT differences across CPU builds.
-FBANK_VALIDATION_SIGNATURE = "sha256:19bb5552b8068d5cd2ccdbb07ac7a7ed1137400d3bdc3c54fb9c21d4f06e16fa"
+# A CPU FFT may differ in harmless last bits across x86/aarch64 and NumPy
+# builds. Validate the public Kaldi configuration with numeric invariants,
+# not a byte hash of implementation-dependent FFT output.
+FBANK_VALIDATION = "kaldi-fbank-invariants-v2"
+CALIBRATION_BAND_MEANS = (11.1405, 17.5231, 12.8845, 9.2557, 7.7213, 6.7842, 6.6405)
 
 
 def emit(payload: dict) -> None:
@@ -163,25 +164,46 @@ def kaldi_fbank80_numpy(waveform, np):
 
 
 def validate_kaldi_fbank_numpy(np):
-    """Validate the no-Torch preprocessing path before readiness is true."""
+    """Validate the no-Torch preprocessing path before readiness is true.
+
+    The calibration intentionally asserts shape, finite/CMN invariants, the
+    expected 220/440 Hz Kaldi mel-band profile and energy range with tolerances
+    that are stable across supported CPU FFT implementations. It must reject a
+    changed window, frame layout, PCM scale, mel bank, pre-emphasis or CMN, but
+    must not reject Jetson due to last-bit numerical differences.
+    """
     t = np.arange(SAMPLE_RATE * 2, dtype=np.float32) / np.float32(SAMPLE_RATE)
     samples = (
         np.float32(0.075) * np.sin(np.float32(2.0 * np.pi * 220.0) * t)
         + np.float32(0.025) * np.sin(np.float32(2.0 * np.pi * 440.0) * t)
     ).astype(np.float32)
-    features = kaldi_fbank80_numpy(samples * np.float32(1 << 15), np)
-    features = (features - np.mean(features, axis=0, dtype=np.float32, keepdims=True)).astype(np.float32)
+    raw_features = kaldi_fbank80_numpy(samples * np.float32(1 << 15), np)
+    features = (
+        raw_features - np.mean(raw_features, axis=0, dtype=np.float32, keepdims=True)
+    ).astype(np.float32)
     if features.shape != (198, 80) or not np.all(np.isfinite(features)):
         raise RuntimeError("NumPy Kaldi fbank calibration produced an invalid feature matrix")
-    if not np.all(np.abs(np.mean(features, axis=0)) < np.float32(5e-5)):
+    cmn_abs_mean_max = float(np.max(np.abs(np.mean(features, axis=0))))
+    if cmn_abs_mean_max > 1e-3:
         raise RuntimeError("NumPy Kaldi fbank calibration failed utterance CMN")
-    rounded = np.rint(features * np.float32(10_000)).astype("<i4", copy=False)
-    signature = "sha256:" + hashlib.sha256(rounded.tobytes()).hexdigest()
-    if signature != FBANK_VALIDATION_SIGNATURE:
+    raw_min = float(np.min(raw_features))
+    raw_max = float(np.max(raw_features))
+    cmn_rms = float(np.sqrt(np.mean(np.square(features))))
+    band_means = raw_features.mean(axis=0)[[0, 5, 10, 20, 40, 60, 79]]
+    if not (4.5 < raw_min < 6.0 and 19.0 < raw_max < 21.5 and 0.55 < cmn_rms < 0.75):
         raise RuntimeError(
-            "NumPy Kaldi fbank calibration signature mismatch: " + signature
+            "NumPy Kaldi fbank calibration energy/range invariant failed"
         )
-    return signature
+    if not np.allclose(band_means, np.asarray(CALIBRATION_BAND_MEANS, dtype=np.float32), rtol=0.0, atol=0.25):
+        raise RuntimeError("NumPy Kaldi fbank calibration mel-band invariant failed")
+    return {
+        "validation": FBANK_VALIDATION,
+        "frames": int(features.shape[0]),
+        "bins": int(features.shape[1]),
+        "cmn_abs_mean_max": round(cmn_abs_mean_max, 8),
+        "cmn_rms": round(cmn_rms, 6),
+        "raw_feature_range": [round(raw_min, 6), round(raw_max, 6)],
+    }
 
 
 class WeSpeakerCamPlus:
@@ -191,7 +213,7 @@ class WeSpeakerCamPlus:
         import onnxruntime as ort
 
         self.np = np
-        self.preprocessing_signature = validate_kaldi_fbank_numpy(np)
+        self.preprocessing_validation = validate_kaldi_fbank_numpy(np)
         options = ort.SessionOptions()
         options.inter_op_num_threads = 1
         options.intra_op_num_threads = 1
@@ -265,7 +287,7 @@ def main() -> int:
             {
                 "type": "preprocessing_probe",
                 "implementation": FBANK_IMPLEMENTATION,
-                "validation_signature": validate_kaldi_fbank_numpy(np),
+                "validation": validate_kaldi_fbank_numpy(np),
             }
         )
         return 0
@@ -285,7 +307,7 @@ def main() -> int:
             "model_load_ms": round(worker.model_load_ms, 3),
             "warmed": True,
             "preprocessing": FBANK_IMPLEMENTATION,
-            "preprocessing_signature": worker.preprocessing_signature,
+            "preprocessing_validation": worker.preprocessing_validation,
         }
     )
     for line in sys.stdin:

package/dist/scripts/ocr-advanced.py

@@ -179,7 +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
 
 
@@ -207,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()),
         )
 
 
@@ -247,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)
@@ -257,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 = []
@@ -273,14 +284,87 @@ def run_tesseract(binary_img, deadline, language="eng", psm=6):
     return text, avg_conf, line_count
 
 
-def compute_score(text, confidence, line_count):
+def assess_ocr_evidence(text, confidence, line_count):
+    """Classify OCR output before it can become agent-visible evidence."""
+    normalized = str(text or "").strip()
+    chars = len(normalized)
+    if chars == 0:
+        return {
+            "state": "low_information",
+            "accepted": False,
+            "reason": "no_readable_text",
+            "chars": 0,
+            "confidence": round(float(confidence), 1),
+            "lines": int(line_count),
+        }
+    alnum_ratio = sum(character.isalnum() for character in normalized) / max(1, chars)
+    if chars < MIN_SUBSTANTIVE_TEXT_CHARS and confidence < MIN_ACCEPTED_CONFIDENCE:
+        return {
+            "state": "low_information",
+            "accepted": False,
+            "reason": "insufficient_low_confidence_text",
+            "chars": chars,
+            "confidence": round(float(confidence), 1),
+            "lines": int(line_count),
+            "alnum_ratio": round(alnum_ratio, 3),
+        }
+    if (
+        (chars >= HIGH_VOLUME_GARBAGE_CHARS and confidence < HIGH_VOLUME_GARBAGE_CONFIDENCE)
+        or confidence < MIN_ACCEPTED_CONFIDENCE
+        or alnum_ratio < 0.45
+    ):
+        reason = (
+            "high_volume_low_confidence_text"
+            if chars >= HIGH_VOLUME_GARBAGE_CHARS and confidence < HIGH_VOLUME_GARBAGE_CONFIDENCE
+            else "low_confidence_or_symbol_heavy_text"
+        )
+        return {
+            "state": "rejected",
+            "accepted": False,
+            "reason": reason,
+            "chars": chars,
+            "confidence": round(float(confidence), 1),
+            "lines": int(line_count),
+            "alnum_ratio": round(alnum_ratio, 3),
+        }
+    return {
+        "state": "accepted",
+        "accepted": True,
+        "reason": "confidence_and_text_quality_met",
+        "chars": chars,
+        "confidence": round(float(confidence), 1),
+        "lines": int(line_count),
+        "alnum_ratio": round(alnum_ratio, 3),
+    }
+
+
+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
       - + line_count * 10              — bonus for structured output (more lines = better parse)
     The agent discovered that line-count is a strong proxy for successful parsing
     on structured documents like invoices and forms."""
+    quality = evidence or assess_ocr_evidence(text, confidence, line_count)
     char_count = len(text)
-    if char_count == 0:
+    if not quality["accepted"] or char_count == 0:
         return 0
     return confidence * (char_count ** 0.5) + line_count * 10
 
@@ -319,7 +403,8 @@ def build_ocr_plan(image_area_px, single_psm=None):
 
 
 def has_sufficient_evidence(text, confidence, line_count):
-    return len(text.strip()) >= 8 and confidence >= 70.0 and line_count >= 1
+    quality = assess_ocr_evidence(text, confidence, line_count)
+    return quality["accepted"] and confidence >= 70.0 and line_count >= 1
 
 
 # ---------------------------------------------------------------------------
@@ -391,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:
@@ -411,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:
@@ -420,22 +510,31 @@ def run_variant_plan(gray, plan, deadline, language, debug_dir=None, debug_prefi
             ocr_errors.append(f"{key}: {error}")
             continue
         char_count = len(text)
-        score = compute_score(text, confidence, line_count)
+        evidence = assess_ocr_evidence(text, confidence, line_count)
+        score = compute_score(text, confidence, line_count, evidence)
         all_results[key] = {
             "text": text,
             "chars": char_count,
             "lines": line_count,
             "confidence": round(confidence, 1),
             "score": round(score, 1),
+            "evidence": evidence,
         }
-        if score > best_score:
+        if evidence["accepted"] and score > best_score:
             best_score = score
             best_key = key
         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,
@@ -460,17 +559,89 @@ 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:
-            detail = ocr_errors[-1] if ocr_errors else "no preprocessing variant completed"
-            return {"error": f"Tesseract failed for every bounded OCR attempt: {detail}"}
+            if not all_results:
+                detail = ocr_errors[-1] if ocr_errors else "no preprocessing variant completed"
+                return {"error": f"Tesseract failed for every bounded OCR attempt: {detail}"}
+            rejected = [item for item in all_results.values() if item["evidence"]["state"] == "rejected"]
+            if rejected:
+                worst = max(rejected, key=lambda item: (item["chars"], -item["confidence"]))
+                evidence = worst["evidence"]
+                message = (
+                    "OCR text was suppressed because it did not meet evidence-quality requirements "
+                    f"({evidence['reason']}; {evidence['chars']} chars at {evidence['confidence']}% confidence)."
+                )
+                return {
+                    "error": message,
+                    "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:
+            # do not invent text and do not report them as a pipeline error.
+            result = {
+                "text": "",
+                "confidence": 0.0,
+                "variant": "none",
+                "chars": 0,
+                "lines": 0,
+                "score": 0.0,
+                "image_size": f"{w_orig}x{h_orig}",
+                "variants_tested": len(all_results),
+                "all_variants": {},
+                "quality": {
+                    "schema": "omnius.ocr-evidence.v1",
+                    "state": "low_information",
+                    "accepted": False,
+                    "reason": "no_accepted_readable_text",
+                    "low_information_variants": len(all_results),
+                },
+                "diagnostic": diagnostic(
+                    "ocr_low_information",
+                    "OCR produced no accepted readable text; the result is low-information rather than evidence.",
+                    deadline,
+                    "evidence_quality",
+                    attempts_completed,
+                    len(plan),
+                ),
+                "strategy": {
+                    "effective_area_px": effective_area,
+                    "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,
+                },
+            }
+            return result
 
         best = all_results[best_key]
+        accepted_results = {
+            key: value for key, value in all_results.items()
+            if value["evidence"]["state"] == "accepted"
+        }
         result = {
             "text": best["text"],
             "confidence": best["confidence"],
@@ -480,12 +651,25 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
             "score": best["score"],
             "image_size": f"{w_orig}x{h_orig}",
             "variants_tested": len(all_results),
-            "all_variants": all_results,
+            # Never leak rejected raw OCR as alternate evidence to agents.
+            "all_variants": accepted_results,
+            "quality": {
+                "schema": "omnius.ocr-evidence.v1",
+                **best["evidence"],
+                "rejected_variants": sum(
+                    1 for item in all_results.values() if item["evidence"]["state"] == "rejected"
+                ),
+                "low_information_variants": sum(
+                    1 for item in all_results.values() if item["evidence"]["state"] == "low_information"
+                ),
+            },
             "strategy": {
                 "effective_area_px": effective_area,
                 "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,
             },
         }
@@ -498,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

@@ -5399,7 +5399,7 @@
           "tags": [
             "Audio"
           ],
-          "description": "Admin-only. Requires kind=acoustic|speaker|semantic in the query (canonical) or JSON body. acoustic reuses the pinned JetPack YAMNet/TensorRT setup; speaker creates a private CPython 3.10 CPU-only WeSpeaker CAM++ venv, installs only checksum-pinned NumPy, ONNX Runtime, and its locked CPU support wheels with --no-deps/--no-index, then downloads the pinned model. Its 80-bin Kaldi-compatible NumPy fbank is validated with a deterministic signature before readiness. The speaker path never imports, links, replaces, or otherwise depends on JetPack Torch/Torchaudio, so an incompatible generic Torchaudio wheel cannot affect CUDA-enabled Egg Torch. semantic installs the isolated JetPack CUDA CLAP dependencies and pinned model. This is the only REST operation allowed to provision. It activates and warms only the requested role worker; no role is substituted for another.",
+          "description": "Admin-only. Requires kind=acoustic|speaker|semantic in the query (canonical) or JSON body. acoustic reuses the pinned JetPack YAMNet/TensorRT setup; speaker creates a private CPython 3.10 CPU-only WeSpeaker CAM++ venv, installs only checksum-pinned NumPy, ONNX Runtime, and its locked CPU support wheels with --no-deps/--no-index, then downloads the pinned model. Its 80-bin Kaldi-compatible NumPy fbank is validated with a versioned cross-platform numeric-invariant probe before readiness. The speaker path never imports, links, replaces, or otherwise depends on JetPack Torch/Torchaudio, so an incompatible generic Torchaudio wheel cannot affect CUDA-enabled Egg Torch. semantic installs the isolated JetPack CUDA CLAP dependencies and pinned model. This is the only REST operation allowed to provision. It activates and warms only the requested role worker; no role is substituted for another.",
           "parameters": [
             {
               "name": "kind",
@@ -6156,6 +6156,18 @@
                       "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)."
@@ -6165,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

@@ -46,6 +46,8 @@ Important body fields:
 | `include_daemon_tools` | array | Permit the bounded core daemon-tool catalog by scope: `read`, `run`, `admin` |
 | `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` |
 
@@ -129,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. Omnius returns a typed HTTP 504 when that budget expires and HTTP 508 when a model repeats the same daemon tool with identical arguments. Tool results are bounded before the next prompt. Without `daemon_tool_names`, Omnius offers only a compact core catalog permitted by `include_daemon_tools`, avoiding a huge local-model prompt; request any other tools by exact name. `prompt_template: "factual-first"` narrows the implicit catalog 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,13 +128,23 @@ 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.
 
+OCR text is evidence-gated before it is returned. Strong text with adequate
+confidence is accepted. An empty or tiny non-substantive result is a successful
+`omnius.ocr-evidence.v1` `low_information` observation with diagnostic code
+`ocr_low_information`, not a fabricated transcript. High-volume low-confidence
+or symbol-heavy output is suppressed and returned as
+`ocr_evidence_rejected`; its raw text is not exposed as alternate OCR evidence.
+
 ## TTS
 
 `POST /v1/voice/tts` returns audio bytes. `format` can be `wav` or `pcm`. `X-Sample-Rate` reports the sample rate.
@@ -270,8 +280,9 @@ managed venv installs it with `--no-deps --no-index`.
 The worker implements the WeSpeaker CAM++ 80-bin Kaldi configuration in pure
 NumPy: 25 ms / 10 ms Hamming frames, dither disabled, Kaldi pre-emphasis and
 mel bank behavior, then full-clip CMN without CVN. Readiness invokes a
-deterministic CPU preprocessing probe and requires its pinned rounded-feature
-SHA-256 signature before it can report ready. The speaker path neither imports
+versioned CPU preprocessing probe. It checks the fixed Kaldi configuration,
+feature shape, CMN, energy range, and expected mel-band profile with explicit
+cross-platform numeric tolerances before it can report ready. The speaker path neither imports
 nor links Torch or Torchaudio, so the generic `torchaudio-2.2.0` ABI mismatch
 cannot bind against, replace, or otherwise affect JetPack's CUDA-enabled Egg
 Torch. Inference remains install-free and network-free; failed package imports

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.640",
+  "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",