@agent-native/core 0.114.13 → 0.114.16

package/corpus/templates/clips/desktop/src-tauri/src/whisper_model.rs

@@ -1,116 +1,205 @@
-//! Whisper model resolution + download for the local meeting transcription
-//! engine (`whisper_speech.rs`).
-//!
-//! Resolves where the `ggml-base.bin` model lives, downloads it from
-//! HuggingFace on first use, and verifies the download against a pinned
-//! SHA-256 + byte size so a corrupted, truncated, or tampered file is rejected
-//! rather than loaded
-
-use std::path::PathBuf;
+//! Local Whisper model catalog, download, and integrity verification.
+
+use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 use serde::Serialize;
 use tauri::{AppHandle, Emitter, Manager};
 
-const MODEL_URL: &str = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin";
-const MODEL_FILENAME: &str = "ggml-base.bin";
-const MODEL_SHA256: &str = "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe";
-const MODEL_SIZE: u64 = 147_951_465;
-const MODEL_SIZE_MB: u64 = MODEL_SIZE / (1024 * 1024);
+#[derive(Debug, Clone, Copy, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WhisperModel {
+    pub id: &'static str,
+    pub title: &'static str,
+    pub description: &'static str,
+    pub url: &'static str,
+    pub filename: &'static str,
+    pub sha256: &'static str,
+    pub size_bytes: u64,
+    pub size_mb: u64,
+}
+
+const TINY_MODEL: WhisperModel = WhisperModel {
+    id: "tiny",
+    title: "Tiny",
+    description: "Transcribes instantly and uses very little space. May miss some words or struggle with accents, but great if speed is all that matters.",
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-tiny.bin",
+    filename: "ggml-tiny.bin",
+    sha256: "be07e048e1e599ad46341c8d2a135645097a538221678b7acdd1b1919c6e1b21",
+    size_bytes: 77_691_713,
+    size_mb: 74,
+};
+
+const BASE_MODEL: WhisperModel = WhisperModel {
+    id: "base",
+    title: "Base",
+    description: "A great everyday choice. Transcribes quickly and gets most things right for dictation and meetings.",
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin",
+    filename: "ggml-base.bin",
+    sha256: "60ed5bc3dd14eea856493d334349b405782ddcaf0028d4b5df4088345fba2efe",
+    size_bytes: 147_951_465,
+    size_mb: 141,
+};
+
+const SMALL_MODEL: WhisperModel = WhisperModel {
+    id: "small",
+    title: "Small",
+    description: "More accurate than Base, especially with accents or background noise. Takes a bit longer and uses more space.",
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin",
+    filename: "ggml-small.bin",
+    sha256: "1be3a9b2063867b937e64e2ec7483364a79917e157fa98c5d94b5c1fffea987b",
+    size_bytes: 487_601_967,
+    size_mb: 488,
+};
+
+const LARGE_V3_TURBO_MODEL: WhisperModel = WhisperModel {
+    id: "large-v3-turbo",
+    title: "Large v3 Turbo",
+    description: "The most accurate option. Catches subtle speech and complex vocabulary well. Best on newer Macs; requires a larger one-time download.",
+    url: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3-turbo.bin",
+    filename: "ggml-large-v3-turbo.bin",
+    sha256: "1fc70f774d38eb169993ac391eea357ef47c88757ef72ee5943879b7e8e2bc69",
+    size_bytes: 1_624_555_275,
+    size_mb: 1549,
+};
+
+const SUPPORTED_MODELS: &[WhisperModel] =
+    &[TINY_MODEL, BASE_MODEL, SMALL_MODEL, LARGE_V3_TURBO_MODEL];
 
-// Global download-in-flight state so the status command and concurrent callers
-// can inspect without re-checking the filesystem.
 static DOWNLOADING: AtomicBool = AtomicBool::new(false);
 static DOWNLOADED_BYTES: AtomicU64 = AtomicU64::new(0);
 
-/// Whether the model path is overridden via `CLIPS_WHISPER_MODEL`. A custom
-/// model is exempt from checksum verification (it may legitimately be a
-/// different model, e.g. multilingual).
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
 pub(crate) fn custom_model_override() -> bool {
     std::env::var("CLIPS_WHISPER_MODEL")
         .map(|v| !v.trim().is_empty())
         .unwrap_or(false)
 }
 
-/// Resolve the model path. Honors `CLIPS_WHISPER_MODEL`, otherwise
-/// `<app_data_dir>/models/ggml-base.bin` (creating the dir).
-pub fn model_file(app: &AppHandle) -> Result<PathBuf, String> {
-    if let Ok(path) = std::env::var("CLIPS_WHISPER_MODEL") {
-        if !path.trim().is_empty() {
-            return Ok(PathBuf::from(path));
-        }
-    }
+pub(crate) fn is_supported_model_id(id: &str) -> bool {
+    SUPPORTED_MODELS.iter().any(|m| m.id == id)
+}
+
+fn find_model(id: &str) -> Result<&'static WhisperModel, String> {
+    SUPPORTED_MODELS
+        .iter()
+        .find(|m| m.id == id)
+        .ok_or_else(|| format!("unsupported Whisper model: {id}"))
+}
+
+/// Returns the directory where model files are stored, creating it if needed.
+fn models_dir(app: &AppHandle) -> Result<PathBuf, String> {
     let dir = app
         .path()
         .app_data_dir()
         .map_err(|e| format!("no app_data_dir: {e}"))?
         .join("models");
     std::fs::create_dir_all(&dir).map_err(|e| format!("mkdir models: {e}"))?;
-    Ok(dir.join(MODEL_FILENAME))
+    Ok(dir)
+}
+
+/// Resolve the full path for a catalog model on disk.
+fn model_path(dir: &Path, model: &WhisperModel) -> PathBuf {
+    dir.join(model.filename)
+}
+
+fn is_complete_on_disk(path: &Path, model: &WhisperModel) -> bool {
+    std::fs::metadata(path)
+        .map(|m| m.len() == model.size_bytes)
+        .unwrap_or(false)
+}
+
+fn downloaded_mb(bytes: u64, model: &WhisperModel) -> u64 {
+    bytes.saturating_mul(model.size_mb) / model.size_bytes
+}
+
+// ---------------------------------------------------------------------------
+// Public: resolve model file path (honors CLIPS_WHISPER_MODEL env override)
+// ---------------------------------------------------------------------------
+
+pub fn model_file(app: &AppHandle) -> Result<PathBuf, String> {
+    if let Ok(path) = std::env::var("CLIPS_WHISPER_MODEL") {
+        if !path.trim().is_empty() {
+            return Ok(PathBuf::from(path));
+        }
+    }
+    let config = crate::config::feature_config(app);
+    let model = find_model(&config.whisper_model_id)?;
+    Ok(model_path(&models_dir(app)?, model))
+}
+
+// ---------------------------------------------------------------------------
+// Tauri commands
+// ---------------------------------------------------------------------------
+
+#[tauri::command]
+pub async fn whisper_models() -> Vec<WhisperModel> {
+    SUPPORTED_MODELS.to_vec()
 }
 
-/// Model status returned to the frontend settings UI.
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ModelStatus {
-    /// One of: "disabled" | "missing" | "downloading" | "ready"
     pub state: String,
-    /// Absolute path where the model file lives (or will live).
     pub path: String,
-    /// How many MB have been downloaded so far (only meaningful during "downloading").
     pub downloaded_mb: u64,
-    /// Total model size in MB.
     pub total_mb: u64,
 }
 
-/// Return the current model state without triggering a download.
 #[tauri::command]
 pub async fn whisper_model_status(app: AppHandle) -> Result<ModelStatus, String> {
-    let path = model_file(&app)?;
-    let path_str = path.to_string_lossy().to_string();
+    if custom_model_override() {
+        let path = model_file(&app)?;
+        let ready = path.exists();
+        return Ok(ModelStatus {
+            state: if ready { "ready" } else { "missing" }.into(),
+            path: path.to_string_lossy().into(),
+            downloaded_mb: 0,
+            total_mb: 0,
+        });
+    }
+
     let config = crate::config::feature_config(&app);
+    let model = find_model(&config.whisper_model_id)?;
+    let dir = models_dir(&app)?;
+    let path = model_path(&dir, model);
+    let path_str = path.to_string_lossy().into_owned();
 
     if !config.whisper_model_enabled {
         return Ok(ModelStatus {
             state: "disabled".into(),
             path: path_str,
             downloaded_mb: 0,
-            total_mb: MODEL_SIZE_MB,
+            total_mb: model.size_mb,
         });
     }
     if DOWNLOADING.load(Ordering::Relaxed) {
-        let downloaded_mb = DOWNLOADED_BYTES.load(Ordering::Relaxed) / (1024 * 1024);
         return Ok(ModelStatus {
             state: "downloading".into(),
             path: path_str,
-            downloaded_mb,
-            total_mb: MODEL_SIZE_MB,
+            downloaded_mb: downloaded_mb(DOWNLOADED_BYTES.load(Ordering::Relaxed), model),
+            total_mb: model.size_mb,
         });
     }
-    let state = match std::fs::metadata(&path) {
-        Ok(m) if m.len() == MODEL_SIZE || custom_model_override() => "ready",
-        _ => "missing",
-    };
+    let ready = is_complete_on_disk(&path, model);
     Ok(ModelStatus {
-        state: state.into(),
+        state: if ready { "ready" } else { "missing" }.into(),
         path: path_str,
-        downloaded_mb: if state == "ready" { MODEL_SIZE_MB } else { 0 },
-        total_mb: MODEL_SIZE_MB,
+        downloaded_mb: if ready { model.size_mb } else { 0 },
+        total_mb: model.size_mb,
     })
 }
 
-/// Spawn a background download. Idempotent — no-ops if already downloading or
-/// already present. Emits `whisper:model-progress`, `whisper:model-ready`, or
-/// `whisper:model-error` as the download progresses.
 #[tauri::command]
 pub async fn whisper_model_download(app: AppHandle) -> Result<(), String> {
-    if DOWNLOADING.load(Ordering::Acquire) {
-        return Ok(());
-    }
-    // Quick check: if model is already present, just emit ready and return.
-    if let Ok(path) = model_file(&app) {
-        if let Ok(m) = std::fs::metadata(&path) {
-            if m.len() == MODEL_SIZE || custom_model_override() {
+    let path = model_file(&app)?;
+    if let Ok(meta) = std::fs::metadata(&path) {
+        let config = crate::config::feature_config(&app);
+        if let Ok(model) = find_model(&config.whisper_model_id) {
+            if meta.len() == model.size_bytes || custom_model_override() {
                 let _ = app.emit("whisper:model-ready", ());
                 return Ok(());
             }
@@ -130,164 +219,196 @@ pub async fn whisper_model_download(app: AppHandle) -> Result<(), String> {
     Ok(())
 }
 
-/// Ensure the model file exists, downloading it on first use. ~142 MB, so the
-/// first meeting after install pays a one-time download cost.
-///
-/// The default `ggml-base.bin` download is verified against `MODEL_SHA256` /
-/// `MODEL_SIZE`. A custom model supplied via `CLIPS_WHISPER_MODEL` is exempt
-/// (it may legitimately be a different model) — we only require it to exist.
-///
-/// Emits `whisper:model-progress { downloadedMb, totalMb }` every ~16 MB.
-pub async fn ensure_model(app: &AppHandle) -> Result<PathBuf, String> {
+#[tauri::command]
+pub async fn whisper_downloaded_models(app: AppHandle) -> Vec<String> {
+    let Ok(dir) = models_dir(&app) else {
+        return vec![];
+    };
+    SUPPORTED_MODELS
+        .iter()
+        .filter(|m| is_complete_on_disk(&model_path(&dir, m), m))
+        .map(|m| m.id.to_string())
+        .collect()
+}
+
+#[tauri::command]
+pub async fn whisper_model_delete(app: AppHandle, model_id: String) -> Result<(), String> {
+    if custom_model_override() {
+        return Err("Cannot manage models while CLIPS_WHISPER_MODEL is set.".to_string());
+    }
+    if crate::config::feature_config(&app).whisper_model_id == model_id {
+        return Err("Cannot delete the model that is currently selected.".to_string());
+    }
+    let model = find_model(&model_id)?;
+    let path = model_path(&models_dir(&app)?, model);
+    if path.exists() {
+        std::fs::remove_file(&path).map_err(|e| format!("delete model: {e}"))?;
+    }
+    let _ = app.emit(
+        "whisper:model-deleted",
+        serde_json::json!({ "modelId": model_id }),
+    );
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Download logic (called by whisper_model_download and lib.rs startup prewarm)
+// ---------------------------------------------------------------------------
+
+pub(crate) async fn ensure_model(app: &AppHandle) -> Result<PathBuf, String> {
     let path = model_file(app)?;
     let custom = custom_model_override();
 
-    if custom && !path.exists() {
+    if custom {
+        if path.exists() {
+            eprintln!("[whisper] using custom model at {}", path.display());
+            return Ok(path);
+        }
         return Err(format!(
-            "CLIPS_WHISPER_MODEL is set to '{}' but the file does not exist.",
+            "CLIPS_WHISPER_MODEL points to '{}' but the file does not exist.",
             path.display()
         ));
     }
 
+    let config = crate::config::feature_config(app);
+    let model = find_model(&config.whisper_model_id)?;
+
+    if is_complete_on_disk(&path, model) {
+        eprintln!("[whisper] model found at {}", path.display());
+        return Ok(path);
+    }
     if path.exists() {
-        if custom {
-            eprintln!("[whisper] using custom model at {}", path.display());
-            return Ok(path);
-        }
-        match std::fs::metadata(&path) {
-            Ok(m) if m.len() == MODEL_SIZE => {
-                eprintln!("[whisper] model found at {}", path.display());
-                return Ok(path);
-            }
-            Ok(m) => {
-                eprintln!(
-                    "[whisper] cached model size {} != expected {} — re-downloading",
-                    m.len(),
-                    MODEL_SIZE
-                );
-            }
-            Err(e) => return Err(format!("stat model: {e}")),
-        }
+        eprintln!(
+            "[whisper] cached model has wrong size — re-downloading {}",
+            path.display()
+        );
     }
 
-    // If a download is already in progress, wait for it rather than failing —
-    // the caller (meeting start) should succeed once the model lands.
-    if DOWNLOADING.load(Ordering::SeqCst) {
-        eprintln!("[whisper] waiting for in-progress model download…");
-        loop {
+    loop {
+        if DOWNLOADING
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+            .is_ok()
+        {
+            break;
+        }
+
+        eprintln!("[whisper] waiting for in-progress download…");
+        while DOWNLOADING.load(Ordering::SeqCst) {
             tokio::time::sleep(std::time::Duration::from_millis(100)).await;
-            if !DOWNLOADING.load(Ordering::SeqCst) {
-                break;
-            }
         }
-        // Re-check: the download that just finished may have placed the model.
-        if path.exists() {
-            if custom {
-                return Ok(path);
-            }
-            if let Ok(m) = std::fs::metadata(&path) {
-                if m.len() == MODEL_SIZE {
-                    return Ok(path);
-                }
-            }
+        if is_complete_on_disk(&path, model) {
+            return Ok(path);
         }
     }
-    // Guard against concurrent downloads.
-    if DOWNLOADING
-        .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-        .is_err()
-    {
-        return Err("Whisper model download already in progress — please wait.".to_string());
-    }
     DOWNLOADED_BYTES.store(0, Ordering::Relaxed);
 
-    let result = do_download(app, &path, custom).await;
+    let result = do_download(app, &path, model).await;
     DOWNLOADING.store(false, Ordering::SeqCst);
     result
 }
 
-async fn do_download(app: &AppHandle, path: &PathBuf, custom: bool) -> Result<PathBuf, String> {
+async fn do_download(
+    app: &AppHandle,
+    path: &Path,
+    model: &WhisperModel,
+) -> Result<PathBuf, String> {
     eprintln!(
-        "[whisper] model not found at {} — downloading {} (~142 MB, one time)",
-        path.display(),
-        MODEL_URL
+        "[whisper] downloading {} (~{} MB)",
+        model.url, model.size_mb
     );
-    let mut resp = reqwest::get(MODEL_URL).await.map_err(|e| {
-        let msg = format!("model download request failed: {e}");
-        eprintln!("[whisper] {msg}");
-        msg
-    })?;
-    if !resp.status().is_success() {
-        let msg = format!("model download HTTP {}", resp.status());
-        eprintln!("[whisper] {msg}");
-        return Err(msg);
+    let mut response = reqwest::get(model.url)
+        .await
+        .map_err(|e| format!("model download failed: {e}"))?;
+    if !response.status().is_success() {
+        return Err(format!("model download HTTP {}", response.status()));
     }
 
-    // Stream body to a temp file, hashing as we go. Keeps memory flat
-    // (no 142 MB heap spike) and lets us verify before the rename.
     use sha2::{Digest, Sha256};
     use std::io::Write as _;
 
     let tmp = path.with_extension("bin.tmp");
-    let mut file = std::fs::File::create(&tmp).map_err(|e| format!("create model tmp: {e}"))?;
+    let mut file = std::fs::File::create(&tmp).map_err(|e| format!("create tmp: {e}"))?;
     let mut hasher = Sha256::new();
-    let mut total: u64 = 0;
-    let mut last_progress: u64 = 0;
+    let mut total = 0_u64;
+    let mut last_progress = 0_u64;
 
-    while let Some(chunk) = resp
+    while let Some(chunk) = response
         .chunk()
         .await
-        .map_err(|e| format!("model download body failed: {e}"))?
+        .map_err(|e| format!("download body: {e}"))?
     {
-        if !custom {
-            hasher.update(&chunk);
-        }
+        hasher.update(&chunk);
         total += chunk.len() as u64;
         DOWNLOADED_BYTES.store(total, Ordering::Relaxed);
 
         if let Err(e) = file.write_all(&chunk) {
             let _ = std::fs::remove_file(&tmp);
-            let msg = format!("write model tmp: {e}");
-            eprintln!("[whisper] {msg}");
-            return Err(msg);
+            return Err(format!("write tmp: {e}"));
         }
 
-        // Emit progress + log every ~16 MB.
         if total - last_progress >= 16 * 1024 * 1024 {
             last_progress = total;
-            let downloaded_mb = total / (1024 * 1024);
-            eprintln!("[whisper] downloading model… {downloaded_mb} / {MODEL_SIZE_MB} MB");
+            let mb = downloaded_mb(total, model);
+            eprintln!("[whisper] {mb} / {} MB", model.size_mb);
             let _ = app.emit(
                 "whisper:model-progress",
-                serde_json::json!({ "downloadedMb": downloaded_mb, "totalMb": MODEL_SIZE_MB }),
+                serde_json::json!({ "downloadedMb": mb, "totalMb": model.size_mb }),
             );
         }
     }
-    file.flush().map_err(|e| format!("flush model tmp: {e}"))?;
+    file.flush().map_err(|e| format!("flush tmp: {e}"))?;
     drop(file);
 
-    if !custom {
-        if total != MODEL_SIZE {
-            let _ = std::fs::remove_file(&tmp);
-            let msg = format!("model size mismatch: got {total} bytes, expected {MODEL_SIZE}");
-            eprintln!("[whisper] {msg}");
-            return Err(msg);
-        }
-        let digest: String = hasher
-            .finalize()
-            .iter()
-            .map(|b| format!("{b:02x}"))
-            .collect();
-        if digest != MODEL_SHA256 {
-            let _ = std::fs::remove_file(&tmp);
-            let msg = format!("model checksum mismatch: got {digest}, expected {MODEL_SHA256}");
-            eprintln!("[whisper] {msg}");
-            return Err(msg);
-        }
-        eprintln!("[whisper] model checksum verified (sha256 {MODEL_SHA256})");
+    if total != model.size_bytes {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(format!(
+            "size mismatch: got {total} bytes, expected {}",
+            model.size_bytes
+        ));
+    }
+    let digest: String = hasher
+        .finalize()
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect();
+    if digest != model.sha256 {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(format!(
+            "checksum mismatch: got {digest}, expected {}",
+            model.sha256
+        ));
     }
 
     std::fs::rename(&tmp, path).map_err(|e| format!("rename model: {e}"))?;
-    eprintln!("[whisper] model saved → {}", path.display());
-    Ok(path.clone())
+    eprintln!("[whisper] saved → {}", path.display());
+    Ok(path.to_path_buf())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn supported_models_have_unique_ids_and_filenames() {
+        for (i, model) in SUPPORTED_MODELS.iter().enumerate() {
+            assert!(model.size_bytes > 0);
+            assert_eq!(model.sha256.len(), 64, "bad sha256 for {}", model.id);
+            assert!(!model.title.is_empty());
+            assert!(!model.description.is_empty());
+            for other in SUPPORTED_MODELS.iter().skip(i + 1) {
+                assert_ne!(model.id, other.id);
+                assert_ne!(model.filename, other.filename);
+            }
+        }
+    }
+
+    #[test]
+    fn base_model_is_default() {
+        assert!(is_supported_model_id("base"));
+    }
+
+    #[test]
+    fn unknown_model_id_is_rejected() {
+        assert!(find_model("does-not-exist").is_err());
+    }
 }

package/corpus/templates/clips/desktop/src-tauri/src/whisper_speech.rs

@@ -134,6 +134,7 @@ pub async fn whisper_transcription_reset_timeline() -> Result<(), String> {
 
 #[cfg(target_os = "macos")]
 mod macos {
+    use std::path::PathBuf;
     use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
     use std::sync::{Arc, Mutex, OnceLock};
     use std::time::{Duration, Instant};
@@ -189,13 +190,20 @@ mod macos {
         // the first call takes effect.
         whisper_rs::install_logging_hooks();
 
-        static CTX: OnceLock<Mutex<Option<Arc<WhisperContext>>>> = OnceLock::new();
+        struct CachedContext {
+            model_path: PathBuf,
+            context: Arc<WhisperContext>,
+        }
+
+        static CTX: OnceLock<Mutex<Option<CachedContext>>> = OnceLock::new();
         let slot = CTX.get_or_init(|| Mutex::new(None));
         let mut guard = slot.lock().map_err(|e| e.to_string())?;
-        if let Some(ctx) = guard.as_ref() {
-            return Ok(ctx.clone());
-        }
         let path = model_file(app)?;
+        if let Some(cached) = guard.as_ref() {
+            if cached.model_path == path {
+                return Ok(cached.context.clone());
+            }
+        }
         let path_str = path
             .to_str()
             .ok_or_else(|| "model path is not valid UTF-8".to_string())?;
@@ -208,9 +216,12 @@ mod macos {
         params.use_gpu(cfg!(target_arch = "aarch64"));
         let ctx = WhisperContext::new_with_params(path_str, params)
             .map_err(|e| format!("whisper model load failed: {e}"))?;
-        let ctx = Arc::new(ctx);
-        *guard = Some(ctx.clone());
-        Ok(ctx)
+        let context = Arc::new(ctx);
+        *guard = Some(CachedContext {
+            model_path: path,
+            context: context.clone(),
+        });
+        Ok(context)
     }
 
     pub fn prewarm(app: &AppHandle) -> Result<(), String> {

package/corpus/templates/clips/learnings.defaults.md

@@ -6,7 +6,7 @@
 
 ## Recording defaults
 
-- New recordings default to **private** visibility unless the user asks otherwise.
+- New recordings default to **public** visibility so anyone with the link can watch them. Organization admins can choose a different default.
 - Default playback speed for viewers is **1.2x** (creator can override per video).
 - Animated GIF thumbnails are enabled by default on new recordings — the first few seconds play as a hover preview.
 

package/corpus/templates/clips/server/plugins/db.ts

@@ -839,6 +839,17 @@ const migrations = runMigrations(
       name: "clips-meetings-share-transcript",
       sql: `ALTER TABLE clips_meetings ADD COLUMN IF NOT EXISTS share_transcript INTEGER NOT NULL DEFAULT 0`,
     },
+    {
+      version: 50,
+      name: "clips-public-organization-default",
+      // Earlier releases persisted the old private default into org rows.
+      // Normalize that state once; the org setting remains an explicit override.
+      // guard:allow-unscoped — startup migration normalizes legacy defaults across organizations.
+      sql: [
+        `UPDATE workspaces SET default_visibility = 'public' WHERE default_visibility = 'private' AND updated_at = created_at`,
+        `UPDATE organization_settings SET default_visibility = 'public' WHERE default_visibility = 'private' AND updated_at = created_at`,
+      ].join("; "),
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/shared/builder-credits.ts

@@ -1,7 +1,7 @@
 export const CLIPS_BUILDER_CREDITS_STATE_KEY = "clips-builder-credits";
 
 export const BUILDER_CREDITS_UPGRADE_URL =
-  "https://builder.io/account/subscription?signupSource=agent-native&agentNativeConnectSource=clips_builder_credits&agentNativeFlow=connect_llm&framework=agent-native";
+  "https://builder.io/account/subscription?signupSource=agent-native&agentNativeConnectSource=clips_builder_credits&agentNativeFlow=connect_llm&framework=agent-native&utm_source=agent-native&utm_medium=product&utm_campaign=onboarding&utm_content=clips_builder_credits";
 
 export const BUILDER_CREDIT_FEATURES = [
   "backup-transcription",