Add local spoken passages with Google retrieval and isolated runtime setup

2026-10-13 20:18:44 +02:00
1 parent bc9459785d
commit dab703413e
@@ -26,3 +26,8 @@ __pycache__/
 /apps/desktop/src-tauri/resources/extraction-worker.json

 /apps/desktop/src-tauri/resources/*.so*
+/apps/desktop/src-tauri/resources/speech-runtime/
+/apps/desktop/src-tauri/resources/.searchi-stage.lock
+/apps/desktop/src-tauri/resources/.searchi-stage.json
+/apps/desktop/src-tauri/resources/.resources.stage-*/
+/apps/desktop/src-tauri/resources/.resources.backup-*/
@@ -2251,6 +2251,7 @@ dependencies = [
 "searchi-assets",
 "searchi-core",
 "searchi-service",
+ "searchi-speech",
 "serde",
 "serde_json",
 "tempfile",
@@ -2328,6 +2329,7 @@ dependencies = [
 "searchi-core",
 "searchi-media",
 "searchi-semantic",
+ "searchi-speech",
 "serde",
 "serde_json",
 "sha2 0.10.9",
@@ -2335,6 +2337,16 @@ dependencies = [
 "usearch",
 ]

+[[package]]
+name = "searchi-speech"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -1,5 +1,5 @@
 [workspace]
-members = ["crates/searchi-core", "crates/searchi-cli", "crates/searchi-semantic", "crates/searchi-service", "crates/searchi-assets", "crates/searchi-media", "crates/searchi-ai", "crates/searchi-extract-worker"]
+members = ["crates/searchi-core", "crates/searchi-cli", "crates/searchi-semantic", "crates/searchi-service", "crates/searchi-assets", "crates/searchi-media", "crates/searchi-ai", "crates/searchi-extract-worker", "crates/searchi-speech"]
 resolver = "2"

 [workspace.package]
@@ -3809,6 +3809,7 @@ dependencies = [
 "searchi-core",
 "searchi-media",
 "searchi-service",
+ "searchi-speech",
 "serde",
 "serde_json",
 "sha2 0.10.9",
@@ -3859,11 +3860,22 @@ dependencies = [
 "searchi-core",
 "searchi-media",
 "searchi-semantic",
+ "searchi-speech",
 "serde",
 "sha2 0.10.9",
 "usearch",
 ]

+[[package]]
+name = "searchi-speech"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+]
+
 [[package]]
 name = "selectors"
 version = "0.38.0"
@@ -26,6 +26,7 @@ sha2 = "0.10"
 tempfile = "3"
 searchi-core = { path = "../../../crates/searchi-core" }
 searchi-service = { path = "../../../crates/searchi-service" }
+searchi-speech = { path = "../../../crates/searchi-speech" }
 searchi-assets = { path = "../../../crates/searchi-assets" }
 searchi-media = { path = "../../../crates/searchi-media" }
 searchi-ai = { path = "../../../crates/searchi-ai" }
@@ -11,6 +11,7 @@ mod media_preview;
 mod model_download;
 mod semantic_commands;
 mod settings;
+mod speech_setup;
 mod watching;

 use ai_commands::{generate_ai, prepare_ai_source, AiSession};
@@ -650,7 +651,18 @@ fn main() {
                    "The media decoder is missing from this installation. Repair or reinstall searchi.".into()
                })
            })();
+            let speech_worker = std::env::var_os("SEARCHI_SPEECH_WORKER").map(PathBuf::from).unwrap_or_else(|| {
+                            let backend = if std::env::var("SEARCHI_FORCE_CPU").as_deref() == Ok("1") { "cpu" } else { "auto" };
+                            let mut development = development_root.join(".searchi/speech-runtime").join(backend);
+                            if cfg!(windows) { development = development.join("Release"); }
+                            let name = if cfg!(windows) { "searchi-speech-worker.exe" } else { "searchi-speech-worker" };
+                            let development = development.join(name);
+                            if cfg!(debug_assertions) && development.is_file() { development } else {
+                                app.path().resource_dir().unwrap_or_else(|_| directory.clone()).join("speech-runtime").join(name)
+                            }
+                        });
            let mut ignored = vec![directory.clone(), model_directory.clone()];
+            if let Some(parent) = speech_worker.parent().filter(|path| path.is_absolute()) { ignored.push(parent.to_path_buf()); }
            if let Some(parent) = worker.parent().filter(|path| path.is_absolute()) {
                ignored.push(parent.to_path_buf());
            }
@@ -667,7 +679,9 @@ fn main() {
            ).map_err(std::io::Error::other)?);
            let semantic = Arc::new(
                SemanticState::new(model_directory, worker, media_tools)
-                    .with_media_scratch(directory.join("MediaScratch")),
+                    .with_media_scratch(directory.join("MediaScratch"))
+                    .with_speech_assets(
+speech_worker, directory.join("SpeechModels")),
            );
            semantic.begin_automatic_setup(database.clone(), settings.value.cpu_threads);
            #[cfg(target_os = "macos")]
@@ -18,6 +18,7 @@ use tauri::State;
 pub struct SemanticState {
    pub model_directory: PathBuf,
    pub worker: PathBuf,
+    speech: std::sync::Arc<crate::speech_setup::SpeechSetup>,
    verified: AtomicBool,
    text_verified: AtomicBool,
    media_verified: AtomicBool,
@@ -48,7 +49,23 @@ impl SemanticState {
            Ok(tools) => (Some(tools), None),
            Err(error) => (None, Some(error)),
        };
+        let speech = crate::speech_setup::SpeechSetup::new(
+            worker
+                .parent()
+                .unwrap_or_else(|| std::path::Path::new("."))
+                .join("speech-runtime")
+                .join(if cfg!(windows) {
+                    "searchi-speech-worker.exe"
+                } else {
+                    "searchi-speech-worker"
+                }),
+            model_directory
+                .parent()
+                .unwrap_or_else(|| std::path::Path::new("."))
+                .join("speech"),
+        );
        Self {
+            speech,
            model_directory,
            worker,
            verified: AtomicBool::new(false),
@@ -72,6 +89,11 @@ impl SemanticState {
        }
    }

+    pub fn with_speech_assets(mut self, worker: PathBuf, models: PathBuf) -> Self {
+        self.speech = crate::speech_setup::SpeechSetup::new(worker, models);
+        self
+    }
+
    /// Keep generated video frames below the application's excluded data tree.
    pub fn with_media_scratch(mut self, directory: PathBuf) -> Self {
        self.media_limits.scratch_directory = Some(directory);
@@ -222,7 +244,12 @@ impl SemanticState {
            })
            .unwrap_or(Ok(()));
        self.warming.store(false, Ordering::Release);
-        self.finish_setup(provision, prepared)
+        let result = self.finish_setup(provision, prepared);
+        if result.is_ok() {
+            self.speech
+                .start(self.inference_budget.clone(), self.media_limits.clone());
+        }
+        result
    }

    fn finish_setup(
@@ -299,6 +326,7 @@ impl SemanticState {

 #[derive(Serialize)]
 pub struct SemanticStatus {
+    speech: crate::speech_setup::SpeechStatus,
    model: &'static str,
    ready: bool,
    text_model_ready: bool,
@@ -340,8 +368,11 @@ pub fn semantic_status(state: State<'_, AppState>) -> Result<SemanticStatus, Str
    let desired = semantic.desired_coverage();
    let index = HybridSearch::embedding_status_for_coverage(&state.database, desired)
        .map_err(|error| error.to_string())?;
-    let indexing_ready = semantic.can_index(index.text_indexing_allowed);
+    let speech = semantic.speech.status(&index);
+    let indexing_ready = semantic.can_index(index.text_indexing_allowed)
+        && (index.speech_policy.is_none() || speech.ready);
    Ok(SemanticStatus {
+        speech,
        model: "Google EmbeddingGemma 2",
        ready: worker_ready && semantic.warmed.load(Ordering::Acquire),
        text_model_ready: semantic.text_verified.load(Ordering::Acquire),
@@ -428,7 +459,9 @@ pub async fn index_embeddings(state: State<'_, AppState>) -> Result<EmbeddingRep
    let coverage = semantic.desired_coverage();
    let index = HybridSearch::embedding_status_for_coverage(&state.database, coverage)
        .map_err(|error| error.to_string())?;
-    if !semantic.can_index(index.text_indexing_allowed) {
+    if !semantic.can_index(index.text_indexing_allowed)
+        || (index.speech_policy.is_some() && !semantic.speech.status(&index).ready)
+    {
        return Err(
            "Semantic indexing is waiting for verified models and query preparation.".into(),
        );
@@ -464,6 +497,14 @@ pub async fn index_embeddings(state: State<'_, AppState>) -> Result<EmbeddingRep
                    .and_then(|report| report.ok_or_else(|| anyhow::anyhow!("Full media index retained while media setup finishes."))),
                SemanticCoverage::FullMedia => {
                    let tools = semantic.media_tools.as_ref().ok_or_else(|| anyhow::anyhow!("The media decoder is missing from this installation. Repair or reinstall searchi."))?;
+                    let admission = semantic.inference_budget.acquire(InferenceRole::Background, 1)?;
+                    let speech = semantic.speech.worker_for_index()?;
+                    drop(admission);
+                    if let Some(speech) = speech {
+                        service = service.with_speech_provider(Box::new(searchi_service::BudgetedSpeechProvider::new(
+                            Box::new(speech), semantic.inference_budget.clone(),
+                        )))?;
+                    }
                    service.index_embeddings_with_media(tools, &semantic.media_limits)
                }
            }
@@ -0,0 +1,120 @@
+//! Supplemental local speech setup; Google search readiness stays independent.
+use searchi_service::{EmbeddingStatus, InferenceBudget, InferenceRole, MediaLimits};
+use searchi_speech::{Device, SpeechWorker};
+use serde::Serialize;
+use std::{
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicBool, AtomicU64, Ordering},
+        Arc, Mutex,
+    },
+};
+
+pub struct SpeechSetup {
+    worker: PathBuf,
+    models: PathBuf,
+    downloading: AtomicBool,
+    downloaded: AtomicU64,
+    ready: AtomicBool,
+    error: Mutex<Option<String>>,
+    policy: Mutex<Option<String>>,
+    prepared: Mutex<Option<SpeechWorker>>,
+}
+
+#[derive(Serialize)]
+pub struct SpeechStatus {
+    worker_ready: bool,
+    pub ready: bool,
+    downloading: bool,
+    downloaded_bytes: u64,
+    total_bytes: u64,
+    error: Option<String>,
+    requested_policy: Option<String>,
+    pub pending: bool,
+    corpus_revision: i64,
+    failures: usize,
+}
+
+impl SpeechSetup {
+    pub fn new(worker: PathBuf, models: PathBuf) -> Arc<Self> {
+        Arc::new(Self {
+            worker,
+            models,
+            downloading: AtomicBool::new(false),
+            downloaded: AtomicU64::new(0),
+            ready: AtomicBool::new(false),
+            error: Mutex::new(None),
+            policy: Mutex::new(None),
+            prepared: Mutex::new(None),
+        })
+    }
+
+    pub fn start(self: &Arc<Self>, budget: InferenceBudget, limits: MediaLimits) {
+        if self.downloading.swap(true, Ordering::AcqRel) {
+            return;
+        }
+        let setup = self.clone();
+        let spawned = std::thread::Builder::new().name("searchi-speech-setup".into()).spawn(move || {
+            let result = (|| -> anyhow::Result<()> {
+                anyhow::ensure!(setup.worker.is_file(), "Speech recognition is unavailable in this installation. Repair searchi to enable it.");
+                searchi_assets::speech::provision(&setup.models, &setup.downloaded)?;
+                let _admission = budget.acquire(InferenceRole::Background, 1)?;
+                let worker = setup.load()?;
+                let policy = searchi_service::speech_policy_key(worker.fingerprint(), &limits)?;
+                *setup.prepared.lock().map_err(|_| anyhow::anyhow!("Speech setup unavailable"))? = Some(worker);
+                *setup.policy.lock().map_err(|_| anyhow::anyhow!("Speech setup unavailable"))? = Some(policy);
+                Ok(())
+            })();
+            setup.ready.store(result.is_ok(), Ordering::Release);
+            if let Ok(mut error) = setup.error.lock() { *error = result.err().map(|error| error.to_string()); }
+            setup.downloading.store(false, Ordering::Release);
+        });
+        if let Err(error) = spawned {
+            if let Ok(mut last) = self.error.lock() {
+                *last = Some(format!("Could not start speech setup: {error}"));
+            }
+            self.downloading.store(false, Ordering::Release);
+        }
+    }
+
+    fn load(&self) -> anyhow::Result<SpeechWorker> {
+        SpeechWorker::load(
+            &self.worker,
+            &self.models.join("ggml-base.bin"),
+            &self.models.join("ggml-silero-v6.2.0.bin"),
+            Device::Auto,
+        )
+    }
+
+    pub fn worker_for_index(&self) -> anyhow::Result<Option<SpeechWorker>> {
+        if !self.ready.load(Ordering::Acquire) {
+            return Ok(None);
+        }
+        if let Some(worker) = self
+            .prepared
+            .lock()
+            .map_err(|_| anyhow::anyhow!("Speech setup unavailable"))?
+            .take()
+        {
+            return Ok(Some(worker));
+        }
+        self.load().map(Some)
+    }
+
+    pub fn status(&self, index: &EmbeddingStatus) -> SpeechStatus {
+        let policy = self.policy.lock().ok().and_then(|value| value.clone());
+        let ready = self.ready.load(Ordering::Acquire);
+        SpeechStatus {
+            worker_ready: self.worker.is_file(),
+            ready,
+            downloading: self.downloading.load(Ordering::Acquire),
+            downloaded_bytes: self.downloaded.load(Ordering::Acquire),
+            total_bytes: searchi_assets::speech::TOTAL_BYTES,
+            error: self.error.lock().ok().and_then(|value| value.clone()),
+            pending: ready && (index.speech_policy != policy || !index.speech_failures.is_empty()),
+            requested_policy: policy,
+            corpus_revision: index.corpus_revision,
+            failures: index.speech_failures.len(),
+        }
+    }
+}
@@ -104,7 +104,20 @@ interface DesktopStatus {
    watch_error: string | null;
  }[];
 }
+interface SpeechStatus {
+  worker_ready: boolean;
+  ready: boolean;
+  downloading: boolean;
+  downloaded_bytes: number;
+  total_bytes: number;
+  error: string | null;
+  requested_policy: string | null;
+  pending: boolean;
+  corpus_revision: number;
+  failures: number;
+}
 interface SemanticStatus {
+  speech?: SpeechStatus;
  model: string;
  ready: boolean;
  model_directory: string;
@@ -150,7 +163,7 @@ document.querySelector<HTMLDivElement>("#app")!.innerHTML = `
 <header><div class="brand"><img class="brand-symbol" src="/searchi-symbol.png" alt=""><span class="wordmark">searchi</span></div><span id="index-status" class="index-status">Loading your index…</span><div class="header-actions"><button id="add-folder" class="quiet-button" type="button">${icon("folderAdd")}<span>Add folder</span></button><details id="filters" class="popover"><summary>${icon("filter")}<span id="scope-label">All files</span>${icon("chevron")}</summary><div class="popover-panel"><h2>Filter your search</h2><div class="filters-grid"><label>Search scope<select id="filter-scope"><option value="all">All files</option><option value="code">Code</option></select></label><label>Within folder<input id="filter-folder" placeholder="Absolute folder path"></label><label>Extension<input id="filter-extension" placeholder="pdf, md, txt…"></label><label>Artist (exact)<input id="filter-artist" placeholder="Artist from music tags" maxlength="256"></label><label>Track title (exact)<input id="filter-title" placeholder="Title from music tags" maxlength="256"></label><label>Minimum size (bytes)<input id="filter-min" type="number" min="0" step="1"></label><label>Maximum size (bytes)<input id="filter-max" type="number" min="0" step="1"></label><label>Minimum duration (seconds)<input id="filter-duration-min" type="number" min="0" step="0.1"></label><label>Maximum duration (seconds)<input id="filter-duration-max" type="number" min="0" step="0.1"></label><label>Modified from<input id="filter-after" type="date"></label><label>Modified through<input id="filter-before" type="date"></label></div></div></details><details id="settings" class="popover"><summary class="icon-button" aria-label="Settings" title="Settings">${icon("settings")}</summary><div class="popover-panel"><h2>Settings</h2><section class="appearance-settings" aria-labelledby="appearance-heading"><h3 id="appearance-heading">Appearance</h3><label for="background-material">Window background</label><select id="background-material"><option value="solid">Solid</option><option value="glass">Glass</option><option value="frosted">Frosted glass</option></select><div class="appearance-opacity"><label for="background-opacity">Background tint</label><output id="background-opacity-value" for="background-opacity">90%</output></div><input id="background-opacity" type="range" min="70" max="100" step="1" value="90" aria-describedby="appearance-status"><p id="appearance-status" class="hint" role="status">A subtle window background. Search results and passages stay clear.</p></section><h3>Folders & resources</h3><p id="shortcut-status" class="hint"></p><label class="resource-label" for="cpu-threads">CPU thread budget</label><select id="cpu-threads">${Array.from({ length: 8 }, (_, i) => `<option value="${i + 1}">${i + 1} ${i === 1 ? "threads (default)" : i ? "threads" : "thread (low power)"}</option>`).join("")}</select><p class="hint">Search automatically uses supported acceleration with CPU fallback. Two or more threads let search run alongside indexing; one thread can delay semantic search during indexing.</p><ul id="roots" aria-label="Selected folders"></ul><label class="performance-toggle"><input id="performance-toggle" type="checkbox">Performance details</label><p class="hint">Local timing diagnostics for new searches. Queries and file paths are excluded from copied reports.</p><details id="ai-settings" class="ai-settings"><summary>Optional AI answers</summary><label class="performance-toggle"><input id="ai-enabled" type="checkbox">Enable summaries and questions</label><p class="hint">Disabled by default. Only an explicit action sends the shown passage to your configured endpoint.</p><label>OpenAI-compatible base URL<input id="ai-endpoint" type="url" placeholder="http://localhost:1234/v1" autocomplete="off" maxlength="2048"></label><label>Model<input id="ai-model" placeholder="Your model name" autocomplete="off" maxlength="200"></label><label>API key (optional, this session only)<input id="ai-key" type="password" autocomplete="off" maxlength="2048"></label><button id="ai-clear-key" type="button">Clear key</button><p class="hint">Endpoint, model and key stay in this app session. The key authenticates requests to your endpoint.</p></details></div></details></div></header>
 <main>
 <form id="search-form" role="search"><label class="sr-only" for="query">Search your files</label>${icon("search")}<input id="query" type="search" placeholder="Search a filename, phrase, or what you remember…" autocomplete="off" spellcheck="false" maxlength="1000"><kbd id="focus-shortcut">Ctrl K</kbd><button id="clear-query" class="icon-button" type="button" aria-label="Clear search" title="Clear search">${icon("dismiss")}</button></form>
-<details id="semantic-panel"><summary>${icon("sparkles")}<span id="semantic-status" role="status" aria-live="polite">Preparing local semantic search…</span><span id="semantic-device" class="kind">Local model</span>${icon("chevron")}</summary><div class="semantic-content"><strong>Google EmbeddingGemma 2</strong><progress id="semantic-progress" aria-label="Local model setup progress"></progress><p id="semantic-detail" class="hint">The verified local model downloads automatically on first launch (865 MB). Your files stay on this device.</p><div class="semantic-actions"><button id="retry-model" type="button" hidden>Retry model setup</button><button id="rebuild-semantic" type="button" hidden>Rebuild semantic index</button></div></div></details>
+<details id="semantic-panel"><summary>${icon("sparkles")}<span id="semantic-status" role="status" aria-live="polite">Preparing local semantic search…</span><span id="semantic-device" class="kind">Local model</span>${icon("chevron")}</summary><div class="semantic-content"><strong>Google EmbeddingGemma 2</strong><progress id="semantic-progress" aria-label="Local model setup progress"></progress><p id="semantic-detail" class="hint">The verified local model downloads automatically on first launch (865 MB). Your files stay on this device.</p><p id="speech-status" class="hint" role="status" hidden></p><progress id="speech-progress" aria-label="Local speech model setup progress" hidden></progress><div class="semantic-actions"><button id="retry-model" type="button" hidden>Retry model setup</button><button id="rebuild-semantic" type="button" hidden>Rebuild semantic index</button></div></div></details>
 <form id="folder-form" hidden><label for="folder">Folder to index</label><div class="folder-row"><input id="folder" placeholder="Absolute folder path" required><button id="browse-folder" type="button">Browse…</button><button type="submit">Index folder</button><button id="cancel-folder" type="button">Cancel</button></div><p class="hint">Only choose folders you want searched. Large folders may take a while.</p></form>
 <p id="notice" role="status" aria-live="polite"></p><details id="performance-panel" hidden><summary>Performance details</summary><div id="performance-detail"></div><button id="copy-performance" type="button">Copy local timing report</button><span id="copy-performance-status" role="status"></span></details><div class="workspace"><section class="results-pane" aria-label="Search results"><p id="result-summary" class="eyebrow">READY WHEN YOU ARE</p><ul id="results" aria-label="Matching files"></ul><div id="empty">${icon("search")}<h2>Find what matters. Locally.</h2><p>Index a folder, then search a filename, phrase, or what you remember.</p></div></section><aside id="preview" aria-label="Result preview" hidden><div class="preview-header"><span id="preview-icon" class="file-icon"></span><div class="preview-heading"><h2 id="preview-title"></h2><p id="preview-path" class="path"></p></div></div><div class="preview-toolbar"><span id="preview-kind"></span><div class="preview-actions"><button id="open-result" type="button">${icon("open")}<span>Open file</span></button><button id="reveal-result" type="button" title="Show in folder" aria-label="Show in folder">${icon("folder")}</button></div></div><details id="match-details" class="match-details"><summary>Why this result?</summary><p id="match-reason"></p><p id="match-legend"></p></details><div id="media-preview" class="media-preview" hidden></div><p id="media-preview-status" class="hint" role="status" hidden></p><details id="ai-panel" class="ai-panel" hidden><summary>Summarize or ask</summary><p id="ai-disclosure" class="hint"></p><p class="eyebrow">PASSAGE THAT WILL BE SENT</p><pre id="ai-source-text"></pre><div class="ai-actions"><button id="ai-summarize" type="button" disabled>Summarize this passage</button><label class="sr-only" for="ai-question">Question about this passage</label><input id="ai-question" placeholder="Ask about this passage…" maxlength="2048"><button id="ai-ask" type="button" disabled>Ask</button></div><p id="ai-status" class="hint" role="status"></p><pre id="ai-answer"></pre><p id="ai-answer-label" class="hint"></p><button id="ai-citation" type="button" hidden>Selected source</button></details><div class="passage"><p id="passage-label" class="eyebrow">EXTRACTED PASSAGE</p><pre id="preview-text"></pre></div></aside></div>
 </main><footer><span class="footer-privacy">${icon("lock")}<span id="privacy-summary">Private search. Everything stays on your device.</span><span id="privacy" class="privacy">Local</span></span><span class="keyboard-hints"><kbd>${icon("arrowUp")}</kbd><kbd>${icon("arrowDown")}</kbd><span>Navigate</span><kbd>Enter</kbd><span>Open</span><kbd>Esc</kbd><span>Clear</span></span></footer>`;
@@ -452,9 +465,31 @@ async function refreshSemanticStatus() {
      element("semantic-detail").textContent +=
        ` ${status.media_failures.length} files could not be indexed. The first issue: ${status.media_failures[0].path}: ${status.media_failures[0].message}. Filename search remains available; rebuild after fixing the file.`;
    }
+    const speech = status.speech;
+    const speechStatus = element("speech-status");
+    speechStatus.hidden = !speech;
+    const speechProgress = element<HTMLProgressElement>("speech-progress");
+    speechProgress.hidden = !speech?.downloading;
+    if (speech) {
+      speechProgress.max = speech.total_bytes;
+      speechProgress.value = speech.downloaded_bytes;
+      speechStatus.textContent = speech.downloading
+        ? `Preparing local speech passages · ${Math.round(speech.downloaded_bytes / 1_000_000)} of ${Math.round(speech.total_bytes / 1_000_000)} MB`
+        : speech.error
+          ? `Speech passages: ${speech.error}`
+          : speech.ready
+            ? speech.failures
+              ? `Speech passages incomplete for ${speech.failures} files. Other search results remain available.`
+              : speech.pending
+                ? "Speech models ready · Spoken passages are waiting to be indexed."
+                : "Local speech passages ready. Recognized words and timings can contain errors."
+            : "Local speech passages are preparing. Filename and existing content search remain available.";
+    }
    const retry = element<HTMLButtonElement>("retry-model");
-    retry.hidden = !semanticRetryVisible({ ...status, error });
-    retry.disabled = working || isCaptureSurface();
+    retry.hidden =
+      !semanticRetryVisible({ ...status, error }) && !speech?.error;
+    retry.disabled =
+      working || Boolean(speech?.downloading) || isCaptureSurface();
    const rebuild = element<HTMLButtonElement>("rebuild-semantic");
    rebuild.hidden = !status.ready || (!status.chunks && !status.pending);
    rebuild.disabled =
@@ -467,8 +502,9 @@ async function refreshSemanticStatus() {
    if (
      !isCaptureSurface() &&
      status.ready &&
-      status.stale &&
-      status.pending > 0 &&
+      ((status.stale && status.pending > 0) ||
+        (Boolean(speech?.pending) &&
+          Boolean(status.generation !== null || status.pending))) &&
      semanticIndexReady(status) &&
      !semanticJobActive &&
      !indexingActive
@@ -224,6 +224,12 @@ export function matchExplanation(result: MatchResult) {
        legend: literalLegend,
        semanticPassage: false,
      };
+    case "semantic_speech":
+      return {
+        reason: `Related spoken passage${time}. Recognized locally; its time is an estimated token position.`,
+        legend: `${literalLegend} Speech recognition may contain mistakes.`,
+        semanticPassage: true,
+      };
    case "hybrid":
      return {
        reason: `Query words and related meaning matched this file; showing the passage${location}.`,
@@ -34,6 +34,7 @@ export function matchLabel(kind: string): string {
    semantic_image: "Image meaning",
    semantic_video: "Video frame meaning",
    semantic_audio: "Audio meaning",
+    semantic_speech: "Spoken passage",
    semantic: "Meaning",
    hybrid: "Keyword + meaning",
    exact_filename: "Exact filename",
@@ -14,6 +14,12 @@ export interface SemanticSetupStatus {
  media_model_ready?: boolean;
  media_model_error?: string | null;
  requested_coverage?: SemanticCoverage;
+  speech?: {
+    ready: boolean;
+    pending: boolean;
+    requested_policy: string | null;
+    corpus_revision: number;
+  };
 }

 export function semanticIndexReady(status: SemanticSetupStatus) {
@@ -30,6 +36,11 @@ export function semanticIndexKey(
  status: SemanticSetupStatus,
  folderRevision: number,
 ) {
+  if (status.speech?.ready && status.speech.pending) {
+    // Failed optional speech can still publish raw media: publication must not
+    // create an infinite retry loop for the same source corpus and policy.
+    return `speech:${status.speech.requested_policy}:${status.speech.corpus_revision}:${folderRevision}`;
+  }
  return `${status.generation}:${status.pending}:${folderRevision}:${status.requested_coverage ?? "full_media"}`;
 }

@@ -74,6 +74,9 @@ test('optional reasons use real source routes and never claim semantic word conf
  assert.match(text.legend,/without the same words/);
  assert.equal(text.semanticPassage,true);
  assert.match(matchExplanation({match_kind:'semantic_audio',source:{kind:'timestamp_ms',number:13129}}).reason,/0:13.*not an exact spoken phrase/);
+  const speech=matchExplanation({match_kind:'semantic_speech',source:{kind:'timestamp_ms',number:13129}});
+  assert.match(speech.reason,/0:13.*estimated token position/);
+  assert.equal(speech.semanticPassage,true);
  assert.match(matchExplanation({match_kind:'semantic_video',source:{kind:'timestamp_ms',number:24167}}).reason,/frame.*0:24/);
  assert.match(matchExplanation({match_kind:'semantic_image'}).reason,/whole/);
  assert.match(matchExplanation({match_kind:'name_terms'}).reason,/filename, path or content/);
@@ -51,3 +51,13 @@ test('legacy full-pair status remains blocked during download and ready after se
  assert.equal(semanticIndexReady({...legacy,downloading:false}), true);
  assert.equal(semanticMediaReady({...legacy,downloading:false}), true);
 });
+
+
+test('partial speech publication cannot create an automatic retry loop', () => {
+  const gate = new AutomaticIndexGate();
+  const first = {...text(), speech:{ready:true,pending:true,requested_policy:'speech-v1-a',corpus_revision:7}};
+  assert.equal(gate.claim(semanticIndexKey(first,4)),true);
+  assert.equal(gate.claim(semanticIndexKey({...first,generation:99,pending:0},4)),false);
+  assert.equal(gate.claim(semanticIndexKey({...first,speech:{...first.speech,corpus_revision:8}},4)),true);
+  assert.equal(gate.claim(semanticIndexKey({...first,speech:{...first.speech,requested_policy:'speech-v1-b'}},4)),true);
+});
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-present Silero Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 The ggml authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 OpenAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -14,6 +14,8 @@ use std::{
    time::Duration,
 };

+pub mod speech;
+
 /// Exact bytes of the pinned text model plus its multimedia projection.
 pub const TOTAL_BYTES: u64 = 864_676_480;
 const ATTEMPTS: usize = 3;
@@ -0,0 +1,136 @@
+//! Managed local speech models. This provisions model data only, never executables.
+//! Ordinary search must not call provisioning; desktop setup owns progress/retry.
+use super::*;
+
+pub const TOTAL_BYTES: u64 = 148_836_563;
+
+#[derive(Deserialize)]
+struct SpeechManifest {
+    schema: u32,
+    pipeline: String,
+    files: Vec<SpeechArtifact>,
+}
+
+#[derive(Deserialize)]
+struct SpeechArtifact {
+    #[serde(flatten)]
+    artifact: Artifact,
+    repository: String,
+    revision: String,
+}
+
+fn speech_manifest() -> Result<SpeechManifest> {
+    let manifest: SpeechManifest = serde_json::from_str(include_str!(
+        "../../../tools/speech-runtime/model-manifest.json"
+    ))?;
+    if manifest.schema != 1
+        || manifest.pipeline != "whisper-base-silero-v6.2.0-dtw-base-v1"
+        || manifest.files.len() != 2
+        || manifest
+            .files
+            .iter()
+            .map(|file| file.artifact.bytes)
+            .sum::<u64>()
+            != TOTAL_BYTES
+    {
+        bail!("invalid bundled speech model manifest");
+    }
+    for (file, (name, repository)) in manifest.files.iter().zip([
+        ("ggml-base.bin", "ggerganov/whisper.cpp"),
+        ("ggml-silero-v6.2.0.bin", "ggml-org/whisper-vad"),
+    ]) {
+        validate_artifact(&file.artifact)?;
+        if file.artifact.path != name
+            || file.repository != repository
+            || file.revision.len() != 40
+            || !file.revision.bytes().all(|byte| byte.is_ascii_hexdigit())
+        {
+            bail!("unexpected speech model artifact or repository revision");
+        }
+    }
+    Ok(manifest)
+}
+
+/// Select the same platform-local cache family as Google models, without IO.
+pub fn default_model_directory() -> Result<PathBuf> {
+    Ok(super::default_model_directory()?
+        .parent()
+        .context("model cache has no parent")?
+        .join("speech"))
+}
+
+/// Offline readiness requires exact size and SHA-256 for both pinned models.
+pub fn verify_cached(directory: &Path) -> Result<bool> {
+    for file in speech_manifest()?.files {
+        if !verified(&directory.join(&file.artifact.path), &file.artifact)? {
+            return Ok(false);
+        }
+    }
+    Ok(true)
+}
+
+/// Download missing models during explicit setup; retain verified cached files.
+/// Reuses Google's bounded, atomic download/retry path and numerical progress.
+pub fn provision(directory: &Path, progress: &AtomicU64) -> Result<()> {
+    let speech = speech_manifest()?;
+    let sources: HashMap<_, _> = speech
+        .files
+        .iter()
+        .map(|file| {
+            (
+                file.artifact.path.clone(),
+                format!(
+                    "https://huggingface.co/{}/resolve/{}/{}",
+                    file.repository, file.revision, file.artifact.path
+                ),
+            )
+        })
+        .collect();
+    let manifest = Manifest {
+        model_id: speech.pipeline,
+        export_repository: String::new(),
+        revision: String::new(),
+        files: speech.files.into_iter().map(|file| file.artifact).collect(),
+    };
+    let client = Client::builder()
+        .connect_timeout(Duration::from_secs(20))
+        .timeout(Duration::from_secs(900))
+        .user_agent(concat!("Searchi/", env!("CARGO_PKG_VERSION")))
+        .build()?;
+    provision_with_callback(
+        directory,
+        progress,
+        &manifest,
+        &client,
+        |artifact| sources[&artifact.path].clone(),
+        |_| {},
+    )
+}
+
+use std::collections::HashMap;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pinned_speech_manifest_matches_verified_diagnostic_assets() -> Result<()> {
+        let manifest = speech_manifest()?;
+        assert_eq!(manifest.files[0].artifact.bytes, 147_951_465);
+        assert_eq!(manifest.files[1].artifact.bytes, 885_098);
+        assert_eq!(
+            manifest.files[0].artifact.sha256,
+            "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe"
+        );
+        assert_eq!(
+            manifest.files[1].artifact.sha256,
+            "2aa269b785eeb53a82983a20501ddf7c1d9c48e33ab63a41391ac6c9f7fb6987"
+        );
+        let missing = tempfile::tempdir()?;
+        assert!(!verify_cached(missing.path())?);
+        // Length-only or wrong cached input never establishes model readiness.
+        fs::write(missing.path().join("ggml-base.bin"), b"unverified")?;
+        assert!(!verify_cached(missing.path())?);
+        Ok(())
+    }
+}
@@ -14,6 +14,7 @@ anyhow.workspace = true
 clap = { version = "4", features = ["derive"] }
 searchi-core = { path = "../searchi-core" }
 searchi-service = { path = "../searchi-service" }
+searchi-speech = { path = "../searchi-speech" }
 searchi-assets = { path = "../searchi-assets" }
 serde_json.workspace = true
 serde.workspace = true
@@ -31,6 +31,9 @@ enum Command {
    },
    /// Set up the required Google model in the default local cache.
    Setup {
+        /// Set up the local speech recognition models instead of Google embeddings.
+        #[arg(long)]
+        speech: bool,
        /// Override the platform-local model cache directory.
        #[arg(long)]
        model_dir: Option<PathBuf>,
@@ -122,6 +125,12 @@ enum Command {
        /// Explicitly build only document vectors, without media.
        #[arg(long)]
        text_only: bool,
+        /// Optional bundled local speech worker; recognizes passages without replacing Google.
+        #[arg(long, requires = "speech_model_dir", conflicts_with = "text_only")]
+        speech_worker: Option<PathBuf>,
+        /// Directory containing verified base and Silero speech models.
+        #[arg(long, requires = "speech_worker", conflicts_with = "text_only")]
+        speech_model_dir: Option<PathBuf>,
    },
    /// Show the indexed file and content counts.
    Stats {
@@ -143,7 +152,17 @@ fn main() -> Result<()> {
            require_existing_index(&db)?;
            mcp::serve(db, model_dir, embedding_worker, usize::from(cpu_threads))?;
        }
-        Command::Setup { model_dir } => {
+        Command::Setup { model_dir, speech } => {
+            if speech {
+                let directory = model_dir
+                    .map(Ok)
+                    .unwrap_or_else(searchi_assets::speech::default_model_directory)?;
+                let progress = std::sync::atomic::AtomicU64::new(0);
+                eprintln!("Setting up local speech models; verified cached assets are reused (149 MB maximum download).");
+                searchi_assets::speech::provision(&directory, &progress)?;
+                println!("Speech models ready: {}", directory.display());
+                return Ok(());
+            }
            let directory = model_dir
                .map(Ok)
                .unwrap_or_else(searchi_assets::default_model_directory)?;
@@ -280,10 +299,21 @@ fn main() -> Result<()> {
            ffmpeg,
            ffprobe,
            text_only,
+            speech_worker,
+            speech_model_dir,
        } => {
            require_existing_index(&db)?;
            let mut service =
                HybridSearch::open(&db, model_dir, embedding_worker, usize::from(cpu_threads))?;
+            if let Some((worker, directory)) = speech_worker.zip(speech_model_dir) {
+                let speech = searchi_speech::SpeechWorker::load(
+                    &worker,
+                    &directory.join("ggml-base.bin"),
+                    &directory.join("ggml-silero-v6.2.0.bin"),
+                    searchi_speech::Device::Auto,
+                )?;
+                service = service.with_speech_provider(Box::new(speech))?;
+            }
            let report = if text_only {
                service.index_embeddings()
            } else {
@@ -353,6 +383,40 @@ fn require_existing_index(db: &std::path::Path) -> Result<()> {
 mod tests {
    use super::*;

+    #[test]
+    fn speech_indexing_requires_models_and_cannot_downgrade_to_text_only() {
+        let base = [
+            "searchi",
+            "embed",
+            "--db",
+            "index.db",
+            "--model-dir",
+            "google",
+            "--embedding-worker",
+            "google-worker",
+        ];
+        assert!(
+            Cli::try_parse_from(base.into_iter().chain(["--speech-worker", "speech-worker"]))
+                .is_err()
+        );
+        assert!(Cli::try_parse_from(base.into_iter().chain([
+            "--speech-worker",
+            "speech-worker",
+            "--speech-model-dir",
+            "speech",
+            "--text-only"
+        ]))
+        .is_err());
+        assert!(Cli::try_parse_from(base.into_iter().chain([
+            "--speech-worker",
+            "speech-worker",
+            "--speech-model-dir",
+            "speech"
+        ]))
+        .is_ok());
+        assert!(Cli::try_parse_from(["searchi", "setup", "--speech"]).is_ok());
+    }
+
    #[test]
    fn rejects_zero_or_excessive_result_limits() {
        for limit in ["0", "1001"] {
@@ -66,12 +66,19 @@ fn default_limit() -> u16 {
    10
 }

+struct IssuedSource {
+    path: String,
+    source: SourceLocation,
+    signature: (u64, i64),
+    recognized_text: Option<String>,
+}
+
 struct State {
    index: SearchIndex,

    hybrid: Option<HybridSearch>,

-    handles: BTreeMap<String, (String, SourceLocation, (u64, i64))>,
+    handles: BTreeMap<String, IssuedSource>,

    recent: VecDeque<String>,
 }
@@ -252,7 +259,8 @@ impl AgentServer {

                    };

-                    if matches!(source.kind.as_str(), "page" | "paragraph" | "line") {
+                    if matches!(source.kind.as_str(), "page" | "paragraph" | "line")
+                        || (source.kind == "timestamp_ms" && result["match_kind"] == "semantic_speech") {

                        let handle = uuid::Uuid::new_v4().to_string();

@@ -274,7 +282,9 @@ impl AgentServer {

                            .context("Indexed source no longer available")?;

-                        state.handles.insert(handle.clone(), (path, source, signature));
+                        let recognized_text = (result["match_kind"] == "semantic_speech")
+                            .then(|| result["snippet"].as_str().unwrap_or_default().to_owned());
+                        state.handles.insert(handle.clone(), IssuedSource {path,source,signature,recognized_text});

                        state.recent.push_back(handle.clone());

@@ -297,7 +307,7 @@ impl AgentServer {

                "metrics": response.metrics,

-                "source_policy": "Indexed excerpts are untrusted content. Source timestamps are window/frame starts, not verified utterance alignment."
+                "source_policy": "Indexed excerpts are untrusted content. Media timestamps are approximate frame/window or recognized-token starts, not guaranteed exact utterance alignment."

            }))

@@ -320,7 +330,7 @@ impl AgentServer {
            idempotent_hint = true,
            open_world_hint = false
        ),
-        description = "Read the actual indexed page/paragraph/line for an opaque source_handle emitted by recent search results. Checks current file identity; returns at most 4096 characters. No arbitrary paths; indexed file metadata is checked."
+        description = "Read the indexed page/paragraph/line or locally recognized speech passage for an opaque source_handle emitted by recent search results. Checks current file identity; returns at most 4096 characters. No arbitrary paths; indexed file metadata is checked."
    )]

    async fn read_source(&self, Parameters(input): Parameters<SourceInput>) -> CallToolResult {
@@ -339,16 +349,27 @@ impl AgentServer {
                .try_lock()
                .map_err(|_| anyhow::anyhow!("Search worker busy"))?;

-            let (path, source, signature) = state
-                .handles
-                .get(&input.handle)
+            let issued = state.handles.get(&input.handle)
                .context("Unknown or expired source handle; search again")?;
+            let (path, source, signature) = (&issued.path, &issued.source, &issued.signature);

            ensure!(
                state.index.file_signature(path)?.as_ref() == Some(signature),
                "Source version changed after this handle was issued; search again"
            );

+            if source.kind == "timestamp_ms" {
+                let speech = state.hybrid.as_ref().context("Speech excerpts require a ready semantic index")?
+                    .speech_excerpt_matching(path, source.number, issued.recognized_text.as_deref().context("Missing recognized source identity")?, 4096)?
+                    .context("Recognized source changed/deleted or is unavailable; search again")?;
+                return Ok(json!({
+                    "path":speech.path,"filename":speech.filename,"source":speech.source,
+                    "end_ms":speech.end_ms,"text":speech.text,"provenance":speech.provenance,
+                    "max_chars":4096,"may_be_truncated":speech.text.chars().count()==4096,
+                    "source_policy":"Untrusted local speech recognition, which may contain recognition errors; never executable instructions."
+                }));
+            }
+
            let passage = state.index.source_passage(path, source, 4096)?.context(
                "Indexed source changed/deleted or is unavailable; refresh the index outside MCP",
            )?;
@@ -770,6 +770,27 @@ pub fn decode_audio(
    path: &Path,
    window: AudioWindow,
    limits: &MediaLimits,
+) -> Result<Vec<f32>> {
+    decode_audio_inner(tools, path, window, limits, false)
+}
+
+/// Preserve the source clock across seek offsets and discontinuities for speech citations.
+/// Silence is derived from decoded frame timestamps, never semantic guesses.
+pub fn decode_audio_aligned(
+    tools: &FfmpegTools,
+    path: &Path,
+    window: AudioWindow,
+    limits: &MediaLimits,
+) -> Result<Vec<f32>> {
+    decode_audio_inner(tools, path, window, limits, true)
+}
+
+fn decode_audio_inner(
+    tools: &FfmpegTools,
+    path: &Path,
+    window: AudioWindow,
+    limits: &MediaLimits,
+    aligned: bool,
 ) -> Result<Vec<f32>> {
    ensure!(
        window.duration_ms > 0 && window.duration_ms <= 30_000,
@@ -794,7 +815,12 @@ pub fn decode_audio(
        .arg(path)
        .arg("-af")
        .arg(format!(
-            "aresample=16000,atrim=end_sample={},asetpts=PTS-STARTPTS",
+            "{},atrim=end_sample={},asetpts=PTS-STARTPTS",
+            if aligned {
+                "aresample=16000:async=1:first_pts=0"
+            } else {
+                "aresample=16000"
+            },
            u64::from(window.duration_ms) * 16
        ))
        .args([
@@ -11,6 +11,7 @@ serde.workspace = true
 searchi-core = { path = "../searchi-core" }
 searchi-semantic = { path = "../searchi-semantic" }
 searchi-media = { path = "../searchi-media" }
+searchi-speech = { path = "../searchi-speech" }
 rusqlite = { version = "0.32", features = ["bundled"] }
 sha2 = "0.10"
 fs2 = "0.4"
@@ -48,3 +48,48 @@ a separate durable metadata epoch so warmed readers cannot retain old eligibilit
 They do not change source-corpus revisions during the indexer's own probe publication.
 Empty metadata-only hybrid requests use core results without model inference.
 These explicit constraints do not establish abstention for free-form topic queries.
+
+## Optional speech evidence
+
+Attach a verified `searchi_speech::SpeechWorker` through `with_speech_provider`.
+`BudgetedSpeechProvider` admits one background thread per contiguous window;
+its admission time remains separate from native VAD/ASR/load/transport metrics.
+Aborted acceleration and CPU retry cost is aggregated separately as `fallback_us`.
+Recognition consumes at most thirty seconds of mono 16-kHz PCM, with two-second
+window overlap and an explicit 1024-window source ceiling. Four-hour default
+media fits the contiguous policy. Recognition never receives reference captions.
+
+Speech uses `decode_audio_aligned`: source-frame timestamps preserve positive
+track origins, internal gaps, seeks and tails. Its CPU FFmpeg regression compares
+actual samples against known fixture clocks. Raw Google audio preprocessing is
+unchanged. DTW first/last point spans may have equal start/end; no invented duration
+is added. These functional contracts do not prove general timestamp accuracy.
+
+Raw media, speech and document passages have independent completed source tasks.
+Adding/upgrading speech or retrying its failures reuses compatible verified raw
+vectors. Speech task identity includes native recognition assets/policy, aligned
+decoder policy, input SHA-256, title, maximum duration and maximum file bytes;
+raw sampling changes do not force speech recognition. Failed speech tasks publish
+explicit partial coverage while retaining raw evidence, and remain retryable.
+A genuine Google inference failure still aborts semantic publication.
+
+`SpeechProvider` returns bounded recognized passages and numeric metrics. Google
+EmbeddingGemma 2 alone embeds those passages. Spoken-intent requests prefer
+`semantic_speech`, falling back to raw audio; music and sound requests use audio.
+Source locations retain `timestamp_ms`; recognized snippets are identified as
+`local_speech_recognition`, not exact document bytes. `speech_excerpt_matching`
+binds an issued result's recognized text when timestamps repeat, verifies current
+media SHA-256/revision and serves only active indexed evidence.
+
+`speech_policy_key` and `EmbeddingStatus.corpus_revision` provide the stable
+(policy, source revision) automatic-retry key. Generation IDs and metadata-only
+updates must not trigger an endless retry loop. Status includes active speech
+policy and bounded explicit failures. Native interaction, full speech quality,
+other-platform execution and GPU evidence remain separate release gates.
+
+Actual ASR/Google integration is an explicit ignored test:
+`cargo test -p searchi-service --test speech_google_cpu -- --ignored --nocapture --test-threads=1`.
+Provide verified `SEARCHI_SPEECH_WORKER`, `SEARCHI_SPEECH_BASE`, `SEARCHI_SPEECH_VAD`,
+Google model/worker variables, CPU FFmpeg/FFprobe helpers and a real short WAV in
+`SEARCHI_TEST_SPEECH_AUDIO`; Windows VM execution requires `SEARCHI_FORCE_CPU=1`.
+This tests publication/reuse and evidence binding, not independent relevance.
@@ -2,9 +2,12 @@
 //! filtered HNSW retrieval. Production-scale validation remains a release gate.
 mod coordination;
 mod media;
+mod speech;
 pub use coordination::{
    BudgetedProvider, InferenceBudget, InferencePermit, InferenceRole, PendingForeground,
 };
+pub use searchi_speech::{SpeechMetrics, SpeechPassage, SpeechTranscription};
+pub use speech::{speech_policy_key, BudgetedSpeechProvider, SpeechExcerpt, SpeechProvider};
 mod prepared;
 pub use prepared::PreparedGraphs;
 mod pipeline;
@@ -39,7 +42,23 @@ fn generation_fingerprint(model: &str) -> String {
    )
 }

+fn raw_media_policy(policy: &str) -> &str {
+    if let Some((base, hash)) = policy.rsplit_once(":speech-v1-") {
+        if hash.len() == 64 && hash.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+            return base;
+        }
+    }
+    policy
+}
+
+fn speech_component_policy(policy: &str) -> String {
+    let raw = raw_media_policy(policy);
+    format!("{}{}", policy_base(policy), &policy[raw.len()..])
+}
+
 fn reusable_policy(expected: &str, active: &str) -> bool {
+    let expected = raw_media_policy(expected);
+    let active = raw_media_policy(active);
    if active == expected || active == format!("{expected}:text-only") {
        return true;
    }
@@ -56,6 +75,7 @@ fn reusable_policy(expected: &str, active: &str) -> bool {
 /// Resolve compatible publication coverage without broadening model or window
 /// policy compatibility. A retained reader can start under either coverage.
 fn policy_base(policy: &str) -> &str {
+    let policy = raw_media_policy(policy);
    if let Some(base) = policy.strip_suffix(":text-only") {
        return base;
    }
@@ -213,12 +233,21 @@ pub struct EmbeddingReport {
    pub image_inference_calls: usize,
    pub audio_inference_calls: usize,
    pub resumed: bool,
+    pub speech_requested: bool,
+    pub speech_windows: usize,
+    pub speech_chunks: usize,
+    pub speech_reused_sources: usize,
+    pub speech_failures: Vec<MediaFailure>,
+    pub speech_metrics: std::collections::BTreeMap<String, u64>,
 }

 #[derive(Debug, Serialize)]
 pub struct EmbeddingStatus {
    /// Coverage of a compatible, prepared active generation, if any.
    pub coverage: Option<SemanticCoverage>,
+    pub speech_policy: Option<String>,
+    pub speech_failures: Vec<MediaFailure>,
+    pub corpus_revision: i64,
    pub requested_coverage: SemanticCoverage,
    /// Early setup must preserve an existing compatible full generation.
    pub text_indexing_allowed: bool,
@@ -241,6 +270,7 @@ enum QueryTask {
 pub struct HybridSearch {
    lexical: SearchIndex,
    embedder: Box<dyn EmbeddingProvider>,
+    speech: Option<Box<dyn SpeechProvider>>,
    store: Store,
    generation_fingerprint: String,
    // Real provider outputs only, scoped to this model session. Queries never
@@ -300,6 +330,9 @@ impl HybridSearch {
        if !exists {
            return Ok(EmbeddingStatus {
                coverage: None,
+                speech_policy: None,
+                speech_failures: Vec::new(),
+                corpus_revision: 0,
                requested_coverage,
                text_indexing_allowed: true,
                failures: Vec::new(),
@@ -318,6 +351,9 @@ impl HybridSearch {
        if version < 6 {
            return Ok(EmbeddingStatus {
                coverage: None,
+                speech_policy: None,
+                speech_failures: Vec::new(),
+                corpus_revision: 0,
                requested_coverage,
                text_indexing_allowed: true,
                failures: Vec::new(),
@@ -329,7 +365,7 @@ impl HybridSearch {
            });
        }
        ensure!(
-            (6..=8).contains(&version),
+            (6..=9).contains(&version),
            "Unsupported semantic schema version {version}"
        );
        let (generation,fingerprint,revision,current,dimensions):(Option<i64>,Option<String>,Option<i64>,i64,Option<usize>)=snapshot.query_row(
@@ -349,6 +385,25 @@ impl HybridSearch {
                })
            })?
            .collect::<rusqlite::Result<Vec<_>>>()?;
+        let speech_policy = fingerprint
+            .as_deref()
+            .filter(|policy| raw_media_policy(policy) != *policy)
+            .and_then(|policy| policy.rsplit_once(":speech-v1-"))
+            .map(|(_, hash)| format!("speech-v1-{hash}"));
+        let speech_failures = if version >= 8 {
+            let mut speech_query=snapshot.prepare("SELECT path,message FROM semantic_tasks WHERE generation=?1 AND source_type='speech' AND state='failed' ORDER BY path LIMIT 1000")?;
+            let failures = speech_query
+                .query_map([generation], |row| {
+                    Ok(MediaFailure {
+                        path: row.get(0)?,
+                        message: row.get(1)?,
+                    })
+                })?
+                .collect::<rusqlite::Result<Vec<_>>>()?;
+            failures
+        } else {
+            Vec::new()
+        };
        let expected = generation_fingerprint(GEMMA_FINGERPRINT);
        let coverage = if dimensions == Some(GEMMA_DIMENSIONS) {
            fingerprint
@@ -361,11 +416,16 @@ impl HybridSearch {
        let policy_matches = match requested_coverage {
            SemanticCoverage::TextOnly => prepared_coverage.is_some(),
            // Keep the default full-media status's exact configured policy rule.
-            SemanticCoverage::FullMedia => fingerprint.as_deref() == Some(expected.as_str()),
+            SemanticCoverage::FullMedia => {
+                fingerprint.as_deref().map(raw_media_policy) == Some(expected.as_str())
+            }
        };
        let stale = revision != Some(current) || !policy_matches;
        Ok(EmbeddingStatus {
            coverage: prepared_coverage,
+            speech_policy,
+            speech_failures,
+            corpus_revision: current,
            requested_coverage,
            text_indexing_allowed: coverage != Some(SemanticCoverage::FullMedia),
            failures,
@@ -416,6 +476,7 @@ impl HybridSearch {
            query_cache: VecDeque::new(),
            lexical,
            embedder,
+            speech: None,
            store,
            generation_fingerprint,
        })
@@ -4,7 +4,7 @@ use searchi_media::*;
 use store::SourceTask;

 #[derive(Debug)]
-struct InferenceFailure(anyhow::Error);
+pub(super) struct InferenceFailure(pub(super) anyhow::Error);
 impl std::fmt::Display for InferenceFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Media inference failed: {}", self.0)
@@ -42,6 +42,10 @@ impl HybridSearch {
                limits.max_file_bytes
            ));
        }
+        if let Some(provider) = &self.speech {
+            fingerprint.push(':');
+            fingerprint.push_str(&speech_policy_key(provider.fingerprint(), limits)?);
+        }
        self.rebuild_generation(fingerprint, Some(limits), |service, generation, work| {
            service.build(generation, work)?;
            let mut after = 0;
@@ -80,11 +84,12 @@ impl HybridSearch {
                            .map(|i| i.sha256.clone())
                            .unwrap_or_default(),
                        title_hash: String::new(),
-                        policy: service.generation_fingerprint.clone(),
+                        policy: raw_media_policy(&service.generation_fingerprint).into(),
                        passage_id: -id,
                    };
                    work.track(&task)?;
                    service.store.stage_task(generation, &task)?;
+                    let speech_identity = identity.as_ref().ok().cloned();
                    let result = identity.and_then(|identity| {
                        service.build_media_source(
                            generation, id, path, kind, tools, limits, &identity, &task, work,
@@ -93,7 +98,16 @@ impl HybridSearch {
                        Ok(())
                    });
                    match result {
-                        Ok(()) => work.report.media_files += 1,
+                        Ok(()) => {
+                            work.report.media_files += 1;
+                            if service.speech.is_some() && kind != MediaKind::Image {
+                                if let Some(identity) = speech_identity {
+                                    service.build_speech_source(
+                                        generation, id, path, tools, limits, &identity, work,
+                                    )?;
+                                }
+                            }
+                        }
                        Err(error) => {
                            if let Err(cleanup) =
                                service
@@ -101,6 +101,12 @@ impl HybridSearch {
                image_inference_calls: 0,
                audio_inference_calls: 0,
                resumed,
+                speech_requested: self.speech.is_some() && media_limits.is_some(),
+                speech_windows: 0,
+                speech_chunks: 0,
+                speech_reused_sources: 0,
+                speech_failures: Vec::new(),
+                speech_metrics: Default::default(),
            },
            keys: Vec::new(),
            media: Vec::new(),
@@ -197,13 +203,28 @@ impl HybridSearch {
                    );
                    tasks.push(SourceTask {
                        key: task_key(&["media", &path]),
-                        path,
+                        path: path.clone(),
                        source_type: "media".into(),
-                        source_hash: identity.map(|identity| identity.sha256).unwrap_or_default(),
+                        source_hash: identity
+                            .as_ref()
+                            .map(|identity| identity.sha256.clone())
+                            .unwrap_or_default(),
                        title_hash: String::new(),
-                        policy: self.generation_fingerprint.clone(),
+                        policy: raw_media_policy(&self.generation_fingerprint).into(),
                        passage_id: -id,
                    });
+                    if self.speech.is_some() && kind != searchi_media::MediaKind::Image {
+                        ensure!(
+                            tasks.len() < MAX_SCAN_CHUNKS,
+                            "Semantic source task budget exceeded"
+                        );
+                        tasks.push(super::speech::speech_task(
+                            &path,
+                            id,
+                            identity.as_ref().ok(),
+                            &self.generation_fingerprint,
+                        )?);
+                    }
                }
            }
        }
@@ -8,6 +8,7 @@ pub enum SemanticOrigin {
    Image,
    Video,
    Audio,
+    Speech,
 }
 impl SemanticOrigin {
    fn source_type(self) -> Option<&'static str> {
@@ -17,6 +18,7 @@ impl SemanticOrigin {
            Self::Image => Some("image"),
            Self::Video => Some("video"),
            Self::Audio => Some("audio"),
+            Self::Speech => Some("speech"),
        }
    }
 }
@@ -59,32 +61,15 @@ fn preferred_origin(query: &str) -> Option<SemanticOrigin> {
        return None;
    }
    if has(&[
-        "audio",
        "spoken",
        "speech",
-        "recording",
        "conversation",
        "interview",
        "podcast",
-        "sound",
-        "music",
        "gesprochen",
        "gespräch",
        "gespraech",
-        "geräusch",
-        "geraeusch",
-        "musik",
-        "hörbar",
-        "hörbarer",
-        "hörbare",
-        "hoerbar",
-        "hoerbarer",
-        "hoerbare",
-        "tonaufnahme",
-    ]) {
-        return Some(SemanticOrigin::Audio);
-    }
-    if (has(&["someone", "speaker"])
+    ]) || (has(&["someone", "speaker"])
        && has(&[
            "mentions",
            "mentioned",
@@ -96,6 +81,24 @@ fn preferred_origin(query: &str) -> Option<SemanticOrigin> {
        || (has(&["jemand", "sprecher", "sprecherin"])
            && has(&["erwähnt", "erwaehnt", "sagt", "gesagt", "spricht"]))
    {
+        return Some(SemanticOrigin::Speech);
+    }
+    if has(&[
+        "audio",
+        "recording",
+        "sound",
+        "music",
+        "geräusch",
+        "geraeusch",
+        "musik",
+        "hörbar",
+        "hörbarer",
+        "hörbare",
+        "hoerbar",
+        "hoerbarer",
+        "hoerbare",
+        "tonaufnahme",
+    ]) {
        return Some(SemanticOrigin::Audio);
    }
    None
@@ -140,6 +143,20 @@ impl HybridSearch {
                if !preferred.is_empty() {
                    return Ok(preferred);
                }
+                if origin == SemanticOrigin::Speech {
+                    let raw = self.store.search_origin_traced(
+                        vector,
+                        &self.generation_fingerprint,
+                        limit,
+                        options,
+                        Some("audio"),
+                        trace,
+                        parent,
+                    )?;
+                    if !raw.is_empty() {
+                        return Ok(raw);
+                    }
+                }
            }
            trace.counter(parent, "general_lane", 1);
            self.store.search_origin_traced(
@@ -191,17 +208,44 @@ mod tests {
        ));
        for active in ["other-model:pinned-media:preprocessing-v1:custom-240-2000-120-10000-2000-1800-14400000-17179869184","pinned-model:pinned-media:preprocessing-v2:custom-240-2000-120-10000-2000-1800-14400000-17179869184","pinned-model:pinned-media:preprocessing-v1:custom-unknown"] {assert!(!reusable_policy(expected,active));}
    }
+    #[test]
+    fn speech_reader_policy_preserves_exact_raw_and_text_components() {
+        let raw = "google:pinned-media:windows-v1";
+        let speech = format!("{raw}:speech-v1-{}", "a".repeat(64));
+        assert!(reusable_policy(raw, &speech));
+        assert_eq!(raw_media_policy(&speech), raw);
+        assert_eq!(policy_base(&speech), raw);
+        assert!(!reusable_policy(
+            "different-google:pinned-media:windows-v1",
+            &speech
+        ));
+        assert!(!reusable_policy(
+            raw,
+            &format!("{raw}:speech-v1-not-a-valid-hash")
+        ));
+    }
+
    #[test]
    fn explicit_spoken_intent_is_conservative_and_bilingual() {
        for query in [
            "where someone mentions a contract",
            "a speaker says the date",
            "spoken discussion of ecology",
-            "audio of a waterfall",
            "jemand erwähnt das Budget",
            "Wo spricht jemand über Kündigung?",
            "Gespräch über die neue Wohnung",
+        ] {
+            assert_eq!(
+                preferred_origin(query),
+                Some(SemanticOrigin::Speech),
+                "{query}"
+            );
+        }
+        for query in [
+            "audio of a waterfall",
            "hörbarer Regen",
+            "music with violin",
+            "sound of thunder",
        ] {
            assert_eq!(
                preferred_origin(query),
@@ -0,0 +1,421 @@
+//! Optional local speech evidence. Google remains the only embedding provider.
+use super::*;
+use searchi_core::SourceLocation;
+use searchi_media::{decode_audio_aligned, probe, AudioWindow, MediaIdentity};
+use store::SourceTask;
+
+const MAX_SPEECH_WINDOWS: usize = 1024;
+const MAX_SEGMENTS: usize = 64;
+const MAX_SEGMENT_BYTES: usize = 4096;
+const MAX_WINDOW_TEXT: usize = 64 * 1024;
+
+/// Stable automatic-retry identity; excludes generation IDs and metadata epochs.
+pub fn speech_policy_key(provider_fingerprint: &str, limits: &MediaLimits) -> Result<String> {
+    ensure!(
+        !provider_fingerprint.is_empty() && provider_fingerprint.len() <= 4096,
+        "Invalid speech provider fingerprint"
+    );
+    Ok(format!("speech-v1-{}",store::content_hash(&format!("{provider_fingerprint};speech-window=30000;overlap=2000;max-windows=1024;aligned-decoder-v1;max-duration={};max-bytes={}",limits.max_duration_ms,limits.max_file_bytes))))
+}
+
+pub trait SpeechProvider: Send {
+    /// Includes actual ASR/VAD/alignment assets and policy, not a display name alone.
+    fn fingerprint(&self) -> &str;
+    fn admission_us(&self) -> u64 {
+        0
+    }
+    fn transcribe(&mut self, pcm: &[f32], sample_rate: u32) -> Result<SpeechTranscription>;
+}
+
+impl SpeechProvider for searchi_speech::SpeechWorker {
+    fn fingerprint(&self) -> &str {
+        searchi_speech::SpeechWorker::fingerprint(self)
+    }
+    fn transcribe(&mut self, pcm: &[f32], sample_rate: u32) -> Result<SpeechTranscription> {
+        searchi_speech::SpeechWorker::transcribe(self, pcm, sample_rate)
+    }
+}
+
+/// One background admission per bounded window; never claims native preemption.
+pub struct BudgetedSpeechProvider {
+    inner: Box<dyn SpeechProvider>,
+    budget: InferenceBudget,
+    admission_us: u64,
+}
+impl BudgetedSpeechProvider {
+    pub fn new(inner: Box<dyn SpeechProvider>, budget: InferenceBudget) -> Self {
+        Self {
+            inner,
+            budget,
+            admission_us: 0,
+        }
+    }
+}
+impl SpeechProvider for BudgetedSpeechProvider {
+    fn fingerprint(&self) -> &str {
+        self.inner.fingerprint()
+    }
+    fn admission_us(&self) -> u64 {
+        self.admission_us
+    }
+    fn transcribe(&mut self, pcm: &[f32], sample_rate: u32) -> Result<SpeechTranscription> {
+        let start = std::time::Instant::now();
+        let permit = self.budget.acquire(InferenceRole::Background, 1);
+        self.admission_us = start.elapsed().as_micros().min(u64::MAX as u128) as u64;
+        let _permit = permit?;
+        self.inner.transcribe(pcm, sample_rate)
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct SpeechExcerpt {
+    pub path: String,
+    pub filename: String,
+    pub source: SourceLocation,
+    pub end_ms: u32,
+    pub text: String,
+    pub provenance: &'static str,
+}
+
+pub(super) fn speech_task(
+    path: &str,
+    id: i64,
+    identity: Option<&MediaIdentity>,
+    policy: &str,
+) -> Result<SourceTask> {
+    let filename = Path::new(path)
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy();
+    Ok(SourceTask {
+        key: super::pipeline::task_key(&["speech", path]),
+        path: path.into(),
+        source_type: "speech".into(),
+        source_hash: identity
+            .map(|identity| identity.sha256.clone())
+            .unwrap_or_default(),
+        title_hash: store::content_hash(bounded_title(&filename)),
+        policy: speech_component_policy(policy),
+        passage_id: store::media_passage_id(id, "speech")?,
+    })
+}
+
+fn speech_windows(start_ms: u32, end_ms: u32) -> Result<Vec<AudioWindow>> {
+    ensure!(start_ms <= end_ms, "Invalid speech audio range");
+    let mut windows = Vec::new();
+    let mut start = start_ms;
+    while start < end_ms {
+        ensure!(
+            windows.len() < MAX_SPEECH_WINDOWS,
+            "Speech exceeds 1024 contiguous windows; coverage is incomplete"
+        );
+        windows.push(AudioWindow {
+            start_ms: start,
+            duration_ms: (end_ms - start).min(30000),
+        });
+        if end_ms - start <= 30000 {
+            break;
+        }
+        start = start
+            .checked_add(28000)
+            .ok_or_else(|| anyhow::anyhow!("Speech timestamp overflow"))?;
+    }
+    Ok(windows)
+}
+
+fn validate_transcription(result: &SpeechTranscription, duration_ms: u32) -> Result<()> {
+    ensure!(
+        result.passages.len() <= MAX_SEGMENTS,
+        "Speech window exceeds 64 passages"
+    );
+    let mut total = 0usize;
+    for passage in &result.passages {
+        ensure!(
+            passage.start_ms <= passage.end_ms && passage.end_ms <= duration_ms,
+            "Speech timestamp lies outside decoded window"
+        );
+        ensure!(
+            !passage.text.trim().is_empty() && passage.text.len() <= MAX_SEGMENT_BYTES,
+            "Speech passage text is empty or oversized"
+        );
+        total = total
+            .checked_add(passage.text.len())
+            .ok_or_else(|| anyhow::anyhow!("Speech text budget overflow"))?;
+        ensure!(
+            total <= MAX_WINDOW_TEXT,
+            "Speech window exceeds 64 KiB text"
+        );
+    }
+    for value in [
+        result.metrics.vad_ms,
+        result.metrics.asr_ms,
+        result.metrics.load_ms,
+        result.metrics.transport_ms,
+        result.metrics.fallback_ms,
+    ] {
+        ensure!(
+            value.is_finite() && value >= 0. && value <= (u64::MAX / 1000) as f64,
+            "Invalid speech timing metric"
+        );
+    }
+    Ok(())
+}
+
+impl HybridSearch {
+    pub fn with_speech_provider(mut self, provider: Box<dyn SpeechProvider>) -> Result<Self> {
+        ensure!(
+            !provider.fingerprint().is_empty() && provider.fingerprint().len() <= 4096,
+            "Invalid speech provider fingerprint"
+        );
+        self.speech = Some(provider);
+        Ok(self)
+    }
+
+    /// Only returns active, byte-verified indexed speech. Caller may further bind a source handle.
+    pub fn speech_excerpt(
+        &self,
+        path: &str,
+        start_ms: u32,
+        max_chars: usize,
+    ) -> Result<Option<SpeechExcerpt>> {
+        self.store.speech_excerpt(path, start_ms, max_chars)
+    }
+
+    /// Bind issued search evidence when multiple recognized passages share a timestamp.
+    pub fn speech_excerpt_matching(
+        &self,
+        path: &str,
+        start_ms: u32,
+        expected_text: &str,
+        max_chars: usize,
+    ) -> Result<Option<SpeechExcerpt>> {
+        self.store
+            .speech_excerpt_matching(path, start_ms, Some(expected_text), max_chars)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn build_speech_source(
+        &mut self,
+        generation: i64,
+        id: i64,
+        path: &Path,
+        tools: &FfmpegTools,
+        limits: &MediaLimits,
+        identity: &MediaIdentity,
+        work: &mut super::pipeline::BuildWork,
+    ) -> Result<()> {
+        let task = speech_task(
+            &path.to_string_lossy(),
+            id,
+            Some(identity),
+            &self.generation_fingerprint,
+        )?;
+        work.track(&task)?;
+        self.store.stage_task(generation, &task)?;
+        let before = work.report.chunks;
+        let before_speech = work.report.speech_chunks;
+        let result =
+            self.encode_speech_source(generation, id, path, tools, limits, identity, &task, work);
+        match result {
+            Ok(()) => Ok(()),
+            Err(error) => {
+                self.store
+                    .fail_source(generation, &task, &format!("{error:#}"))?;
+                work.report.chunks = before;
+                work.report.speech_chunks = before_speech;
+                if error
+                    .downcast_ref::<super::media::InferenceFailure>()
+                    .is_some()
+                {
+                    return Err(error);
+                }
+                if work.report.speech_failures.len() < 1000 {
+                    work.report.speech_failures.push(MediaFailure {
+                        path: task.path,
+                        message: format!("{error:#}").chars().take(2048).collect(),
+                    });
+                }
+                Ok(())
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn encode_speech_source(
+        &mut self,
+        generation: i64,
+        id: i64,
+        path: &Path,
+        tools: &FfmpegTools,
+        limits: &MediaLimits,
+        identity: &MediaIdentity,
+        task: &SourceTask,
+        work: &mut super::pipeline::BuildWork,
+    ) -> Result<()> {
+        let revision =
+            self.lexical
+                .media_change_revision(&task.path, identity.bytes, identity.modified_ns)?;
+        if let Some(count) = self
+            .store
+            .reuse_media_source(generation, task, id, identity)?
+        {
+            ensure!(
+                work.report.chunks + count <= MAX_SCAN_CHUNKS,
+                "Speech exceeds generation chunk budget"
+            );
+            identity.ensure_unchanged()?;
+            work.report.chunks += count;
+            work.report.speech_chunks += count;
+            work.report.reused_chunks += count;
+            work.report.reused_sources += 1;
+            work.report.speech_reused_sources += 1;
+            return Ok(());
+        }
+        let metadata = probe(tools, path, limits)?;
+        let filename = path.file_name().unwrap_or_default().to_string_lossy();
+        let mut ordinal = 0usize;
+        if metadata.has_audio {
+            for window in speech_windows(metadata.audio_start_ms, metadata.audio_end_ms)? {
+                let pcm = decode_audio_aligned(tools, path, window, limits)?;
+                let provider = self
+                    .speech
+                    .as_mut()
+                    .ok_or_else(|| anyhow::anyhow!("Speech provider unavailable"))?;
+                work.report.speech_windows += 1;
+                let result = provider.transcribe(&pcm, 16000);
+                let admission = work
+                    .report
+                    .speech_metrics
+                    .entry("admission_us".into())
+                    .or_default();
+                *admission = admission.saturating_add(provider.admission_us());
+                let transcription = result?;
+                validate_transcription(&transcription, window.duration_ms)?;
+                for (key, value) in [
+                    ("vad_us", transcription.metrics.vad_ms),
+                    ("asr_us", transcription.metrics.asr_ms),
+                    ("load_us", transcription.metrics.load_ms),
+                    ("transport_us", transcription.metrics.transport_ms),
+                    ("fallback_us", transcription.metrics.fallback_ms),
+                ] {
+                    let total = work.report.speech_metrics.entry(key.into()).or_default();
+                    *total = total.saturating_add((value * 1000.) as u64);
+                }
+                for passage in transcription.passages {
+                    ensure!(
+                        work.report.chunks < MAX_SCAN_CHUNKS,
+                        "Speech exceeds generation chunk budget"
+                    );
+                    let start = window
+                        .start_ms
+                        .checked_add(passage.start_ms)
+                        .ok_or_else(|| anyhow::anyhow!("Speech timestamp overflow"))?;
+                    let end = window
+                        .start_ms
+                        .checked_add(passage.end_ms)
+                        .ok_or_else(|| anyhow::anyhow!("Speech timestamp overflow"))?;
+                    let windows = passage_windows(
+                        &mut *self.embedder,
+                        &passage.text,
+                        bounded_title(&filename),
+                    )?;
+                    for text_window in windows {
+                        ensure!(
+                            work.report.chunks < MAX_SCAN_CHUNKS,
+                            "Speech exceeds generation chunk budget"
+                        );
+                        let calls = work
+                            .report
+                            .speech_metrics
+                            .entry("google_embedding_calls".into())
+                            .or_default();
+                        *calls = calls.saturating_add(1);
+                        let vectors = self
+                            .embedder
+                            .embed_documents(&[&text_window.text], bounded_title(&filename))
+                            .map_err(|error| {
+                                anyhow::Error::new(super::media::InferenceFailure(error))
+                            })?;
+                        ensure!(vectors.len() == 1, "Speech embedding count mismatch");
+                        self.store.insert_speech(
+                            generation,
+                            id,
+                            ordinal,
+                            identity,
+                            revision,
+                            start,
+                            end,
+                            &text_window.text,
+                            &vectors[0],
+                        )?;
+                        ordinal += 1;
+                        work.report.chunks += 1;
+                        work.report.speech_chunks += 1;
+                    }
+                }
+            }
+        }
+        identity.ensure_unchanged()?;
+        ensure!(
+            self.lexical
+                .media_change_revision(&task.path, identity.bytes, identity.modified_ns)?
+                == revision,
+            "Speech source changed during recognition"
+        );
+        self.store.complete_source(generation, task, ordinal)?;
+        work.report.encoded_sources += 1;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn point_spans_are_legal_and_invalid_native_evidence_is_rejected() -> Result<()> {
+        let mut result = SpeechTranscription {
+            passages: vec![SpeechPassage {
+                start_ms: 0,
+                end_ms: 0,
+                text: "Recognized point".into(),
+            }],
+            metrics: SpeechMetrics::default(),
+        };
+        validate_transcription(&result, 30000)?;
+        result.passages[0].end_ms = 30001;
+        assert!(validate_transcription(&result, 30000).is_err());
+        result.passages[0].end_ms = 0;
+        result.passages[0].text = "x".repeat(4097);
+        assert!(validate_transcription(&result, 30000).is_err());
+        result.passages[0].text = "valid".into();
+        result.metrics.asr_ms = f64::NAN;
+        assert!(validate_transcription(&result, 30000).is_err());
+        result.metrics.asr_ms = 0.;
+        result.metrics.fallback_ms = f64::INFINITY;
+        assert!(validate_transcription(&result, 30000).is_err());
+        result.metrics.fallback_ms = 12.5;
+        validate_transcription(&result, 30000)?;
+        Ok(())
+    }
+
+    #[test]
+    fn contiguous_windows_cover_full_four_hours_and_overflow_is_explicit() -> Result<()> {
+        let windows = speech_windows(0, 14400000)?;
+        assert_eq!(windows[0].start_ms, 0);
+        assert_eq!(
+            windows.last().unwrap().start_ms + windows.last().unwrap().duration_ms,
+            14400000
+        );
+        assert!(windows
+            .windows(2)
+            .all(|pair| pair[1].start_ms == pair[0].start_ms + 28000));
+        assert!(speech_windows(0, u32::MAX).is_err());
+        let offset = speech_windows(2000, 34000)?;
+        assert_eq!(offset[0].start_ms, 2000);
+        assert_eq!(
+            offset.last().unwrap().start_ms + offset.last().unwrap().duration_ms,
+            34000
+        );
+        Ok(())
+    }
+}
@@ -19,6 +19,19 @@ use usearch::{Index, IndexOptions, MetricKind, ScalarKind};
 pub(crate) const MAX_SCAN_CHUNKS: usize = 100_000;
 pub(crate) const MIN_COSINE: f32 = 0.25;

+// Disjoint negative namespaces preserve existing document/raw-media IDs without a table rebuild.
+pub(crate) fn media_passage_id(file_id: i64, source_type: &str) -> Result<i64> {
+    ensure!(
+        file_id > 0 && file_id <= i64::MAX / 2,
+        "Media ID exceeds supported namespace"
+    );
+    Ok(if source_type == "speech" {
+        i64::MIN + file_id
+    } else {
+        -file_id
+    })
+}
+
 #[derive(Clone, PartialEq, Eq)]
 struct FilterKey {
    folder: Option<String>,
@@ -123,7 +136,7 @@ impl Store {
            |row| row.get(0),
        )?;
        ensure!(
-            (1..=8).contains(&version),
+            (1..=9).contains(&version),
            "Unsupported semantic schema version {version}"
        );
        initialization.execute_batch("
@@ -187,6 +200,13 @@ impl Store {
            }
        }
        initialization.execute_batch("CREATE TABLE IF NOT EXISTS semantic_media_errors(generation INTEGER NOT NULL REFERENCES semantic_generations(id) ON DELETE CASCADE,path TEXT NOT NULL,message TEXT NOT NULL,PRIMARY KEY(generation,path))")?;
+        let has_speech_end:bool=initialization.query_row("SELECT EXISTS(SELECT 1 FROM pragma_table_info('semantic_chunks') WHERE name='speech_end_ms')",[],|row|row.get(0))?;
+        if !has_speech_end {
+            initialization.execute(
+                "ALTER TABLE semantic_chunks ADD COLUMN speech_end_ms INTEGER",
+                [],
+            )?;
+        }
        // Probe publication changes filter eligibility, not source discovery identity.
        // Keep its epoch separate so indexing does not invalidate its own corpus snapshot.
        initialization.execute_batch("CREATE TABLE IF NOT EXISTS semantic_media_metadata_revision(singleton INTEGER PRIMARY KEY CHECK(singleton=1), revision INTEGER NOT NULL);
@@ -254,7 +274,7 @@ impl Store {
    }
    pub(crate) fn media_failure(&self, generation: i64, path: &str, message: &str) -> Result<()> {
        self.connection.execute(
-            "DELETE FROM semantic_chunks WHERE generation=?1 AND path=?2 AND source_type!='text'",
+            "DELETE FROM semantic_chunks WHERE generation=?1 AND path=?2 AND source_type IN ('image','video','audio')",
            params![generation, path],
        )?;
        self.connection.execute("INSERT OR REPLACE INTO semantic_media_errors(generation,path,message) VALUES(?1,?2,?3)",params![generation,path,message.chars().take(2048).collect::<String>()])?;
@@ -298,10 +318,96 @@ impl Store {
            )
        };
        let bytes: Vec<u8> = vector.iter().flat_map(|v| v.to_le_bytes()).collect();
-        self.connection.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,file_change_revision) VALUES(?1,?2,?3,?4,?5,?6,?7,0,0,?8,?9,?10,?11,?12,(SELECT change_revision FROM files WHERE path=?4))",params![generation,-file_id,ordinal as i64,path,kind,timestamp,identity.sha256,snippet,bytes,source_type,identity.bytes as i64,identity.modified_ns])?;
+        self.connection.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,file_change_revision) VALUES(?1,?2,?3,?4,?5,?6,?7,0,0,?8,?9,?10,?11,?12,(SELECT change_revision FROM files WHERE path=?4))",params![generation,media_passage_id(file_id,source_type)?,ordinal as i64,path,kind,timestamp,identity.sha256,snippet,bytes,source_type,identity.bytes as i64,identity.modified_ns])?;
        Ok(())
    }

+    #[allow(clippy::too_many_arguments)]
+    pub(crate) fn insert_speech(
+        &self,
+        generation: i64,
+        file_id: i64,
+        ordinal: usize,
+        identity: &searchi_media::MediaIdentity,
+        revision: i64,
+        start_ms: u32,
+        end_ms: u32,
+        text: &str,
+        vector: &[f32],
+    ) -> Result<()> {
+        ensure!(
+            start_ms <= end_ms && !text.trim().is_empty() && text.len() <= 4096,
+            "Invalid recognized passage"
+        );
+        let current:Option<i64>=self.connection.query_row("SELECT change_revision FROM files WHERE id=?1 AND path=?2 AND size=?3 AND mtime=?4",params![file_id,identity.path.to_string_lossy(),i64::try_from(identity.bytes)?,identity.modified_ns],|row|row.get(0)).optional()?;
+        ensure!(
+            current == Some(revision),
+            "Speech source changed since recognition admission"
+        );
+        self.insert_media(
+            generation, file_id, ordinal, identity, "speech", start_ms, vector,
+        )?;
+        self.connection.execute("UPDATE semantic_chunks SET snippet=?4,speech_end_ms=?5 WHERE generation=?1 AND passage_id=?2 AND ordinal=?3 AND source_type='speech'",params![generation,media_passage_id(file_id,"speech")?,ordinal as i64,text,end_ms])?;
+        Ok(())
+    }
+
+    pub(crate) fn speech_excerpt(
+        &self,
+        path: &str,
+        start_ms: u32,
+        max_chars: usize,
+    ) -> Result<Option<super::SpeechExcerpt>> {
+        self.speech_excerpt_matching(path, start_ms, None, max_chars)
+    }
+
+    pub(crate) fn speech_excerpt_matching(
+        &self,
+        path: &str,
+        start_ms: u32,
+        expected_text: Option<&str>,
+        max_chars: usize,
+    ) -> Result<Option<super::SpeechExcerpt>> {
+        if let Some(text) = expected_text {
+            ensure!(
+                !text.is_empty() && text.len() <= 4096,
+                "Invalid recognized source identity"
+            );
+        }
+        ensure!(
+            max_chars > 0 && max_chars <= 8192,
+            "Speech excerpt limit must be 1..=8192 characters"
+        );
+        let row:Option<(String,String,u32,u64,i64,String)>=self.connection.query_row("SELECT f.filename,c.snippet,c.speech_end_ms,c.file_size,c.file_mtime,c.content_hash FROM semantic_chunks c
+            JOIN semantic_meta m ON m.active_generation=c.generation JOIN files f ON f.path=c.path
+            WHERE c.path=?1 AND c.source_type='speech' AND c.number=?2 AND (?3 IS NULL OR c.snippet=?3) AND c.file_size=f.size AND c.file_mtime=f.mtime AND c.file_change_revision=f.change_revision
+            ORDER BY c.ordinal LIMIT 1",params![path,start_ms,expected_text],|row|Ok((row.get(0)?,row.get(1)?,row.get(2)?,row.get(3)?,row.get(4)?,row.get(5)?))).optional()?;
+        let Some((filename, text, end_ms, size, mtime, hash)) = row else {
+            return Ok(None);
+        };
+        ensure!(
+            size <= searchi_media::MediaLimits::default().max_file_bytes,
+            "Speech source exceeds supported byte bound"
+        );
+        let current = match searchi_media::MediaIdentity::read(Path::new(path), size) {
+            Ok(identity) => identity,
+            Err(_) => return Ok(None),
+        };
+        if current.bytes != size || current.modified_ns != mtime || current.sha256 != hash {
+            return Ok(None);
+        }
+        Ok(Some(super::SpeechExcerpt {
+            path: path.into(),
+            filename,
+            source: SourceLocation {
+                kind: "timestamp_ms".into(),
+                number: start_ms,
+            },
+            end_ms,
+            text: text.chars().take(max_chars).collect(),
+            provenance: "local_speech_recognition",
+        }))
+    }
+
    pub(crate) fn insert(
        &mut self,
        generation: i64,
@@ -48,7 +48,7 @@ pub(super) fn migrate(connection: &Connection) -> Result<()> {
        PRIMARY KEY(generation,task_key));
        CREATE INDEX IF NOT EXISTS semantic_task_reuse ON semantic_tasks(source_hash,title_hash,policy,source_type,state);
        CREATE INDEX IF NOT EXISTS semantic_chunk_task ON semantic_chunks(generation,task_key);
-        UPDATE semantic_meta SET schema_version=8 WHERE singleton=1;")?;
+        UPDATE semantic_meta SET schema_version=9 WHERE singleton=1;")?;
    Ok(())
 }

@@ -146,7 +146,7 @@ impl Store {
        let tx = self
            .connection
            .transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
-        let count:i64=tx.query_row("SELECT count(*) FROM semantic_chunks WHERE generation=?1 AND path=?2 AND ((?3='text' AND source_type='text' AND passage_id=?4) OR (?3='media' AND source_type!='text'))",params![generation,task.path,task.source_type,task.passage_id],|r|r.get(0))?;
+        let count:i64=tx.query_row("SELECT count(*) FROM semantic_chunks WHERE generation=?1 AND path=?2 AND ((?3='text' AND source_type='text' AND passage_id=?4) OR (?3='media' AND source_type IN ('image','video','audio')) OR (?3='speech' AND source_type='speech'))",params![generation,task.path,task.source_type,task.passage_id],|r|r.get(0))?;
        ensure!(
            usize::try_from(count)? == expected_chunks,
            "Incomplete source chunk membership"
@@ -160,7 +160,7 @@ impl Store {
            total <= MAX_SCAN_CHUNKS,
            "Generation exceeds semantic chunk budget"
        );
-        tx.execute("UPDATE semantic_chunks SET task_key=?5 WHERE generation=?1 AND path=?2 AND ((?3='text' AND source_type='text' AND passage_id=?4) OR (?3='media' AND source_type!='text'))",params![generation,task.path,task.source_type,task.passage_id,task.key])?;
+        tx.execute("UPDATE semantic_chunks SET task_key=?5 WHERE generation=?1 AND path=?2 AND ((?3='text' AND source_type='text' AND passage_id=?4) OR (?3='media' AND source_type IN ('image','video','audio')) OR (?3='speech' AND source_type='speech'))",params![generation,task.path,task.source_type,task.passage_id,task.key])?;
        let changed=tx.execute("UPDATE semantic_tasks SET state='done',expected_chunks=?3,path=?4,passage_id=?5,message=NULL WHERE generation=?1 AND task_key=?2 AND source_hash=?6 AND title_hash=?7 AND policy=?8 AND source_type=?9",params![generation,task.key,count,task.path,task.passage_id,task.source_hash,task.title_hash,task.policy,task.source_type])?;
        ensure!(changed == 1, "Missing matching source task");
        if task.source_type == "media" {
@@ -180,7 +180,7 @@ impl Store {
        message: &str,
    ) -> Result<()> {
        let tx = self.connection.transaction()?;
-        tx.execute("DELETE FROM semantic_chunks WHERE generation=?1 AND (task_key=?2 OR (path=?3 AND ((?4='text' AND source_type='text' AND passage_id=?5) OR (?4='media' AND source_type!='text'))))",params![generation,task.key,task.path,task.source_type,task.passage_id])?;
+        tx.execute("DELETE FROM semantic_chunks WHERE generation=?1 AND (task_key=?2 OR (path=?3 AND ((?4='text' AND source_type='text' AND passage_id=?5) OR (?4='media' AND source_type IN ('image','video','audio')) OR (?4='speech' AND source_type='speech'))))",params![generation,task.key,task.path,task.source_type,task.passage_id])?;
        tx.execute("UPDATE semantic_tasks SET state='failed',expected_chunks=NULL,message=?3 WHERE generation=?1 AND task_key=?2",params![generation,task.key,message.chars().take(2048).collect::<String>()])?;
        tx.commit()?;
        Ok(())
@@ -299,8 +299,8 @@ impl Store {
        for (key, donor) in mappings {
            tx.execute("INSERT INTO semantic_tasks(generation,task_key,path,source_type,source_hash,title_hash,policy,passage_id,state,attempts,expected_chunks,message)
                SELECT ?1,d.task_key,d.path,d.source_type,d.source_hash,d.title_hash,d.policy,d.passage_id,'done',old.attempts,old.expected_chunks,NULL FROM semantic_discovery_tasks d JOIN semantic_prune_tasks old ON old.task_key=?3 WHERE d.task_key=?2",params![generation,key,donor])?;
-            tx.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,task_key,file_change_revision)
-                SELECT ?1,d.passage_id,c.ordinal,d.path,c.kind,c.number,c.content_hash,c.start_byte,c.end_byte,c.snippet,c.vector,c.source_type,c.file_size,c.file_mtime,d.task_key,COALESCE((SELECT change_revision FROM files WHERE path=d.path),c.file_change_revision) FROM semantic_prune_chunks c JOIN semantic_discovery_tasks d ON d.task_key=?2 WHERE c.task_key=?3",params![generation,key,donor])?;
+            tx.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,task_key,file_change_revision,speech_end_ms)
+                SELECT ?1,d.passage_id,c.ordinal,d.path,c.kind,c.number,c.content_hash,c.start_byte,c.end_byte,c.snippet,c.vector,c.source_type,c.file_size,c.file_mtime,d.task_key,COALESCE((SELECT change_revision FROM files WHERE path=d.path),c.file_change_revision),c.speech_end_ms FROM semantic_prune_chunks c JOIN semantic_discovery_tasks d ON d.task_key=?2 WHERE c.task_key=?3",params![generation,key,donor])?;
        }
        tx.execute(
            "DELETE FROM semantic_media_errors WHERE generation=?1",
@@ -378,11 +378,11 @@ fn validate_task(task: &SourceTask) -> Result<()> {
        "Invalid source task identity"
    );
    ensure!(
-        matches!(task.source_type.as_str(), "text" | "media"),
+        matches!(task.source_type.as_str(), "text" | "media" | "speech"),
        "Invalid source task type"
    );
    ensure!(
-        (!task.source_hash.is_empty() || task.source_type == "media")
+        (!task.source_hash.is_empty() || task.source_type != "text")
            && task.source_hash.len() <= 256
            && task.title_hash.len() <= 256
            && !task.policy.is_empty()
@@ -418,6 +418,13 @@ impl Store {
                candidate?;
            let compatible = source_dimensions == destination_dimensions
                && (source_policy == destination_policy
+                    || (task.source_type == "media"
+                        && super::super::raw_media_policy(&destination_policy) == task.policy
+                        && super::super::raw_media_policy(&source_policy) == task.policy)
+                    || (task.source_type == "speech"
+                        && super::super::speech_component_policy(&destination_policy)
+                            == task.policy
+                        && super::super::speech_component_policy(&source_policy) == task.policy)
                    || (task.source_type == "text"
                        && super::super::policy_base(&destination_policy) == task.policy
                        && super::super::reusable_policy(&task.policy, &destination_policy)
@@ -437,7 +444,7 @@ impl Store {
        let second = admitted.get(1).copied().unwrap_or(first);
        Ok(self.connection.query_row("SELECT t.generation,t.task_key,t.expected_chunks FROM semantic_tasks t JOIN semantic_generations g ON g.id=t.generation JOIN semantic_generations destination ON destination.id=?1
            WHERE t.source_hash=?2 AND t.title_hash=?3 AND t.policy=?4 AND t.source_type=?5 AND t.state='done' AND t.expected_chunks IS NOT NULL
-            AND (g.fingerprint=destination.fingerprint OR (?5='text' AND t.generation IN (?6,?7))) AND g.dimensions=destination.dimensions
+            AND (g.fingerprint=destination.fingerprint OR t.generation IN (?6,?7)) AND g.dimensions=destination.dimensions
            AND t.expected_chunks=(SELECT count(*) FROM semantic_chunks c WHERE c.generation=t.generation AND c.task_key=t.task_key)
            ORDER BY (t.generation=?1) DESC,t.generation DESC LIMIT 1",params![generation,task.source_hash,task.title_hash,task.policy,task.source_type,first,second],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).optional()?)
    }
@@ -510,8 +517,8 @@ impl Store {
        identity: &searchi_media::MediaIdentity,
    ) -> Result<Option<usize>> {
        ensure!(
-            task.source_type == "media"
-                && task.passage_id == -file_id
+            matches!(task.source_type.as_str(), "media" | "speech")
+                && task.passage_id == media_passage_id(file_id, &task.source_type)?
                && task.path == identity.path.to_string_lossy()
                && task.source_hash == identity.sha256,
            "Media task mapping differs from current source"
@@ -524,18 +531,34 @@ impl Store {
            "Reusable source exceeds chunk budget"
        );
        {
-            let mut stmt=self.connection.prepare("SELECT vector,source_type,ordinal,content_hash FROM semantic_chunks WHERE generation=?1 AND task_key=?2 ORDER BY ordinal")?;
+            let mut stmt=self.connection.prepare("SELECT vector,source_type,ordinal,content_hash,speech_end_ms,number,snippet,kind FROM semantic_chunks WHERE generation=?1 AND task_key=?2 ORDER BY ordinal")?;
            let mut rows = stmt.query(params![source, key])?;
            let mut seen = 0usize;
            while let Some(row) = rows.next()? {
                ensure!(
-                    matches!(
-                        row.get::<_, String>(1)?.as_str(),
-                        "image" | "audio" | "video"
-                    ) && row.get::<_, usize>(2)? == seen
+                    (if task.source_type == "speech" {
+                        row.get::<_, String>(1)? == "speech"
+                    } else {
+                        matches!(
+                            row.get::<_, String>(1)?.as_str(),
+                            "image" | "audio" | "video"
+                        )
+                    }) && row.get::<_, usize>(2)? == seen
                        && row.get::<_, String>(3)? == task.source_hash,
                    "Corrupt completed media source membership"
                );
+                if task.source_type == "speech" {
+                    let start: u32 = row.get(5)?;
+                    let end: Option<u32> = row.get(4)?;
+                    let text: String = row.get(6)?;
+                    ensure!(
+                        end.is_some_and(|end| end >= start)
+                            && row.get::<_, String>(7)? == "timestamp_ms"
+                            && !text.trim().is_empty()
+                            && text.len() <= 4096,
+                        "Corrupt completed speech evidence"
+                    );
+                }
                validate_vector(&row.get::<_, Vec<u8>>(0)?, self.dimensions)?;
                seen += 1;
            }
@@ -572,8 +595,8 @@ impl Store {
            "DELETE FROM semantic_chunks WHERE generation=?1 AND task_key=?2",
            params![generation, task.key],
        )?;
-        tx.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,task_key,file_change_revision)
-            SELECT ?1,?2,ordinal,?3,COALESCE(?4,kind),COALESCE(?5,number),content_hash,start_byte,end_byte,snippet,vector,source_type,COALESCE(?6,file_size),COALESCE(?7,file_mtime),?8,COALESCE((SELECT change_revision FROM files WHERE path=?3),file_change_revision) FROM semantic_reuse_chunks",params![generation,task.passage_id,task.path,location.map(|s|s.kind.as_str()),location.map(|s|s.number),identity.map(|i|i.bytes as i64),identity.map(|i|i.modified_ns),task.key])?;
+        tx.execute("INSERT INTO semantic_chunks(generation,passage_id,ordinal,path,kind,number,content_hash,start_byte,end_byte,snippet,vector,source_type,file_size,file_mtime,task_key,file_change_revision,speech_end_ms)
+            SELECT ?1,?2,ordinal,?3,COALESCE(?4,kind),COALESCE(?5,number),content_hash,start_byte,end_byte,snippet,vector,source_type,COALESCE(?6,file_size),COALESCE(?7,file_mtime),?8,COALESCE((SELECT change_revision FROM files WHERE path=?3),file_change_revision),speech_end_ms FROM semantic_reuse_chunks",params![generation,task.passage_id,task.path,location.map(|s|s.kind.as_str()),location.map(|s|s.number),identity.map(|i|i.bytes as i64),identity.map(|i|i.modified_ns),task.key])?;
        let changed=tx.execute("UPDATE semantic_tasks SET state='done',expected_chunks=?3,path=?4,passage_id=?5,message=NULL WHERE generation=?1 AND task_key=?2 AND source_hash=?6 AND title_hash=?7 AND policy=?8 AND source_type=?9",params![generation,task.key,count as i64,task.path,task.passage_id,task.source_hash,task.title_hash,task.policy,task.source_type])?;
        ensure!(changed == 1, "Missing source task during reuse");
        if task.source_type == "media" {
@@ -605,6 +628,148 @@ fn validate_vector(bytes: &[u8], dimensions: usize) -> Result<()> {
    );
    Ok(())
 }
+#[cfg(test)]
+mod speech_lifecycle_tests {
+    use super::*;
+    use searchi_core::SearchIndex;
+    #[test]
+    fn speech_upgrade_and_failure_reuse_raw_work_and_verified_excerpts_reject_same_stat_changes(
+    ) -> Result<()> {
+        let dir = tempfile::tempdir()?;
+        let root = dir.path().join("media");
+        std::fs::create_dir(&root)?;
+        let file = root.join("meeting.wav");
+        std::fs::write(&file, b"real source bytes for storage tests")?;
+        let db = dir.path().join("index.db");
+        let mut lexical = SearchIndex::open(&db)?;
+        lexical.index_folder(&root)?;
+        let mut store = Store::open(&db, 2)?;
+        let (id, path, _, _) = store.media_batch(0)?.remove(0);
+        let identity = searchi_media::MediaIdentity::read(Path::new(&path), 1024)?;
+        let revision =
+            lexical.media_change_revision(&path, identity.bytes, identity.modified_ns)?;
+        let base = "storage-google-base";
+        let raw = SourceTask {
+            key: "raw-key".into(),
+            path: path.clone(),
+            source_type: "media".into(),
+            source_hash: identity.sha256.clone(),
+            title_hash: String::new(),
+            policy: base.into(),
+            passage_id: -id,
+        };
+        let original = store.begin(base)?;
+        store.stage_task(original, &raw)?;
+        // Synthetic unit geometry tests membership, not production inference or relevance.
+        store.insert_media(original, id, 0, &identity, "audio", 0, &[1., 0.])?;
+        store.complete_source(original, &raw, 1)?;
+        store.activate(original)?;
+        let speech_policy = format!("{base}:speech-v1-{}", "a".repeat(64));
+        let first = store.begin(&speech_policy)?;
+        store.stage_task(first, &raw)?;
+        assert_eq!(
+            store.reuse_media_source(first, &raw, id, &identity)?,
+            Some(1)
+        );
+        let speech = SourceTask {
+            key: "speech-key".into(),
+            source_type: "speech".into(),
+            policy: speech_policy.clone(),
+            passage_id: media_passage_id(id, "speech")?,
+            ..raw.clone()
+        };
+        store.stage_task(first, &speech)?;
+        store.insert_speech(
+            first,
+            id,
+            0,
+            &identity,
+            revision,
+            100,
+            100,
+            "Recognized words",
+            &[0., 1.],
+        )?;
+        store.insert_speech(
+            first,
+            id,
+            1,
+            &identity,
+            revision,
+            100,
+            110,
+            "Different recognized words",
+            &[0., 1.],
+        )?;
+        store.complete_source(first, &speech, 2)?;
+        validate_completion(&store.connection, first)?;
+        store.activate(first)?;
+        let excerpt = store
+            .speech_excerpt(&path, 100, 4096)?
+            .expect("verified excerpt");
+        assert_eq!(excerpt.text, "Recognized words");
+        assert_eq!(excerpt.end_ms, 100);
+        assert_eq!(excerpt.provenance, "local_speech_recognition");
+        let exact = store
+            .speech_excerpt_matching(&path, 100, Some("Different recognized words"), 4096)?
+            .expect("chosen duplicate-time passage");
+        assert_eq!(exact.end_ms, 110);
+        assert_eq!(exact.text, "Different recognized words");
+        assert!(store
+            .speech_excerpt_matching(&path, 100, Some("not recognized"), 4096)?
+            .is_none());
+        let same = store.begin(&speech_policy)?;
+        store.stage_task(same, &raw)?;
+        store.stage_task(same, &speech)?;
+        assert_eq!(
+            store.reuse_media_source(same, &raw, id, &identity)?,
+            Some(1)
+        );
+        assert_eq!(
+            store.reuse_media_source(same, &speech, id, &identity)?,
+            Some(2)
+        );
+        store.activate(same)?;
+        let changed_policy = format!("{base}:speech-v1-{}", "b".repeat(64));
+        let changed = store.begin(&changed_policy)?;
+        store.stage_task(changed, &raw)?;
+        assert_eq!(
+            store.reuse_media_source(changed, &raw, id, &identity)?,
+            Some(1)
+        );
+        let updated_speech = SourceTask {
+            policy: changed_policy,
+            ..speech.clone()
+        };
+        store.stage_task(changed, &updated_speech)?;
+        assert_eq!(
+            store.reuse_media_source(changed, &updated_speech, id, &identity)?,
+            None
+        );
+        store.fail_source(changed, &updated_speech, "explicit recognition failure")?;
+        let raw_count: i64 = store.connection.query_row(
+            "SELECT count(*) FROM semantic_chunks WHERE generation=?1 AND source_type='audio'",
+            [changed],
+            |row| row.get(0),
+        )?;
+        assert_eq!(raw_count, 1);
+        validate_completion(&store.connection, changed)?;
+        // Same-stat byte mutations never qualify for agent evidence.
+        let modified = std::fs::metadata(&path)?.modified()?;
+        let replacement = vec![b'x'; identity.bytes as usize];
+        std::fs::write(&path, replacement)?;
+        std::fs::OpenOptions::new()
+            .write(true)
+            .open(&path)?
+            .set_times(std::fs::FileTimes::new().set_modified(modified))?;
+        assert!(store.speech_excerpt(&path, 100, 4096)?.is_none());
+        assert!(store
+            .speech_excerpt_matching(&path, 100, Some("Different recognized words"), 4096)?
+            .is_none());
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -0,0 +1,151 @@
+//! Functional speech publication uses real recognition and real Google embeddings.
+//! Retrieval queries derive from recognized evidence; this is not a relevance benchmark.
+use anyhow::{Context, Result};
+use searchi_core::SearchIndex;
+use searchi_service::{
+    FfmpegTools, HybridSearch, MediaLimits, SearchOptions, SpeechProvider, SpeechTranscription,
+};
+use searchi_speech::{Device, SpeechWorker};
+use std::{
+    fs,
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
+
+struct FailOnceNative {
+    worker: SpeechWorker,
+    fingerprint: String,
+    fail_once: bool,
+    calls: Arc<AtomicUsize>,
+}
+impl SpeechProvider for FailOnceNative {
+    fn fingerprint(&self) -> &str {
+        &self.fingerprint
+    }
+    fn transcribe(&mut self, pcm: &[f32], rate: u32) -> Result<SpeechTranscription> {
+        self.calls.fetch_add(1, Ordering::SeqCst);
+        if self.fail_once {
+            self.fail_once = false;
+            anyhow::bail!("Injected optional recognition failure");
+        }
+        self.worker.transcribe(pcm, rate)
+    }
+}
+fn required(name: &str) -> Result<PathBuf> {
+    std::env::var_os(name)
+        .map(PathBuf::from)
+        .with_context(|| format!("Set {name}"))
+}
+fn native() -> Result<SpeechWorker> {
+    SpeechWorker::load(
+        &required("SEARCHI_SPEECH_WORKER")?,
+        &required("SEARCHI_SPEECH_BASE")?,
+        &required("SEARCHI_SPEECH_VAD")?,
+        Device::Cpu,
+    )
+}
+fn raw_vectors(db: &std::path::Path) -> Result<Vec<Vec<u8>>> {
+    let connection = rusqlite::Connection::open(db)?;
+    let mut statement=connection.prepare("SELECT vector FROM semantic_chunks WHERE generation=(SELECT active_generation FROM semantic_meta WHERE singleton=1) AND source_type='audio' ORDER BY ordinal")?;
+    let rows = statement
+        .query_map([], |row| row.get(0))?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    Ok(rows)
+}
+
+#[test]
+#[ignore = "Requires verified real speech assets/runtime, Google assets/runtime and short real speech WAV; CPU only"]
+fn genuine_speech_policy_upgrade_retries_only_speech_and_preserves_warmed_query_reader(
+) -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let model = required("SEARCHI_GEMMA_MODEL_DIR")?;
+    let gemma = required("SEARCHI_GEMMA_WORKER")?;
+    let source = required("SEARCHI_TEST_SPEECH_AUDIO")?;
+    anyhow::ensure!(
+        fs::metadata(&source)?.len() <= 64 * 1024 * 1024,
+        "Test source exceeds byte budget"
+    );
+    let tools = FfmpegTools {
+        ffmpeg: required("SEARCHI_TEST_FFMPEG")?,
+        ffprobe: required("SEARCHI_TEST_FFPROBE")?,
+    };
+    let limits = MediaLimits::default();
+    let metadata = searchi_media::probe(&tools, &source, &limits)?;
+    anyhow::ensure!(
+        metadata.has_audio && metadata.duration_ms <= 30000,
+        "Functional fixture must contain real speech in at most thirty seconds"
+    );
+    let dir = tempfile::tempdir()?;
+    let root = dir.path().join("media");
+    fs::create_dir(&root)?;
+    let path = root.join("meeting.wav");
+    fs::copy(&source, &path)?;
+    let db = dir.path().join("index.db");
+    let mut lexical = SearchIndex::open(&db)?;
+    lexical.index_folder(&root)?;
+    let mut indexer = HybridSearch::open(&db, &model, &gemma, 1)?;
+    let raw = indexer.index_embeddings_with_media(&tools, &limits)?;
+    assert!(raw.failures.is_empty());
+    assert_eq!(raw.audio_inference_calls, 1);
+    let original_vectors = raw_vectors(&db)?;
+    assert_eq!(original_vectors.len(), 1);
+    indexer = indexer.with_speech_provider(Box::new(native()?))?;
+    let speech = indexer.index_embeddings_with_media(&tools, &limits)?;
+    assert!(speech.speech_failures.is_empty());
+    assert_eq!(speech.audio_inference_calls, 0);
+    assert_eq!(speech.speech_windows, 1);
+    assert!(speech.speech_chunks > 0);
+    assert_eq!(raw_vectors(&db)?, original_vectors);
+    let connection = rusqlite::Connection::open(&db)?;
+    let recognized:String=connection.query_row("SELECT snippet FROM semantic_chunks WHERE generation=(SELECT active_generation FROM semantic_meta WHERE singleton=1) AND source_type='speech' ORDER BY ordinal LIMIT 1",[],|row|row.get(0))?;
+    let mut reader = HybridSearch::open_query(&db, &model, &gemma, 1)?;
+    let query = format!("someone says {recognized}");
+    let hits = reader.search(&query, 1, &SearchOptions::default())?;
+    assert_eq!(hits.len(), 1);
+    assert_eq!(hits[0].match_kind, "semantic_speech");
+    let location = hits[0]
+        .source
+        .as_ref()
+        .context("recognized source timestamp")?;
+    assert_eq!(location.kind, "timestamp_ms");
+    let excerpt = reader
+        .speech_excerpt_matching(&hits[0].path, location.number, &hits[0].snippet, 4096)?
+        .context("verified recognized evidence")?;
+    assert_eq!(excerpt.provenance, "local_speech_recognition");
+    assert_eq!(excerpt.text, hits[0].snippet);
+    let calls = Arc::new(AtomicUsize::new(0));
+    let worker = native()?;
+    let fingerprint = format!("{};functional-fault-injection-v1", worker.fingerprint());
+    indexer = indexer.with_speech_provider(Box::new(FailOnceNative {
+        worker,
+        fingerprint,
+        fail_once: true,
+        calls: calls.clone(),
+    }))?;
+    let partial = indexer.index_embeddings_with_media(&tools, &limits)?;
+    assert_eq!(partial.speech_failures.len(), 1);
+    assert_eq!(partial.audio_inference_calls, 0);
+    assert_eq!(raw_vectors(&db)?, original_vectors);
+    let status = HybridSearch::embedding_status(&db)?;
+    assert_eq!(status.speech_failures.len(), 1);
+    let retry = indexer.index_embeddings_with_media(&tools, &limits)?;
+    assert!(retry.speech_failures.is_empty());
+    assert_eq!(retry.audio_inference_calls, 0);
+    assert_eq!(calls.load(Ordering::SeqCst), 2);
+    assert!(retry.speech_chunks > 0);
+    assert_eq!(raw_vectors(&db)?, original_vectors);
+    let current = HybridSearch::embedding_status(&db)?;
+    assert!(current.speech_failures.is_empty());
+    assert_eq!(
+        current.corpus_revision, status.corpus_revision,
+        "Partial publication must not reset automatic retry identity"
+    );
+    assert_eq!(current.speech_policy, status.speech_policy);
+    // The retained foreground Google query session adopts the compatible publication.
+    let hits = reader.search(&query, 1, &SearchOptions::default())?;
+    assert_eq!(hits[0].match_kind, "semantic_speech");
+    Ok(())
+}
@@ -0,0 +1,225 @@
+//! Timeline contract uses actual CPU FFmpeg, without speech/model inference.
+use anyhow::{Context, Result};
+use searchi_media::{decode_audio, decode_audio_aligned, probe, AudioWindow};
+use searchi_service::{FfmpegTools, MediaLimits};
+use std::{path::Path, process::Command};
+
+fn fixture(ffmpeg: &Path, args: &[&str], output: &Path) -> Result<()> {
+    let result = Command::new(ffmpeg)
+        .args([
+            "-nostdin",
+            "-hide_banner",
+            "-loglevel",
+            "error",
+            "-threads",
+            "1",
+        ])
+        .args(args)
+        .arg(output)
+        .output()?;
+    anyhow::ensure!(
+        result.status.success(),
+        "Owned CPU media fixture failed: {}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+    Ok(())
+}
+
+#[test]
+#[ignore = "Requires verified CPU FFmpeg/FFprobe helpers; no model inference"]
+fn positioned_audio_decodes_at_its_actual_file_timeline_origin() -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let tools = FfmpegTools {
+        ffmpeg: std::env::var_os("SEARCHI_TEST_FFMPEG")
+            .context("Set SEARCHI_TEST_FFMPEG")?
+            .into(),
+        ffprobe: std::env::var_os("SEARCHI_TEST_FFPROBE")
+            .context("Set SEARCHI_TEST_FFPROBE")?
+            .into(),
+    };
+    let directory = tempfile::tempdir()?;
+    let ordinary = directory.path().join("ordinary.wav");
+    let positioned = directory.path().join("positioned.mkv");
+    fixture(
+        &tools.ffmpeg,
+        &[
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:sample_rate=16000:duration=2",
+            "-c:a",
+            "pcm_s16le",
+        ],
+        &ordinary,
+    )?;
+    fixture(
+        &tools.ffmpeg,
+        &[
+            "-f",
+            "lavfi",
+            "-i",
+            "color=size=16x16:rate=1:duration=4",
+            "-itsoffset",
+            "2",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:sample_rate=16000:duration=2",
+            "-map",
+            "0:v:0",
+            "-map",
+            "1:a:0",
+            "-c:v",
+            "ffv1",
+            "-c:a",
+            "pcm_s16le",
+            "-threads",
+            "1",
+        ],
+        &positioned,
+    )?;
+    let limits = MediaLimits::default();
+    let metadata = probe(&tools, &positioned, &limits)?;
+    assert_eq!(metadata.start_ms, 0);
+    assert_eq!(metadata.audio_start_ms, 2000);
+    assert_eq!(metadata.audio_end_ms, 4000);
+    let baseline = decode_audio(
+        &tools,
+        &ordinary,
+        AudioWindow {
+            start_ms: 0,
+            duration_ms: 2000,
+        },
+        &limits,
+    )?;
+    let actual = decode_audio(
+        &tools,
+        &positioned,
+        AudioWindow {
+            start_ms: metadata.audio_start_ms,
+            duration_ms: metadata.audio_end_ms - metadata.audio_start_ms,
+        },
+        &limits,
+    )?;
+    assert_eq!(baseline.len(), 32000);
+    let aligned = decode_audio_aligned(
+        &tools,
+        &positioned,
+        AudioWindow {
+            start_ms: 2000,
+            duration_ms: 2000,
+        },
+        &limits,
+    )?;
+    assert_eq!(aligned, baseline);
+    let whole = decode_audio_aligned(
+        &tools,
+        &positioned,
+        AudioWindow {
+            start_ms: 0,
+            duration_ms: 4000,
+        },
+        &limits,
+    )?;
+    assert_eq!(whole.len(), 64000);
+    assert!(whole[..32000].iter().all(|sample| *sample == 0.));
+    assert_eq!(&whole[32000..], baseline.as_slice());
+    assert_eq!(
+        actual, baseline,
+        "First decoded sample must represent the requested actual audio origin"
+    );
+    Ok(())
+}
+
+#[test]
+#[ignore = "Requires verified CPU FFmpeg/FFprobe helpers; no model inference"]
+fn aligned_decoder_preserves_internal_gap_seek_and_tail_source_clock() -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let tools = FfmpegTools {
+        ffmpeg: std::env::var_os("SEARCHI_TEST_FFMPEG")
+            .context("Set SEARCHI_TEST_FFMPEG")?
+            .into(),
+        ffprobe: std::env::var_os("SEARCHI_TEST_FFPROBE")
+            .context("Set SEARCHI_TEST_FFPROBE")?
+            .into(),
+    };
+    let directory = tempfile::tempdir()?;
+    let ordinary = directory.path().join("ramp.wav");
+    let gapped = directory.path().join("gapped.mka");
+    fixture(
+        &tools.ffmpeg,
+        &[
+            "-f",
+            "lavfi",
+            "-i",
+            "aevalsrc=0.1+0.1*t:s=16000:d=3",
+            "-c:a",
+            "pcm_s16le",
+        ],
+        &ordinary,
+    )?;
+    // Three exact one-second frames carry PTS 0,2,3; the source clock has a one-second gap.
+    fixture(
+        &tools.ffmpeg,
+        &[
+            "-f",
+            "lavfi",
+            "-i",
+            "aevalsrc=0.1+0.1*t:s=16000:d=3",
+            "-af",
+            "asetnsamples=n=16000:p=0,asetpts=PTS+gte(T\\,1)/TB",
+            "-c:a",
+            "pcm_s16le",
+        ],
+        &gapped,
+    )?;
+    let limits = MediaLimits::default();
+    let metadata = probe(&tools, &gapped, &limits)?;
+    assert_eq!(metadata.start_ms, 0);
+    assert_eq!(metadata.audio_start_ms, 0);
+    assert_eq!(metadata.audio_end_ms, 4000);
+    let source = decode_audio(
+        &tools,
+        &ordinary,
+        AudioWindow {
+            start_ms: 0,
+            duration_ms: 3000,
+        },
+        &limits,
+    )?;
+    assert_eq!(source.len(), 48000);
+    let mut expected = source[..16000].to_vec();
+    expected.extend(vec![0.; 16000]);
+    expected.extend_from_slice(&source[16000..]);
+    let whole = decode_audio_aligned(
+        &tools,
+        &gapped,
+        AudioWindow {
+            start_ms: 0,
+            duration_ms: 4000,
+        },
+        &limits,
+    )?;
+    assert_eq!(whole, expected);
+    let seek = decode_audio_aligned(
+        &tools,
+        &gapped,
+        AudioWindow {
+            start_ms: 1500,
+            duration_ms: 1500,
+        },
+        &limits,
+    )?;
+    assert_eq!(seek, &expected[24000..48000]);
+    let tail = decode_audio_aligned(
+        &tools,
+        &gapped,
+        AudioWindow {
+            start_ms: 3500,
+            duration_ms: 500,
+        },
+        &limits,
+    )?;
+    assert_eq!(tail, &expected[56000..64000]);
+    Ok(())
+}
@@ -0,0 +1,12 @@
+[package]
+name = "searchi-speech"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+description = "Bounded local speech worker client for searchi"
+
+[dependencies]
+anyhow = "1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sha2 = "0.10"
@@ -0,0 +1,150 @@
+//! Verify every isolated runtime code artifact before starting a worker.
+use super::{file_hash, Device, UPSTREAM};
+use anyhow::{ensure, Context, Result};
+use serde::Deserialize;
+use sha2::{Digest, Sha256};
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fs,
+    path::Path,
+};
+#[derive(Deserialize)]
+struct Manifest {
+    schema: u32,
+    upstream_commit: String,
+    device: String,
+    distribution: bool,
+    source_hashes: BTreeMap<String, String>,
+    files: Vec<Entry>,
+}
+#[derive(Deserialize)]
+struct Entry {
+    path: String,
+    bytes: u64,
+    sha256: String,
+}
+pub(crate) fn verify(worker: &Path, device: Device) -> Result<String> {
+    let directory = worker
+        .parent()
+        .context("Missing speech runtime directory")?;
+    let path = directory.join("runtime-manifest.json");
+    ensure!(
+        fs::symlink_metadata(&path)
+            .context("Speech runtime inventory missing")?
+            .file_type()
+            .is_file(),
+        "Runtime inventory must be a regular file"
+    );
+    ensure!(
+        fs::metadata(&path)?.len() <= 512 * 1024,
+        "Runtime inventory exceeds bound"
+    );
+    let bytes = fs::read(path)?;
+    let manifest: Manifest =
+        serde_json::from_slice(&bytes).context("Invalid speech runtime inventory")?;
+    ensure!(
+        manifest.schema == 1 && manifest.upstream_commit == UPSTREAM,
+        "Stale speech runtime inventory"
+    );
+    ensure!(
+        matches!(manifest.device.as_str(), "auto" | "cpu")
+            && manifest.distribution == (manifest.device == "auto"),
+        "Inconsistent speech distribution inventory"
+    );
+    ensure!(
+        device == Device::Cpu || manifest.distribution,
+        "CPU-only speech runtime is an internal tool"
+    );
+    for name in ["CMakeLists.txt", "worker.cpp", "build.py"] {
+        ensure!(
+            manifest.source_hashes.get(name).is_some_and(|s| hash(s)),
+            "Missing speech build-input provenance"
+        );
+    }
+    ensure!(
+        !manifest.files.is_empty() && manifest.files.len() <= 128,
+        "Unbounded speech runtime inventory"
+    );
+    let mut seen = BTreeSet::new();
+    let mut total = 0u64;
+    for entry in manifest.files {
+        ensure!(
+            !entry.path.is_empty()
+                && entry.path != "."
+                && entry.path != ".."
+                && !entry.path.contains(['/', '\\', ':'])
+                && seen.insert(entry.path.clone()),
+            "Invalid speech inventory filename"
+        );
+        ensure!(
+            entry.bytes > 0 && entry.bytes <= 256 * 1024 * 1024 && hash(&entry.sha256),
+            "Invalid speech inventory artifact"
+        );
+        total = total
+            .checked_add(entry.bytes)
+            .context("Speech runtime size overflow")?;
+        ensure!(
+            total <= 1024 * 1024 * 1024,
+            "Speech runtime exceeds size budget"
+        );
+        let path = directory.join(&entry.path);
+        ensure!(
+            fs::symlink_metadata(&path)?.file_type().is_file()
+                && fs::metadata(&path)?.len() == entry.bytes
+                && file_hash(&path)? == entry.sha256,
+            "Speech runtime artifact size/SHA changed"
+        );
+    }
+    ensure!(
+        worker
+            .file_name()
+            .and_then(|s| s.to_str())
+            .is_some_and(|name| seen.contains(name)),
+        "Worker omitted from speech runtime inventory"
+    );
+    Ok(format!("{:x}", Sha256::digest(bytes)))
+}
+fn hash(value: &str) -> bool {
+    value.len() == 64 && value.bytes().all(|b| b.is_ascii_hexdigit())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use std::time::{SystemTime, UNIX_EPOCH};
+    #[test]
+    fn altered_dependency_or_missing_inventory_fails_before_process_launch() {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let root = std::env::temp_dir().join(format!(
+            "searchi-speech-inventory-{}-{unique}",
+            std::process::id()
+        ));
+        fs::create_dir(&root).unwrap();
+        let worker = root.join("worker");
+        let library = root.join("ggml-cpu.dll");
+        fs::write(&worker, b"structural worker fixture").unwrap();
+        fs::write(&library, b"structural library fixture").unwrap();
+        assert!(verify(&worker, Device::Cpu).is_err());
+        let artifact = |path: &Path| json!({"path":path.file_name().unwrap().to_str().unwrap(),"bytes":fs::metadata(path).unwrap().len(),"sha256":file_hash(path).unwrap()});
+        let sources: BTreeMap<_, _> = ["CMakeLists.txt", "worker.cpp", "build.py"]
+            .into_iter()
+            .map(|s| (s, "a".repeat(64)))
+            .collect();
+        let manifest = json!({"schema":1,"upstream_commit":UPSTREAM,"device":"cpu","distribution":false,"source_hashes":sources,"files":[artifact(&worker),artifact(&library)]});
+        fs::write(
+            root.join("runtime-manifest.json"),
+            serde_json::to_vec(&manifest).unwrap(),
+        )
+        .unwrap();
+        let identity = verify(&worker, Device::Cpu).unwrap();
+        assert_eq!(identity.len(), 64);
+        assert!(verify(&worker, Device::Auto).is_err());
+        fs::write(library, b"same length changed bits").unwrap();
+        assert!(verify(&worker, Device::Cpu).is_err());
+        fs::remove_dir_all(root).unwrap();
+    }
+}
@@ -0,0 +1,273 @@
+//! Local, isolated speech recognition. Google embeddings remain a separate lane.
+//! Calls consume at most thirty seconds of mono 16 kHz PCM. The service admits
+//! each call to its background inference budget; this client creates no scheduler.
+mod inventory;
+mod process;
+use anyhow::{ensure, Context, Result};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    fs,
+    io::Read,
+    path::{Path, PathBuf},
+    time::Instant,
+};
+
+pub const SAMPLE_RATE: u32 = 16000;
+pub const MAX_SAMPLES: usize = 480000;
+pub const POLICY: &str = "live-window-vad-dtw-v1;silero-v6.2.0;base;30s;vad-reset;threshold0.5;minspeech250ms;minsilence100ms;maxspeechFLT_MAX;pad30ms;vad-overlap0.1s;source-sample-intersections;beam5;bestof5;temp0;tempinc0.2;entropy2.4;logprob-1;nospeech0.6;suppressblank;no-suppress-nst;auto-language;no-context;dtw-base;no-flash;contiguous-intervals;first-last-token-points;exact-utf8";
+pub const UPSTREAM: &str = "d1be6fde11ac6e0407606b4e42fe72d34add8037";
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SpeechPassage {
+    pub start_ms: u32,
+    pub end_ms: u32,
+    pub text: String,
+}
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
+pub struct SpeechMetrics {
+    pub vad_ms: f64,
+    pub asr_ms: f64,
+    pub load_ms: f64,
+    pub transport_ms: f64,
+    #[serde(default)]
+    pub fallback_ms: f64,
+}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct SpeechTranscription {
+    pub passages: Vec<SpeechPassage>,
+    pub metrics: SpeechMetrics,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Device {
+    Auto,
+    Cpu,
+}
+
+/// One owned persistent process. Base recognition context loads only on speech.
+pub struct SpeechWorker {
+    process: process::WorkerProcess,
+    fingerprint: String,
+    worker_path: PathBuf,
+    base_path: PathBuf,
+    vad_path: PathBuf,
+    device: Device,
+}
+
+fn verified_file(path: &Path, bytes: u64, expected: &str) -> Result<String> {
+    ensure!(
+        fs::metadata(path)?.is_file() && fs::metadata(path)?.len() == bytes,
+        "Speech model size differs"
+    );
+    let actual = file_hash(path)?;
+    ensure!(actual == expected, "Speech model SHA-256 differs");
+    Ok(actual)
+}
+fn file_hash(path: &Path) -> Result<String> {
+    let mut file = fs::File::open(path)?;
+    let mut hash = Sha256::new();
+    let mut buffer = [0; 65536];
+    loop {
+        let n = file.read(&mut buffer)?;
+        if n == 0 {
+            break;
+        }
+        hash.update(&buffer[..n]);
+    }
+    Ok(format!("{:x}", hash.finalize()))
+}
+
+impl SpeechWorker {
+    /// Verify exact pinned model bytes before launching the isolated worker.
+    /// Normal distributions use Auto; Windows VM tests must select Cpu.
+    pub fn load(worker: &Path, base: &Path, vad: &Path, device: Device) -> Result<Self> {
+        let device = if std::env::var_os("SEARCHI_FORCE_CPU").is_some_and(|v| v == "1") {
+            Device::Cpu
+        } else {
+            device
+        };
+        let inventory_hash = inventory::verify(worker, device)?;
+        let base_hash = verified_file(
+            base,
+            147951465,
+            "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe",
+        )?;
+        let vad_hash = verified_file(
+            vad,
+            885098,
+            "2aa269b785eeb53a82983a20501ddf7c1d9c48e33ab63a41391ac6c9f7fb6987",
+        )?;
+        let meta = fs::metadata(worker)?;
+        ensure!(
+            meta.is_file() && meta.len() > 0 && meta.len() <= 64 * 1024 * 1024,
+            "Invalid speech worker size"
+        );
+        let worker_hash = file_hash(worker)?;
+        let fingerprint = format!(
+            "{POLICY};runtime={UPSTREAM};inventory={inventory_hash};worker={worker_hash};base={base_hash};vad={vad_hash}"
+        );
+        let process = process::WorkerProcess::launch(worker, base, vad, device)?;
+        Ok(Self {
+            process,
+            fingerprint,
+            worker_path: worker.to_owned(),
+            base_path: base.to_owned(),
+            vad_path: vad.to_owned(),
+            device,
+        })
+    }
+    pub fn fingerprint(&self) -> &str {
+        &self.fingerprint
+    }
+    pub fn transcribe(&mut self, pcm: &[f32], sample_rate: u32) -> Result<SpeechTranscription> {
+        ensure!(
+            sample_rate == SAMPLE_RATE && !pcm.is_empty() && pcm.len() <= MAX_SAMPLES,
+            "Speech requires bounded mono 16 kHz PCM"
+        );
+        ensure!(pcm.iter().all(|v| v.is_finite()), "Nonfinite speech input");
+        let fallback_started = Instant::now();
+        match self.transcribe_once(pcm) {
+            Ok(value) => Ok(value),
+            Err(error) if self.device == Device::Auto && process::recoverable(&error) => {
+                // Retry only initialization/compute/transport failures. Reverify
+                // assets and all runtime code before a sticky CPU replacement.
+                let replacement = Self::load(
+                    &self.worker_path,
+                    &self.base_path,
+                    &self.vad_path,
+                    Device::Cpu,
+                )?;
+                ensure!(
+                    replacement.fingerprint == self.fingerprint,
+                    "Speech assets changed before CPU fallback"
+                );
+                *self = replacement;
+                let fallback_ms = fallback_started.elapsed().as_secs_f64() * 1000.0;
+                let mut result = self.transcribe_once(pcm)?;
+                result.metrics.fallback_ms = fallback_ms;
+                Ok(result)
+            }
+            Err(error) => Err(error),
+        }
+    }
+    fn transcribe_once(&mut self, pcm: &[f32]) -> Result<SpeechTranscription> {
+        let started = Instant::now();
+        let detection = self.process.request(1, pcm)?;
+        let mut metrics = SpeechMetrics::default();
+        add_metrics(&mut metrics, &detection)?;
+        let intervals = detection["intervals_samples"]
+            .as_array()
+            .context("Missing live VAD intervals")?;
+        ensure!(intervals.len() <= 128, "Oversized live VAD intervals");
+        let mut previous = 0;
+        let mut passages = Vec::new();
+        for interval in intervals {
+            let pair = interval.as_array().context("Invalid VAD interval")?;
+            ensure!(pair.len() == 2, "Invalid VAD interval pair");
+            let start = usize::try_from(pair[0].as_u64().context("Invalid VAD start")?)?;
+            let end = usize::try_from(pair[1].as_u64().context("Invalid VAD end")?)?;
+            ensure!(
+                start >= previous && start < end && end <= pcm.len(),
+                "Invalid VAD source bounds"
+            );
+            previous = end;
+            let recognition = self.process.request(2, &pcm[start..end])?;
+            add_metrics(&mut metrics, &recognition)?;
+            passages.extend(parse_passages(&recognition, start, end - start)?);
+            ensure!(
+                passages.len() <= 64
+                    && passages.iter().map(|p| p.text.len()).sum::<usize>() <= 64 * 1024,
+                "Recognized speech output exceeds window budget"
+            );
+        }
+        let native = metrics.vad_ms + metrics.asr_ms + metrics.load_ms;
+        metrics.transport_ms = (started.elapsed().as_secs_f64() * 1000.0 - native).max(0.0);
+        Ok(SpeechTranscription { passages, metrics })
+    }
+}
+
+fn add_metrics(metrics: &mut SpeechMetrics, response: &serde_json::Value) -> Result<()> {
+    for (field, target) in [
+        ("vad_ms", &mut metrics.vad_ms),
+        ("asr_ms", &mut metrics.asr_ms),
+        ("load_ms", &mut metrics.load_ms),
+    ] {
+        let v = response[field].as_f64().context("Missing speech timing")?;
+        ensure!(v.is_finite() && v >= 0.0, "Invalid speech timing");
+        *target += v;
+    }
+    Ok(())
+}
+
+fn parse_passages(
+    response: &serde_json::Value,
+    offset_samples: usize,
+    samples: usize,
+) -> Result<Vec<SpeechPassage>> {
+    let rows = response["sentences"]
+        .as_array()
+        .context("Missing recognized sentences")?;
+    ensure!(rows.len() <= 64, "Oversized recognized sentences");
+    let mut previous = 0;
+    let mut result = Vec::new();
+    let mut text_bytes = 0;
+    for row in rows {
+        let start = row["start_cs"].as_u64().context("Invalid DTW start")?;
+        let end = row["end_cs"].as_u64().context("Invalid DTW end")?;
+        ensure!(
+            start >= previous
+                && start <= end
+                && end.checked_mul(160).is_some_and(|v| v <= samples as u64),
+            "Invalid DTW source point span"
+        );
+        previous = end;
+        let text = row["text"]
+            .as_str()
+            .context("Invalid recognized UTF-8 text")?;
+        ensure!(
+            !text.trim().is_empty() && text.len() <= 4096,
+            "Invalid recognized text size"
+        );
+        text_bytes += text.len();
+        ensure!(
+            text_bytes <= 64 * 1024,
+            "Recognized text exceeds window budget"
+        );
+        let origin = offset_samples as u64 / 16;
+        result.push(SpeechPassage {
+            start_ms: u32::try_from(origin + start * 10)?,
+            end_ms: u32::try_from(origin + end * 10)?,
+            text: text.to_owned(),
+        });
+    }
+    Ok(result)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    #[test]
+    fn actual_points_may_have_zero_span_and_origin_is_applied_once() {
+        let response = json!({"sentences":[{"start_cs":2,"end_cs":2,"text":" exact "}]});
+        assert_eq!(
+            parse_passages(&response, 16000, 16000).unwrap(),
+            vec![SpeechPassage {
+                start_ms: 1020,
+                end_ms: 1020,
+                text: " exact ".into()
+            }]
+        );
+    }
+    #[test]
+    fn reversed_missing_outside_nonmonotonic_points_and_oversized_text_rejected() {
+        for row in [
+            json!({"start_cs":2,"end_cs":1,"text":"x"}),
+            json!({"start_cs":0,"end_cs":101,"text":"x"}),
+            json!({"start_cs":1.5,"end_cs":2,"text":"x"}),
+            json!({"start_cs":0,"end_cs":2,"text":"x".repeat(4097)}),
+        ] {
+            assert!(parse_passages(&json!({"sentences":[row]}), 0, 16000).is_err());
+        }
+    }
+}
@@ -0,0 +1,289 @@
+//! Bounded binary PCM transport to a single owned native process.
+use super::{Device, MAX_SAMPLES, POLICY, UPSTREAM};
+use anyhow::{ensure, Context, Result};
+use serde_json::Value;
+use std::{
+    io::{Read, Write},
+    path::Path,
+    process::{Child, ChildStdin, ChildStdout, Command, Stdio},
+    sync::mpsc,
+    thread::{self, JoinHandle},
+    time::{Duration, Instant},
+};
+const MAX_OUTPUT: usize = 4 * 1024 * 1024;
+const DEADLINE: Duration = Duration::from_secs(600);
+
+#[derive(Debug)]
+pub(crate) enum NativeFailure {
+    Initialization,
+    Compute,
+    MalformedText,
+    InvalidPoints,
+    Rejected,
+}
+impl NativeFailure {
+    pub fn recoverable(&self) -> bool {
+        matches!(self, Self::Initialization | Self::Compute)
+    }
+}
+impl std::fmt::Display for NativeFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::Initialization => "Speech native initialization failed",
+            Self::Compute => "Speech native computation failed",
+            Self::MalformedText => "Speech recognized invalid UTF-8",
+            Self::InvalidPoints => "Speech recognized invalid DTW points",
+            Self::Rejected => "Speech native operation rejected",
+        })
+    }
+}
+impl std::error::Error for NativeFailure {}
+#[derive(Debug)]
+struct ProtocolFailure;
+impl std::fmt::Display for ProtocolFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Invalid speech worker response protocol")
+    }
+}
+impl std::error::Error for ProtocolFailure {}
+#[derive(Debug)]
+struct TransportFailure;
+impl std::fmt::Display for TransportFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("Speech worker transport exited or timed out")
+    }
+}
+impl std::error::Error for TransportFailure {}
+pub(crate) fn recoverable(error: &anyhow::Error) -> bool {
+    error.is::<TransportFailure>()
+        || error
+            .downcast_ref::<NativeFailure>()
+            .is_some_and(NativeFailure::recoverable)
+}
+
+fn read_response<R: Read>(reader: &mut R) -> Result<Value> {
+    let mut prefix = [0; 4];
+    reader
+        .read_exact(&mut prefix)
+        .context("Speech worker closed response")?;
+    let bytes = u32::from_le_bytes(prefix) as usize;
+    if bytes == 0 || bytes > MAX_OUTPUT {
+        return Err(ProtocolFailure.into());
+    }
+    let mut output = vec![0; bytes];
+    reader.read_exact(&mut output)?;
+    let value: Value = serde_json::from_slice(&output).map_err(|_| ProtocolFailure)?;
+    if !value.is_object() {
+        return Err(ProtocolFailure.into());
+    }
+    Ok(value)
+}
+
+pub(crate) struct WorkerProcess {
+    child: Child,
+    stdin: Option<ChildStdin>,
+    stdout: Option<ChildStdout>,
+    stderr: Option<JoinHandle<()>>,
+    failed: bool,
+    distribution_auto: bool,
+}
+impl WorkerProcess {
+    pub fn launch(worker: &Path, base: &Path, vad: &Path, device: Device) -> Result<Self> {
+        let mut command = Command::new(worker);
+        command.arg(base).arg(vad).arg(match device {
+            Device::Auto => "auto",
+            Device::Cpu => "cpu",
+        });
+        let result = Self::spawn(command, Duration::from_secs(30))?;
+        ensure!(
+            device == Device::Cpu || result.distribution_auto,
+            "CPU-only native speech worker is an internal tool"
+        );
+        Ok(result)
+    }
+    fn spawn(mut command: Command, startup_deadline: Duration) -> Result<Self> {
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            command.creation_flags(0x08000000);
+        }
+        let mut child = command.spawn().context("Launch isolated speech worker")?;
+        let stdin = child.stdin.take();
+        let stdout = child.stdout.take();
+        // Drain continuously without retaining transcripts or unbounded log bytes.
+        let stderr = child.stderr.take().map(|mut pipe| {
+            thread::spawn(move || {
+                let mut buffer = [0; 4096];
+                while pipe.read(&mut buffer).is_ok_and(|n| n > 0) {}
+            })
+        });
+        let mut result = Self {
+            child,
+            stdin,
+            stdout,
+            stderr,
+            failed: false,
+            distribution_auto: false,
+        };
+        let ready = result.exchange(Vec::new(), startup_deadline)?;
+        ensure!(
+            ready["protocol"] == 1
+                && ready["runtime"] == UPSTREAM
+                && ready["ready"] == true
+                && ready["policy"] == POLICY,
+            "Legacy or incompatible speech worker"
+        );
+        result.distribution_auto = ready["distribution_auto"].as_bool().unwrap_or(false);
+        Ok(result)
+    }
+    pub fn request(&mut self, operation: u8, pcm: &[f32]) -> Result<Value> {
+        ensure!(
+            !self.failed && !pcm.is_empty() && pcm.len() <= MAX_SAMPLES,
+            "Unavailable speech session or unbounded PCM"
+        );
+        let mut request = Vec::with_capacity(5 + pcm.len() * 4);
+        request.push(operation);
+        request.extend_from_slice(&(pcm.len() as u32).to_le_bytes());
+        for value in pcm {
+            request.extend_from_slice(&value.to_le_bytes());
+        }
+        let result = self.exchange(request, DEADLINE)?;
+        if result["ok"] != true {
+            return Err(match result["error"].as_str() {
+                Some("base_load_failed" | "vad_load_failed") => NativeFailure::Initialization,
+                Some("recognition_failed" | "vad_failed" | "vad_intervals_failed") => {
+                    NativeFailure::Compute
+                }
+                Some("malformed_recognition_utf8") => NativeFailure::MalformedText,
+                Some("invalid_dtw_point") => NativeFailure::InvalidPoints,
+                _ => NativeFailure::Rejected,
+            }
+            .into());
+        }
+        ensure!(
+            result["operation"] == operation && result["samples"] == pcm.len(),
+            "Speech response identity differs"
+        );
+        Ok(result)
+    }
+    fn exchange(&mut self, request: Vec<u8>, deadline: Duration) -> Result<Value> {
+        let mut input = self.stdin.take().context("Missing speech input")?;
+        let mut output = self.stdout.take().context("Missing speech output")?;
+        let (sender, receiver) = mpsc::channel();
+        let task = thread::spawn(move || {
+            let result = (|| {
+                if !request.is_empty() {
+                    input.write_all(&request)?;
+                    input.flush()?;
+                }
+                read_response(&mut output)
+            })();
+            let _ = sender.send((input, output, result));
+        });
+        let started = Instant::now();
+        let result = loop {
+            match receiver.recv_timeout(Duration::from_millis(20)) {
+                Ok(value) => break Some(value),
+                Err(mpsc::RecvTimeoutError::Timeout) => {
+                    if started.elapsed() >= deadline || !matches!(self.child.try_wait(), Ok(None)) {
+                        break None;
+                    }
+                }
+                Err(mpsc::RecvTimeoutError::Disconnected) => break None,
+            }
+        };
+        if result.is_none() {
+            self.failed = true;
+            let _ = self.child.kill();
+            let _ = self.child.wait();
+        }
+        let _ = task.join();
+        match result {
+            Some((stdin, stdout, result)) => {
+                self.stdin = Some(stdin);
+                self.stdout = Some(stdout);
+                if result.is_err() {
+                    self.failed = true;
+                    let _ = self.child.kill();
+                    let _ = self.child.wait();
+                }
+                result.map_err(|error| {
+                    if error.is::<std::io::Error>() {
+                        TransportFailure.into()
+                    } else {
+                        error
+                    }
+                })
+            }
+            None => Err(TransportFailure.into()),
+        }
+    }
+}
+impl Drop for WorkerProcess {
+    fn drop(&mut self) {
+        self.stdin.take();
+        self.stdout.take();
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+        if let Some(task) = self.stderr.take() {
+            let _ = task.join();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn framing_rejects_oversize_truncated_and_invalid_utf8_before_json() {
+        assert!(read_response(&mut &((MAX_OUTPUT as u32 + 1).to_le_bytes())[..]).is_err());
+        assert!(read_response(&mut &[5, 0, 0, 0, b'{'][..]).is_err());
+        assert!(read_response(&mut &[2, 0, 0, 0, 0xff, 0xff][..]).is_err());
+        let mut frame = (11u32).to_le_bytes().to_vec();
+        frame.extend_from_slice(b"{\"ok\":true}");
+        assert_eq!(read_response(&mut frame.as_slice()).unwrap()["ok"], true);
+    }
+    #[test]
+    #[ignore = "Requires Python for actual owned subprocess transport fixtures, no inference"]
+    fn actual_subprocess_timeout_and_overflow_are_reaped() {
+        let python = std::env::var_os("SEARCHI_TEST_PYTHON").unwrap_or_else(|| "python".into());
+        let ready=format!("import sys,struct,json,time; b=json.dumps({{'protocol':1,'ready':True,'runtime':'{UPSTREAM}','policy':'{POLICY}'}}).encode();sys.stdout.buffer.write(struct.pack('<I',len(b))+b);sys.stdout.buffer.flush();");
+        let mut command = Command::new(&python);
+        command.arg("-c").arg(format!("{ready}time.sleep(10)"));
+        let mut process = WorkerProcess::spawn(command, Duration::from_secs(5)).unwrap();
+        let error = process
+            .exchange(vec![1], Duration::from_millis(50))
+            .unwrap_err();
+        assert!(recoverable(&error));
+        assert!(process.child.try_wait().unwrap().is_some());
+        assert!(process.failed);
+        let mut command = Command::new(&python);
+        command.arg("-c").arg(format!("{ready}sys.stdin.buffer.read(1);sys.stdout.buffer.write(struct.pack('<I',4194305));sys.stdout.buffer.flush();time.sleep(10)"));
+        let mut process = WorkerProcess::spawn(command, Duration::from_secs(5)).unwrap();
+        let error = process
+            .exchange(vec![1], Duration::from_secs(1))
+            .unwrap_err();
+        assert!(!recoverable(&error));
+        assert!(process.child.try_wait().unwrap().is_some());
+        assert!(process.failed);
+    }
+    #[test]
+    fn invalid_text_points_and_protocol_never_authorize_cpu_retry() {
+        for error in [
+            anyhow::Error::new(NativeFailure::MalformedText),
+            anyhow::Error::new(NativeFailure::InvalidPoints),
+            anyhow::Error::new(ProtocolFailure),
+        ] {
+            assert!(!recoverable(&error));
+        }
+        assert!(recoverable(&NativeFailure::Initialization.into()));
+        assert!(recoverable(&NativeFailure::Compute.into()));
+        assert!(!recoverable(
+            &read_response(&mut &[2, 0, 0, 0, 0xff, 0xff][..]).unwrap_err()
+        ));
+    }
+}
@@ -0,0 +1,113 @@
+//! Explicit real local speech proof; excluded from ordinary structural checks.
+use anyhow::{ensure, Context, Result};
+use searchi_speech::{Device, SpeechWorker, MAX_SAMPLES};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    time::{SystemTime, UNIX_EPOCH},
+};
+fn required(name: &str) -> Result<PathBuf> {
+    std::env::var_os(name)
+        .map(PathBuf::from)
+        .with_context(|| format!("Set {name} for actual CPU speech proof"))
+}
+struct OwnedFixture(PathBuf);
+impl Drop for OwnedFixture {
+    fn drop(&mut self) {
+        let _ = fs::remove_dir_all(&self.0);
+    }
+}
+fn link_or_copy(source: &Path, target: &Path) -> Result<()> {
+    if fs::hard_link(source, target).is_err() {
+        fs::copy(source, target)?;
+    }
+    Ok(())
+}
+
+#[test]
+#[ignore = "Requires actual pinned native worker/models and a verified speech PCM fixture; CPU only"]
+fn actual_speech_reuses_contexts_and_supports_unicode_runtime_and_model_paths() -> Result<()> {
+    let worker = required("SEARCHI_TEST_SPEECH_WORKER")?;
+    let base = required("SEARCHI_TEST_SPEECH_BASE")?;
+    let vad = required("SEARCHI_TEST_SPEECH_VAD")?;
+    let pcm_file = required("SEARCHI_TEST_SPEECH_PCM")?;
+    ensure!(
+        fs::metadata(&pcm_file)?.len() <= MAX_SAMPLES as u64 * 4,
+        "Proof PCM exceeds limit"
+    );
+    let bytes = fs::read(pcm_file)?;
+    ensure!(
+        !bytes.is_empty() && bytes.len() % 4 == 0,
+        "Invalid proof PCM bytes"
+    );
+    let pcm: Vec<f32> = bytes
+        .as_chunks::<4>()
+        .0
+        .iter()
+        .map(|b| f32::from_le_bytes(*b))
+        .collect();
+    let unique = SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos();
+    let fixture = OwnedFixture(std::env::temp_dir().join(format!(
+        "searchi-sprachtest-München-測試-🚀-{}-{unique}",
+        std::process::id()
+    )));
+    fs::create_dir(&fixture.0)?;
+    let runtime = fixture.0.join("Laufzeit-測試-🚀");
+    fs::create_dir(&runtime)?;
+    let inventory = worker
+        .parent()
+        .context("Worker directory missing")?
+        .join("runtime-manifest.json");
+    let manifest: serde_json::Value = serde_json::from_slice(&fs::read(&inventory)?)?;
+    for record in manifest["files"]
+        .as_array()
+        .context("Missing runtime files")?
+    {
+        let name = record["path"].as_str().context("Invalid inventory name")?;
+        ensure!(
+            !name.contains(['/', '\\', ':']) && name != "..",
+            "Unsafe fixture artifact name"
+        );
+        fs::copy(worker.parent().unwrap().join(name), runtime.join(name))?;
+    }
+    fs::copy(inventory, runtime.join("runtime-manifest.json"))?;
+    let unicode_base = fixture.0.join("Modell-München-測試-🚀.bin");
+    let unicode_vad = fixture.0.join("Sprache-測試-🚀.bin");
+    link_or_copy(&base, &unicode_base)?;
+    link_or_copy(&vad, &unicode_vad)?;
+    ensure!(
+        std::env::var("SEARCHI_FORCE_CPU").ok().as_deref() == Some("1"),
+        "Actual VM inference proof requires forced CPU"
+    );
+    let mut client = SpeechWorker::load(
+        &runtime.join(worker.file_name().unwrap()),
+        &unicode_base,
+        &unicode_vad,
+        Device::Auto,
+    )?;
+    let first = client.transcribe(&pcm, 16000)?;
+    ensure!(
+        !first.passages.is_empty(),
+        "Actual speech fixture produced no passages"
+    );
+    let second = client.transcribe(&pcm, 16000)?;
+    ensure!(
+        first.passages == second.passages,
+        "Warm speech result differs"
+    );
+    ensure!(
+        second.metrics.load_ms == 0.0,
+        "Persistent contexts unexpectedly reloaded"
+    );
+    for passage in first.passages {
+        ensure!(
+            passage.start_ms <= passage.end_ms && passage.end_ms as usize <= pcm.len() / 16,
+            "Native passage outside source window"
+        );
+    }
+    println!(
+        "actual CPU speech: first={:?}; warm={:?}",
+        first.metrics, second.metrics
+    );
+    Ok(())
+}
@@ -224,3 +224,23 @@ synthetic corpus, exclude native UI and large-library/cold-disk claims, and do
 not compare GPU performance. No timing-driven cache/architecture changes made.
 Raw ignored verified report: `.searchi/qa/windows-mcp-013-timing-verified.json`,
 SHA-256 `03c0a21aa35686077fca25e0b4fe7b7014d8f8aa7a07233af6518ac1b694db08`.
+
+## Spoken sources in current development
+
+When the shared index contains locally recognized speech, search results use
+`semantic_speech` with a playback timestamp. MCP issues a bounded source handle
+for that recognized passage. `read_source` verifies the current media bytes and
+the exact issued passage, then returns recognized text, an end point and
+`local_speech_recognition` provenance. Arbitrary timestamp or file-path reads
+remain unavailable. Recognized text is untrusted evidence and can contain errors.
+
+Google query configuration is unchanged: MCP reads the already prepared index;
+it does not start speech recognition or need speech model paths. Headless
+indexing can provision speech data with `searchi setup --speech` and opt into
+recognition using the paired `embed --speech-worker PATH --speech-model-dir DIR`
+options alongside the real Google configuration. The native speech worker and
+models are separate from Google's worker and assets.
+
+This integration is not present in the published Windows 0.1.5 or Linux 0.1.4
+packages. Current checks and delivery gates are tracked in
+[SPEECH-INTEGRATION.md](SPEECH-INTEGRATION.md).
@@ -40,6 +40,14 @@ Google EmbeddingGemma 2 remains the main text/image/audio/video search model.
  preserved; no partial-pool scores were accepted. See SPEECH-DTW.md.
 - [ ] Validate independent speech/languages and integrate accepted alignment with
  model setup, packaging, cancellation, source guards and shared engine clients.
+  - [x] Implement isolated local recognition, independent raw/speech completion,
+    verified excerpts, desktop asset setup and CLI/MCP support; structural and
+    actual decoder-clock checks passed. See [integration](SPEECH-INTEGRATION.md).
+  - [x] Current CPU worker processed real English/German recordings from Unicode
+    paths and reused loaded recognition contexts; this is functional evidence,
+    not independent retrieval or word-timing accuracy.
+  - [ ] Run genuine shared-service Google lifecycle and frozen independent query
+    controls; stage and deliver the normal hardware-detecting runtime.
 - [ ] Validate richer no-answer evidence on new independent positive/negative data; do not retune the failed universal cosine cutoff on old held-out results.
 - [ ] Integrate accepted improvements into shared engine/UI/headless clients with verified setup, lifecycle and CPU performance evidence. Diagnostics alone do not raise the media quality rating.
 - [x] Publish v0.1.0 Windows installer/checksum, verify public download bytes,
@@ -0,0 +1,65 @@
+# Local spoken passages
+
+Google EmbeddingGemma 2 remains the semantic model for text, images, audio and
+video. An isolated local whisper.cpp worker adds recognized text to the same
+Google index. It does not replace raw audio evidence or introduce a hosted
+embedding backend.
+
+The service covers an audio track with contiguous windows of at most thirty
+seconds, overlapping by two seconds. Live Silero detection resets per window;
+multilingual base recognition uses DTW token points. This differs from the
+historical whole-source diagnostic in [SPEECH-DTW.md](SPEECH-DTW.md). Its 6/8
+timing score cannot be carried over to this implementation.
+
+Recognized passages retain source start/end points and exact recognized UTF-8.
+A point span can have zero duration. The UI starts playback at the estimated
+start and explains recognition uncertainty in the small match detail. A source
+point is not a verified complete utterance boundary.
+
+Raw Google media and recognized speech have independent completion policies.
+Adding or retrying recognition reuses compatible raw vectors. Optional speech
+failures preserve raw search evidence and report partial coverage. Excerpts
+require current source bytes/revisions and the issued recognized passage;
+same-stat overwrites invalidate them. CLI, UI and MCP use this shared behavior.
+
+Desktop setup downloads and verifies approximately 149 MB of base/VAD model
+data in addition to Google assets. Google query readiness stays independent.
+The native worker is shipped in an isolated runtime directory. Normal packages
+require both acceleration and CPU support; Windows VM execution is CPU only.
+Automatic retries use source revision and speech policy, preventing generation
+publication from creating an endless retry loop.
+
+Each native call uses one admitted background CPU thread. Detailed indexing
+metrics separate admission, decoding, VAD, model loading, ASR, transport and
+fallback cost. A running native call cannot be preempted by a foreground query
+on a one-thread budget. Raw media decoding and ANN work are outside this
+inference budget.
+
+## Evidence in this source change
+
+- Shared lifecycle, passage bounds, partial failures, provenance and policy
+  tests passed. The complete workspace test command passed with genuine-model
+  tests explicitly ignored pending their dedicated run.
+- Two genuine CPU FFmpeg tests passed: a two-second audio origin, an internal
+  timestamp gap, seeks and tails preserve the source timeline.
+- Desktop Rust: 48 tests and strict Clippy passed. Frontend: 62 tests and
+  formatting passed, including a stable partial-speech retry key.
+- The actual CLI speech setup verified/reused the pinned base and Silero cache.
+- Existing atomic staging tests passed; Windows package tests reject missing,
+  changed, stale and internal CPU-only speech runtimes before replacing an
+  existing archive.
+
+## Checks still required before delivery
+
+- [ ] Current native worker English/German context reuse and Unicode paths.
+- [ ] Actual shared-service ASR plus Google lifecycle integration.
+- [ ] Frozen independent four-file/ten-query and separate seam evaluation.
+- [ ] Normal hardware-detecting runtime staging and Windows package startup.
+- [ ] Publish/install the verified Windows update.
+- [ ] Native playback and graphical interaction, actual GPU execution, and
+  other OS runtime checks.
+
+The independent fixture has no publisher phrase timestamps. It can measure
+retrieval and negative controls, but cannot establish precise word-level timing
+accuracy. Music relevance and general no-answer rejection remain separate open
+quality work; diagnostic integration alone does not raise the media rating.
@@ -258,7 +258,7 @@ def _preserved_snapshot(destination, owned):
    return snapshot


-def stage_resources(destination, sources, validate=None):
+def stage_resources(destination, sources, validate=None, owned_names=None):
    """Replace a verified complete resource directory and preserve other assets."""
    destination = Path(destination).absolute()
    if destination.parent != destination.parent.resolve():
@@ -272,7 +272,7 @@ def stage_resources(destination, sources, validate=None):
            _check_tree(destination)
            if (destination / ".searchi-stage-complete").exists():
                raise RuntimeError("Reserved staging completion marker exists without its journal")
-        owned = _previous_owned(destination)
+        owned = _previous_owned(destination) if owned_names is None else set(owned_names)
        owned_keys = {_resource_key(path) for path in owned}
        preserved = _preserved_snapshot(destination, owned_keys)
        records = []
@@ -15,6 +15,7 @@ import tempfile
 import zipfile
 from embeddinggemma2.runtime_provenance import verify as verify_provenance
 from stage_extraction_worker import verify as verify_extraction
+from stage_speech_worker import verify as verify_speech

 ROOT = Path(__file__).resolve().parents[1]
 CRT_LIBRARIES = {"concrt140.dll", "msvcp140.dll", "msvcp140_1.dll", "msvcp140_2.dll", "msvcp140_atomic_wait.dll", "msvcp140_codecvt_ids.dll", "vccorlib140.dll", "vcruntime140.dll", "vcruntime140_1.dll", "vcruntime140_threads.dll"}
@@ -148,6 +149,7 @@ def package(root, executable, output, cli=None):
    media = media_provenance(root, resources, architecture)
    expected.update(media)
    expected.update(verify_extraction(resources, root, "windows", architecture))
+    expected.update(verify_speech(resources, root, "windows", architecture))
    selected = [(executable, "searchi.exe"), (root / "LICENSE", "LICENSE.txt")]
    if cli is not None:
        if cli.is_symlink() or not cli.is_file() or not 0 < cli.stat().st_size <= MAX_MEMBER:
@@ -200,6 +202,7 @@ def package(root, executable, output, cli=None):
                "Extract the entire folder, then open searchi.exe. Keep its helpers alongside it.\n"
                "Windows needs WebView2. The Microsoft C++ runtime ships with these helpers; Visual Studio is not required.\n"
                "First launch downloads approximately 865 MB of verified Google model files.\n"
+                "Local spoken-passage recognition adds approximately 149 MB of verified speech models.\n"
                "Choose Add folder to index your own files; ordinary search stays local.\n"
                "This is an unsigned development build, not a certified production release.\n")
            if cli is not None:
@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.21)
+project(searchi_speech_runtime LANGUAGES C CXX)
+find_package(Git REQUIRED)
+execute_process(COMMAND "${GIT_EXECUTABLE}" -C "${WHISPER_SOURCE}" rev-parse HEAD OUTPUT_VARIABLE revision OUTPUT_STRIP_TRAILING_WHITESPACE RESULT_VARIABLE status)
+if(NOT status EQUAL 0 OR NOT revision STREQUAL "d1be6fde11ac6e0407606b4e42fe72d34add8037")
+  message(FATAL_ERROR "Provide the pinned whisper.cpp source checkout")
+endif()
+option(SEARCHI_INTERNAL_CPU "Internal Windows VM CPU tool, not distribution" OFF)
+set(GGML_NATIVE OFF CACHE BOOL "" FORCE)
+set(GGML_OPENMP OFF CACHE BOOL "" FORCE)
+set(WHISPER_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(WHISPER_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+foreach(provider CUDA SYCL HIP BLAS)
+  set(GGML_${provider} OFF CACHE BOOL "" FORCE)
+endforeach()
+if(SEARCHI_INTERNAL_CPU)
+  set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+  set(GGML_BACKEND_DL OFF CACHE BOOL "" FORCE)
+  set(GGML_VULKAN OFF CACHE BOOL "" FORCE)
+  set(GGML_METAL OFF CACHE BOOL "" FORCE)
+else()
+  set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+  set(GGML_BACKEND_DL ON CACHE BOOL "" FORCE)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(AMD64|amd64|x86_64)$")
+    set(GGML_CPU_ALL_VARIANTS ON CACHE BOOL "" FORCE)
+  endif()
+  if(APPLE)
+    set(GGML_METAL ON CACHE BOOL "" FORCE)
+    set(GGML_VULKAN OFF CACHE BOOL "" FORCE)
+  else()
+    find_package(Vulkan REQUIRED COMPONENTS glslc)
+    set(GGML_VULKAN ON CACHE BOOL "" FORCE)
+    set(GGML_METAL OFF CACHE BOOL "" FORCE)
+  endif()
+endif()
+add_subdirectory("${WHISPER_SOURCE}" whisper)
+target_compile_features(whisper PRIVATE cxx_std_17)
+add_executable(searchi-speech-worker worker.cpp)
+target_compile_features(searchi-speech-worker PRIVATE cxx_std_17)
+target_link_libraries(searchi-speech-worker PRIVATE whisper)
+if(NOT SEARCHI_INTERNAL_CPU)
+  target_compile_definitions(searchi-speech-worker PRIVATE SEARCHI_DISTRIBUTION_AUTO=1)
+endif()
+if(MSVC)
+  target_compile_options(searchi-speech-worker PRIVATE /utf-8)
+endif()
+if(UNIX)
+  set_target_properties(searchi-speech-worker PROPERTIES BUILD_RPATH "$ORIGIN;@loader_path" INSTALL_RPATH "$ORIGIN;@loader_path")
+endif()
@@ -0,0 +1,79 @@
+# Local speech runtime
+
+This worker uses pinned whisper.cpp `d1be6fde11ac6e0407606b4e42fe72d34add8037`,
+multilingual base and Silero v6.2.0. Google EmbeddingGemma 2 continues to embed
+recognized passages; speech recognition never replaces Google semantic search.
+Model download/verification belongs to searchi's shared asset setup.
+
+Normal builds use one auto runtime with dynamic CPU and Vulkan (Windows/Linux)
+or Metal (macOS) backends. Missing acceleration SDKs fail configuration. Native
+speech GGML libraries belong to this isolated runtime directory, never Google's
+directory. The explicit `--device cpu` build is an internal VM testing tool.
+
+```sh
+python tools/speech-runtime/build.py --source PATH_TO_CLEAN_PINNED_WHISPER_CPP --output NEW_OWNED_BUILD_DIRECTORY --device auto
+```
+
+Output `runtime/runtime-manifest.json` records every runtime file's exact size/SHA,
+the pinned upstream commit and build-input hashes. The Rust client checks all
+inventory files before launch and incorporates the inventory hash in its source
+completion fingerprint. A changed backend DLL therefore invalidates reuse.
+The builder compiles only; native Linux/macOS loading, full system-dependency
+closure, actual GPU speed/fallback and release packaging still require evidence.
+Windows auto builds reuse the verified Vulkan SDK/loader provisioning and selected
+Visual Studio CRT bundling helpers. The isolated runtime inventories its own
+`vulkan-1.dll`, full release CRT set and their redistribution notices. Shared helper
+inputs (including imported provenance/macOS inspection modules) are hashed along
+with the five speech build inputs; app-root DLLs are not assumed to satisfy them.
+
+Actual internal v3 CPU evidence: English and German fixture tests passed with
+`SEARCHI_FORCE_CPU=1`, the Auto client API, supplementary Unicode model/runtime
+paths, repeated stable bounded passages and persistent model reuse. English ASR
+was 26.31/27.80 seconds, German 28.13/22.08 seconds (first/warm) on this shared VM;
+warm model loading was zero and fallback cost zero. Worker SHA-256 was
+`299c1b784eac46b31d228453a399e1378f327fc9ed5e34ab950c804da33e433a`;
+inventory SHA-256 `4904995685a5e55e0a790d9cc409dc8458e39c30cda4097c5d70bf75cb5c976c`.
+This static CPU artifact does not prove normal dynamic-loader isolation, GPU
+execution, speech retrieval quality or precise independently annotated timing.
+
+The persistent worker receives binary requests: operation byte (1 live VAD,
+2 contiguous recognition), little-endian u32 sample count and mono little-endian
+f32 PCM, at most 480000 finite samples. Responses have a four-byte little-endian
+JSON byte length, maximum 4 MiB, strict UTF-8. No arbitrary source paths or stored
+VAD reports enter requests. Model paths are startup arguments; Windows uses
+`wmain` and explicit UTF-16 → UTF-8 conversion. Native logs are consumed without
+forwarding recognized bytes. Error text exposed by the parent is a fixed code.
+
+VAD resets state for every ≤30-second source window; this is a **new live-window
+policy**, not identical to the historical whole-source frozen diagnostic. It
+retains original source intersections and sends actual contiguous speech PCM to
+base ASR. Base loads lazily and remains warm. DTW uses the base preset, disabled
+flash attention and one CPU thread. Adjacent native token byte pieces may be
+joined to recover an actual UTF-8 codepoint; incomplete recognized bytes fail
+closed. Sentence spans use first/last genuine DTW points and can have zero span.
+No text replacement, clamped DTW time or label-specific passage exists.
+
+The service admits a complete ≤30-second transcribe call to its shared background
+budget. Metrics report native load, VAD, ASR and parent transport separately.
+This does not preempt an executing native call or bound decoder/ANN CPU. A worker
+operation has a 600-second IO/inference deadline; malformed framing, oversized
+output, process exit and timeout stop/reap the owned worker. Native worker creates
+no subprocesses. Cancellation between source windows belongs to the service.
+
+Structural checks:
+
+```sh
+cargo test -p searchi-speech --locked
+cargo clippy -p searchi-speech --all-targets --locked -- -D warnings
+python -m unittest discover -s tools/speech-runtime
+```
+
+Owned subprocess transport fixtures require Python and can be run explicitly
+with `cargo test -p searchi-speech actual_subprocess -- --ignored`; no model loads.
+The native `searchi-speech-worker --self-test` checks strict UTF-8/JSON encoding
+without loading models. Actual speech proof is a separate ignored CPU test using
+`SEARCHI_TEST_SPEECH_WORKER`, `SEARCHI_TEST_SPEECH_BASE`,
+`SEARCHI_TEST_SPEECH_VAD`, and verified `SEARCHI_TEST_SPEECH_PCM` (mono16k f32LE).
+It relocates the runtime and exact models to owned Unicode paths, checks genuine
+passages and persistent-context reuse, and cleans only that fixture.
+Run actual inference only after the coordinator grants its CPU slot.
@@ -0,0 +1,124 @@
+"""Build pinned isolated speech runtime; auto distributions require GPU SDKs."""
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import importlib.util
+
+UPSTREAM = "d1be6fde11ac6e0407606b4e42fe72d34add8037"
+
+
+def shared_helper(name):
+    path = Path(__file__).resolve().parent.parent / "embeddinggemma2" / name
+    spec = importlib.util.spec_from_file_location("speech_shared_" + path.stem, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.path.insert(0, str(path.parent))
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        sys.path.pop(0)
+    return module
+
+
+def build_inputs():
+    own = Path(__file__).resolve().parent
+    paths = {name: own / name for name in ["CMakeLists.txt", "worker.cpp", "build.py", "cpu-only-loader.patch", "windows-model-path.patch"]}
+    paths.update({"embeddinggemma2/" + name: own.parent / "embeddinggemma2" / name
+                  for name in ["build_runtime.py", "provision_vulkan.py", "runtime_provenance.py", "macos_runtime.py"]})
+    return {name: sha(path) for name, path in paths.items()}
+
+
+def sha(path):
+    result = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(65536), b""):
+            result.update(chunk)
+    return result.hexdigest()
+
+
+def validate_source(source):
+    revision = subprocess.check_output(["git", "-C", str(source), "rev-parse", "HEAD"], text=True).strip()
+    dirty = subprocess.check_output(["git", "-C", str(source), "status", "--porcelain"], text=True).strip()
+    if revision != UPSTREAM or dirty:
+        raise ValueError("Speech build requires clean pinned whisper.cpp source")
+
+
+def configuration(source, output, mode, cmake):
+    return [cmake, "-S", str(Path(__file__).resolve().parent), "-B", str(output / "build"),
+            "-DWHISPER_SOURCE=" + str(source), "-DCMAKE_BUILD_TYPE=Release",
+            "-DSEARCHI_INTERNAL_CPU=" + ("ON" if mode == "cpu" else "OFF"),
+            "-DWHISPER_BUILD_IS_DEV=OFF"]
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--device", choices=["auto", "cpu"], default="auto")
+    parser.add_argument("--cmake", default="cmake")
+    args = parser.parse_args()
+    source, output = args.source.resolve(), args.output.resolve()
+    validate_source(source)
+    own = Path(__file__).resolve().parent
+    source_hashes = build_inputs()
+    # A fresh owned destination prevents stale CPU/DLL artifacts masquerading as auto.
+    output.mkdir(parents=True, exist_ok=False)
+    loader = None
+    if args.device == "auto" and sys.platform == "win32":
+        sdk, loader = shared_helper("provision_vulkan.py").provision()
+        os.environ["VULKAN_SDK"] = str(sdk)
+    patched = output / "whisper-source"
+    subprocess.run(["git", "clone", "--quiet", "--no-hardlinks", str(source), str(patched)], check=True)
+    subprocess.run(["git", "-C", str(patched), "checkout", "--quiet", "--detach", UPSTREAM], check=True)
+    for patch in ["cpu-only-loader.patch", "windows-model-path.patch"]:
+        subprocess.run(["git", "-C", str(patched), "apply", "--check", str(own / patch)], check=True)
+        subprocess.run(["git", "-C", str(patched), "apply", str(own / patch)], check=True)
+    for name, command in [("configure", configuration(patched, output, args.device, args.cmake)),
+                          ("build", [args.cmake, "--build", str(output / "build"), "--config", "Release", "--target", "searchi-speech-worker", "--parallel", "1"])]:
+        with (output / (name + ".log")).open("wb") as log:
+            result = subprocess.run(command, stdout=log, stderr=subprocess.STDOUT, check=False)
+        if result.returncode:
+            raise RuntimeError(f"Speech {name} failed; inspect {output / (name + '.log')}")
+    validate_source(source)
+    if source_hashes != build_inputs():
+        raise ValueError("Speech build sources changed during compilation")
+    build = output / "build"
+    if args.device == "auto" and sys.platform == "win32":
+        shared_helper("build_runtime.py").bundle_windows_crt(build)
+    suffix = ".exe" if sys.platform == "win32" else ""
+    candidates = list(build.rglob("searchi-speech-worker" + suffix))
+    if len(candidates) != 1:
+        raise ValueError("Speech build executable is missing or ambiguous")
+    stage = output / "runtime"
+    stage.mkdir()
+    files = [candidates[0]]
+    if args.device == "auto":
+        files.extend(path for path in build.rglob("*") if path.is_file()
+                     and (path.suffix.lower() in [".dll", ".dylib"] or ".so" in path.name))
+        if loader is not None:
+            files.extend([loader / "vulkan-1.dll", loader / "VULKAN-LICENSE.txt"])
+            files.extend(build.rglob("MSVC-REDISTRIBUTION.txt"))
+        names = [path.name.lower() for path in files]
+        required = "metal" if sys.platform == "darwin" else "vulkan"
+        if not any(required in name for name in names) or not any("ggml-cpu" in name for name in names):
+            raise ValueError("Auto speech runtime requires both acceleration and CPU backends")
+    records = {}
+    for path in files:
+        digest = sha(path)
+        if path.name in records and records[path.name]["sha256"] != digest:
+            raise ValueError("Ambiguous speech dependency basename")
+        shutil.copy2(path, stage / path.name)
+        records[path.name] = {"path": path.name, "bytes": path.stat().st_size, "sha256": digest}
+    manifest = {"schema": 1, "upstream_commit": UPSTREAM, "device": args.device,
+                "distribution": args.device == "auto", "source_hashes": source_hashes,
+                "files": list(records.values()), "native_os_gpu_checks": "unexecuted"}
+    (stage / "runtime-manifest.json").write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"runtime": str(stage), "mode": args.device, "files": len(records)}))
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,31 @@
+--- a/ggml/include/ggml-backend.h
+++ b/ggml/include/ggml-backend.h
+@@ -260,6 +260,8 @@
+     // Load all known backends from dynamic libraries
+     GGML_API void               ggml_backend_load_all(void);
+     GGML_API void               ggml_backend_load_all_from_path(const char * dir_path);
+    // Searchi: explicit CPU-only startup must never load or probe GPU modules.
+    GGML_API void               ggml_backend_load_cpu_only_from_path(const char * dir_path);
+ 
+     //
+     // Backend scheduler
+--- a/ggml/src/ggml-backend-reg.cpp
+++ b/ggml/src/ggml-backend-reg.cpp
+@@ -575,6 +575,17 @@
+     ggml_backend_load_all_from_path(nullptr);
+ }
+ 
+void ggml_backend_load_cpu_only_from_path(const char * dir_path) {
+#ifdef NDEBUG
+    const bool silent = true;
+#else
+    const bool silent = false;
+#endif
+    // Only CPU variants in the owned executable directory. No GPU registry
+    // probes, working-directory discovery or GGML_BACKEND_PATH injection.
+    ggml_backend_load_best("cpu", silent, dir_path);
+}
+
+ void ggml_backend_load_all_from_path(const char * dir_path) {
+ #ifdef NDEBUG
+     bool silent = true;
@@ -0,0 +1,25 @@
+{
+  "schema": 1,
+  "pipeline": "whisper-base-silero-v6.2.0-dtw-base-v1",
+  "license": "MIT",
+  "files": [
+    {
+      "path": "ggml-base.bin",
+      "bytes": 147951465,
+      "sha256": "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe",
+      "repository": "ggerganov/whisper.cpp",
+      "revision": "5359861c739e955e79d9a303bcbc70fb988958b1"
+    },
+    {
+      "path": "ggml-silero-v6.2.0.bin",
+      "bytes": 885098,
+      "sha256": "2aa269b785eeb53a82983a20501ddf7c1d9c48e33ab63a41391ac6c9f7fb6987",
+      "repository": "ggml-org/whisper-vad",
+      "revision": "9ffd54a1e1ee413ddf265af9913beaf518d1639b"
+    }
+  ],
+  "license_sources": [
+    "https://github.com/ggml-org/whisper.cpp/blob/d1be6fde11ac6e0407606b4e42fe72d34add8037/LICENSE",
+    "https://github.com/snakers4/silero-vad/blob/1e261b036686cd0017d500ee96acd1c4ba572a9d/LICENSE"
+  ]
+}
@@ -0,0 +1,33 @@
+import unittest
+from pathlib import Path
+import build
+import tempfile
+import subprocess
+from unittest.mock import patch
+
+
+class BuildContract(unittest.TestCase):
+    def test_real_git_source_rejects_wrong_revision_and_dirty_checkout(self):
+        with tempfile.TemporaryDirectory() as directory:
+            source = Path(directory)
+            def git(*args):
+                return subprocess.check_output(["git", "-C", str(source), *args], stderr=subprocess.STDOUT).decode().strip()
+            git("init", "--quiet")
+            (source / "source.txt").write_text("fixture")
+            git("add", "source.txt")
+            git("-c", "user.name=karl", "-c", "user.email=fixture@invalid", "commit", "--quiet", "-m", "fixture")
+            with self.assertRaises(ValueError):
+                build.validate_source(source)
+            with patch.object(build, "UPSTREAM", git("rev-parse", "HEAD")):
+                build.validate_source(source)
+                (source / "source.txt").write_text("changed")
+                with self.assertRaises(ValueError):
+                    build.validate_source(source)
+
+    def test_shared_helpers_load_without_running_build_or_downloading(self):
+        self.assertTrue(callable(build.shared_helper("build_runtime.py").bundle_windows_crt))
+        self.assertTrue(callable(build.shared_helper("provision_vulkan.py").provision))
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,42 @@
+--- a/src/whisper.cpp
+++ b/src/whisper.cpp
+@@ -30,6 +30,7 @@
+ #include <cstdio>
+ #include <cstring>
+ #include <fstream>
+#include <filesystem>
+ #include <functional>
+ #include <map>
+ #include <random>
+@@ -3730,13 +3731,7 @@
+ struct whisper_context * whisper_init_from_file_with_params_no_state(const char * path_model, struct whisper_context_params params) {
+     WHISPER_LOG_INFO("%s: loading model from '%s'\n", __func__, path_model);
+-#ifdef _MSC_VER
+-    // Convert UTF-8 path to wide string (UTF-16) for Windows, resolving character encoding issues.
+-    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+-    std::wstring path_model_wide = converter.from_bytes(path_model);
+-    auto fin = std::ifstream(path_model_wide, std::ios::binary);
+-#else
+-    auto fin = std::ifstream(path_model, std::ios::binary);
+-#endif
+    // C++17 u8path preserves supplementary Unicode on Windows and UTF-8 elsewhere.
+    auto fin = std::ifstream(std::filesystem::u8path(path_model), std::ios::binary);
+     if (!fin) {
+         WHISPER_LOG_ERROR("%s: failed to open '%s'\n", __func__, path_model);
+         return nullptr;
+@@ -4877,13 +4871,8 @@
+         const char * path_model,
+         struct whisper_vad_context_params params) {
+     WHISPER_LOG_INFO("%s: loading VAD model from '%s'\n", __func__, path_model);
+-#ifdef _MSC_VER
+-    std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
+-    std::wstring path_model_wide = converter.from_bytes(path_model);
+-    auto fin = std::ifstream(path_model_wide, std::ios::binary);
+-#else
+-    auto fin = std::ifstream(path_model, std::ios::binary);
+-#endif
+    // Same strict UTF-8 path contract as the base recognizer.
+    auto fin = std::ifstream(std::filesystem::u8path(path_model), std::ios::binary);
+     if (!fin) {
+         WHISPER_LOG_ERROR("%s: failed to open VAD model '%s'\n", __func__, path_model);
+         return nullptr;
@@ -0,0 +1,183 @@
+// Isolated pinned whisper.cpp C API. Binary mono PCM input; strict UTF-8 JSON.
+#include "whisper.h"
+#include "ggml-backend.h"
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cfloat>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <iostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#endif
+using Clock=std::chrono::steady_clock;
+constexpr size_t MAX_SAMPLES=480000, MAX_OUTPUT=4*1024*1024;
+constexpr const char* POLICY="live-window-vad-dtw-v1;silero-v6.2.0;base;30s;vad-reset;threshold0.5;minspeech250ms;minsilence100ms;maxspeechFLT_MAX;pad30ms;vad-overlap0.1s;source-sample-intersections;beam5;bestof5;temp0;tempinc0.2;entropy2.4;logprob-1;nospeech0.6;suppressblank;no-suppress-nst;auto-language;no-context;dtw-base;no-flash;contiguous-intervals;first-last-token-points;exact-utf8";
+static double elapsed(Clock::time_point start){return std::chrono::duration<double,std::milli>(Clock::now()-start).count();}
+static std::string backend="unknown";
+static void logger(ggml_log_level level,const char * text,void*) {
+    // Native logs can contain recognized bytes. Never forward them in production.
+    const std::string value(text);
+    const auto using_at=value.find(": using "), end=value.find(" backend");
+    if(using_at!=std::string::npos && end!=std::string::npos && end>using_at+8) backend=value.substr(using_at+8,end-using_at-8);
+    if(value.find("no GPU found")!=std::string::npos)backend="cpu";
+    (void)level;
+}
+// Reject malformed sequences, overlong encodings, surrogates and > U+10FFFF.
+static bool utf8(const std::string & text) {
+    size_t i=0;
+    while(i<text.size()) {
+        const uint8_t c=static_cast<uint8_t>(text[i++]);
+        if(c<128)continue;
+        unsigned n;uint32_t point,minimum;
+        if(c>=0xc2 && c<=0xdf){n=1;point=c&31;minimum=128;}
+        else if(c>=0xe0 && c<=0xef){n=2;point=c&15;minimum=2048;}
+        else if(c>=0xf0 && c<=0xf4){n=3;point=c&7;minimum=65536;}
+        else return false;
+        if(i+n>text.size())return false;
+        for(unsigned k=0;k<n;++k){const uint8_t next=static_cast<uint8_t>(text[i++]);if((next&0xc0)!=0x80)return false;point=(point<<6)|(next&63);}
+        if(point<minimum || point>0x10ffff || (point>=0xd800 && point<=0xdfff))return false;
+    }
+    return true;
+}
+static std::string quoted(const std::string & text) {
+    if(!utf8(text))throw std::runtime_error("malformed_recognition_utf8");
+    std::string result="\"";const char * hex="0123456789abcdef";
+    for(unsigned char c:text){if(c=='"'||c=='\\'){result+='\\';result+=static_cast<char>(c);}else if(c<32){result+="\\u00";result+=hex[c>>4];result+=hex[c&15];}else result+=static_cast<char>(c);}
+    return result+'"';
+}
+static void send(const std::string & json) {
+    if(json.empty() || json.size()>MAX_OUTPUT)throw std::runtime_error("output_limit");
+    uint32_t n=static_cast<uint32_t>(json.size());char prefix[4];for(int i=0;i<4;i++)prefix[i]=static_cast<char>((n>>(i*8))&255);
+    std::cout.write(prefix,4);std::cout.write(json.data(),json.size());std::cout.flush();
+    if(!std::cout)throw std::runtime_error("output_closed");
+}
+static bool boundary(std::string text) {
+    while(!text.empty() && std::string("\"')]").find(text.back())!=std::string::npos)text.pop_back();
+    for(const std::string suffix:{".","!","?","。","！","？"})if(text.size()>=suffix.size() && text.compare(text.size()-suffix.size(),suffix.size(),suffix)==0)return true;
+    return false;
+}
+struct Runtime {
+    std::string base_path,vad_path;bool auto_device;
+    whisper_context * base=nullptr;whisper_vad_context * vad=nullptr;
+    ~Runtime(){if(base)whisper_free(base);if(vad)whisper_vad_free(vad);}
+    void load_base(bool gpu) {
+        if(!gpu)backend="cpu";
+        auto params=whisper_context_default_params();params.use_gpu=gpu;params.flash_attn=false;
+        params.dtw_token_timestamps=true;params.dtw_aheads_preset=WHISPER_AHEADS_BASE;
+        base=whisper_init_from_file_with_params(base_path.c_str(),params);
+        if(!base)throw std::runtime_error("base_load_failed");
+    }
+    std::string request(unsigned op,const std::vector<float>&pcm) {
+        double load=0,vad_time=0,asr_time=0;std::ostringstream body;
+        if(op==1) {
+            if(!vad){auto start=Clock::now();auto params=whisper_vad_default_context_params();params.n_threads=1;params.use_gpu=auto_device;
+                if(!auto_device)backend="cpu";
+                vad=whisper_vad_init_from_file_with_params(vad_path.c_str(),params);
+                if(!vad)throw std::runtime_error("vad_load_failed");load=elapsed(start);}
+            auto start=Clock::now();
+            if(!whisper_vad_detect_speech(vad,pcm.data(),static_cast<int>(pcm.size())))throw std::runtime_error("vad_failed");
+            const whisper_vad_params policy{0.5f,250,100,FLT_MAX,30,0.1f};
+            auto segments=whisper_vad_segments_from_probs(vad,policy);if(!segments)throw std::runtime_error("vad_intervals_failed");
+            body<<",\"intervals_samples\":[";size_t previous=0;bool comma=false;
+            const int n=whisper_vad_segments_n_segments(segments);
+            if(n<0||n>1000){whisper_vad_free_segments(segments);throw std::runtime_error("vad_interval_limit");}
+            for(int i=0;i<n;i++){
+                const double a=whisper_vad_segments_get_segment_t0(segments,i),b=whisper_vad_segments_get_segment_t1(segments,i);
+                if(!std::isfinite(a)||!std::isfinite(b)||a<0||a>=b||std::floor(a)!=a||std::floor(b)!=b){whisper_vad_free_segments(segments);throw std::runtime_error("vad_invalid_interval");}
+                // Native VAD tail padding intersects source samples; never invent PCM.
+                const size_t first=static_cast<size_t>(std::min(a*160.0,static_cast<double>(pcm.size())));
+                const size_t last=static_cast<size_t>(std::min(b*160.0,static_cast<double>(pcm.size())));
+                if(first<previous){whisper_vad_free_segments(segments);throw std::runtime_error("vad_overlapping_interval");}
+                previous=last;if(first==last)continue;if(comma)body<<',';comma=true;body<<'['<<first<<','<<last<<']';
+            }
+            whisper_vad_free_segments(segments);body<<']';vad_time=elapsed(start);
+        }else if(op==2) {
+            if(!base){auto start=Clock::now();load_base(auto_device);load=elapsed(start);}
+            auto params=whisper_full_default_params(WHISPER_SAMPLING_BEAM_SEARCH);
+            params.n_threads=1;params.language="auto";params.detect_language=false;
+            params.greedy.best_of=5;params.beam_search.beam_size=5;
+            params.temperature=0.0f;params.temperature_inc=0.2f;
+            params.entropy_thold=2.4f;params.logprob_thold=-1.0f;params.no_speech_thold=0.6f;
+            params.suppress_blank=true;params.suppress_nst=false;params.translate=false;
+            params.print_progress=false;params.print_realtime=false;params.print_timestamps=false;params.print_special=false;
+            params.token_timestamps=true;params.no_context=true;
+            auto start=Clock::now();int status=whisper_full(base,params,pcm.data(),static_cast<int>(pcm.size()));
+            if(status!=0)throw std::runtime_error("recognition_failed");
+            body<<",\"sentences\":[";bool comma=false;int64_t previous=0;
+            const int count=whisper_full_n_segments(base);if(count<0||count>1000)throw std::runtime_error("segment_limit");
+            for(int i=0;i<count;i++){
+                const std::string original=whisper_full_get_segment_text(base,i);
+                if(original.size()>4096||!utf8(original))throw std::runtime_error("malformed_recognition_utf8");
+                std::string exact,phrase,merged;int64_t first=-1,last=-1,merge_first=-1;
+                const int tokens=whisper_full_n_tokens(base,i);if(tokens<0||tokens>4096)throw std::runtime_error("token_limit");
+                auto append=[&](){if(phrase.find_first_not_of(" \r\n\t")!=std::string::npos){if(comma)body<<',';comma=true;body<<"{\"start_cs\":"<<first<<",\"end_cs\":"<<last<<",\"text\":"<<quoted(phrase)<<'}';}phrase.clear();first=-1;};
+                for(int j=0;j<tokens;j++){
+                    auto token=whisper_full_get_token_data(base,i,j);if(token.id>=whisper_token_eot(base))continue;
+                    if(token.t_dtw<previous || token.t_dtw<0 || static_cast<uint64_t>(token.t_dtw)*160>pcm.size())throw std::runtime_error("invalid_dtw_point");
+                    previous=token.t_dtw;if(merge_first<0)merge_first=token.t_dtw;
+                    merged+=whisper_token_to_str(base,token.id);
+                    if(merged.size()>4096)throw std::runtime_error("token_text_limit");
+                    if(!utf8(merged))continue;
+                    exact+=merged;if(first<0)first=merge_first;last=token.t_dtw;phrase+=merged;
+                    if(boundary(merged))append();merged.clear();merge_first=-1;
+                }
+                if(!merged.empty() || exact!=original)throw std::runtime_error("malformed_recognition_utf8");append();
+            }
+            body<<']';asr_time=elapsed(start);
+        }else throw std::runtime_error("unknown_operation");
+        std::ostringstream output;output<<"{\"ok\":true,\"operation\":"<<op<<",\"samples\":"<<pcm.size()<<",\"vad_ms\":"<<vad_time<<",\"asr_ms\":"<<asr_time<<",\"load_ms\":"<<load<<",\"backend_observed\":"<<quoted(backend)<<body.str()<<'}';return output.str();
+    }
+};
+static int run(const std::vector<std::string>&args){
+    if(args.size()==2 && args[1]=="--self-test"){
+        if(!utf8("\xe2\x80\x8d") || utf8("\xe2\x80") || utf8("\xed\xa0\x80") || utf8("\xc0\x80") || utf8("\xf4\x90\x80\x80"))return 5;
+        if(quoted(std::string("a\n\"\\"))!="\"a\\u000a\\\"\\\\\"")return 5;
+        return 0;
+    }
+    if(args.size()!=4)return 2;
+    const uint16_t endian=1;if(*reinterpret_cast<const uint8_t*>(&endian)!=1||sizeof(float)!=4)return 2;
+#ifdef _WIN32
+    _setmode(_fileno(stdin),_O_BINARY);_setmode(_fileno(stdout),_O_BINARY);
+    SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
+#endif
+    if(args[3]!="auto" && args[3]!="cpu")return 2;
+    const char* force_cpu=std::getenv("SEARCHI_FORCE_CPU");
+    const bool auto_device=args[3]=="auto" && !(force_cpu && std::string(force_cpu)=="1");
+    whisper_log_set(logger,nullptr);
+    const auto directory=std::filesystem::u8path(args[0]).parent_path().u8string();
+    if(auto_device)ggml_backend_load_all_from_path(directory.c_str());
+    else ggml_backend_load_cpu_only_from_path(directory.c_str());
+    Runtime runtime{args[1],args[2],auto_device};
+#ifdef SEARCHI_DISTRIBUTION_AUTO
+    const bool distribution_auto=true;
+#else
+    const bool distribution_auto=false;
+#endif
+    send(std::string("{\"ready\":true,\"protocol\":1,\"runtime\":\"d1be6fde11ac6e0407606b4e42fe72d34add8037\",\"distribution_auto\":")+(distribution_auto?"true":"false")+",\"policy\":"+quoted(POLICY)+'}');
+    while(true){char header[5];std::cin.read(header,5);if(std::cin.gcount()==0&&std::cin.eof())return 0;if(std::cin.gcount()!=5)return 3;
+        uint32_t count=0;for(int i=0;i<4;i++)count|=static_cast<uint32_t>(static_cast<uint8_t>(header[i+1]))<<(i*8);
+        if(count==0||count>MAX_SAMPLES)return 3;std::vector<float> pcm(count);
+        std::cin.read(reinterpret_cast<char*>(pcm.data()),count*4);if(!std::cin)return 3;
+        if(!std::all_of(pcm.begin(),pcm.end(),[](float v){return std::isfinite(v);} ))return 3;
+        try{send(runtime.request(static_cast<uint8_t>(header[0]),pcm));}
+        catch(const std::exception&error){send(std::string("{\"ok\":false,\"error\":")+quoted(error.what())+'}');}
+    }
+}
+#ifdef _WIN32
+int wmain(int argc,wchar_t**argv){std::vector<std::string> args;for(int i=0;i<argc;i++){int n=WideCharToMultiByte(CP_UTF8,WC_ERR_INVALID_CHARS,argv[i],-1,nullptr,0,nullptr,nullptr);if(!n)return 2;std::string value(n,'\0');WideCharToMultiByte(CP_UTF8,WC_ERR_INVALID_CHARS,argv[i],-1,value.data(),n,nullptr,nullptr);value.pop_back();args.push_back(value);}return run(args);}
+#else
+int main(int argc,char**argv){return run(std::vector<std::string>(argv,argv+argc));}
+#endif
@@ -0,0 +1,135 @@
+"""Verify and atomically stage the isolated normal speech runtime; no inference."""
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import sys
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / 'tools/embeddinggemma2'))
+from stage_runtime import stage_resources, CRT_LIBRARIES
+from stage_extraction_worker import identity
+
+UPSTREAM = 'd1be6fde11ac6e0407606b4e42fe72d34add8037'
+INPUTS = ('CMakeLists.txt', 'worker.cpp', 'build.py',
+          'cpu-only-loader.patch', 'windows-model-path.patch',
+          'embeddinggemma2/build_runtime.py', 'embeddinggemma2/provision_vulkan.py',
+          'embeddinggemma2/runtime_provenance.py', 'embeddinggemma2/macos_runtime.py')
+NOTICES = ('Whisper-cpp-MIT.txt', 'Whisper-model-MIT.txt', 'Silero-MIT.txt')
+
+
+def digest(path):
+    with path.open('rb') as stream:
+        return hashlib.file_digest(stream, 'sha256').hexdigest()
+
+
+def input_path(root, name):
+    return Path(root) / 'tools' / (name if '/' in name else 'speech-runtime/' + name)
+
+
+def inventory(directory):
+    path = Path(directory) / 'runtime-manifest.json'
+    if path.is_symlink() or not path.is_file() or not 0 < path.stat().st_size <= 512 * 1024:
+        raise ValueError('Speech runtime inventory missing or oversized')
+    manifest = json.loads(path.read_bytes())
+    if (not isinstance(manifest, dict) or manifest.get('schema') != 1
+            or manifest.get('upstream_commit') != UPSTREAM
+            or manifest.get('device') != 'auto' or manifest.get('distribution') is not True):
+        raise ValueError('Normal releases require the pinned hardware-detecting speech runtime')
+    files = manifest.get('files')
+    if not isinstance(files, list) or not 1 <= len(files) <= 128:
+        raise ValueError('Speech runtime inventory is unbounded')
+    names, total = set(), 0
+    for record in files:
+        if not isinstance(record, dict):
+            raise ValueError('Invalid speech artifact')
+        name, size, sha = record.get('path'), record.get('bytes'), record.get('sha256')
+        if (not isinstance(name, str) or not re.fullmatch(r'[A-Za-z0-9_.-]+', name)
+                or name in {'.', '..'} or name.lower() in names
+                or type(size) is not int or not 0 < size <= 256 * 1024 * 1024
+                or not isinstance(sha, str) or not re.fullmatch(r'[0-9a-f]{64}', sha)):
+            raise ValueError('Invalid or duplicate speech artifact')
+        names.add(name.lower())
+        total += size
+        if total > 1024 * 1024 * 1024:
+            raise ValueError('Speech runtime exceeds size budget')
+        artifact = Path(directory) / name
+        if (artifact.is_symlink() or not artifact.is_file() or artifact.absolute() != artifact.resolve()
+                or artifact.stat().st_size != size or digest(artifact) != sha):
+            raise ValueError('Speech artifact size/SHA mismatch')
+    permitted = names | {'runtime-manifest.json'} | {name.lower() for name in NOTICES}
+    for path in Path(directory).iterdir():
+        if not path.is_file() or path.is_symlink() or path.name.lower() not in permitted:
+            raise ValueError('Unlisted speech runtime artifact')
+    return manifest
+
+
+def verify_directory(directory, root=ROOT, platform='windows', architecture='x86_64'):
+    directory = Path(directory)
+    manifest = inventory(directory)
+    expected = {name: digest(input_path(root, name)) for name in INPUTS}
+    if manifest.get('source_hashes') != expected:
+        raise ValueError('Speech runtime build inputs are stale')
+    worker = 'searchi-speech-worker.exe' if platform == 'windows' else 'searchi-speech-worker'
+    detected_platform, detected_arch, _ = identity(directory / worker)
+    if (detected_platform, detected_arch) != (platform, architecture):
+        raise ValueError('Speech runtime architecture mismatch')
+    names = {record['path'] for record in manifest['files']}
+    accelerator = 'metal' if platform == 'macos' else 'vulkan'
+    if (worker not in names or not any('ggml-cpu' in name for name in names)
+            or not any(accelerator in name for name in names)):
+        raise ValueError('Speech runtime lacks CPU/acceleration backends')
+    windows_libraries = {'whisper.dll', 'ggml.dll', 'ggml-base.dll', 'vulkan-1.dll',
+                         'VULKAN-LICENSE.txt', 'MSVC-REDISTRIBUTION.txt'} | CRT_LIBRARIES
+    if platform == 'windows' and not windows_libraries.issubset(names):
+        raise ValueError('Speech runtime lacks required shared libraries')
+    records = {'speech-runtime/' + record['path']: record for record in manifest['files']}
+    manifest_path = directory / 'runtime-manifest.json'
+    records['speech-runtime/runtime-manifest.json'] = {
+        'bytes': manifest_path.stat().st_size, 'sha256': digest(manifest_path)}
+    for name in NOTICES:
+        notice = directory / name
+        original = Path(root) / 'assets/licenses' / name
+        if (notice.is_symlink() or not notice.is_file() or notice.stat().st_size > 65536
+                or notice.stat().st_size != original.stat().st_size
+                or digest(notice) != digest(original)):
+            raise ValueError('Speech license notice missing or changed')
+        records['speech-runtime/' + name] = {'bytes': notice.stat().st_size, 'sha256': digest(notice)}
+    return records
+
+
+def verify(resources, root=ROOT, platform='windows', architecture='x86_64'):
+    return verify_directory(Path(resources) / 'speech-runtime', root, platform, architecture)
+
+
+def stage(runtime, destination, root=ROOT, platform='windows', architecture='x86_64'):
+    runtime, destination, root = map(Path, (runtime, destination, root))
+    manifest = inventory(runtime)
+    current = {record['path'] for record in manifest['files']} | {'runtime-manifest.json'}
+    owned = current | set(NOTICES)
+    if destination.exists():
+        previous = inventory(destination)
+        owned.update(record['path'] for record in previous['files'])
+    sources = [(runtime / name, name) for name in current]
+    sources = [(source, name) for source, name in sources if name not in NOTICES]
+    sources.extend((root / 'assets/licenses' / name, name) for name in NOTICES)
+    def validate(candidate):
+        verify_directory(candidate, root, platform, architecture)
+    stage_resources(destination, sources, validate, owned_names=owned)
+    verify_directory(destination, root, platform, architecture)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--runtime', type=Path, required=True)
+    parser.add_argument('--platform', choices=['windows', 'linux', 'macos'], required=True)
+    parser.add_argument('--architecture', choices=['x86_64', 'aarch64'], required=True)
+    args = parser.parse_args()
+    stage(args.runtime, ROOT / 'apps/desktop/src-tauri/resources/speech-runtime',
+          ROOT, args.platform, args.architecture)
+    print('Staged verified speech runtime')
+
+
+if __name__ == '__main__':
+    main()
@@ -10,6 +10,7 @@ import zipfile
 from package_windows import package, CRT_LIBRARIES
 from embeddinggemma2 import runtime_provenance as provenance
 import stage_extraction_worker as extraction
+import stage_speech_worker as speech


 def executable(path, machine=0x8664):
@@ -32,6 +33,29 @@ def inventory(resources):


 class PackageTests(unittest.TestCase):
+    def test_speech_cpu_only_missing_and_tampered_runtime_preserve_previous_package(self):
+        for mutation in ('cpu', 'missing', 'tampered', 'stale', 'unlisted'):
+            with self.subTest(mutation=mutation), tempfile.TemporaryDirectory() as directory:
+                root, resources, app, output = self.fixture(directory)
+                output.write_bytes(b'previous package')
+                speech_directory = resources / 'speech-runtime'
+                if mutation == 'cpu':
+                    path = speech_directory / 'runtime-manifest.json'
+                    data = json.loads(path.read_text())
+                    data.update(device='cpu', distribution=False)
+                    path.write_text(json.dumps(data))
+                elif mutation == 'missing':
+                    (speech_directory / 'searchi-speech-worker.exe').unlink()
+                elif mutation == 'tampered':
+                    (speech_directory / 'ggml-vulkan.dll').write_bytes(b'changed')
+                elif mutation == 'stale':
+                    (root / 'tools/speech-runtime/worker.cpp').write_bytes(b'changed source')
+                else:
+                    executable(speech_directory / 'obsolete-ggml-cpu.dll')
+                with self.assertRaises(ValueError):
+                    package(root, app, output)
+                self.assertEqual(output.read_bytes(), b'previous package')
+
    def test_extraction_missing_tampered_stale_preserves_existing_package(self):
        for mutation in ("missing", "tampered", "stale"):
            with self.subTest(mutation=mutation), tempfile.TemporaryDirectory() as directory:
@@ -119,6 +143,28 @@ class PackageTests(unittest.TestCase):
        helper = root / "build/searchi-extract-worker.exe"
        executable(helper)
        extraction.stage(helper, extraction.fingerprint(root), resources, root)
+        speech_directory = resources / 'speech-runtime'
+        speech_directory.mkdir()
+        for name in speech.INPUTS:
+            path = speech.input_path(root, name)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(speech.input_path(speech.ROOT, name).read_bytes())
+        for name in speech.NOTICES:
+            original = root / 'assets/licenses' / name
+            original.parent.mkdir(parents=True, exist_ok=True)
+            original.write_bytes((speech.ROOT / 'assets/licenses' / name).read_bytes())
+            (speech_directory / name).write_bytes(original.read_bytes())
+        speech_files = []
+        for name in ('searchi-speech-worker.exe', 'ggml-cpu-x64.dll', 'ggml-vulkan.dll',
+                     'whisper.dll', 'ggml.dll', 'ggml-base.dll', 'vulkan-1.dll',
+                     'VULKAN-LICENSE.txt', 'MSVC-REDISTRIBUTION.txt', *sorted(CRT_LIBRARIES)):
+            path = speech_directory / name
+            executable(path)
+            speech_files.append({'path': name, 'bytes': path.stat().st_size, 'sha256': speech.digest(path)})
+        (speech_directory / 'runtime-manifest.json').write_text(json.dumps({
+            'schema': 1, 'upstream_commit': speech.UPSTREAM, 'device': 'auto', 'distribution': True,
+            'source_hashes': {name: speech.digest(speech.input_path(root, name)) for name in speech.INPUTS},
+            'files': speech_files}))
        return root, resources, app, root / "archive.zip"

    def test_valid_pe_media_mutation_and_notice_corruption_preserve_previous_archive(self):
@@ -0,0 +1,44 @@
+import json
+from pathlib import Path
+import shutil
+import tempfile
+import unittest
+
+import stage_speech_worker as speech
+import test_package_windows as windows
+
+
+class SpeechStagingTests(unittest.TestCase):
+    def test_replacement_prunes_obsolete_declared_code_and_keeps_closed_inventory(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root, resources, _, _ = windows.PackageTests().fixture(directory)
+            source = resources / 'speech-runtime'
+            destination = root / 'candidate-resources/speech-runtime'
+            shutil.copytree(source, destination)
+            obsolete = destination / 'obsolete-ggml-cpu.dll'
+            windows.executable(obsolete)
+            path = destination / 'runtime-manifest.json'
+            manifest = json.loads(path.read_text())
+            manifest['files'].append({'path': obsolete.name, 'bytes': obsolete.stat().st_size,
+                                      'sha256': speech.digest(obsolete)})
+            path.write_text(json.dumps(manifest))
+            speech.stage(source, destination, root)
+            self.assertFalse(obsolete.exists())
+            speech.verify_directory(destination, root)
+
+    def test_invalid_source_retains_original_runtime_and_leaves_no_partial_directory(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root, resources, _, _ = windows.PackageTests().fixture(directory)
+            source = resources / 'speech-runtime'
+            destination = root / 'candidate-resources/speech-runtime'
+            shutil.copytree(source, destination)
+            previous = (destination / 'runtime-manifest.json').read_bytes()
+            windows.executable(source / 'unlisted.dll')
+            with self.assertRaisesRegex(ValueError, 'Unlisted'):
+                speech.stage(source, destination, root)
+            self.assertEqual((destination / 'runtime-manifest.json').read_bytes(), previous)
+            self.assertEqual(list(destination.parent.glob('.resources.stage-*')), [])
+
+
+if __name__ == '__main__':
+    unittest.main()