omnius 1.0.640 → 1.0.641

package/dist/index.js

@@ -5859,7 +5859,7 @@ function usesSystemSitePackages() {
 function loadManifest3() {
   try {
     const manifest = JSON.parse(readFileSync10(manifestPath3(), "utf8"));
-    if (manifest.runtimeVersion !== RUNTIME_VERSION3 || manifest.model !== MODEL_NAME2 || manifest.modelRevision !== MODEL_REVISION2 || manifest.modelDigest !== `sha256:${MODEL_SHA2562}` || manifest.backend !== "onnxruntime-cpu" || manifest.onnxRuntimeVersion !== ONNXRUNTIME_VERSION || manifest.numpyVersion !== NUMPY_VERSION || manifest.preprocessing?.implementation !== FBANK_IMPLEMENTATION || manifest.preprocessing?.validationSignature !== FBANK_VALIDATION_SIGNATURE || !hasExpectedSpeakerRuntimePackages(manifest.packages) || usesSystemSitePackages() || !existsSync11(modelPath2()) || !existsSync11(managedPython())) {
+    if (manifest.runtimeVersion !== RUNTIME_VERSION3 || manifest.model !== MODEL_NAME2 || manifest.modelRevision !== MODEL_REVISION2 || manifest.modelDigest !== `sha256:${MODEL_SHA2562}` || manifest.backend !== "onnxruntime-cpu" || manifest.onnxRuntimeVersion !== ONNXRUNTIME_VERSION || manifest.numpyVersion !== NUMPY_VERSION || manifest.preprocessing?.implementation !== FBANK_IMPLEMENTATION || manifest.preprocessing?.validation !== FBANK_VALIDATION || !hasExpectedSpeakerRuntimePackages(manifest.packages) || usesSystemSitePackages() || !existsSync11(modelPath2()) || !existsSync11(managedPython())) {
       return null;
     }
     return sha256File4(modelPath2()) === MODEL_SHA2562 ? manifest : null;
@@ -5914,8 +5914,8 @@ async function preprocessingProbe(python2, workerScript) {
   try {
     const output2 = await execFileText2(python2, [workerScript, "--preprocessing-probe"], { timeout: 3e4, env: managedEnv3() });
     const event = JSON.parse(output2.trim().split(/\r?\n/).pop() || "{}");
-    if (event.type !== "preprocessing_probe" || event.implementation !== FBANK_IMPLEMENTATION || event.validation_signature !== FBANK_VALIDATION_SIGNATURE) {
-      return { verified: false, error: "managed NumPy Kaldi fbank calibration did not match the pinned signature" };
+    if (event.type !== "preprocessing_probe" || event.implementation !== FBANK_IMPLEMENTATION || event.validation?.validation !== FBANK_VALIDATION) {
+      return { verified: false, error: "managed NumPy Kaldi fbank did not satisfy the pinned versioned calibration invariants" };
     }
     return { verified: true };
   } catch (error) {
@@ -6089,7 +6089,7 @@ async function getSpeakerEmbeddingReadiness() {
       packages: manifest?.packages,
       preprocessing: {
         implementation: FBANK_IMPLEMENTATION,
-        validation_signature: FBANK_VALIDATION_SIGNATURE,
+        validation: FBANK_VALIDATION,
         verified: runtime2.preprocessingVerified
       },
       providers: runtime2.providers,
@@ -6120,7 +6120,7 @@ async function ensureSpeakerEmbeddingSetup() {
     await installPinnedSpeakerRuntimeDependencies(python2);
     const runtime2 = await probeRuntime(python2, findWorkerScript4());
     if (!runtime2.available || runtime2.onnxruntimeVersion !== ONNXRUNTIME_VERSION || runtime2.numpyVersion !== NUMPY_VERSION || !runtime2.preprocessingVerified || !runtime2.providers.includes("CPUExecutionProvider") || usesSystemSitePackages()) {
-      throw new Error(`Managed CPU NumPy Kaldi-fbank validation failed after speaker setup${runtime2.error ? `: ${runtime2.error}` : ""}. The private speaker venv must prove pinned NumPy ${NUMPY_VERSION}, ONNX Runtime ${ONNXRUNTIME_VERSION}, the bundled preprocessing signature, and CPUExecutionProvider without importing Torch or Torchaudio.`);
+      throw new Error(`Managed CPU NumPy Kaldi-fbank validation failed after speaker setup${runtime2.error ? `: ${runtime2.error}` : ""}. The private speaker venv must prove pinned NumPy ${NUMPY_VERSION}, ONNX Runtime ${ONNXRUNTIME_VERSION}, the bundled versioned preprocessing invariants, and CPUExecutionProvider without importing Torch or Torchaudio.`);
     }
     await downloadChecked2(MODEL_URL2, modelPath2(), MODEL_SHA2562);
     const manifest = {
@@ -6134,7 +6134,7 @@ async function ensureSpeakerEmbeddingSetup() {
       packages: speakerRuntimeManifest(),
       preprocessing: {
         implementation: FBANK_IMPLEMENTATION,
-        validationSignature: FBANK_VALIDATION_SIGNATURE
+        validation: FBANK_VALIDATION
       },
       pythonVersion: runtime2.pythonVersion ?? bootstrapRuntime.pythonVersion,
       installedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -6234,7 +6234,7 @@ async function activateSpeakerEmbedding() {
         }
       });
     });
-    if (ready.pid !== worker2.pid || ready.backend !== "onnxruntime-cpu" || ready.provider !== "CPUExecutionProvider" || ready.model !== MODEL_NAME2 || ready.model_digest !== manifest.modelDigest || ready.dimension !== 512 || !ready.warmed || ready.preprocessing !== FBANK_IMPLEMENTATION || ready.preprocessing_signature !== FBANK_VALIDATION_SIGNATURE) {
+    if (ready.pid !== worker2.pid || ready.backend !== "onnxruntime-cpu" || ready.provider !== "CPUExecutionProvider" || ready.model !== MODEL_NAME2 || ready.model_digest !== manifest.modelDigest || ready.dimension !== 512 || !ready.warmed || ready.preprocessing !== FBANK_IMPLEMENTATION || ready.preprocessing_validation?.validation !== FBANK_VALIDATION) {
       throw new Error("Speaker embedding worker did not report the pinned CPU CAM++ runtime");
     }
     state3.ready = ready;
@@ -6372,7 +6372,7 @@ async function bootstrapSpeakerEmbeddingRuntime() {
   await ensureSpeakerEmbeddingSetup();
   return activateSpeakerEmbedding();
 }
-var RUNTIME_VERSION3, MODEL_NAME2, MODEL_REVISION2, MODEL_FILE, MODEL_URL2, MODEL_SHA2562, ONNXRUNTIME_VERSION, ONNXRUNTIME_WHEEL, ONNXRUNTIME_WHEEL_SHA256, NUMPY_VERSION, NUMPY_WHEEL, NUMPY_WHEEL_SHA256, FBANK_IMPLEMENTATION, FBANK_VALIDATION_SIGNATURE, SETUP_TIMEOUT_MS3, START_TIMEOUT_MS3, EMBED_TIMEOUT_MS2, WESPEAKER_CAMPP_ONNX_SHA256, WESPEAKER_CAMPP_MODEL_REVISION, WESPEAKER_CAMPP_ONNXRUNTIME_VERSION, WESPEAKER_CAMPP_NUMPY_VERSION, WESPEAKER_CAMPP_FBANK_IMPLEMENTATION, WESPEAKER_CAMPP_EMBEDDING_SET_SLUG, SPEAKER_RUNTIME_WHEELS, state3;
+var RUNTIME_VERSION3, MODEL_NAME2, MODEL_REVISION2, MODEL_FILE, MODEL_URL2, MODEL_SHA2562, ONNXRUNTIME_VERSION, ONNXRUNTIME_WHEEL, ONNXRUNTIME_WHEEL_SHA256, NUMPY_VERSION, NUMPY_WHEEL, NUMPY_WHEEL_SHA256, FBANK_IMPLEMENTATION, FBANK_VALIDATION, SETUP_TIMEOUT_MS3, START_TIMEOUT_MS3, EMBED_TIMEOUT_MS2, WESPEAKER_CAMPP_ONNX_SHA256, WESPEAKER_CAMPP_MODEL_REVISION, WESPEAKER_CAMPP_ONNXRUNTIME_VERSION, WESPEAKER_CAMPP_NUMPY_VERSION, WESPEAKER_CAMPP_FBANK_IMPLEMENTATION, WESPEAKER_CAMPP_FBANK_VALIDATION, WESPEAKER_CAMPP_EMBEDDING_SET_SLUG, SPEAKER_RUNTIME_WHEELS, state3;
 var init_speaker_embedding_runtime = __esm({
   "packages/execution/dist/speaker-embedding-runtime.js"() {
     "use strict";
@@ -6380,7 +6380,7 @@ var init_speaker_embedding_runtime = __esm({
     init_process_async();
     init_model_store();
     init_venv_paths();
-    RUNTIME_VERSION3 = 4;
+    RUNTIME_VERSION3 = 5;
     MODEL_NAME2 = "wespeaker-voxceleb-campplus";
     MODEL_REVISION2 = "acf623ad8ca746e50baa432255cf8fc57c669c45";
     MODEL_FILE = "voxceleb_CAM++.onnx";
@@ -6393,7 +6393,7 @@ var init_speaker_embedding_runtime = __esm({
     NUMPY_WHEEL = "https://files.pythonhosted.org/packages/fc/a5/4beee6488160798683eed5bdb7eead455892c3b4e1f78d79d8d3f3b084ac/numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl";
     NUMPY_WHEEL_SHA256 = "d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4";
     FBANK_IMPLEMENTATION = "kaldi-fbank-numpy-v1";
-    FBANK_VALIDATION_SIGNATURE = "sha256:19bb5552b8068d5cd2ccdbb07ac7a7ed1137400d3bdc3c54fb9c21d4f06e16fa";
+    FBANK_VALIDATION = "kaldi-fbank-invariants-v2";
     SETUP_TIMEOUT_MS3 = 10 * 6e4;
     START_TIMEOUT_MS3 = 6e4;
     EMBED_TIMEOUT_MS2 = 45e3;
@@ -6402,6 +6402,7 @@ var init_speaker_embedding_runtime = __esm({
     WESPEAKER_CAMPP_ONNXRUNTIME_VERSION = ONNXRUNTIME_VERSION;
     WESPEAKER_CAMPP_NUMPY_VERSION = NUMPY_VERSION;
     WESPEAKER_CAMPP_FBANK_IMPLEMENTATION = FBANK_IMPLEMENTATION;
+    WESPEAKER_CAMPP_FBANK_VALIDATION = FBANK_VALIDATION;
     WESPEAKER_CAMPP_EMBEDDING_SET_SLUG = "speaker-identity-wespeaker-voxceleb-campplus-acf623ad8ca746e50baa432255cf8fc57c669c45-fbank80-cmn-fullclip-l2";
     SPEAKER_RUNTIME_WHEELS = [
       {
@@ -345916,6 +345917,48 @@ function ocrPythonEnv(extra = {}) {
     ...extra
   };
 }
+function assessAdvancedOcrEvidence(input) {
+  const text3 = String(input.text ?? "").trim();
+  const chars = text3.length;
+  const confidence2 = Number.isFinite(input.confidence) ? input.confidence : 0;
+  const lines = Number.isFinite(input.lines) ? input.lines : 0;
+  if (chars === 0) {
+    return { state: "low_information", accepted: false, reason: "no_readable_text", chars, confidence: confidence2, lines };
+  }
+  const alnum = [...text3].filter((character) => /[\p{L}\p{N}]/u.test(character)).length;
+  const alnumRatio2 = alnum / Math.max(1, chars);
+  if (chars < MIN_SUBSTANTIVE_OCR_CHARS && confidence2 < MIN_ACCEPTED_OCR_CONFIDENCE) {
+    return {
+      state: "low_information",
+      accepted: false,
+      reason: "insufficient_low_confidence_text",
+      chars,
+      confidence: confidence2,
+      lines,
+      alnum_ratio: Number(alnumRatio2.toFixed(3))
+    };
+  }
+  if (chars >= HIGH_VOLUME_GARBAGE_CHARS && confidence2 < HIGH_VOLUME_GARBAGE_CONFIDENCE || confidence2 < MIN_ACCEPTED_OCR_CONFIDENCE || alnumRatio2 < 0.45) {
+    return {
+      state: "rejected",
+      accepted: false,
+      reason: chars >= HIGH_VOLUME_GARBAGE_CHARS && confidence2 < HIGH_VOLUME_GARBAGE_CONFIDENCE ? "high_volume_low_confidence_text" : "low_confidence_or_symbol_heavy_text",
+      chars,
+      confidence: confidence2,
+      lines,
+      alnum_ratio: Number(alnumRatio2.toFixed(3))
+    };
+  }
+  return {
+    state: "accepted",
+    accepted: true,
+    reason: "confidence_and_text_quality_met",
+    chars,
+    confidence: confidence2,
+    lines,
+    alnum_ratio: Number(alnumRatio2.toFixed(3))
+  };
+}
 function ocrDiagnostic(code8, message2, extra = {}) {
   return {
     schema: "omnius.ocr-diagnostic.v1",
@@ -345934,7 +345977,7 @@ function parsePipelineDiagnostic(error) {
     return null;
   }
 }
-var OCR_PIPELINE_TIMEOUT_MS, OCR_PROCESS_DRAIN_MS, 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, OcrImageAdvancedTool;
 var init_ocr_image_advanced = __esm({
   "packages/execution/dist/tools/ocr-image-advanced.js"() {
     "use strict";
@@ -345942,6 +345985,10 @@ var init_ocr_image_advanced = __esm({
     init_ocr_advanced_runtime();
     OCR_PIPELINE_TIMEOUT_MS = 8e4;
     OCR_PROCESS_DRAIN_MS = 3e3;
+    MIN_ACCEPTED_OCR_CONFIDENCE = 50;
+    MIN_SUBSTANTIVE_OCR_CHARS = 12;
+    HIGH_VOLUME_GARBAGE_CHARS = 64;
+    HIGH_VOLUME_GARBAGE_CONFIDENCE = 35;
     OcrImageAdvancedTool = class {
       workingDir;
       name = "ocr_image_advanced";
@@ -346136,7 +346183,8 @@ var init_ocr_image_advanced = __esm({
                 stage: result.diagnostic?.stage ?? "pipeline",
                 deadline_ms: result.diagnostic?.deadline_ms ?? OCR_PIPELINE_TIMEOUT_MS,
                 attempts_completed: result.diagnostic?.attempts_completed ?? null,
-                attempts_planned: result.diagnostic?.attempts_planned ?? null
+                attempts_planned: result.diagnostic?.attempts_planned ?? null,
+                evidence: result.diagnostic?.evidence ?? null
               })
             };
           }
@@ -346160,22 +346208,61 @@ var init_ocr_image_advanced = __esm({
               data: result
             };
           }
+          const boundaryEvidence = assessAdvancedOcrEvidence({
+            text: result.text,
+            confidence: result.confidence,
+            lines: result.lines
+          });
+          if (boundaryEvidence.state === "rejected") {
+            return {
+              success: false,
+              output: "",
+              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
+              })
+            };
+          }
+          const report2 = {
+            ...result,
+            ...boundaryEvidence.state === "low_information" ? { text: "", chars: 0, lines: 0, score: 0 } : {},
+            quality: {
+              ...result.quality ?? {},
+              ...boundaryEvidence,
+              schema: "omnius.ocr-evidence.v1"
+            },
+            ...boundaryEvidence.state === "low_information" && !result.diagnostic ? {
+              diagnostic: {
+                schema: "omnius.ocr-diagnostic.v1",
+                code: "ocr_low_information",
+                message: "OCR produced no accepted readable text; the result is low-information rather than evidence.",
+                stage: "evidence_quality"
+              }
+            } : {}
+          };
           const parts = [];
-          parts.push(`OCR extracted from ${basename11(imagePath)} (${result.image_size})`);
-          parts.push(`Best variant: ${result.variant} (confidence: ${result.confidence}%, ${result.chars} chars, ${result.lines} lines, score: ${result.score})`);
-          parts.push(`Variants tested: ${result.variants_tested}`);
-          if (result.output_files) {
-            const files = result.output_files;
+          parts.push(`OCR extracted from ${basename11(imagePath)} (${report2.image_size})`);
+          if (boundaryEvidence.state === "low_information") {
+            parts.push(`OCR found no accepted readable text (${boundaryEvidence.reason}); low-information result.`);
+          } else {
+            parts.push(`Best variant: ${report2.variant} (confidence: ${report2.confidence}%, ${report2.chars} chars, ${report2.lines} lines, score: ${report2.score})`);
+          }
+          parts.push(`Variants tested: ${report2.variants_tested}`);
+          if (report2.output_files) {
+            const files = report2.output_files;
             const saved = [files.txt, files.csv, files.pdf].filter(Boolean);
             parts.push(`Output files: ${saved.join(", ")}`);
           }
-          parts.push("");
-          parts.push("--- Extracted Text ---");
-          parts.push(result.text);
-          if (result.regions) {
+          if (boundaryEvidence.state === "accepted") {
+            parts.push("");
+            parts.push("--- Extracted Text ---");
+            parts.push(report2.text);
+          }
+          if (report2.regions) {
             parts.push("");
             parts.push("--- Region Extraction ---");
-            for (const [rname, rtext] of Object.entries(result.regions)) {
+            for (const [rname, rtext] of Object.entries(report2.regions)) {
               if (rtext) {
                 parts.push(`
 [${rname.toUpperCase()}]`);
@@ -346183,8 +346270,8 @@ var init_ocr_image_advanced = __esm({
               }
             }
           }
-          if (result.all_variants) {
-            const sorted = Object.entries(result.all_variants).filter(([_, v]) => v.chars > 0).sort((a2, b) => b[1].score - a2[1].score).slice(0, 5);
+          if (report2.all_variants) {
+            const sorted = Object.entries(report2.all_variants).filter(([_, v]) => v.chars > 0).sort((a2, b) => b[1].score - a2[1].score).slice(0, 5);
             if (sorted.length > 1) {
               parts.push("");
               parts.push("--- Top Variants ---");
@@ -346201,7 +346288,7 @@ var init_ocr_image_advanced = __esm({
             success: true,
             output: parts.join("\n"),
             durationMs: performance.now() - start2,
-            data: result
+            data: report2
           };
         } catch (err) {
           const pipelineResult = parsePipelineDiagnostic(err);
@@ -346215,7 +346302,8 @@ var init_ocr_image_advanced = __esm({
                 stage: pipelineResult.diagnostic?.stage ?? "pipeline",
                 deadline_ms: pipelineResult.diagnostic?.deadline_ms ?? OCR_PIPELINE_TIMEOUT_MS,
                 attempts_completed: pipelineResult.diagnostic?.attempts_completed ?? null,
-                attempts_planned: pipelineResult.diagnostic?.attempts_planned ?? null
+                attempts_planned: pipelineResult.diagnostic?.attempts_planned ?? null,
+                evidence: pipelineResult.diagnostic?.evidence ?? null
               })
             };
           }
@@ -616978,6 +617066,7 @@ __export(dist_exports2, {
   VisualTriggerTool: () => VisualTriggerTool,
   WESPEAKER_CAMPP_EMBEDDING_SET_SLUG: () => WESPEAKER_CAMPP_EMBEDDING_SET_SLUG,
   WESPEAKER_CAMPP_FBANK_IMPLEMENTATION: () => WESPEAKER_CAMPP_FBANK_IMPLEMENTATION,
+  WESPEAKER_CAMPP_FBANK_VALIDATION: () => WESPEAKER_CAMPP_FBANK_VALIDATION,
   WESPEAKER_CAMPP_MODEL_REVISION: () => WESPEAKER_CAMPP_MODEL_REVISION,
   WESPEAKER_CAMPP_NUMPY_VERSION: () => WESPEAKER_CAMPP_NUMPY_VERSION,
   WESPEAKER_CAMPP_ONNXRUNTIME_VERSION: () => WESPEAKER_CAMPP_ONNXRUNTIME_VERSION,
@@ -687469,8 +687558,11 @@ import { existsSync as existsSync128, mkdirSync as mkdirSync79, readFileSync as
 import { dirname as dirname51, join as join140 } from "node:path";
 import { homedir as homedir41 } from "node:os";
 import { fileURLToPath as fileURLToPath25 } from "node:url";
+function managedAsrRuntimeRoot() {
+  return process.env["OMNIUS_ASR_RUNTIME_ROOT"]?.trim() || MANAGED_ASR_ROOT;
+}
 function managedAsrStateFile(engineId) {
-  return join140(MANAGED_ASR_ROOT, engineId, "models.json");
+  return join140(managedAsrRuntimeRoot(), engineId, "models.json");
 }
 function managedAsrModelDir(engineId) {
   return join140(MANAGED_ASR_MODEL_ROOT, engineId);
@@ -687483,16 +687575,18 @@ function readManagedAsrState(engineId) {
   }
 }
 function persistManagedAsrReadiness(readiness) {
-  const root = join140(MANAGED_ASR_ROOT, readiness.engineId);
+  const root = join140(managedAsrRuntimeRoot(), readiness.engineId);
   mkdirSync79(root, { recursive: true });
   const state5 = readManagedAsrState(readiness.engineId);
   state5.models ??= {};
   state5.models[readiness.modelId] = {
     installed: readiness.installed,
     weightsReady: readiness.weightsReady,
+    active: readiness.active,
     device: readiness.device,
     lastError: readiness.lastError,
-    pulledAt: readiness.pulledAt
+    pulledAt: readiness.pulledAt,
+    activeAt: readiness.activeAt
   };
   writeFileSync70(managedAsrStateFile(readiness.engineId), `${JSON.stringify(state5, null, 2)}
 `, "utf8");
@@ -687885,17 +687979,34 @@ ${log22.slice(-2e3)}` };
 function getManagedAsrReadiness(engineId, modelId) {
   assertManagedAsrModel(engineId, modelId);
   const saved = readManagedAsrState(engineId).models?.[modelId];
+  const active = saved?.active === true && saved.weightsReady === true && typeof saved.activeAt === "string" && /^cuda(?::\d+)?$/i.test(saved.device ?? "");
   return {
     engineId,
     modelId,
     installed: Boolean(saved?.installed && existsSync128(getVenvPython())),
     weightsReady: Boolean(saved?.weightsReady),
-    active: false,
+    // Managed direct ASR has no resident process. `active` therefore means
+    // this exact model last completed a CUDA inference successfully, not that
+    // a Python child happens to still be alive after a request returned.
+    active,
     device: saved?.device,
     lastError: saved?.lastError,
-    pulledAt: saved?.pulledAt
+    pulledAt: saved?.pulledAt,
+    activeAt: saved?.activeAt
   };
 }
+function recordManagedAsrInference(input, outcome) {
+  const prior = getManagedAsrReadiness(input.engineId, input.modelId);
+  const cuda = typeof input.device === "string" && /^cuda(?::\d+)?$/i.test(input.device);
+  const activeAt = outcome.ok && cuda ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+  persistManagedAsrReadiness({
+    ...prior,
+    device: input.device || prior.device,
+    active: Boolean(activeAt),
+    activeAt,
+    lastError: outcome.ok ? void 0 : outcome.error
+  });
+}
 function ensureManagedAsrModel(input) {
   const engineId = input.engineId.trim().toLowerCase();
   const modelId = input.modelId.trim().toLowerCase();
@@ -688058,12 +688169,16 @@ function transcribeManagedNemotronFile(input) {
   const ready = events.find((event) => event["type"] === "ready");
   const error = events.find((event) => event["type"] === "error");
   if (result.status !== 0 || !transcript) {
-    throw new Error(String(error?.["message"] ?? (`${result.stderr || ""}`.trim() || result.error || "Nemotron file transcription failed")));
+    const message2 = String(error?.["message"] ?? (`${result.stderr || ""}`.trim() || result.error || "Nemotron file transcription failed"));
+    recordManagedAsrInference({ engineId: "nemotron-streaming", modelId, device: existing.device }, { ok: false, error: message2 });
+    throw new Error(message2);
   }
+  const device2 = typeof ready?.["device"] === "string" ? ready["device"] : existing.device;
+  recordManagedAsrInference({ engineId: "nemotron-streaming", modelId, device: device2 }, { ok: true });
   return {
     text: String(transcript["text"] ?? ""),
     duration: Number.isFinite(Number(transcript["audioSeconds"])) ? Number(transcript["audioSeconds"]) : null,
-    device: typeof ready?.["device"] === "string" ? ready["device"] : existing.device,
+    device: device2,
     segments: [],
     warnings: []
   };
@@ -688102,6 +688217,7 @@ function transcribeManagedWhisperFile(input) {
   const payload = [...parseWorkerEvents(`${result.stdout || ""}`)].reverse().find((event) => event["ok"] === true);
   if (result.status !== 0 || !payload) {
     const detail = `${result.stderr || ""}`.trim() || String(result.error ?? "Whisper file transcription failed");
+    recordManagedAsrInference({ engineId: "openai-whisper", modelId, device: existing.device }, { ok: false, error: detail });
     throw new Error(detail);
   }
   const segments = Array.isArray(payload["segments"]) ? payload["segments"].flatMap((segment) => {
@@ -688113,10 +688229,12 @@ function transcribeManagedWhisperFile(input) {
       text: String(value2["text"] ?? "")
     }];
   }) : [];
+  const device2 = typeof payload["device"] === "string" ? payload["device"] : existing.device;
+  recordManagedAsrInference({ engineId: "openai-whisper", modelId, device: device2 }, { ok: true });
   return {
     text: String(payload["text"] ?? ""),
     duration: Number.isFinite(Number(payload["duration"])) ? Number(payload["duration"]) : null,
-    device: typeof payload["device"] === "string" ? payload["device"] : existing.device,
+    device: device2,
     segments,
     warnings: []
   };
@@ -688152,17 +688270,21 @@ function transcribeManagedAsrFile(input) {
     const payload = [...events].reverse().find((event) => event["type"] === "transcript");
     if (result.status !== 0 || !payload) {
       const workerError = [...events].reverse().find((event) => event["type"] === "error");
-      throw new Error(String(workerError?.["message"] ?? result.stderr ?? result.error ?? "Voxtral file transcription failed"));
+      const message2 = String(workerError?.["message"] ?? result.stderr ?? result.error ?? "Voxtral file transcription failed");
+      recordManagedAsrInference({ engineId, modelId, device: existing.device }, { ok: false, error: message2 });
+      throw new Error(message2);
     }
     const segments = Array.isArray(payload["segments"]) ? payload["segments"].flatMap((segment) => {
       if (!segment || typeof segment !== "object") return [];
       const value2 = segment;
       return [{ start: Number(value2["start"] ?? 0), end: Number(value2["end"] ?? 0), text: String(value2["text"] ?? "") }];
     }) : [];
+    const device2 = typeof payload["device"] === "string" ? payload["device"] : existing.device;
+    recordManagedAsrInference({ engineId, modelId, device: device2 }, { ok: true });
     return {
       text: String(payload["text"] ?? ""),
       duration: Number.isFinite(Number(payload["duration"])) ? Number(payload["duration"]) : null,
-      device: existing.device,
+      device: device2,
       segments,
       warnings: []
     };
@@ -792931,6 +793053,7 @@ function getRuntimeStatus() {
   const persisted = _listenEngine ? null : loadGlobalSettings();
   const asrEngineId = _listenEngine?.currentEngine ?? persisted?.asrEngine ?? "openai-whisper";
   const asrModelId = _listenEngine?.currentModel ?? persisted?.asrModel ?? "medium";
+  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 {
     state: _state3,
@@ -792942,9 +793065,9 @@ function getRuntimeStatus() {
     listenPaused: _listenEngine?.isPaused ?? false,
     asrEngineId,
     asrModelId,
-    asrBackend: asrEngineId === "vibevoice-transformers" ? "vibevoice-transformers" : listenState.backend,
-    asrPhase: asrEngineId === "vibevoice-transformers" ? vibePhase : listenState.phase,
-    asrReady: asrEngineId === "vibevoice-transformers" ? vibe.active : Boolean(_listenEngine?.isActive),
+    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),
     micDevice: listenState.micDevice || null,
     micSourceKind: listenState.micSourceKind,
     micSourceChannels: listenState.micSourceChannels,
@@ -793173,6 +793296,7 @@ var init_voice_runtime = __esm({
     init_listen();
     init_dist5();
     init_voicechat();
+    init_py_embed();
     _voiceEngine = null;
     _listenEngine = null;
     _voiceChatSession = null;
@@ -828251,6 +828375,7 @@ function getOpenApiSpec() {
             include_daemon_tools: { type: "array", items: { type: "string", enum: ["read", "run", "admin"] }, description: "Scopes from which Omnius may offer its bounded core daemon-tool catalog. Use daemon_tool_names to request other exact tools." },
             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." },
             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." }
           } } } } },
@@ -828873,7 +828998,7 @@ function getOpenApiSpec() {
         post: {
           summary: "Provision and activate one role-typed audio embedding runtime",
           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", in: "query", required: false, schema: { type: "string", enum: ["acoustic", "speaker", "semantic"] }, description: "Canonical required role selector; JSON body.kind is accepted for compatibility." }],
           requestBody: { required: false, content: { "application/json": { schema: { type: "object", properties: { kind: { type: "string", enum: ["acoustic", "speaker", "semantic"] } } } } } },
           responses: { 200: { description: "Requested role runtime provisioned and warm." }, 202: { description: "Provisioning finished but requested role did not prove warm; poll its health URL." }, 400: { description: "kind is missing or invalid." }, 403: { description: "Admin scope required." }, 500: { description: "Role-specific setup/preflight failed." } }
@@ -830485,6 +830610,32 @@ function getAgentLoopTotalTimeoutMs(body) {
     AGENT_LOOP_TOTAL_TIMEOUT_MAX_MS
   );
 }
+function getAgentLoopPlannerMaxTokens() {
+  return boundedModelCheckInteger(
+    Number(process.env["OMNIUS_AGENT_LOOP_PLANNER_MAX_TOKENS"]),
+    AGENT_LOOP_PLANNER_DEFAULT_MAX_TOKENS,
+    32,
+    512
+  );
+}
+function getAgentLoopMaxToolRounds(body) {
+  const requested = body["agent_max_tool_rounds"];
+  const configured = Number(process.env["OMNIUS_AGENT_LOOP_MAX_TOOL_ROUNDS"]);
+  return boundedModelCheckInteger(
+    requested ?? configured,
+    AGENT_LOOP_MAX_TOOL_ROUNDS_DEFAULT,
+    1,
+    8
+  );
+}
+function getAgentLoopToolResultMaxChars() {
+  return boundedModelCheckInteger(
+    Number(process.env["OMNIUS_AGENT_LOOP_TOOL_RESULT_MAX_CHARS"]),
+    AGENT_LOOP_TOOL_RESULT_DEFAULT_MAX_CHARS,
+    1e3,
+    32e3
+  );
+}
 function compactAgentLoopToolResult(value2) {
   let encoded;
   try {
@@ -830492,11 +830643,12 @@ function compactAgentLoopToolResult(value2) {
   } catch {
     encoded = JSON.stringify({ success: false, error: "tool result was not JSON serializable" });
   }
-  if (encoded.length <= AGENT_LOOP_TOOL_RESULT_MAX_CHARS) return encoded;
+  const maxChars = getAgentLoopToolResultMaxChars();
+  if (encoded.length <= maxChars) return encoded;
   return JSON.stringify({
     truncated: true,
     original_chars: encoded.length,
-    preview: encoded.slice(0, AGENT_LOOP_TOOL_RESULT_MAX_CHARS)
+    preview: encoded.slice(0, maxChars)
   });
 }
 function parseJsonObject8(value2) {
@@ -832987,6 +833139,7 @@ async function runAgentLoopChatCompletions(opts) {
     const targetTransport = requestProviderTransport(targetUrl, route?.endpoint);
     const useNativeOllamaChat = targetTransport.protocol === "ollama";
     const maxTurns = typeof requestBody["max_turns"] === "number" ? Math.max(1, Math.min(64, requestBody["max_turns"])) : 8;
+    const maxDaemonToolRounds = getAgentLoopMaxToolRounds(requestBody);
     const remoteIp = (req3.socket?.remoteAddress || "").replace(/^::ffff:/, "");
     const origin = /^(127\.\d+\.\d+\.\d+|::1|localhost)$/.test(remoteIp) ? "loopback" : "remote";
     const reqAuth = req3;
@@ -833118,6 +833271,7 @@ ${messages2[firstSystemIdx].content}`
     const chatId = `chatcmpl-${randomBytes30(12).toString("hex")}`;
     const turnsLog = [];
     const seenDaemonCalls = /* @__PURE__ */ new Set();
+    let daemonToolRoundsExecuted = 0;
     for (let turn = 1; turn <= maxTurns; turn++) {
       if (isClientDisconnected()) return;
       if (Date.now() > totalDeadline) {
@@ -833142,15 +833296,19 @@ ${messages2[firstSystemIdx].content}`
         return;
       }
       const transportMessages = forceNoThinkForTools ? messages2.map((message3) => typeof message3.content === "string" ? { ...message3, content: stripNoThinkPromptDirectives(message3.content) } : message3) : messages2;
+      const daemonToolsForTurn = daemonToolRoundsExecuted < maxDaemonToolRounds ? daemonToolEntries : [];
+      const toolsForTurn = [...callerTools, ...daemonToolsForTurn];
+      const planningTurn = toolsForTurn.length > 0;
       const ollamaOptions = {};
       if (typeof requestBody["temperature"] === "number") ollamaOptions["temperature"] = requestBody["temperature"];
       if (typeof requestBody["top_p"] === "number") ollamaOptions["top_p"] = requestBody["top_p"];
-      if (typeof requestBody["max_tokens"] === "number") ollamaOptions["num_predict"] = requestBody["max_tokens"];
+      if (planningTurn) ollamaOptions["num_predict"] = getAgentLoopPlannerMaxTokens();
+      else if (typeof requestBody["max_tokens"] === "number") ollamaOptions["num_predict"] = requestBody["max_tokens"];
       if (typeof requestBody["seed"] === "number") ollamaOptions["seed"] = requestBody["seed"];
       const turnBody = useNativeOllamaChat ? {
         model: originalModel,
         messages: agentLoopMessagesForOllama(transportMessages),
-        tools: mergedTools.length > 0 ? mergedTools : void 0,
+        tools: toolsForTurn.length > 0 ? toolsForTurn : void 0,
         stream: false,
         think: false,
         options: ollamaOptions
@@ -833158,7 +833316,8 @@ ${messages2[firstSystemIdx].content}`
         ...requestBody,
         model: originalModel,
         messages: transportMessages,
-        tools: mergedTools.length > 0 ? mergedTools : void 0,
+        tools: toolsForTurn.length > 0 ? toolsForTurn : void 0,
+        ...planningTurn ? { max_tokens: getAgentLoopPlannerMaxTokens() } : {},
         stream: false,
         ...forceNoThinkForTools ? { think: false } : {},
         // Strip our own loop-control fields so they don't confuse the backend
@@ -833166,6 +833325,7 @@ ${messages2[firstSystemIdx].content}`
         include_daemon_tools: void 0,
         daemon_tool_names: void 0,
         agent_timeout_s: void 0,
+        agent_max_tool_rounds: void 0,
         max_turns: void 0,
         timeout_s: void 0,
         realtime: void 0,
@@ -833432,6 +833592,7 @@ ${messages2[firstSystemIdx].content}`
         daemon_executed: executed,
         client_yielded: 0
       });
+      if (executed > 0) daemonToolRoundsExecuted += 1;
     }
     jsonResponse(res, 200, {
       id: chatId,
@@ -837627,7 +837788,10 @@ data: ${JSON.stringify(data)}
         const baseReadiness = engine.id === "vibevoice-transformers" ? vibe : getManagedAsrReadiness(engine.id, selectedModel ?? engine.models[0].id);
         const readiness = {
           ...baseReadiness,
-          active: unavailableReason ? false : baseReadiness.active,
+          // Direct managed ASR is request-scoped rather than a resident child
+          // process. Expose its successful CUDA inference only for the exact
+          // selected engine/model; never promote an unselected model to active.
+          active: unavailableReason ? false : selected && baseReadiness.active,
           disabled: Boolean(unavailableReason),
           ...unavailableReason ? { unavailableReason, lastError: unavailableReason } : {}
         };
@@ -837641,7 +837805,7 @@ data: ${JSON.stringify(data)}
             const modelBaseReadiness = engine.id === "vibevoice-transformers" ? vibe : getManagedAsrReadiness(engine.id, model.id);
             const modelReadiness = {
               ...modelBaseReadiness,
-              active: unavailableReason ? false : modelBaseReadiness.active,
+              active: unavailableReason ? false : selected && model.id === listen.currentModel && modelBaseReadiness.active,
               disabled: Boolean(unavailableReason),
               ...unavailableReason ? { unavailableReason, lastError: unavailableReason } : {}
             };
@@ -837683,9 +837847,11 @@ data: ${JSON.stringify(data)}
         runtimes: listAsrEngines().filter((engine) => engine.id === "openai-whisper" || engine.id === "nemotron-streaming" || engine.id === "voxtral-transformers").flatMap((engine) => engine.models.map((model) => {
           const readiness = getManagedAsrReadiness(engine.id, model.id);
           const unavailableReason = getAsrEngineUnavailableReason(engine.id);
+          const selected = engine.id === listen.currentEngine && model.id === listen.currentModel;
           return {
             ...readiness,
-            active: unavailableReason ? false : readiness.active,
+            active: unavailableReason ? false : selected && readiness.active,
+            selected,
             disabled: Boolean(unavailableReason),
             ...unavailableReason ? { unavailableReason, lastError: unavailableReason } : {}
           };
@@ -841937,7 +842103,7 @@ function setTimerEnabled(name10, enabled2) {
     return false;
   }
 }
-var require4, NEXUS_DIRECTORY_ORIGIN3, NEXUS_SPONSORS_URL3, SERVER_BOOT_IDENTITY, voiceTtsTransactionTail, endpointRegistry, modelRouteMap, endpointUsage, _lastEndpointDiagnostics, BACKEND_TIMEOUT_DEFAULT_MS, BACKEND_TIMEOUT_MAX_MS, AGENT_LOOP_TOTAL_TIMEOUT_DEFAULT_MS, AGENT_LOOP_TOTAL_TIMEOUT_MIN_MS, AGENT_LOOP_TOTAL_TIMEOUT_MAX_MS, AGENT_LOOP_TOOL_TIMEOUT_DEFAULT_MS, AGENT_LOOP_TOOL_TIMEOUT_MAX_MS, AGENT_LOOP_TOOL_RESULT_MAX_CHARS, DEFAULT_AGENT_LOOP_DAEMON_TOOL_NAMES, MODEL_LIST_TIMEOUT_DEFAULT_MS, MODEL_CHECK_TIMEOUT_DEFAULT_MS, MODEL_CHECK_TIMEOUT_MAX_MS, MODEL_CHECK_MAX_TOKENS, cancelledAgentLoopTools, metrics, startedAt, FILE_MIME_BY_EXT, realtimeOllamaFallbackCache, runningProcesses, LOCAL_UI_SESSION_COOKIE, LOCAL_UI_SESSION_TOKEN, perKeyUsage, CRON_MARKER2;
+var require4, NEXUS_DIRECTORY_ORIGIN3, NEXUS_SPONSORS_URL3, SERVER_BOOT_IDENTITY, voiceTtsTransactionTail, endpointRegistry, modelRouteMap, endpointUsage, _lastEndpointDiagnostics, BACKEND_TIMEOUT_DEFAULT_MS, BACKEND_TIMEOUT_MAX_MS, AGENT_LOOP_TOTAL_TIMEOUT_DEFAULT_MS, AGENT_LOOP_TOTAL_TIMEOUT_MIN_MS, AGENT_LOOP_TOTAL_TIMEOUT_MAX_MS, AGENT_LOOP_TOOL_TIMEOUT_DEFAULT_MS, AGENT_LOOP_TOOL_TIMEOUT_MAX_MS, AGENT_LOOP_TOOL_RESULT_DEFAULT_MAX_CHARS, AGENT_LOOP_PLANNER_DEFAULT_MAX_TOKENS, AGENT_LOOP_MAX_TOOL_ROUNDS_DEFAULT, DEFAULT_AGENT_LOOP_DAEMON_TOOL_NAMES, MODEL_LIST_TIMEOUT_DEFAULT_MS, MODEL_CHECK_TIMEOUT_DEFAULT_MS, MODEL_CHECK_TIMEOUT_MAX_MS, MODEL_CHECK_MAX_TOKENS, cancelledAgentLoopTools, metrics, startedAt, FILE_MIME_BY_EXT, realtimeOllamaFallbackCache, runningProcesses, LOCAL_UI_SESSION_COOKIE, LOCAL_UI_SESSION_TOKEN, perKeyUsage, CRON_MARKER2;
 var init_serve = __esm({
   "packages/cli/src/api/serve.ts"() {
     init_config();
@@ -841998,7 +842164,9 @@ var init_serve = __esm({
     AGENT_LOOP_TOTAL_TIMEOUT_MAX_MS = 10 * 60 * 1e3;
     AGENT_LOOP_TOOL_TIMEOUT_DEFAULT_MS = 3e4;
     AGENT_LOOP_TOOL_TIMEOUT_MAX_MS = 12e4;
-    AGENT_LOOP_TOOL_RESULT_MAX_CHARS = 16e3;
+    AGENT_LOOP_TOOL_RESULT_DEFAULT_MAX_CHARS = 6e3;
+    AGENT_LOOP_PLANNER_DEFAULT_MAX_TOKENS = 96;
+    AGENT_LOOP_MAX_TOOL_ROUNDS_DEFAULT = 1;
     DEFAULT_AGENT_LOOP_DAEMON_TOOL_NAMES = /* @__PURE__ */ new Set([
       "web_search",
       "web_fetch",

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

@@ -180,6 +180,10 @@ MEDIUM_IMAGE_AREA_PX = 2_000_000
 MAX_PIPELINE_DEADLINE_MS = 80_000
 MAX_TESSERACT_ATTEMPT_SECONDS = 12.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
 ACTIVE_DEADLINE = None
 
 
@@ -273,14 +277,69 @@ 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 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 +378,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
 
 
 # ---------------------------------------------------------------------------
@@ -420,15 +480,17 @@ 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):
@@ -467,10 +529,66 @@ def run_pipeline(image_path, deadline, language="eng", do_regions=False, debug_d
         )
         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,
+                    },
+                }
+            # 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,
+                    "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,7 +598,18 @@ 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),

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,13 @@
                       "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."
+                    },
                     "max_turns": {
                       "type": "integer",
                       "description": "Q2 — agent_loop max iterations (default 8, max 64)."

package/docs/rest/endpoints/chat.md

@@ -46,6 +46,7 @@ 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 |
 | `max_turns` | integer | Server-side agent loop turn cap |
 | `prompt_template` | string | Optional template such as `factual-first` |
 
@@ -129,4 +130,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. 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`.

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

@@ -135,6 +135,13 @@ return diagnostics. A timeout or cancellation returns
 `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 +277,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.641",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.640",
+      "version": "1.0.641",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

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