feat(v2): add SSH management, ctx integration, themes, detached mode, auto-updater

SSH session management:
- SshSession struct + ssh_sessions SQLite table in session.rs
- CRUD Tauri commands (ssh_session_list/save/delete) in lib.rs
- SshDialog.svelte (create/edit modal), SshSessionList.svelte (sidebar)
- SSH pane routes to TerminalPane with shell=/usr/bin/ssh + args

ctx context database integration:
- ctx.rs: read-only CtxDb (SQLITE_OPEN_READ_ONLY for ~/.claude-context/context.db)
- 5 Tauri commands (ctx_list_projects/get_context/get_shared/get_summaries/search)
- ContextPane.svelte with project selector, tabs, search
- ctx-bridge.ts adapter

Catppuccin theme flavors (Latte/Frappe/Macchiato/Mocha):
- themes.ts: all 4 palette definitions + buildXtermTheme/applyCssVariables
- theme.svelte.ts: reactive store with SQLite persistence
- SettingsDialog flavor dropdown, TerminalPane theme-aware

Detached pane mode (pop-out windows):
- detach.ts: isDetachedMode/getDetachedConfig from URL params
- App.svelte: conditional rendering of single pane without chrome

Other additions:
- Shiki syntax highlighting (highlight.ts, lazy singleton, 13 languages)
- Tauri auto-updater plugin (tauri-plugin-updater + updater.ts)
- AgentPane markdown rendering with Shiki code highlighting
- New deps: shiki, @tauri-apps/plugin-updater, tauri-plugin-updater

v2/src-tauri/src/ctx.rs

@@ -0,0 +1,172 @@
+// ctx — Read-only access to the Claude Code context manager database
+// Database: ~/.claude-context/context.db (managed by ctx CLI tool)
+
+use rusqlite::{Connection, params};
+use serde::Serialize;
+use std::sync::Mutex;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CtxProject {
+    pub name: String,
+    pub description: String,
+    pub work_dir: Option<String>,
+    pub created_at: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CtxEntry {
+    pub project: String,
+    pub key: String,
+    pub value: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CtxSummary {
+    pub project: String,
+    pub summary: String,
+    pub created_at: String,
+}
+
+pub struct CtxDb {
+    conn: Mutex<Option<Connection>>,
+}
+
+impl CtxDb {
+    pub fn new() -> Self {
+        let db_path = dirs::home_dir()
+            .unwrap_or_default()
+            .join(".claude-context")
+            .join("context.db");
+
+        let conn = if db_path.exists() {
+            Connection::open_with_flags(
+                &db_path,
+                rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ).ok()
+        } else {
+            None
+        };
+
+        Self { conn: Mutex::new(conn) }
+    }
+
+    pub fn list_projects(&self) -> Result<Vec<CtxProject>, String> {
+        let lock = self.conn.lock().unwrap();
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT name, description, work_dir, created_at FROM sessions ORDER BY name")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let projects = stmt
+            .query_map([], |row| {
+                Ok(CtxProject {
+                    name: row.get(0)?,
+                    description: row.get(1)?,
+                    work_dir: row.get(2)?,
+                    created_at: row.get(3)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(projects)
+    }
+
+    pub fn get_context(&self, project: &str) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().unwrap();
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, key, value, updated_at FROM contexts WHERE project = ?1 ORDER BY key")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let entries = stmt
+            .query_map(params![project], |row| {
+                Ok(CtxEntry {
+                    project: row.get(0)?,
+                    key: row.get(1)?,
+                    value: row.get(2)?,
+                    updated_at: row.get(3)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+
+    pub fn get_shared(&self) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().unwrap();
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT key, value, updated_at FROM shared ORDER BY key")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let entries = stmt
+            .query_map([], |row| {
+                Ok(CtxEntry {
+                    project: "shared".to_string(),
+                    key: row.get(0)?,
+                    value: row.get(1)?,
+                    updated_at: row.get(2)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+
+    pub fn get_summaries(&self, project: &str, limit: i64) -> Result<Vec<CtxSummary>, String> {
+        let lock = self.conn.lock().unwrap();
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, summary, created_at FROM summaries WHERE project = ?1 ORDER BY created_at DESC LIMIT ?2")
+            .map_err(|e| format!("ctx query failed: {e}"))?;
+
+        let summaries = stmt
+            .query_map(params![project, limit], |row| {
+                Ok(CtxSummary {
+                    project: row.get(0)?,
+                    summary: row.get(1)?,
+                    created_at: row.get(2)?,
+                })
+            })
+            .map_err(|e| format!("ctx query failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(summaries)
+    }
+
+    pub fn search(&self, query: &str) -> Result<Vec<CtxEntry>, String> {
+        let lock = self.conn.lock().unwrap();
+        let conn = lock.as_ref().ok_or("ctx database not found")?;
+
+        let mut stmt = conn
+            .prepare("SELECT project, key, value FROM contexts_fts WHERE contexts_fts MATCH ?1 LIMIT 50")
+            .map_err(|e| format!("ctx search failed: {e}"))?;
+
+        let entries = stmt
+            .query_map(params![query], |row| {
+                Ok(CtxEntry {
+                    project: row.get(0)?,
+                    key: row.get(1)?,
+                    value: row.get(2)?,
+                    updated_at: String::new(),
+                })
+            })
+            .map_err(|e| format!("ctx search failed: {e}"))?
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|e| format!("ctx row read failed: {e}"))?;
+
+        Ok(entries)
+    }
+}