omnius 1.0.633 → 1.0.634

package/dist/memory-maintenance-worker.js

@@ -340,6 +340,107 @@ function runMigrations(db) {
     CREATE INDEX IF NOT EXISTS idx_memory_embedding_v2_set
       ON memory_embedding_v2 (embedding_set_id);
 
+    -- Role-isolated audio observations and embeddings.  These intentionally
+    -- do not reuse episodes.embedding or memory_embedding_v2: speaker
+    -- identity, acoustic features, and sound semantics are incomparable
+    -- vector spaces even when their dimensions happen to match.
+    CREATE TABLE IF NOT EXISTS audio_observation (
+      id                      TEXT    PRIMARY KEY,
+      episode_id              TEXT    NOT NULL DEFAULT '',
+      asset_digest            TEXT    NOT NULL,
+      source_uri              TEXT    NOT NULL DEFAULT '',
+      start_ms                INTEGER NOT NULL DEFAULT 0,
+      end_ms                  INTEGER NOT NULL DEFAULT 0,
+      channel                 INTEGER NOT NULL DEFAULT 0,
+      sample_rate_hz          INTEGER NOT NULL DEFAULT 0,
+      diarization_cluster_id  TEXT    NOT NULL DEFAULT '',
+      observed_at             TEXT,
+      quality_json            TEXT    NOT NULL DEFAULT '{}',
+      metadata_json           TEXT    NOT NULL DEFAULT '{}',
+      provenance_json         TEXT    NOT NULL DEFAULT '{}',
+      created_at              TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at              TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      CHECK (start_ms >= 0),
+      CHECK (end_ms >= start_ms),
+      CHECK (channel >= 0),
+      CHECK (sample_rate_hz >= 0),
+      UNIQUE(episode_id, asset_digest, start_ms, end_ms, channel, sample_rate_hz, diarization_cluster_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audio_observation_episode
+      ON audio_observation (episode_id);
+    CREATE INDEX IF NOT EXISTS idx_audio_observation_asset
+      ON audio_observation (asset_digest);
+    CREATE INDEX IF NOT EXISTS idx_audio_observation_diarization
+      ON audio_observation (diarization_cluster_id);
+
+    CREATE TABLE IF NOT EXISTS audio_observation_embedding (
+      id                  TEXT    PRIMARY KEY,
+      observation_id      TEXT    NOT NULL REFERENCES audio_observation(id) ON DELETE CASCADE,
+      role                TEXT    NOT NULL,
+      embedding_set_slug  TEXT    NOT NULL,
+      model               TEXT    NOT NULL,
+      model_revision      TEXT    NOT NULL,
+      model_digest        TEXT    NOT NULL,
+      vector              BLOB    NOT NULL,
+      dimensions          INTEGER NOT NULL,
+      normalization       TEXT    NOT NULL DEFAULT '',
+      input_digest        TEXT    NOT NULL,
+      quality_json        TEXT    NOT NULL DEFAULT '{}',
+      metadata_json       TEXT    NOT NULL DEFAULT '{}',
+      provenance_json     TEXT    NOT NULL DEFAULT '{}',
+      created_at          TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at          TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      CHECK (role IN ('speaker_identity_embedding', 'sound_acoustic_embedding', 'sound_semantic_embedding')),
+      CHECK (dimensions > 0),
+      UNIQUE(observation_id, role, embedding_set_slug, model, model_revision, model_digest, input_digest)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_audio_observation_embedding_role_set
+      ON audio_observation_embedding (role, embedding_set_slug, dimensions);
+    CREATE INDEX IF NOT EXISTS idx_audio_observation_embedding_observation
+      ON audio_observation_embedding (observation_id);
+
+    -- Durable speaker identities are consent-gated profiles over only
+    -- speaker_identity_embedding exemplars. These tables intentionally do not
+    -- create temporal-graph edges: sender IDs and diarization labels are never
+    -- biometric proof and must not silently become voice_sample_of evidence.
+    CREATE TABLE IF NOT EXISTS speaker_identity_profile (
+      id                  TEXT    PRIMARY KEY,
+      scope_id            TEXT    NOT NULL,
+      identity            TEXT    NOT NULL,
+      identity_key        TEXT    NOT NULL,
+      embedding_set_slug  TEXT    NOT NULL,
+      model               TEXT    NOT NULL,
+      model_revision      TEXT    NOT NULL,
+      model_digest        TEXT    NOT NULL,
+      dimensions          INTEGER NOT NULL,
+      normalization       TEXT    NOT NULL,
+      centroid            BLOB    NOT NULL,
+      consent_json        TEXT    NOT NULL,
+      created_at          TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      updated_at          TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      CHECK (dimensions > 0),
+      CHECK (normalization = 'l2'),
+      UNIQUE(scope_id, identity_key, embedding_set_slug, model, model_revision, model_digest, dimensions, normalization)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_speaker_identity_profile_exact_space
+      ON speaker_identity_profile (scope_id, embedding_set_slug, model, model_revision, model_digest, dimensions, normalization);
+
+    CREATE TABLE IF NOT EXISTS speaker_identity_exemplar (
+      profile_id          TEXT    NOT NULL REFERENCES speaker_identity_profile(id) ON DELETE CASCADE,
+      audio_embedding_id  TEXT    NOT NULL REFERENCES audio_observation_embedding(id) ON DELETE RESTRICT,
+      observation_id      TEXT    NOT NULL REFERENCES audio_observation(id) ON DELETE RESTRICT,
+      consent_json        TEXT    NOT NULL,
+      created_at          TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+      PRIMARY KEY(profile_id, audio_embedding_id),
+      UNIQUE(audio_embedding_id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_speaker_identity_exemplar_profile
+      ON speaker_identity_exemplar (profile_id, created_at);
+
     CREATE TABLE IF NOT EXISTS memory_link_v2 (
       id              TEXT    PRIMARY KEY,
       source_item_id  TEXT    NOT NULL REFERENCES memory_item(id) ON DELETE CASCADE,
@@ -1605,6 +1706,21 @@ var EpisodeStore = class {
   }
 };
 
+// packages/memory/dist/audioNoveltyPrototype.js
+var AUDIO_NOVELTY_WEIGHTS = Object.freeze({
+  distance: 0.6,
+  uncertainty: 0.1,
+  recurrence: 0.15,
+  direction: 0.075,
+  scene: 0.075
+});
+
+// packages/memory/dist/speakerIdentityStore.js
+var DEFAULT_THRESHOLDS = Object.freeze({
+  provisional: 0.78,
+  ambiguityMargin: 0.04
+});
+
 // packages/memory/dist/crl/index.js
 var CRL_SYMBOLS = {
   // Logical operators (Core)

package/dist/scripts/audio-clap-semantic-worker.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Persistent, offline CLAP semantic-audio embedding worker.
+
+This process deliberately has no setup behavior.  The Node runtime has already
+created the system-site venv, installed its pinned non-Torch requirements, and
+verified the immutable model artifact before this process is started.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+import time
+import wave
+
+if os.environ.get("HF_HUB_OFFLINE") != "1" or os.environ.get("TRANSFORMERS_OFFLINE") != "1":
+    raise RuntimeError("CLAP worker must be started with offline model access enabled")
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from transformers import ClapModel, ClapProcessor
+
+MODEL_ID = "laion/clap-htsat-unfused"
+# The worker receives exactly Egg's caller-conditioned audio window.  It does
+# not decode arbitrary media, downmix, trim, or otherwise silently redefine
+# the observation that will later be persisted.
+SOURCE_SAMPLE_RATE_HZ = 16000
+MAX_SOURCE_SAMPLES = 96000
+SAMPLE_RATE_HZ = 48000
+MAX_SAMPLES = 288000
+EMBEDDING_DIMENSION = 512
+
+
+def json_line(value):
+    print(json.dumps(value, separators=(",", ":")), flush=True)
+
+
+def sha256_file(path):
+    digest = hashlib.sha256()
+    with open(path, "rb") as source:
+        while True:
+            block = source.read(1024 * 1024)
+            if not block:
+                break
+            digest.update(block)
+    return "sha256:" + digest.hexdigest()
+
+
+def read_pcm_wav(path):
+    with wave.open(path, "rb") as handle:
+        if handle.getcomptype() != "NONE":
+            raise ValueError("Expected caller-conditioned uncompressed mono PCM16/16 kHz WAV")
+        channels = handle.getnchannels()
+        width = handle.getsampwidth()
+        sample_rate = handle.getframerate()
+        frames = handle.readframes(handle.getnframes())
+    if channels != 1 or width != 2 or sample_rate != SOURCE_SAMPLE_RATE_HZ:
+        raise ValueError("Expected caller-conditioned mono PCM16/16 kHz WAV")
+    if not frames or len(frames) % 2:
+        raise ValueError("WAV contains no complete PCM16 samples")
+    if len(frames) // 2 > MAX_SOURCE_SAMPLES:
+        raise ValueError("Expected caller-conditioned WAV of at most 6 seconds")
+    # The digest is the exact PCM window actually consumed, not mutable RIFF
+    # metadata such as timestamp, comment, or chunk ordering.
+    input_digest = "sha256:" + hashlib.sha256(frames).hexdigest()
+    return np.frombuffer(frames, dtype="<i2").astype(np.float32) / 32768.0, input_digest
+
+
+def resample_conditioned_16k_to_48k(samples):
+    # SOURCE_SAMPLE_RATE_HZ divides CLAP's rate exactly. Linear interpolation
+    # keeps preprocessing explicit and deterministic without adding another
+    # resampling dependency to JetPack's pinned venv.
+    target_count = samples.size * 3
+    old = np.arange(samples.size, dtype=np.float64)
+    new = np.linspace(0, max(0, samples.size - 1), target_count, dtype=np.float64)
+    return np.interp(new, old, samples).astype(np.float32)
+
+
+class ClapSemanticWorker:
+    def __init__(self, model_dir, model_digest, model_revision):
+        actual = sha256_file(os.path.join(model_dir, "pytorch_model.bin"))
+        if actual != model_digest:
+            raise RuntimeError("CLAP weight digest mismatch: expected %s, got %s" % (model_digest, actual))
+        self.model_digest = model_digest
+        self.model_revision = model_revision
+        self.device = torch.device("cuda:0")
+        if not torch.cuda.is_available():
+            raise RuntimeError("JetPack CUDA Torch is unavailable")
+        if torch.cuda.get_device_capability(0) != (8, 7) or not str(torch.version.cuda or "").startswith("12.2"):
+            raise RuntimeError("CLAP requires the preflighted JetPack Orin CUDA:0 (CC 8.7 / CUDA 12.2)")
+        self.processor = ClapProcessor.from_pretrained(model_dir, local_files_only=True)
+        self.model = ClapModel.from_pretrained(model_dir, local_files_only=True).to(self.device).eval()
+        if getattr(self.model.config, "projection_dim", None) != EMBEDDING_DIMENSION:
+            raise RuntimeError("Pinned CLAP model did not expose a 512-dimensional projection")
+        self._warm()
+
+    def _features(self, samples):
+        encoded = self.processor(audios=samples, sampling_rate=SAMPLE_RATE_HZ, return_tensors="pt")
+        encoded = {key: value.to(self.device) for key, value in encoded.items() if isinstance(value, torch.Tensor)}
+        with torch.inference_mode():
+            output = self.model.get_audio_features(**encoded)
+            output = F.normalize(output.float(), p=2, dim=-1)
+        vector = output[0].detach().cpu().numpy().astype(np.float32)
+        if vector.shape != (EMBEDDING_DIMENSION,) or not np.isfinite(vector).all():
+            raise RuntimeError("CLAP did not return one finite 512-dimensional vector")
+        return vector
+
+    def _warm(self):
+        self._features(np.zeros(MAX_SAMPLES, dtype=np.float32))
+        torch.cuda.synchronize(self.device)
+
+    def embed(self, path):
+        started = time.perf_counter()
+        samples, input_digest = read_pcm_wav(path)
+        decode_ms = (time.perf_counter() - started) * 1000
+        source_duration_seconds = samples.size / SOURCE_SAMPLE_RATE_HZ
+        samples = resample_conditioned_16k_to_48k(samples)
+        rms = float(np.sqrt(np.mean(np.square(samples))))
+        peak = float(np.max(np.abs(samples)))
+        duration_seconds = source_duration_seconds
+        common = {
+            "sample_rate_hz": SOURCE_SAMPLE_RATE_HZ,
+            "semantic_sample_rate_hz": SAMPLE_RATE_HZ,
+            "duration_seconds": duration_seconds,
+            "input_digest": input_digest,
+            "acoustic": {"rms": rms, "peak": peak},
+            "timings_ms": {"decode": decode_ms, "inference": 0.0},
+        }
+        if rms < 0.0005 and peak < 0.002:
+            return dict(common, low_information=True, embedding=None, segment_count=0)
+        inference_started = time.perf_counter()
+        vectors = []
+        # The contract bounds inputs to six seconds, so one explicit 48 kHz
+        # window is embedded; semantic segment pooling is kept in the schema
+        # for model-set compatibility, not used to hide arbitrary long input.
+        vectors.append(self._features(samples))
+        vector = np.mean(np.stack(vectors), axis=0)
+        vector /= max(float(np.linalg.norm(vector)), 1e-12)
+        inference_ms = (time.perf_counter() - inference_started) * 1000
+        return dict(common,
+            low_information=False,
+            segment_count=len(vectors),
+            embedding={"dimension": EMBEDDING_DIMENSION, "pooling": "segment_mean_l2", "dtype": "float32", "normalization": "l2", "values": vector.tolist()},
+            timings_ms={"decode": decode_ms, "inference": inference_ms},
+        )
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", required=True)
+    parser.add_argument("--model-digest", required=True)
+    parser.add_argument("--model-revision", required=True)
+    args = parser.parse_args()
+    worker = ClapSemanticWorker(args.model_dir, args.model_digest, args.model_revision)
+    capability = torch.cuda.get_device_capability(0)
+    json_line({"type": "ready", "pid": os.getpid(), "backend": "transformers-clap", "device": torch.cuda.get_device_name(0), "cuda_visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES", ""), "compute_capability": "%d.%d" % capability, "torch_cuda_version": str(torch.version.cuda), "model": MODEL_ID, "model_revision": args.model_revision, "model_digest": args.model_digest, "embedding_dimension": EMBEDDING_DIMENSION, "sample_rate_hz": SAMPLE_RATE_HZ, "warmed": True})
+    for line in sys.stdin:
+        try:
+            request = json.loads(line)
+            if request.get("type") != "embed" or not isinstance(request.get("id"), str) or not isinstance(request.get("file"), str):
+                raise ValueError("Expected an embed request with id and file")
+            result = worker.embed(request["file"])
+            json_line(dict(result, type="result", id=request["id"], action="embed", success=True))
+        except Exception as error:
+            json_line({"type": "result", "id": request.get("id") if "request" in locals() and isinstance(request, dict) else "", "action": "embed", "success": False, "error": str(error)})
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Persistent CPU-only WeSpeaker CAM++ speaker-identity embedding worker.
+
+This process accepts only caller-owned, already-conditioned mono PCM16/16 kHz
+WAV paths.  It never records audio, installs dependencies, downloads models,
+or enables CUDA.  The parent runtime checksums the pinned ONNX artifact before
+this worker can start.
+
+The fbank path is deliberately the official WeSpeaker ONNX preprocessing:
+torchaudio.compliance.kaldi.fbank with 80 bins, 25 ms / 10 ms Hamming frames,
+dither=0 and utterance CMN (without CVN).
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+import time
+import traceback
+import wave
+
+
+# Set before importing Torch or ONNX Runtime so a globally configured Jetson
+# CUDA device cannot become an accidental provider for speaker embeddings.
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+MODEL_NAME = "wespeaker-voxceleb-campplus"
+SAMPLE_RATE = 16000
+EMBEDDING_DIMENSION = 512
+MIN_DURATION_SECONDS = 1.5
+MAX_DURATION_SECONDS = 30.0
+MIN_RMS = 0.003
+MIN_PEAK = 0.01
+MAX_CLIPPED_FRACTION = 0.01
+
+
+def emit(payload: dict) -> None:
+    sys.stdout.write(json.dumps(payload, separators=(",", ":")) + "\n")
+    sys.stdout.flush()
+
+
+def fail(message: str) -> None:
+    emit({"type": "fatal", "error": message})
+    raise RuntimeError(message)
+
+
+def read_pcm16_16khz_wav(path: str, np):
+    started = time.perf_counter()
+    with wave.open(path, "rb") as reader:
+        channels = reader.getnchannels()
+        sample_width = reader.getsampwidth()
+        sample_rate = reader.getframerate()
+        frames = reader.getnframes()
+        compression = reader.getcomptype()
+        raw = reader.readframes(frames)
+    if compression != "NONE":
+        raise RuntimeError("Only uncompressed RIFF/WAV input is supported")
+    if channels != 1:
+        raise RuntimeError(f"Expected mono WAV from the caller, received {channels} channels")
+    if sample_width != 2:
+        raise RuntimeError(f"Expected PCM16 WAV from the caller, received {sample_width * 8}-bit samples")
+    if sample_rate != SAMPLE_RATE:
+        raise RuntimeError(f"Expected 16 kHz WAV from the caller, received {sample_rate} Hz")
+    samples = np.frombuffer(raw, dtype="<i2").astype(np.float32) / 32768.0
+    if samples.size > int(MAX_DURATION_SECONDS * SAMPLE_RATE):
+        raise RuntimeError(
+            f"Expected at most {MAX_DURATION_SECONDS:.0f} seconds of caller-conditioned speech, received {samples.size / sample_rate:.3f} seconds"
+        )
+    return (
+        samples,
+        sample_rate,
+        "sha256:" + hashlib.sha256(raw).hexdigest(),
+        (time.perf_counter() - started) * 1000,
+    )
+
+
+def acoustic_metrics(samples, np):
+    if samples.size == 0:
+        return {"rms": 0.0, "peak": 0.0, "clipped_fraction": 0.0}
+    absolute = np.abs(samples)
+    return {
+        "rms": float(np.sqrt(np.mean(np.square(samples)))),
+        "peak": float(np.max(absolute)),
+        "clipped_fraction": float(np.mean(absolute >= 0.999)),
+    }
+
+
+def quality_gate(samples, metrics):
+    duration = samples.size / SAMPLE_RATE
+    if duration < MIN_DURATION_SECONDS:
+        return "insufficient_duration"
+    if metrics["rms"] < MIN_RMS or metrics["peak"] < MIN_PEAK:
+        return "low_energy"
+    if metrics["clipped_fraction"] > MAX_CLIPPED_FRACTION:
+        return "clipped"
+    return "usable"
+
+
+class WeSpeakerCamPlus:
+    def __init__(self, model_path: str):
+        started = time.perf_counter()
+        import numpy as np
+        import onnxruntime as ort
+        import torch
+        from torchaudio.compliance import kaldi
+
+        self.np = np
+        self.torch = torch
+        self.kaldi = kaldi
+        torch.set_num_threads(1)
+        options = ort.SessionOptions()
+        options.inter_op_num_threads = 1
+        options.intra_op_num_threads = 1
+        self.session = ort.InferenceSession(
+            model_path,
+            sess_options=options,
+            providers=["CPUExecutionProvider"],
+        )
+        providers = self.session.get_providers()
+        if providers != ["CPUExecutionProvider"]:
+            raise RuntimeError(f"WeSpeaker must run only on CPUExecutionProvider, got {providers}")
+        inputs = self.session.get_inputs()
+        outputs = self.session.get_outputs()
+        if len(inputs) != 1 or inputs[0].name != "feats" or inputs[0].type != "tensor(float)":
+            raise RuntimeError("Pinned CAM++ ONNX model must expose float input 'feats'")
+        if len(inputs[0].shape) != 3 or inputs[0].shape[-1] != 80:
+            raise RuntimeError(f"Pinned CAM++ input must be [batch, frames, 80], got {inputs[0].shape}")
+        if len(outputs) != 1 or outputs[0].name != "embs" or outputs[0].type != "tensor(float)":
+            raise RuntimeError("Pinned CAM++ ONNX model must expose float output 'embs'")
+        if len(outputs[0].shape) != 2 or outputs[0].shape[-1] != EMBEDDING_DIMENSION:
+            raise RuntimeError(f"Pinned CAM++ output must be [batch, {EMBEDDING_DIMENSION}], got {outputs[0].shape}")
+        self.model_load_ms = (time.perf_counter() - started) * 1000
+
+    def features(self, samples):
+        # Mirrors wespeaker/bin/infer_onnx.py exactly. Its torchaudio.load
+        # values are normalized PCM16 floats and multiplied by 2**15 before
+        # Kaldi fbank; samples are decoded PCM16 values in that same range.
+        waveform = self.torch.from_numpy(
+            self.np.ascontiguousarray(samples * (1 << 15), dtype=self.np.float32)
+        ).unsqueeze(0)
+        mat = self.kaldi.fbank(
+            waveform,
+            num_mel_bins=80,
+            frame_length=25,
+            frame_shift=10,
+            dither=0.0,
+            sample_frequency=SAMPLE_RATE,
+            window_type="hamming",
+            use_energy=False,
+        )
+        if mat.ndim != 2 or mat.shape[0] < 1 or mat.shape[1] != 80:
+            raise RuntimeError(f"Official WeSpeaker fbank produced an invalid shape: {tuple(mat.shape)}")
+        # CMN without CVN, over the full input utterance, per official script.
+        mat = mat - self.torch.mean(mat, dim=0)
+        return mat.unsqueeze(0).detach().cpu().numpy().astype(self.np.float32, copy=False)
+
+    def embed(self, samples):
+        started = time.perf_counter()
+        features = self.features(samples)
+        output = self.session.run(["embs"], {"feats": features})[0]
+        vector = self.np.asarray(output, dtype=self.np.float32)
+        if vector.shape != (1, EMBEDDING_DIMENSION):
+            raise RuntimeError(f"CAM++ produced invalid embedding shape: {vector.shape}")
+        vector = vector[0]
+        norm = float(self.np.linalg.norm(vector))
+        if not self.np.isfinite(norm) or norm <= 0.0:
+            raise RuntimeError("CAM++ embedding has an invalid L2 norm")
+        return {
+            "dimension": EMBEDDING_DIMENSION,
+            "dtype": "float32",
+            "normalization": "l2",
+            "values": (vector / norm).astype(self.np.float32).tolist(),
+        }, (time.perf_counter() - started) * 1000
+
+    def warm(self):
+        # A deterministic voiced-like probe validates the official fbank and
+        # the CPU session before readiness is published. It is not user audio.
+        t = self.np.arange(SAMPLE_RATE * 2, dtype=self.np.float32) / SAMPLE_RATE
+        samples = (0.1 * self.np.sin(2.0 * self.np.pi * 220.0 * t)).astype(self.np.float32)
+        embedding, _ = self.embed(samples)
+        if len(embedding["values"]) != EMBEDDING_DIMENSION:
+            raise RuntimeError("CAM++ warmup did not produce a 512-dimensional embedding")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", required=True)
+    parser.add_argument("--model-digest", required=True)
+    args = parser.parse_args()
+    worker = WeSpeakerCamPlus(args.model)
+    worker.warm()
+    emit(
+        {
+            "type": "ready",
+            "pid": os.getpid(),
+            "backend": "onnxruntime-cpu",
+            "provider": "CPUExecutionProvider",
+            "model": MODEL_NAME,
+            "model_digest": args.model_digest,
+            "dimension": EMBEDDING_DIMENSION,
+            "model_load_ms": round(worker.model_load_ms, 3),
+            "warmed": True,
+        }
+    )
+    for line in sys.stdin:
+        request = None
+        action = ""
+        try:
+            request = json.loads(line)
+            if request.get("type") == "shutdown":
+                emit({"type": "stopped"})
+                return 0
+            action = str(request.get("type") or "").strip().lower()
+            if action != "embed":
+                raise RuntimeError("unknown speaker embedding action")
+            request_id = str(request.get("id") or "")
+            file_path = str(request.get("file") or "")
+            if not request_id or not file_path:
+                raise RuntimeError("speaker embedding requires id and file")
+            samples, sample_rate, input_digest, decode_ms = read_pcm16_16khz_wav(file_path, worker.np)
+            metrics = acoustic_metrics(samples, worker.np)
+            quality = quality_gate(samples, metrics)
+            if quality == "usable":
+                embedding, inference_ms = worker.embed(samples)
+            else:
+                embedding, inference_ms = None, 0.0
+            emit(
+                {
+                    "type": "result",
+                    "id": request_id,
+                    "action": "embed",
+                    "success": True,
+                    "sample_rate_hz": sample_rate,
+                    "input_digest": input_digest,
+                    "duration_seconds": round(float(samples.size) / sample_rate, 6),
+                    "quality": quality,
+                    "embedding": embedding,
+                    "acoustic": {key: round(value, 8) for key, value in metrics.items()},
+                    "timings_ms": {"decode": round(decode_ms, 3), "inference": round(inference_ms, 3)},
+                }
+            )
+        except Exception as exc:  # Keep the persistent worker alive per request.
+            emit(
+                {
+                    "type": "result",
+                    "id": str(request.get("id", "")) if isinstance(request, dict) else "",
+                    "action": action,
+                    "success": False,
+                    "error": str(exc),
+                }
+            )
+            print(traceback.format_exc(), file=sys.stderr, flush=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())