diff --git a/src-tauri/src/db.rs b/src-tauri/src/db.rs
index 3e325ef..07e76c3 100644
--- a/src-tauri/src/db.rs
+++ b/src-tauri/src/db.rs
@@ -1,6 +1,8 @@
 use serde::Deserialize;
 use serde_json::Value as JsonValue;
-use tauri::State;
+use std::fs;
+use std::time::{SystemTime, UNIX_EPOCH};
+use tauri::{Manager, State};
 use tauri_plugin_sql::{DbInstances, DbPool};
 
 #[derive(Debug, Deserialize)]
@@ -47,6 +49,49 @@ pub async fn execute_transaction(
     }
 }
 
+#[tauri::command]
+pub fn backup_database_file(
+    app: tauri::AppHandle,
+    reason: String,
+) -> Result<Option<String>, String> {
+    let app_config_dir = app
+        .path()
+        .app_config_dir()
+        .map_err(|error| error.to_string())?;
+    let db_path = app_config_dir.join("glossa.db");
+    if !db_path.exists() {
+        return Ok(None);
+    }
+
+    let safe_reason: String = reason
+        .chars()
+        .map(|ch| {
+            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
+                ch
+            } else {
+                '-'
+            }
+        })
+        .collect();
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|error| error.to_string())?
+        .as_secs();
+    let backup_path = app_config_dir.join(format!("glossa.{timestamp}.{safe_reason}.db.bak"));
+    fs::copy(&db_path, &backup_path).map_err(|error| error.to_string())?;
+
+    for suffix in ["wal", "shm"] {
+        let sidecar_path = app_config_dir.join(format!("glossa.db-{suffix}"));
+        if sidecar_path.exists() {
+            let sidecar_backup_path =
+                app_config_dir.join(format!("glossa.{timestamp}.{safe_reason}.db-{suffix}.bak"));
+            fs::copy(&sidecar_path, sidecar_backup_path).map_err(|error| error.to_string())?;
+        }
+    }
+
+    Ok(Some(backup_path.to_string_lossy().into_owned()))
+}
+
 fn bind_json_value<'q>(
     query: sqlx::query::Query<'q, sqlx::Sqlite, sqlx::sqlite::SqliteArguments<'q>>,
     value: JsonValue,
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 1b56a77..bebbdd5 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -62,9 +62,10 @@ pub fn run() {
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
+            db::backup_database_file,
             db::execute_transaction,
             llm::pipeline::compute_blobs,
-llm::pipeline::run_stage,
+            llm::pipeline::run_stage,
             llm::pipeline::run_stage_stream,
             llm::pipeline::cancel_stream,
             llm::pipeline::judge_translation,
@@ -86,6 +87,9 @@ llm::pipeline::run_stage,
             vector::embedding::get_embeddings,
             vector::embedding::split_phrases_llm,
             vector::embedding::vec_upsert_source_phrase,
+            vector::embedding::vec_list_phrase_memory,
+            vector::embedding::vec_delete_phrase_memory,
+            vector::embedding::vec_update_phrase_memory,
             vector::embedding::vec_search_phrase_memory,
             vector::embedding::vec_save_locked_phrases,
         ])
diff --git a/src-tauri/src/vector/embedding.rs b/src-tauri/src/vector/embedding.rs
index f9d4d2f..42809ec 100644
--- a/src-tauri/src/vector/embedding.rs
+++ b/src-tauri/src/vector/embedding.rs
@@ -1,7 +1,11 @@
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
+use std::time::{Duration, Instant};
 use tauri::Manager;
 
+const OPENAI_CONNECT_TIMEOUT_SECS: u64 = 10;
+const OPENAI_REQUEST_TIMEOUT_SECS: u64 = 45;
+
 #[derive(Debug, thiserror::Error)]
 pub enum EmbeddingError {
     #[error("API key not found for provider openai")]
@@ -20,7 +24,7 @@ impl Serialize for EmbeddingError {
 
 fn db_path(app: &tauri::AppHandle) -> Result<PathBuf, EmbeddingError> {
     app.path()
-        .app_data_dir()
+        .app_config_dir()
         .map(|p| p.join("glossa.db"))
         .map_err(|e| EmbeddingError::Http(format!("cannot resolve db path: {e}")))
 }
@@ -29,6 +33,53 @@ fn floats_to_blob(v: &[f32]) -> Vec<u8> {
     v.iter().flat_map(|f| f.to_le_bytes()).collect()
 }
 
+fn openai_client() -> Result<reqwest::Client, EmbeddingError> {
+    reqwest::Client::builder()
+        .connect_timeout(Duration::from_secs(OPENAI_CONNECT_TIMEOUT_SECS))
+        .timeout(Duration::from_secs(OPENAI_REQUEST_TIMEOUT_SECS))
+        .build()
+        .map_err(|e| EmbeddingError::Http(format!("cannot build OpenAI client: {e}")))
+}
+
+fn ensure_source_phrase_embeddings_schema(
+    conn: &rusqlite::Connection,
+) -> Result<(), EmbeddingError> {
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS source_phrase_embeddings (
+            id TEXT PRIMARY KEY,
+            project_id TEXT NOT NULL REFERENCES projects(id),
+            chunk_id TEXT,
+            source_phrase TEXT NOT NULL,
+            embedding BLOB NOT NULL,
+            created_at TEXT NOT NULL
+        );",
+    )
+    .map_err(|e| EmbeddingError::Http(e.to_string()))
+}
+
+fn ensure_phrase_memory_schema(conn: &rusqlite::Connection) -> Result<(), EmbeddingError> {
+    conn.execute_batch(
+        "CREATE TABLE IF NOT EXISTS phrase_memory (
+            id TEXT PRIMARY KEY,
+            workspace_id TEXT NOT NULL REFERENCES workspaces(id),
+            source_phrase TEXT NOT NULL,
+            target_phrase TEXT NOT NULL,
+            source_language TEXT NOT NULL,
+            target_language TEXT NOT NULL,
+            author TEXT,
+            work TEXT,
+            domain TEXT,
+            tags TEXT,
+            notes TEXT,
+            chunk_id TEXT,
+            project_id TEXT REFERENCES projects(id),
+            embedding BLOB NOT NULL,
+            created_at TEXT NOT NULL
+        );",
+    )
+    .map_err(|e| EmbeddingError::Http(e.to_string()))
+}
+
 // ── OpenAI response types ────────────────────────────────────────────
 
 #[derive(Deserialize)]
@@ -52,9 +103,15 @@ pub async fn get_embeddings(
     if texts.is_empty() {
         return Ok(vec![]);
     }
+    let request_started = Instant::now();
+    let total_chars: usize = texts.iter().map(|text| text.len()).sum();
+    log::debug!(
+        "phrase_memory.get_embeddings.start model={model} input_count={} total_chars={total_chars}",
+        texts.len()
+    );
 
-    let api_key = crate::keystore::get_api_key(&app, "openai")
-        .map_err(|_| EmbeddingError::MissingApiKey)?;
+    let api_key =
+        crate::keystore::get_api_key(&app, "openai").map_err(|_| EmbeddingError::MissingApiKey)?;
     if api_key.is_empty() {
         return Err(EmbeddingError::MissingApiKey);
     }
@@ -65,25 +122,51 @@ pub async fn get_embeddings(
         "encoding_format": "float"
     });
 
-    let response = reqwest::Client::new()
+    let response = openai_client()?
         .post("https://api.openai.com/v1/embeddings")
         .bearer_auth(&api_key)
         .json(&body)
         .send()
         .await
-        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.get_embeddings.request_failed model={model} input_count={} elapsed_ms={} error={e}",
+                texts.len(),
+                request_started.elapsed().as_millis()
+            );
+            EmbeddingError::Http(e.to_string())
+        })?;
 
     if !response.status().is_success() {
         let status = response.status();
         let text = response.text().await.unwrap_or_default();
+        let preview: String = text.chars().take(500).collect();
+        log::warn!(
+            "phrase_memory.get_embeddings.http_error model={model} input_count={} elapsed_ms={} status={status} body_preview={preview:?}",
+            texts.len(),
+            request_started.elapsed().as_millis()
+        );
         return Err(EmbeddingError::Http(format!("{status}: {text}")));
     }
 
     let parsed: OpenAiEmbeddingResponse = response
         .json()
         .await
-        .map_err(|e| EmbeddingError::Parse(e.to_string()))?;
-
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.get_embeddings.parse_failed model={model} input_count={} elapsed_ms={} error={e}",
+                texts.len(),
+                request_started.elapsed().as_millis()
+            );
+            EmbeddingError::Parse(e.to_string())
+        })?;
+
+    log::debug!(
+        "phrase_memory.get_embeddings.done model={model} input_count={} output_count={} elapsed_ms={}",
+        texts.len(),
+        parsed.data.len(),
+        request_started.elapsed().as_millis()
+    );
     Ok(parsed.data.into_iter().map(|o| o.embedding).collect())
 }
 
@@ -92,8 +175,13 @@ pub async fn split_phrases_llm(
     app: tauri::AppHandle,
     source_text: String,
 ) -> Result<Vec<String>, EmbeddingError> {
-    let api_key = crate::keystore::get_api_key(&app, "openai")
-        .map_err(|_| EmbeddingError::MissingApiKey)?;
+    let request_started = Instant::now();
+    log::debug!(
+        "phrase_memory.split_phrases_llm.start source_chars={}",
+        source_text.len()
+    );
+    let api_key =
+        crate::keystore::get_api_key(&app, "openai").map_err(|_| EmbeddingError::MissingApiKey)?;
     if api_key.is_empty() {
         return Err(EmbeddingError::MissingApiKey);
     }
@@ -113,24 +201,41 @@ pub async fn split_phrases_llm(
         "response_format": {"type": "json_object"}
     });
 
-    let response = reqwest::Client::new()
+    let response = openai_client()?
         .post("https://api.openai.com/v1/chat/completions")
         .bearer_auth(&api_key)
         .json(&body)
         .send()
         .await
-        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.split_phrases_llm.request_failed source_chars={} elapsed_ms={} error={e}",
+                source_text.len(),
+                request_started.elapsed().as_millis()
+            );
+            EmbeddingError::Http(e.to_string())
+        })?;
 
     if !response.status().is_success() {
         let status = response.status();
         let text = response.text().await.unwrap_or_default();
+        let preview: String = text.chars().take(500).collect();
+        log::warn!(
+            "phrase_memory.split_phrases_llm.http_error source_chars={} elapsed_ms={} status={status} body_preview={preview:?}",
+            source_text.len(),
+            request_started.elapsed().as_millis()
+        );
         return Err(EmbeddingError::Http(format!("{status}: {text}")));
     }
 
-    let json: serde_json::Value = response
-        .json()
-        .await
-        .map_err(|e| EmbeddingError::Parse(e.to_string()))?;
+    let json: serde_json::Value = response.json().await.map_err(|e| {
+        log::warn!(
+            "phrase_memory.split_phrases_llm.parse_failed source_chars={} elapsed_ms={} error={e}",
+            source_text.len(),
+            request_started.elapsed().as_millis()
+        );
+        EmbeddingError::Parse(e.to_string())
+    })?;
 
     let content = json["choices"][0]["message"]["content"]
         .as_str()
@@ -157,6 +262,12 @@ pub async fn split_phrases_llm(
         .map(|s| s.to_string())
         .collect();
 
+    log::debug!(
+        "phrase_memory.split_phrases_llm.done source_chars={} phrase_count={} elapsed_ms={}",
+        source_text.len(),
+        validated.len(),
+        request_started.elapsed().as_millis()
+    );
     Ok(validated)
 }
 
@@ -171,6 +282,7 @@ pub async fn vec_upsert_source_phrase(
     let path = db_path(&app)?;
     let conn = crate::vector::open_vec_connection(&path)
         .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    ensure_source_phrase_embeddings_schema(&conn)?;
 
     conn.execute(
         "INSERT OR REPLACE INTO source_phrase_embeddings \
@@ -191,6 +303,122 @@ pub struct PhraseMatchResult {
     pub distance: f64,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PhraseMemoryEntryResult {
+    pub id: String,
+    pub workspace_id: String,
+    pub source_phrase: String,
+    pub target_phrase: String,
+    pub source_language: String,
+    pub target_language: String,
+    pub author: Option<String>,
+    pub work: Option<String>,
+    pub domain: Option<String>,
+    pub tags: Option<String>,
+    pub notes: Option<String>,
+    pub chunk_id: Option<String>,
+    pub project_id: Option<String>,
+    pub created_at: String,
+}
+
+#[tauri::command]
+pub async fn vec_list_phrase_memory(
+    app: tauri::AppHandle,
+    workspace_id: String,
+) -> Result<Vec<PhraseMemoryEntryResult>, EmbeddingError> {
+    let path = db_path(&app)?;
+    let conn = crate::vector::open_vec_connection(&path)
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    ensure_phrase_memory_schema(&conn)?;
+
+    let mut stmt = conn
+        .prepare(
+            "SELECT id, workspace_id, source_phrase, target_phrase, source_language, target_language, \
+                    author, work, domain, tags, notes, chunk_id, project_id, created_at \
+             FROM phrase_memory \
+             WHERE workspace_id = ?1 \
+             ORDER BY datetime(created_at) DESC, id DESC",
+        )
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+
+    let results: rusqlite::Result<Vec<PhraseMemoryEntryResult>> = stmt
+        .query_map(rusqlite::params![workspace_id], |row| {
+            Ok(PhraseMemoryEntryResult {
+                id: row.get(0)?,
+                workspace_id: row.get(1)?,
+                source_phrase: row.get(2)?,
+                target_phrase: row.get(3)?,
+                source_language: row.get(4)?,
+                target_language: row.get(5)?,
+                author: row.get(6)?,
+                work: row.get(7)?,
+                domain: row.get(8)?,
+                tags: row.get(9)?,
+                notes: row.get(10)?,
+                chunk_id: row.get(11)?,
+                project_id: row.get(12)?,
+                created_at: row.get(13)?,
+            })
+        })
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?
+        .collect();
+
+    results.map_err(|e| EmbeddingError::Http(e.to_string()))
+}
+
+#[tauri::command]
+pub async fn vec_delete_phrase_memory(
+    app: tauri::AppHandle,
+    workspace_id: String,
+    phrase_memory_id: String,
+) -> Result<u32, EmbeddingError> {
+    let path = db_path(&app)?;
+    let conn = crate::vector::open_vec_connection(&path)
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    ensure_phrase_memory_schema(&conn)?;
+
+    let deleted = conn
+        .execute(
+            "DELETE FROM phrase_memory WHERE id = ?1 AND workspace_id = ?2",
+            rusqlite::params![phrase_memory_id, workspace_id],
+        )
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+
+    Ok(deleted as u32)
+}
+
+#[tauri::command]
+pub async fn vec_update_phrase_memory(
+    app: tauri::AppHandle,
+    workspace_id: String,
+    phrase_memory_id: String,
+    source_phrase: String,
+    target_phrase: String,
+    embedding: Vec<f32>,
+) -> Result<u32, EmbeddingError> {
+    let path = db_path(&app)?;
+    let conn = crate::vector::open_vec_connection(&path)
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    ensure_phrase_memory_schema(&conn)?;
+
+    let updated = conn
+        .execute(
+            "UPDATE phrase_memory \
+             SET source_phrase = ?1, target_phrase = ?2, embedding = ?3 \
+             WHERE id = ?4 AND workspace_id = ?5",
+            rusqlite::params![
+                source_phrase,
+                target_phrase,
+                floats_to_blob(&embedding),
+                phrase_memory_id,
+                workspace_id
+            ],
+        )
+        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+
+    Ok(updated as u32)
+}
+
 #[tauri::command]
 pub async fn vec_search_phrase_memory(
     app: tauri::AppHandle,
@@ -202,6 +430,7 @@ pub async fn vec_search_phrase_memory(
     let path = db_path(&app)?;
     let conn = crate::vector::open_vec_connection(&path)
         .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    ensure_phrase_memory_schema(&conn)?;
 
     let blob = floats_to_blob(&query_embedding);
 
@@ -259,22 +488,87 @@ pub async fn vec_save_locked_phrases(
     source_language: String,
     target_language: String,
 ) -> Result<u32, EmbeddingError> {
+    let save_started = Instant::now();
+    log::debug!(
+        "phrase_memory.vec_save_locked_phrases.start workspace_id={workspace_id} project_id={project_id} chunk_id={chunk_id} pair_count={} min_phrase_length={min_phrase_length}",
+        pairs.len()
+    );
     if pairs.is_empty() {
         return Ok(0);
     }
 
     let path = db_path(&app)?;
-    let conn = crate::vector::open_vec_connection(&path)
-        .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+    log::debug!(
+        "phrase_memory.vec_save_locked_phrases.db_path path={}",
+        path.display()
+    );
+    let mut conn = crate::vector::open_vec_connection(&path).map_err(|e| {
+        log::warn!(
+            "phrase_memory.vec_save_locked_phrases.db_open_failed path={} error={e}",
+            path.display()
+        );
+        EmbeddingError::Http(e.to_string())
+    })?;
+    log::debug!("phrase_memory.vec_save_locked_phrases.db_opened");
+    ensure_phrase_memory_schema(&conn).map_err(|e| {
+        log::warn!("phrase_memory.vec_save_locked_phrases.schema_phrase_failed error={e}");
+        e
+    })?;
+    ensure_source_phrase_embeddings_schema(&conn).map_err(|e| {
+        log::warn!("phrase_memory.vec_save_locked_phrases.schema_source_failed error={e}");
+        e
+    })?;
+    log::debug!("phrase_memory.vec_save_locked_phrases.schema_ready");
+
+    let workspace_exists: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM workspaces WHERE id = ?1",
+            rusqlite::params![&workspace_id],
+            |row| row.get(0),
+        )
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.vec_save_locked_phrases.workspace_check_failed workspace_id={workspace_id} error={e}"
+            );
+            EmbeddingError::Http(e.to_string())
+        })?;
+    let project_exists: i64 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM projects WHERE id = ?1",
+            rusqlite::params![&project_id],
+            |row| row.get(0),
+        )
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.vec_save_locked_phrases.project_check_failed project_id={project_id} error={e}"
+            );
+            EmbeddingError::Http(e.to_string())
+        })?;
+    log::debug!(
+        "phrase_memory.vec_save_locked_phrases.refs workspace_id={workspace_id} workspace_exists={workspace_exists} project_id={project_id} project_exists={project_exists}"
+    );
+    if workspace_exists == 0 || project_exists == 0 {
+        return Err(EmbeddingError::Http(format!(
+            "phrase memory references missing: workspace_id={workspace_id} exists={workspace_exists}, project_id={project_id} exists={project_exists}"
+        )));
+    }
 
     let mut saved: u32 = 0;
-
-    for pair in &pairs {
+    let mut attempted: u32 = 0;
+    let mut skipped_short: u32 = 0;
+    let tx = conn.transaction().map_err(|e| {
+        log::warn!("phrase_memory.vec_save_locked_phrases.transaction_failed error={e}");
+        EmbeddingError::Http(e.to_string())
+    })?;
+
+    for (index, pair) in pairs.iter().enumerate() {
         if (pair.source_phrase.len() as u32) < min_phrase_length {
+            skipped_short += 1;
             continue;
         }
 
-        let rows = conn
+        attempted += 1;
+        let rows = tx
             .execute(
                 "INSERT OR IGNORE INTO phrase_memory \
                  (id, workspace_id, project_id, chunk_id, source_phrase, target_phrase, \
@@ -291,16 +585,46 @@ pub async fn vec_save_locked_phrases(
                     floats_to_blob(&pair.source_embedding)
                 ],
             )
-            .map_err(|e| EmbeddingError::Http(e.to_string()))?;
+            .map_err(|e| {
+                log::warn!(
+                    "phrase_memory.vec_save_locked_phrases.insert_failed workspace_id={workspace_id} project_id={project_id} chunk_id={chunk_id} pair_index={index} source_chars={} target_chars={} embedding_dim={} error={e}",
+                    pair.source_phrase.len(),
+                    pair.target_phrase.len(),
+                    pair.source_embedding.len()
+                );
+                EmbeddingError::Http(format!("phrase memory insert failed at pair {index}: {e}"))
+            })?;
 
         saved += rows as u32;
     }
+    log::debug!(
+        "phrase_memory.vec_save_locked_phrases.insert_loop_done pair_count={} attempted={attempted} skipped_short={skipped_short} saved={saved}",
+        pairs.len()
+    );
 
-    conn.execute(
-        "DELETE FROM source_phrase_embeddings WHERE chunk_id = ?1 AND project_id = ?2",
-        rusqlite::params![chunk_id, project_id],
-    )
-    .map_err(|e| EmbeddingError::Http(e.to_string()))?;
-
+    let deleted_source_embeddings = tx
+        .execute(
+            "DELETE FROM source_phrase_embeddings WHERE chunk_id = ?1 AND project_id = ?2",
+            rusqlite::params![&chunk_id, &project_id],
+        )
+        .map_err(|e| {
+            log::warn!(
+                "phrase_memory.vec_save_locked_phrases.cleanup_failed project_id={project_id} chunk_id={chunk_id} error={e}"
+            );
+            EmbeddingError::Http(e.to_string())
+        })?;
+    log::debug!(
+        "phrase_memory.vec_save_locked_phrases.cleanup_done deleted_source_embeddings={deleted_source_embeddings}"
+    );
+    tx.commit().map_err(|e| {
+        log::warn!("phrase_memory.vec_save_locked_phrases.commit_failed error={e}");
+        EmbeddingError::Http(e.to_string())
+    })?;
+
+    log::info!(
+        "phrase_memory.vec_save_locked_phrases.done workspace_id={workspace_id} project_id={project_id} chunk_id={chunk_id} pair_count={} attempted={attempted} skipped_short={skipped_short} saved={saved} elapsed_ms={}",
+        pairs.len(),
+        save_started.elapsed().as_millis()
+    );
     Ok(saved)
 }
diff --git a/src-tauri/src/vector/mod.rs b/src-tauri/src/vector/mod.rs
index fd07cfa..31e22e0 100644
--- a/src-tauri/src/vector/mod.rs
+++ b/src-tauri/src/vector/mod.rs
@@ -18,7 +18,9 @@ pub fn register_vec_extension() {
 
 pub fn open_vec_connection(db_path: &PathBuf) -> RusqliteResult<Connection> {
     let conn = Connection::open(db_path)?;
-    conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;")?;
+    conn.execute_batch(
+        "PRAGMA foreign_keys=ON; PRAGMA journal_mode=WAL; PRAGMA busy_timeout=10000;",
+    )?;
     Ok(conn)
 }
 
@@ -26,15 +28,13 @@ pub fn open_vec_connection(db_path: &PathBuf) -> RusqliteResult<Connection> {
 pub fn vec_ping(app: tauri::AppHandle) -> Result<String, String> {
     let db_path = get_db_path(&app)?;
     open_vec_connection(&db_path)
-        .and_then(|conn| {
-            conn.query_row("SELECT vec_version()", [], |row| row.get::<_, String>(0))
-        })
+        .and_then(|conn| conn.query_row("SELECT vec_version()", [], |row| row.get::<_, String>(0)))
         .map_err(|e| e.to_string())
 }
 
 pub fn get_db_path(app: &tauri::AppHandle) -> Result<PathBuf, String> {
     app.path()
-        .app_data_dir()
+        .app_config_dir()
         .map(|d| d.join("glossa.db"))
         .map_err(|e| e.to_string())
 }
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 0d415eb..ef2f526 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -13,10 +13,10 @@
     "windows": [
       {
         "title": "Glossa — Translation Pipeline",
-        "width": 1600,
-        "height": 1280,
-        "minWidth": 1200,
-        "minHeight": 900,
+        "width": 1920,
+        "height": 1080,
+        "minWidth": 1280,
+        "minHeight": 760,
         "resizable": true,
         "fullscreen": false
       }
diff --git a/src/App.tsx b/src/App.tsx
index 86f91cf..7f49c32 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -356,7 +356,7 @@ export default function App() {
   // ── Shell loading ────────────────────────────────────────────────────
   if (!isLoaded) {
     return (
-      <div className="flex h-screen items-center justify-center bg-editorial-bg">
+      <div className="flex h-dvh min-h-[var(--app-min-height)] min-w-[var(--app-min-width)] items-center justify-center bg-editorial-bg">
         <div className="text-sm text-editorial-muted">Caricamento...</div>
       </div>
     );
@@ -378,9 +378,9 @@ export default function App() {
   }
 
   return (
-    <ErrorBoundary>
+      <ErrorBoundary>
       <HighlightColorSync />
-      <div className="h-screen overflow-hidden bg-editorial-bg text-editorial-ink font-sans flex flex-col">
+      <div className="flex h-dvh min-h-[var(--app-min-height)] min-w-[var(--app-min-width)] flex-col overflow-hidden bg-editorial-bg font-sans text-editorial-ink">
         <div className="flex-shrink-0">
           <Header />
         </div>
diff --git a/src/components/common/HighlightedText.tsx b/src/components/common/HighlightedText.tsx
index 739687e..b29f4c4 100644
--- a/src/components/common/HighlightedText.tsx
+++ b/src/components/common/HighlightedText.tsx
@@ -1,19 +1,20 @@
 import { forwardRef } from 'react';
-import type { CSSProperties } from 'react';
+import type { CSSProperties, HTMLAttributes } from 'react';
 
-interface Props {
+interface Props extends HTMLAttributes<HTMLDivElement> {
   html: string;
   className?: string;
   style?: CSSProperties;
 }
 
 export const HighlightedText = forwardRef<HTMLDivElement, Props>(
-  function HighlightedText({ html, className = '', style }, ref) {
+  function HighlightedText({ html, className = '', style, ...rest }, ref) {
     return (
       <div
         ref={ref}
         className={`w-full whitespace-pre-wrap break-words ${className}`}
         style={style}
+        {...rest}
         // eslint-disable-next-line react/no-danger
         dangerouslySetInnerHTML={{ __html: html }}
       />
diff --git a/src/components/common/MarkdownEditor.test.tsx b/src/components/common/MarkdownEditor.test.tsx
new file mode 100644
index 0000000..8eb47ea
--- /dev/null
+++ b/src/components/common/MarkdownEditor.test.tsx
@@ -0,0 +1,45 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { useState } from 'react';
+import { describe, expect, it } from 'vitest';
+import { MarkdownEditor } from './MarkdownEditor';
+
+function EditableFixture() {
+  const [value, setValue] = useState('Ciao');
+  return (
+    <MarkdownEditor
+      value={value}
+      onChange={setValue}
+      identityKey="chunk-1:candidate:final"
+    />
+  );
+}
+
+describe('MarkdownEditor', () => {
+  it('gestisce Ctrl+Z su textarea controlled', async () => {
+    render(<EditableFixture />);
+
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'Ciao mondo' } });
+    expect(textarea).toHaveValue('Ciao mondo');
+
+    fireEvent.keyDown(textarea, { key: 'z', ctrlKey: true });
+
+    await waitFor(() => {
+      expect(textarea).toHaveValue('Ciao');
+    });
+  });
+
+  it('non renderizza una textarea per contenuti readonly senza highlight', () => {
+    render(
+      <MarkdownEditor
+        value="Output stage readonly"
+        onChange={() => {}}
+        readOnly
+        identityKey="chunk-1:stage:translation"
+      />,
+    );
+
+    expect(screen.queryByRole('textbox')).not.toBeInTheDocument();
+    expect(screen.getByText('Output stage readonly')).toBeInTheDocument();
+  });
+});
diff --git a/src/components/common/MarkdownEditor.tsx b/src/components/common/MarkdownEditor.tsx
index 7177957..c004a29 100644
--- a/src/components/common/MarkdownEditor.tsx
+++ b/src/components/common/MarkdownEditor.tsx
@@ -1,7 +1,8 @@
-import { Bold, Columns2, Eye, Heading1, Heading2, Heading3, Italic, Link2, List, ListOrdered, Minus, PanelTopClose, PanelTopOpen, Pencil, Pilcrow, Plus, Type } from 'lucide-react';
-import type { ReactNode } from 'react';
+import { Bold, CircleHelp, Columns2, Eye, Heading1, Heading2, Heading3, Italic, Link2, List, ListOrdered, Minus, PanelTopClose, PanelTopOpen, Pencil, Pilcrow, Plus, Type } from 'lucide-react';
+import type { KeyboardEvent as ReactKeyboardEvent, MutableRefObject, ReactNode } from 'react';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
+import { useUiStore } from '../../stores/uiStore';
 import { renderMarkdownToHtmlFragment } from '../../services/markdown';
 import {
   applyMarkdownCommand,
@@ -9,9 +10,16 @@ import {
   type MarkdownCommand,
 } from './markdownEditorUtils';
 import { HighlightedText } from './HighlightedText';
+import { IconButton } from '../ui';
 
 type EditorMode = 'write' | 'preview' | 'split';
 
+type HistoryEntry = {
+  value: string;
+  selectionStart: number;
+  selectionEnd: number;
+};
+
 const TEXT_SIZE_STEPS = [
   { fontSize: '0.75rem', lineHeight: '1.5rem' },
   { fontSize: '0.825rem', lineHeight: '1.65rem' },
@@ -22,6 +30,8 @@ const TEXT_SIZE_STEPS = [
   { fontSize: '1.375rem', lineHeight: '2.75rem' },
 ] as const;
 const DEFAULT_TEXT_SIZE_STEP = 3;
+const MAX_UNDO_ENTRIES = 100;
+const TYPING_UNDO_COALESCE_MS = 800;
 
 interface MarkdownEditorProps {
   value: string;
@@ -38,6 +48,7 @@ interface MarkdownEditorProps {
   focusRequestId?: number;
   onFocusQueryHandled?: () => void;
   fillHeight?: boolean;
+  identityKey?: string;
 }
 
 export function MarkdownEditor({
@@ -55,10 +66,18 @@ export function MarkdownEditor({
   focusRequestId = 0,
   onFocusQueryHandled,
   fillHeight = false,
+  identityKey = 'default',
 }: MarkdownEditorProps) {
   const { t } = useTranslation();
+  const setShowHelp = useUiStore((state) => state.setShowHelp);
   const textareaRef = useRef<HTMLTextAreaElement | null>(null);
   const highlightLayerRef = useRef<HTMLDivElement | null>(null);
+  const readOnlyHighlightRef = useRef<HTMLDivElement | null>(null);
+  const undoStackRef = useRef<HistoryEntry[]>([]);
+  const redoStackRef = useRef<HistoryEntry[]>([]);
+  const lastValueRef = useRef(value);
+  const lastTypingChangeAtRef = useRef(0);
+  const previousIdentityRef = useRef(identityKey);
   const [mode, setMode] = useState<EditorMode>('write');
   const [textSizeStep, setTextSizeStep] = useState(DEFAULT_TEXT_SIZE_STEP);
   const [selection, setSelection] = useState({ start: 0, end: 0 });
@@ -86,6 +105,29 @@ export function MarkdownEditor({
   }, [markdownEnabled, mode, selection.end, selection.start, value]);
   const commandEditingDisabled = readOnly || disabled || mode === 'preview';
 
+  useEffect(() => {
+    if (previousIdentityRef.current === identityKey) {
+      lastValueRef.current = value;
+      return;
+    }
+
+    previousIdentityRef.current = identityKey;
+    lastValueRef.current = value;
+    lastTypingChangeAtRef.current = 0;
+    undoStackRef.current = [];
+    redoStackRef.current = [];
+    updateSelection(0, 0);
+    requestAnimationFrame(() => {
+      const element = textareaRef.current ?? readOnlyHighlightRef.current;
+      if (!element) return;
+      element.scrollTop = 0;
+      if (element instanceof HTMLTextAreaElement) {
+        element.setSelectionRange(0, 0);
+      }
+      syncHighlightLayer();
+    });
+  }, [identityKey, value]);
+
   useEffect(() => {
     if (!markdownEnabled && mode === 'split') {
       setMode('write');
@@ -106,8 +148,6 @@ export function MarkdownEditor({
 
   useEffect(() => {
     if (!focusQuery) return;
-    const element = textareaRef.current;
-    if (!element) return;
     const normalizedQuery = focusQuery.trim();
     if (!normalizedQuery) return;
     const lowerValue = value.toLowerCase();
@@ -117,8 +157,11 @@ export function MarkdownEditor({
 
     setMode('write');
     requestAnimationFrame(() => {
+      const element = textareaRef.current ?? readOnlyHighlightRef.current;
+      if (!element) return;
       element.scrollTop = Math.max(0, element.scrollHeight * (matchIndex / Math.max(1, value.length)) - 120);
       syncHighlightLayer();
+      element.dispatchEvent(new Event('scroll', { bubbles: true }));
       onFocusQueryHandled?.();
     });
   }, [focusQuery, focusRequestId, onFocusQueryHandled, value]);
@@ -143,15 +186,99 @@ export function MarkdownEditor({
     updateSelection(element.selectionStart, element.selectionEnd);
   };
 
+  const currentHistoryEntry = (): HistoryEntry => {
+    const element = textareaRef.current;
+    return {
+      value: lastValueRef.current,
+      selectionStart: element?.selectionStart ?? selection.start,
+      selectionEnd: element?.selectionEnd ?? selection.end,
+    };
+  };
+
+  const pushUndoEntry = (entry: HistoryEntry, coalesceTyping = false) => {
+    const now = Date.now();
+    const stack = undoStackRef.current;
+    const shouldCoalesce =
+      coalesceTyping &&
+      stack.length > 0 &&
+      now - lastTypingChangeAtRef.current < TYPING_UNDO_COALESCE_MS;
+
+    if (!shouldCoalesce && stack[stack.length - 1]?.value !== entry.value) {
+      stack.push(entry);
+      if (stack.length > MAX_UNDO_ENTRIES) stack.shift();
+    }
+
+    lastTypingChangeAtRef.current = coalesceTyping ? now : 0;
+    redoStackRef.current = [];
+  };
+
+  const restoreHistoryEntry = (
+    entry: HistoryEntry,
+    oppositeStack: MutableRefObject<HistoryEntry[]>,
+  ) => {
+    oppositeStack.current.push(currentHistoryEntry());
+    if (oppositeStack.current.length > MAX_UNDO_ENTRIES) oppositeStack.current.shift();
+    lastValueRef.current = entry.value;
+    onChange(entry.value);
+    requestAnimationFrame(() => {
+      const element = textareaRef.current;
+      if (!element) return;
+      element.focus();
+      const safeStart = Math.min(entry.selectionStart, entry.value.length);
+      const safeEnd = Math.min(entry.selectionEnd, entry.value.length);
+      element.setSelectionRange(safeStart, safeEnd);
+      updateSelection(safeStart, safeEnd);
+      syncHighlightLayer();
+    });
+  };
+
+  const undo = () => {
+    const entry = undoStackRef.current.pop();
+    if (!entry) return;
+    restoreHistoryEntry(entry, redoStackRef);
+  };
+
+  const redo = () => {
+    const entry = redoStackRef.current.pop();
+    if (!entry) return;
+    restoreHistoryEntry(entry, undoStackRef);
+  };
+
+  const handleKeyDown = (event: ReactKeyboardEvent<HTMLTextAreaElement>) => {
+    if (readOnly || disabled) return;
+    const modifier = event.metaKey || event.ctrlKey;
+    const key = event.key.toLowerCase();
+    if (!modifier || event.altKey) return;
+
+    if (key === 'z') {
+      event.preventDefault();
+      if (event.shiftKey) redo();
+      else undo();
+    } else if (key === 'y') {
+      event.preventDefault();
+      redo();
+    }
+  };
+
+  const handleTextChange = (nextValue: string) => {
+    if (readOnly || disabled) return;
+    if (nextValue === lastValueRef.current) return;
+    pushUndoEntry(currentHistoryEntry(), true);
+    lastValueRef.current = nextValue;
+    onChange(nextValue);
+  };
+
   const applyCommand = (command: MarkdownCommand) => {
     const element = textareaRef.current;
     if (!element || readOnly || disabled || !markdownEnabled) return;
+    pushUndoEntry(currentHistoryEntry());
     const result = applyMarkdownCommand({
       command,
       value,
       selectionStart: element.selectionStart,
       selectionEnd: element.selectionEnd,
     });
+    lastValueRef.current = result.value;
     onChange(result.value);
     requestAnimationFrame(() => {
       element.focus();
@@ -160,19 +287,22 @@ export function MarkdownEditor({
     });
   };
 
-  const textareaClassName = `${fillHeight ? 'flex-1 min-h-[100px] h-0' : minHeightClassName} w-full resize-y bg-transparent outline-none ${textClassName} disabled:opacity-70 read-only:cursor-not-allowed`;
+  const textareaClassName = `${fillHeight ? 'flex-1 min-h-[100px] h-0' : minHeightClassName} w-full resize-y bg-transparent outline-none custom-scrollbar ${textClassName} disabled:opacity-70 read-only:cursor-not-allowed`;
 
   const textarea = (
     <textarea
       ref={textareaRef}
+      data-scroll-sync="true"
       value={value}
-      onChange={(event) => onChange(event.target.value)}
+      onChange={(event) => handleTextChange(event.target.value)}
       readOnly={readOnly}
       disabled={disabled}
       placeholder={placeholder}
       onClick={syncSelection}
+      onKeyDown={handleKeyDown}
       onKeyUp={syncSelection}
       onSelect={syncSelection}
+      onScroll={syncHighlightLayer}
       spellCheck={false}
       autoCorrect="off"
       autoCapitalize="off"
@@ -181,9 +311,25 @@ export function MarkdownEditor({
     />
   );
 
+  const readOnlyText = (
+    <div
+      ref={readOnlyHighlightRef}
+      data-scroll-sync="true"
+      className={`${fillHeight ? 'flex-1 min-h-0 overflow-y-auto custom-scrollbar' : minHeightClassName} w-full whitespace-pre-wrap break-words ${textClassName}`}
+      style={textSizeStyle}
+    >
+      {value || (
+        <span className="text-editorial-muted">
+          {placeholder ?? ''}
+        </span>
+      )}
+    </div>
+  );
+
   const preview = (
     <div
-      className={`${fillHeight ? 'flex-1 min-h-0 overflow-y-auto' : minHeightClassName} rounded-2xl border border-editorial-border bg-editorial-textbox/60 p-4 ${previewClassName}`}
+      data-scroll-sync="true"
+      className={`${fillHeight ? 'flex-1 min-h-0 overflow-y-auto custom-scrollbar' : minHeightClassName} rounded-2xl border border-editorial-border bg-editorial-textbox/60 p-4 ${previewClassName}`}
       style={textSizeStyle}
     >
       {value.trim() ? (
@@ -198,27 +344,40 @@ export function MarkdownEditor({
     <div className={fillHeight ? 'flex flex-col flex-1 min-h-0' : 'space-y-3'}>
       <div className={`sticky top-0 z-20 rounded-2xl border border-editorial-border/70 bg-[#fcfaf5]/95 px-3 py-3 shadow-sm backdrop-blur${fillHeight ? ' shrink-0' : ''}`}>
         <div className="flex items-center justify-between gap-3">
-          <button
-            type="button"
+          <IconButton
+            size="md"
             onClick={() => setToolbarOpen((open) => !open)}
             title={toolbarOpen ? t('editor.hideToolbar') : t('editor.showToolbar')}
-            aria-label={toolbarOpen ? t('editor.hideToolbar') : t('editor.showToolbar')}
-            className="rounded-full border border-editorial-border bg-white/70 p-2 text-editorial-muted transition-colors hover:text-editorial-ink"
+            ariaPressed={toolbarOpen}
+            tooltipSide="bottom"
           >
             {toolbarOpen ? <PanelTopClose size={15} /> : <PanelTopOpen size={15} />}
-          </button>
+          </IconButton>
           {/* Mode indicators — non-interactive, show current editor state */}
-          <div className="flex items-center gap-1" aria-hidden="true">
-            <span className={`rounded-full p-1.5 transition-colors ${mode === 'write' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
-              <Pencil size={11} />
-            </span>
-            <span className={`rounded-full p-1.5 transition-colors ${mode === 'preview' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
-              <Eye size={11} />
-            </span>
-            {markdownEnabled ? (
-              <span className={`rounded-full p-1.5 transition-colors ${mode === 'split' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
-                <Columns2 size={11} />
+          <div className="flex items-center gap-2">
+            <div className="flex items-center gap-1" aria-hidden="true">
+              <span className={`rounded-full p-1.5 transition-colors ${mode === 'write' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
+                <Pencil size={11} />
+              </span>
+              <span className={`rounded-full p-1.5 transition-colors ${mode === 'preview' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
+                <Eye size={11} />
               </span>
+              {markdownEnabled ? (
+                <span className={`rounded-full p-1.5 transition-colors ${mode === 'split' ? 'bg-editorial-accent text-white' : 'text-editorial-border'}`}>
+                  <Columns2 size={11} />
+                </span>
+              ) : null}
+            </div>
+            {toolbarOpen ? (
+              <IconButton
+                size="md"
+                tone="muted"
+                onClick={() => setShowHelp(true, 'features')}
+                title={t('editor.markdownHelpTooltip')}
+                tooltipSide="bottom"
+              >
+                <CircleHelp size={15} />
+              </IconButton>
             ) : null}
           </div>
         </div>
@@ -392,11 +551,13 @@ export function MarkdownEditor({
             />
             <textarea
               ref={textareaRef}
+              data-scroll-sync="true"
               value={value}
-              onChange={(event) => onChange(event.target.value)}
+              onChange={(event) => handleTextChange(event.target.value)}
               disabled={disabled}
               placeholder={placeholder}
               onClick={syncSelection}
+              onKeyDown={handleKeyDown}
               onKeyUp={syncSelection}
               onSelect={syncSelection}
               onScroll={syncHighlightLayer}
@@ -415,29 +576,39 @@ export function MarkdownEditor({
         )
       ) : null}
       {mode === 'write' && readOnly && highlightHtml ? (
-        <HighlightedText html={highlightHtml} style={textSizeStyle} className={fillHeight ? `flex-1 min-h-0 overflow-y-auto ${textClassName}` : `${minHeightClassName} ${textClassName}`} />
+        <HighlightedText
+          ref={readOnlyHighlightRef}
+          data-scroll-sync="true"
+          html={highlightHtml}
+          style={textSizeStyle}
+          className={fillHeight ? `flex-1 min-h-0 overflow-y-auto custom-scrollbar ${textClassName}` : `${minHeightClassName} ${textClassName}`}
+        />
       ) : null}
-      {mode === 'write' && !highlightHtml ? textarea : null}
+      {mode === 'write' && readOnly && !highlightHtml ? readOnlyText : null}
+      {mode === 'write' && !readOnly && !highlightHtml ? textarea : null}
       {mode === 'preview' ? preview : null}
       {mode === 'split' ? (
         fillHeight ? (
           <div className="flex-1 min-h-0 grid gap-4 xl:grid-cols-2">
-            <textarea
-              ref={textareaRef}
-              value={value}
-              onChange={(event) => onChange(event.target.value)}
-              readOnly={readOnly}
-              disabled={disabled}
-              placeholder={placeholder}
-              onClick={syncSelection}
-              onKeyUp={syncSelection}
-              onSelect={syncSelection}
-              spellCheck={false}
-              autoCorrect="off"
-              autoCapitalize="off"
-              className={`h-full resize-none w-full bg-transparent outline-none ${textClassName} disabled:opacity-70 read-only:cursor-not-allowed`}
-              style={textSizeStyle}
-            />
+            {readOnly ? readOnlyText : (
+              <textarea
+                ref={textareaRef}
+                data-scroll-sync="true"
+                value={value}
+                onChange={(event) => handleTextChange(event.target.value)}
+                disabled={disabled}
+                placeholder={placeholder}
+                onClick={syncSelection}
+                onKeyDown={handleKeyDown}
+                onKeyUp={syncSelection}
+                onSelect={syncSelection}
+                spellCheck={false}
+                autoCorrect="off"
+                autoCapitalize="off"
+                className={`h-full resize-none w-full bg-transparent outline-none custom-scrollbar ${textClassName} disabled:opacity-70`}
+                style={textSizeStyle}
+              />
+            )}
             {preview}
           </div>
         ) : (
@@ -467,21 +638,19 @@ function ToolbarButton({
   children: ReactNode;
 }) {
   return (
-    <button
-      type="button"
+    <IconButton
+      size="md"
+      tone={active ? 'accent' : 'default'}
       onMouseDown={(event) => event.preventDefault()}
       onClick={onClick}
       title={title}
-      aria-label={ariaLabel}
+      ariaLabel={ariaLabel}
       disabled={disabled}
-      className={`rounded-full border p-2 transition-colors disabled:cursor-not-allowed disabled:opacity-35 ${
-        active
-          ? 'border-editorial-accent bg-editorial-accent text-white'
-          : 'border-editorial-border text-editorial-muted hover:text-editorial-charcoal'
-      }`}
+      ariaPressed={active}
+      tooltipSide="bottom"
     >
       {children}
-    </button>
+    </IconButton>
   );
 }
 
@@ -501,22 +670,19 @@ function CommandButton({
   children: ReactNode;
 }) {
   return (
-    <button
-      type="button"
+    <IconButton
+      size="md"
+      tone={active ? 'accent' : 'default'}
       onMouseDown={(event) => event.preventDefault()}
       onClick={onClick}
       title={title}
-      aria-label={ariaLabel}
-      aria-pressed={active}
+      ariaLabel={ariaLabel}
       disabled={disabled}
-      className={`rounded-full border px-3 py-2 transition-colors disabled:cursor-not-allowed disabled:opacity-35 ${
-        active
-          ? 'border-editorial-accent bg-editorial-accent text-white shadow-sm'
-          : 'border-editorial-border bg-white/80 text-editorial-muted hover:text-editorial-ink'
-      }`}
+      ariaPressed={active}
+      tooltipSide="bottom"
     >
       {children}
-    </button>
+    </IconButton>
   );
 }
 
diff --git a/src/components/document/DocumentView.tsx b/src/components/document/DocumentView.tsx
index d9851ae..cd0a5ff 100644
--- a/src/components/document/DocumentView.tsx
+++ b/src/components/document/DocumentView.tsx
@@ -10,7 +10,9 @@ import {
   Pencil,
   RotateCcw,
   ScanLine,
+  Search,
   Wand2,
+  X,
   Zap,
 } from 'lucide-react';
 import type { LucideIcon } from 'lucide-react';
@@ -93,6 +95,8 @@ export function DocumentView({
   const [selectedStageId, setSelectedStageId] = useState<string>('');
   const [showDiffMode, setShowDiffMode] = useState(false);
   const [diffPairKey, setDiffPairKey] = useState<string>('');
+  const [sourcePaneSearch, setSourcePaneSearch] = useState('');
+  const [translationPaneSearch, setTranslationPaneSearch] = useState('');
 
   const { sourceRef: scrollSourceRef, translationRef: scrollTranslationRef } = usePanelScrollSync(
     paneFocus === 'both' && syncScrollEnabled,
@@ -178,17 +182,19 @@ export function DocumentView({
   // Hooks devono essere chiamati prima di qualsiasi return condizionale
   const hasGlossary = config.glossary.length > 0;
   const showHighlight = highlightsEnabled && hasGlossary;
+  const sourceEffectiveSearch = sourcePaneSearch.trim() || (highlightsEnabled ? searchQuery.trim() : '');
+  const translationEffectiveSearch = translationPaneSearch.trim() || (highlightsEnabled ? searchQuery.trim() : '');
   const sourceHighlight = useGlossaryHighlight(
     paneFocus !== 'translation' ? deferredSourceText : '',
     showHighlight && paneFocus !== 'translation' ? config.glossary : [],
     'source',
-    highlightsEnabled ? searchQuery : '',
+    sourceEffectiveSearch,
   );
   const translationHighlight = useGlossaryHighlight(
     paneFocus !== 'source' ? deferredStageContent : '',
     showHighlight && paneFocus !== 'source' ? config.glossary : [],
     'translation',
-    highlightsEnabled ? searchQuery : '',
+    translationEffectiveSearch,
     focusedIssueQuery ?? '',
   );
 
@@ -206,11 +212,11 @@ export function DocumentView({
   const sourceHighlightHtml = useMemo(() => {
     const hasFootnoteMarkers = /\[[⁰¹²³⁴⁵⁶⁷⁸⁹]/.test(deferredSourceText);
     const showGlossary = showHighlight && paneFocus !== 'translation';
-    const hasSearch = highlightsEnabled && !!searchQuery.trim() && paneFocus !== 'translation';
+    const hasSearch = !!sourceEffectiveSearch && paneFocus !== 'translation';
     if (!showGlossary && !hasSearch && !hasFootnoteMarkers) return null;
     const base = (showGlossary || hasSearch) ? sourceHighlight.html : escapeHtml(deferredSourceText);
     return hasFootnoteMarkers ? highlightSuperscriptMarkersHtml(base) : base;
-  }, [deferredSourceText, showHighlight, highlightsEnabled, searchQuery, paneFocus, sourceHighlight.html]);
+  }, [deferredSourceText, showHighlight, sourceEffectiveSearch, paneFocus, sourceHighlight.html]);
 
   const currentProject = projects.find((project) => project.id === currentProjectId) ?? null;
 
@@ -397,9 +403,13 @@ export function DocumentView({
                   )}
                 </div>
               }
+              searchValue={sourcePaneSearch}
+              onSearchChange={setSourcePaneSearch}
+              searchLabel={t('document.searchInSource')}
               scrollRef={scrollSourceRef}
             >
               <MarkdownEditor
+                identityKey={`${currentChunk.id}:source`}
                 value={currentChunk.sourceDisplayText}
                 onChange={(nextValue) => updateChunkOriginalText(currentChunk.id, nextValue)}
                 markdownEnabled={config.markdownAware === true}
@@ -507,10 +517,13 @@ export function DocumentView({
                 statusBadge={currentChunk.translationStale ? (
                   <InlineStatusBadge tone="amber" icon={<AlertTriangle size={13} />} label={t('document.translationStaleBadge')} />
                 ) : lockToggle}
+                searchValue={translationPaneSearch}
+                onSearchChange={setTranslationPaneSearch}
+                searchLabel={t('document.searchInTranslation')}
                 scrollRef={scrollTranslationRef}
               >
                 {showDiffMode ? (
-                  <div className="flex flex-col flex-1 min-h-0 overflow-y-auto custom-scrollbar">
+                  <div data-scroll-sync="true" className="flex flex-col flex-1 min-h-0 overflow-y-auto custom-scrollbar">
                     <HighlightedText
                       html={stageDiff.html}
                       className="text-[15px] leading-8 text-editorial-ink min-h-[280px]"
@@ -518,6 +531,7 @@ export function DocumentView({
                   </div>
                 ) : (
                   <MarkdownEditor
+                    identityKey={`${currentChunk.id}:candidate:${effectiveSelectedStageId}`}
                     value={rawStageContent}
                     onChange={isLastSelected ? (nextValue) => updateChunkDraft(currentChunk.id, nextValue) : NOOP_CHANGE}
                     markdownEnabled={config.markdownAware === true}
@@ -526,7 +540,7 @@ export function DocumentView({
                     textClassName="text-[15px] leading-8 text-editorial-ink"
                     previewClassName="min-h-[280px] text-[15px] leading-8 text-editorial-ink"
                     placeholder={isLastSelected ? t('pipeline.candidatePlaceholder') : ''}
-                    highlightHtml={(showHighlight || (highlightsEnabled && !!searchQuery.trim()) || !!focusedIssueQuery) ? translationHighlight.html : null}
+                    highlightHtml={(showHighlight || !!translationEffectiveSearch || !!focusedIssueQuery) ? translationHighlight.html : null}
                     focusQuery={isLastSelected && focusedChunkId === currentChunk.id ? focusedIssueQuery : null}
                     focusRequestId={isLastSelected && focusedChunkId === currentChunk.id ? focusedIssueRequestId : 0}
                   />
@@ -561,6 +575,9 @@ interface DocumentPageProps {
   statusBadge?: React.ReactNode;
   actions?: React.ReactNode | null;
   footer?: React.ReactNode;
+  searchValue?: string;
+  onSearchChange?: (value: string) => void;
+  searchLabel?: string;
   scrollRef?: React.RefObject<HTMLDivElement | null>;
   children: React.ReactNode;
 }
@@ -649,6 +666,9 @@ function DocumentPage({
   statusBadge,
   actions,
   footer,
+  searchValue,
+  onSearchChange,
+  searchLabel,
   scrollRef,
   children,
 }: DocumentPageProps) {
@@ -689,6 +709,13 @@ function DocumentPage({
         </div>
       </div>
       <div ref={scrollRef} className={`flex flex-col flex-1 min-h-0 ${readOnly ? 'opacity-90' : ''}`}>
+        {onSearchChange && searchLabel ? (
+          <PaneSearch
+            value={searchValue ?? ''}
+            onChange={onSearchChange}
+            label={searchLabel}
+          />
+        ) : null}
         {children}
       </div>
       {footer && (
@@ -700,6 +727,50 @@ function DocumentPage({
   );
 }
 
+function PaneSearch({
+  value,
+  onChange,
+  label,
+}: {
+  value: string;
+  onChange: (value: string) => void;
+  label: string;
+}) {
+  const { t } = useTranslation();
+
+  return (
+    <form
+      role="search"
+      className="mb-3 shrink-0"
+      onSubmit={(event) => event.preventDefault()}
+    >
+      <label className="sr-only">{label}</label>
+      <div className="flex items-center gap-2 rounded-full border border-editorial-divider-soft bg-editorial-bg/70 px-3 py-2 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] transition-colors focus-within:border-editorial-accent/40 focus-within:ring-2 focus-within:ring-editorial-accent/20">
+        <Search size={13} className="shrink-0 text-editorial-muted" aria-hidden="true" />
+        <input
+          type="search"
+          value={value}
+          onChange={(event) => onChange(event.target.value)}
+          placeholder={t('document.searchChunkPlaceholder')}
+          aria-label={label}
+          className="min-w-0 flex-1 bg-transparent text-xs text-editorial-ink placeholder:text-editorial-muted/55 focus:outline-none"
+        />
+        {value ? (
+          <IconButton
+            size="sm"
+            tone="muted"
+            onClick={() => onChange('')}
+            title={t('document.clearPaneSearch')}
+            className="shrink-0"
+          >
+            <X size={12} />
+          </IconButton>
+        ) : null}
+      </div>
+    </form>
+  );
+}
+
 function InlineStatusBadge({
   tone,
   icon,
diff --git a/src/components/document/InsightsDrawer.tsx b/src/components/document/InsightsDrawer.tsx
index 3ed5527..bc0c058 100644
--- a/src/components/document/InsightsDrawer.tsx
+++ b/src/components/document/InsightsDrawer.tsx
@@ -48,6 +48,7 @@ import { usePipeline } from '../../hooks/usePipeline';
 import { OperationsTab } from './OperationsTab';
 import { SearchTab } from './SearchTab';
 import type { TranslationChunk } from '../../types';
+import { IconButton, Tooltip } from '../ui';
 
 interface InsightsDrawerProps {
   onReauditChunk: (chunkId: string) => void;
@@ -212,12 +213,15 @@ export function InsightsDrawer({ onReauditChunk, onRunCoherenceAudit }: Insights
             onClick={() => setShowChunkDrawer(true)}
             className="flex w-8 shrink-0 flex-col items-center justify-center gap-3 self-stretch border-l border-editorial-border bg-editorial-bg/80 text-editorial-muted transition-colors hover:bg-editorial-textbox/50 hover:text-editorial-ink focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-editorial-accent"
             aria-label={t('document.openChunkPanel')}
-            title={t('document.openChunkPanel')}
           >
-            <ShieldCheck size={14} />
-            <span className="[writing-mode:vertical-lr] rotate-180 text-[9px] font-bold uppercase tracking-[0.3em]">
-              {t('document.chunkPanelTitle')}
-            </span>
+            <Tooltip label={t('document.openChunkPanel')} side="left" className="h-full w-full">
+              <span className="flex h-full w-full flex-col items-center justify-center gap-3">
+                <ShieldCheck size={14} />
+                <span className="[writing-mode:vertical-lr] rotate-180 text-[9px] font-bold uppercase tracking-[0.3em]">
+                  {t('document.chunkPanelTitle')}
+                </span>
+              </span>
+            </Tooltip>
           </motion.button>
         )}
       </AnimatePresence>
@@ -239,14 +243,15 @@ export function InsightsDrawer({ onReauditChunk, onRunCoherenceAudit }: Insights
                 <div className="text-[10px] font-sans uppercase tracking-[0.35em] text-editorial-muted">
                   {chunkLabel}
                 </div>
-                <button
-                  type="button"
+                <IconButton
+                  size="md"
                   onClick={() => setShowChunkDrawer(false)}
-                  className="shrink-0 rounded-full border border-editorial-border p-2 text-editorial-muted transition-colors hover:bg-editorial-textbox/50 hover:text-editorial-ink focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent"
-                  aria-label={t('header.closeDrawer')}
+                  title={t('header.closeDrawer')}
+                  tooltipSide="left"
+                  className="shrink-0"
                 >
                   <X size={16} />
-                </button>
+                </IconButton>
               </div>
 
               <div className="flex items-center gap-2 border-b border-editorial-border bg-editorial-bg/60 px-4 py-2">
@@ -325,12 +330,15 @@ export function InsightsDrawer({ onReauditChunk, onRunCoherenceAudit }: Insights
             onClick={() => setShowDocumentDrawer(true)}
             className="flex w-8 shrink-0 flex-col items-center justify-center gap-3 self-stretch border-l border-editorial-border bg-editorial-bg/80 text-editorial-muted transition-colors hover:bg-editorial-textbox/50 hover:text-editorial-ink focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-editorial-accent"
             aria-label={t('header.openInsights')}
-            title={t('header.openInsights')}
           >
-            <PanelRight size={14} />
-            <span className="[writing-mode:vertical-lr] rotate-180 text-[9px] font-bold uppercase tracking-[0.3em]">
-              {t('document.insightsDrawerTitle')}
-            </span>
+            <Tooltip label={t('header.openInsights')} side="left" className="h-full w-full">
+              <span className="flex h-full w-full flex-col items-center justify-center gap-3">
+                <PanelRight size={14} />
+                <span className="[writing-mode:vertical-lr] rotate-180 text-[9px] font-bold uppercase tracking-[0.3em]">
+                  {t('document.insightsDrawerTitle')}
+                </span>
+              </span>
+            </Tooltip>
           </motion.button>
         )}
       </AnimatePresence>
@@ -352,14 +360,15 @@ export function InsightsDrawer({ onReauditChunk, onRunCoherenceAudit }: Insights
                 <div className="text-[10px] font-sans uppercase tracking-[0.35em] text-editorial-muted">
                   {t('document.insightsDrawerTitle')}
                 </div>
-                <button
-                  type="button"
+                <IconButton
+                  size="md"
                   onClick={() => setShowDocumentDrawer(false)}
-                  className="shrink-0 rounded-full border border-editorial-border p-2 text-editorial-muted transition-colors hover:bg-editorial-textbox/50 hover:text-editorial-ink focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent"
-                  aria-label={t('header.closeDrawer')}
+                  title={t('header.closeDrawer')}
+                  tooltipSide="left"
+                  className="shrink-0"
                 >
                   <X size={16} />
-                </button>
+                </IconButton>
               </div>
 
               <div className="flex items-center gap-2 border-b border-editorial-border bg-editorial-bg/60 px-4 py-2">
@@ -455,9 +464,11 @@ interface TabButtonProps {
 
 function TabButton({ buttonId, active, disabled, onClick, onKeyDown, label, icon, controls, buttonRef }: TabButtonProps) {
   return (
-    <button
+    <IconButton
       id={buttonId}
-      type="button"
+      ref={buttonRef}
+      size="lg"
+      tone={active ? 'accent' : 'default'}
       role="tab"
       aria-selected={active}
       aria-controls={controls}
@@ -466,19 +477,12 @@ function TabButton({ buttonId, active, disabled, onClick, onKeyDown, label, icon
       tabIndex={active ? 0 : -1}
       onClick={onClick}
       onKeyDown={onKeyDown}
-      ref={buttonRef}
       title={label}
-      aria-label={label}
-      className={`rounded-full border p-2.5 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${
-        disabled
-          ? 'cursor-not-allowed border-editorial-border/30 text-editorial-muted/25'
-          : active
-          ? 'border-editorial-accent bg-editorial-accent text-white'
-          : 'border-editorial-border text-editorial-muted hover:border-editorial-accent/40 hover:text-editorial-accent'
-      }`}
+      ariaLabel={label}
+      tooltipSide="bottom"
     >
       {icon}
-    </button>
+    </IconButton>
   );
 }
 
@@ -881,16 +885,16 @@ function CoherenceTab({ panelId, labelledBy, currentChunk, isProcessing, allChun
           <div className="flex items-center gap-2 text-[10px] font-sans uppercase tracking-[0.35em] text-editorial-muted">
             <Link2 size={11} className="text-editorial-accent shrink-0" /> {t('coherence.title')}
           </div>
-          <button
-            type="button"
+          <IconButton
+            size="md"
             onClick={onRunCoherenceAudit}
             disabled={coherenceDisabled}
             title={coherenceTitle}
-            aria-label={t('coherence.runAudit')}
-            className="rounded-full border border-editorial-border p-2 text-editorial-muted transition-colors hover:border-editorial-accent/40 hover:text-editorial-accent focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent disabled:opacity-30"
+            ariaLabel={t('coherence.runAudit')}
+            tooltipSide="left"
           >
             {coherence?.status === 'processing' ? <Loader2 size={14} className="animate-spin" /> : <ScanLine size={14} />}
-          </button>
+          </IconButton>
         </div>
 
         {allChunksTranslated && !allChunksLocked && (
@@ -963,16 +967,15 @@ function AuditTab({ panelId, labelledBy, currentChunk, isProcessing, onReauditCh
             <div className="text-[10px] font-sans uppercase tracking-[0.35em] text-editorial-muted">{t('audit.title')}</div>
             <div className={`mt-2 font-display text-xl italic ${QUALITY_TONE_COLOR[tone]}`}>{qualityLabel}</div>
           </div>
-          <button
-            type="button"
+          <IconButton
+            size="md"
             onClick={() => onReauditChunk(currentChunk.id)}
             disabled={isProcessing || !currentChunk.currentDraft}
             title={t('pipeline.reauditChunk')}
-            aria-label={t('pipeline.reauditChunk')}
-            className="rounded-full border border-editorial-border p-2 text-editorial-muted transition-colors hover:border-editorial-accent/40 hover:text-editorial-accent focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent disabled:opacity-30"
+            tooltipSide="left"
           >
             <RefreshCcw size={14} />
-          </button>
+          </IconButton>
         </div>
 
         {currentChunk.judgeResult.status === 'error' && (
@@ -1062,8 +1065,9 @@ function IssueList({ issues, chunkId, onSelectChunk, onFocusIssue }: IssueListPr
             {issue.phrase && (() => {
               const isActive = focusedIssueQuery === issue.phrase;
               return (
-                <button
-                  type="button"
+                <IconButton
+                  size="sm"
+                  tone={isActive ? 'accent' : 'default'}
                   onClick={() => {
                     if (isActive) {
                       clearFocusedIssue();
@@ -1073,15 +1077,11 @@ function IssueList({ issues, chunkId, onSelectChunk, onFocusIssue }: IssueListPr
                     }
                   }}
                   title={t('audit.locateInTextTooltip')}
-                  aria-label={t('audit.locateInTextTooltip')}
-                  className={`rounded-full border p-1.5 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${
-                    isActive
-                      ? 'border-editorial-accent bg-editorial-accent/10 text-editorial-accent'
-                      : 'border-editorial-border text-editorial-muted hover:border-editorial-accent/40 hover:text-editorial-accent'
-                  }`}
+                  ariaPressed={isActive}
+                  tooltipSide="left"
                 >
                   <Crosshair size={13} />
-                </button>
+                </IconButton>
               );
             })()}
           </div>
diff --git a/src/components/help/HelpGuide.tsx b/src/components/help/HelpGuide.tsx
index 4615a5d..28a035f 100644
--- a/src/components/help/HelpGuide.tsx
+++ b/src/components/help/HelpGuide.tsx
@@ -13,6 +13,7 @@ import { appLogDir } from '@tauri-apps/api/path';
 import { useTranslation } from 'react-i18next';
 import { toast } from 'sonner';
 import { useFocusTrap } from '../../hooks/useFocusTrap';
+import { useUiStore, type HelpSection } from '../../stores/uiStore';
 import { EditorialModalShell } from '../common';
 
 interface HelpGuideProps {
@@ -20,12 +21,17 @@ interface HelpGuideProps {
   onClose: () => void;
 }
 
-type Section = 'overview' | 'pipeline' | 'features' | 'context' | 'audit' | 'projects' | 'providers' | 'ollama' | 'glossary' | 'shortcuts' | 'troubleshooting' | 'design';
+type Section = HelpSection;
 
 export function HelpGuide({ open, onClose }: HelpGuideProps) {
   const [activeSection, setActiveSection] = useState<Section>('overview');
   const { t } = useTranslation();
   const trapRef = useFocusTrap(open, onClose);
+  const requestedSection = useUiStore((state) => state.helpSection);
+
+  useEffect(() => {
+    if (open) setActiveSection(requestedSection);
+  }, [open, requestedSection]);
 
   const sections: { id: Section; label: string }[] = [
     { id: 'overview',        label: t('help.sections.overview') },
@@ -316,6 +322,9 @@ function FeaturesSection() {
       <SubTitle>{t('help.features.documentToolsTitle')}</SubTitle>
       <P>{t('help.features.documentToolsDesc')}</P>
 
+      <SubTitle>{t('help.features.markdownToolsTitle')}</SubTitle>
+      <P>{t('help.features.markdownToolsDesc')}</P>
+
       <SubTitle>{t('help.features.insightsTitle')}</SubTitle>
       <P>{t('help.features.insightsDesc')}</P>
 
@@ -614,6 +623,7 @@ function ShortcutsSection() {
     { label: t('help.shortcuts.sandbox'),       icon: <LayoutTemplate size={14} /> },
     { label: t('help.shortcuts.openInsights'),  icon: <PanelRight size={14} /> },
     { label: t('help.shortcuts.toggleEditorTools'), icon: <PanelTopClose size={14} /> },
+    { label: t('help.shortcuts.markdownHelp'), icon: <HelpCircle size={14} /> },
     { label: t('help.shortcuts.lockTranslation'), icon: <CheckCheck size={14} /> },
     { label: t('help.shortcuts.openStageTrace'), icon: <ScanLine size={14} /> },
   ];
diff --git a/src/components/layout/PipelineSidebar.tsx b/src/components/layout/PipelineSidebar.tsx
index df03c3f..7550316 100644
--- a/src/components/layout/PipelineSidebar.tsx
+++ b/src/components/layout/PipelineSidebar.tsx
@@ -19,10 +19,21 @@ import {
   Settings2,
   Square,
   Upload,
-
   Zap,
 } from 'lucide-react';
-import { lazy, Suspense, useMemo, useState } from 'react';
+import {
+  lazy,
+  Suspense,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  type CSSProperties,
+  type RefObject,
+} from 'react';
+import { createPortal } from 'react-dom';
 import { useTranslation } from 'react-i18next';
 import { motion } from 'motion/react';
 import { toast } from 'sonner';
@@ -35,7 +46,7 @@ import { useUiStore } from '../../stores/uiStore';
 import { useWorkspaceStore } from '../../stores/workspaceStore';
 import { estimatePipelineCost } from '../../utils/costEstimate';
 import { CostBreakdownPanel } from '../pipeline/CostBadge';
-import { IconButton, SectionLabel } from '../ui';
+import { IconButton, SectionLabel, Tooltip } from '../ui';
 import { exportTranslation, exportBilingual } from '../../services/fileService';
 import type { ExportFormat } from '../document/ExportDialog';
 import { DashboardSidebar } from './DashboardSidebar';
@@ -43,6 +54,83 @@ import { DashboardSidebar } from './DashboardSidebar';
 const ExportDialog = lazy(() =>
   import('../document/ExportDialog').then((m) => ({ default: m.ExportDialog })),
 );
+
+const COST_PANEL_OFFSET = 12;
+const COST_PANEL_WIDTH = 256;
+const VIEWPORT_MARGIN = 12;
+
+function clamp(value: number, min: number, max: number) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function SidebarCostPanel({
+  anchorRef,
+  estimate,
+  open,
+  onMouseEnter,
+  onMouseLeave,
+}: {
+  anchorRef: RefObject<HTMLDivElement | null>;
+  estimate: ReturnType<typeof estimatePipelineCost>;
+  open: boolean;
+  onMouseEnter: () => void;
+  onMouseLeave: () => void;
+}) {
+  const panelRef = useRef<HTMLDivElement | null>(null);
+  const [style, setStyle] = useState<CSSProperties | null>(null);
+
+  const updatePosition = useCallback(() => {
+    if (!anchorRef.current) return;
+    const anchorRect = anchorRef.current.getBoundingClientRect();
+    const panelHeight = panelRef.current?.offsetHeight ?? 220;
+    const left = Math.min(
+      anchorRect.right + COST_PANEL_OFFSET,
+      window.innerWidth - VIEWPORT_MARGIN - COST_PANEL_WIDTH,
+    );
+    const top = clamp(
+      anchorRect.top + anchorRect.height / 2,
+      VIEWPORT_MARGIN + panelHeight / 2,
+      window.innerHeight - VIEWPORT_MARGIN - panelHeight / 2,
+    );
+    setStyle({
+      left,
+      top,
+      width: COST_PANEL_WIDTH,
+      transform: 'translateY(-50%)',
+    });
+  }, [anchorRef]);
+
+  useLayoutEffect(() => {
+    if (!open) return;
+    updatePosition();
+  }, [estimate, open, updatePosition]);
+
+  useEffect(() => {
+    if (!open) return;
+    window.addEventListener('scroll', updatePosition, true);
+    window.addEventListener('resize', updatePosition);
+    return () => {
+      window.removeEventListener('scroll', updatePosition, true);
+      window.removeEventListener('resize', updatePosition);
+    };
+  }, [open, updatePosition]);
+
+  if (!open || typeof document === 'undefined') return null;
+
+  return createPortal(
+    <div
+      ref={panelRef}
+      className="fixed z-[160]"
+      style={style ?? undefined}
+      onMouseEnter={onMouseEnter}
+      onMouseLeave={onMouseLeave}
+    >
+      <CostBreakdownPanel estimate={estimate} />
+    </div>,
+    document.body,
+  );
+}
+
 interface PipelineSidebarProps {
   mode?: 'dashboard' | 'editor';
   onRunPipeline?: () => void;
@@ -100,6 +188,8 @@ export function PipelineSidebar({
   // ── Local state ───────────────────────────────────────────────────
   const [showCostPanel, setShowCostPanel] = useState(false);
   const [showExportDialog, setShowExportDialog] = useState(false);
+  const costButtonRef = useRef<HTMLDivElement | null>(null);
+  const costPanelCloseTimer = useRef<number | null>(null);
 
   // ── Derived ───────────────────────────────────────────────────────
   const isRunning = runStatus === 'running';
@@ -123,6 +213,32 @@ export function PipelineSidebar({
   );
   const activePipelineName = pipelines.find((p) => p.id === activePipelineId)?.name ?? null;
 
+  const openCostPanel = useCallback(() => {
+    if (costPanelCloseTimer.current !== null) {
+      window.clearTimeout(costPanelCloseTimer.current);
+      costPanelCloseTimer.current = null;
+    }
+    setShowCostPanel(true);
+  }, []);
+
+  const scheduleCloseCostPanel = useCallback(() => {
+    if (costPanelCloseTimer.current !== null) {
+      window.clearTimeout(costPanelCloseTimer.current);
+    }
+    costPanelCloseTimer.current = window.setTimeout(() => {
+      setShowCostPanel(false);
+      costPanelCloseTimer.current = null;
+    }, 120);
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (costPanelCloseTimer.current !== null) {
+        window.clearTimeout(costPanelCloseTimer.current);
+      }
+    };
+  }, []);
+
   // ── Pipeline delete ───────────────────────────────────────────────
   const handleDeletePipeline = async (pipelineId: string, pipelineName: string) => {
     const ok = await confirm({
@@ -238,11 +354,10 @@ export function PipelineSidebar({
                     ariaLabel={t('pipeline.modeTest')}
                     ariaPressed={pipelineMode === 'test'}
                     tooltipSide="right"
-                    className={`h-11 w-11 ${
-                      pipelineMode === 'test'
-                        ? 'border-editorial-accent bg-editorial-bg text-editorial-ink shadow-sm'
-                        : 'bg-editorial-textbox'
-                    }`}
+                    className={`h-11 w-11 ${pipelineMode === 'test'
+                      ? 'border-editorial-accent bg-editorial-bg text-editorial-ink shadow-sm'
+                      : 'bg-editorial-textbox'
+                      }`}
                   >
                     <FlaskConical size={14} />
                   </IconButton>
@@ -255,11 +370,10 @@ export function PipelineSidebar({
                     ariaLabel={t('pipeline.modeProduction')}
                     ariaPressed={pipelineMode === 'production'}
                     tooltipSide="right"
-                    className={`h-11 w-11 ${
-                      pipelineMode === 'production'
-                        ? 'border-editorial-accent bg-editorial-bg text-editorial-charcoal shadow-sm'
-                        : 'bg-editorial-textbox'
-                    }`}
+                    className={`h-11 w-11 ${pipelineMode === 'production'
+                      ? 'border-editorial-accent bg-editorial-bg text-editorial-charcoal shadow-sm'
+                      : 'bg-editorial-textbox'
+                      }`}
                   >
                     <Zap size={14} />
                   </IconButton>
@@ -307,16 +421,18 @@ export function PipelineSidebar({
                   )}
                   {costEstimate.stages.length > 0 && (
                     <div
+                      ref={costButtonRef}
                       className="absolute -bottom-1.5 -right-1.5"
-                      onMouseEnter={() => setShowCostPanel(true)}
-                      onMouseLeave={() => setShowCostPanel(false)}
+                      onMouseEnter={openCostPanel}
+                      onMouseLeave={scheduleCloseCostPanel}
                     >
                       <IconButton
                         size="sm"
                         tone="charcoal"
-                        onFocus={() => setShowCostPanel(true)}
-                        onBlur={() => setShowCostPanel(false)}
-                        title={t('cost.breakdown')}
+                        onFocus={openCostPanel}
+                        onBlur={scheduleCloseCostPanel}
+                        title=""
+                        ariaLabel={t('cost.breakdown')}
                         tooltipSide="right"
                         className="h-6 w-6 bg-editorial-bg p-0"
                       >
@@ -324,15 +440,13 @@ export function PipelineSidebar({
                       </IconButton>
                     </div>
                   )}
-                  {showCostPanel && costEstimate.stages.length > 0 && (
-                    <div
-                      className="absolute left-full top-1/2 z-[120] ml-3 w-64 -translate-y-1/2"
-                      onMouseEnter={() => setShowCostPanel(true)}
-                      onMouseLeave={() => setShowCostPanel(false)}
-                    >
-                      <CostBreakdownPanel estimate={costEstimate} />
-                    </div>
-                  )}
+                  <SidebarCostPanel
+                    anchorRef={costButtonRef}
+                    estimate={costEstimate}
+                    open={showCostPanel && costEstimate.stages.length > 0}
+                    onMouseEnter={openCostPanel}
+                    onMouseLeave={scheduleCloseCostPanel}
+                  />
                 </div>
                 {hasDocument && (
                   <span className="text-xs font-bold tabular-nums tracking-[0.12em] text-editorial-muted">
@@ -354,16 +468,19 @@ export function PipelineSidebar({
                   >
                     <Minus size={12} />
                   </IconButton>
-                  <div
-                    className={`flex h-10 min-w-[38px] items-center justify-center rounded-full border px-2 text-xs font-bold tracking-[0.12em] ${
-                      pipelineMode === 'test'
+                  <Tooltip
+                    label={t('pipeline.runChunkCount', { count: runChunkCount })}
+                    side="right"
+                  >
+                    <div
+                      className={`flex h-10 min-w-[38px] items-center justify-center rounded-full border px-2 text-xs font-bold tracking-[0.12em] ${pipelineMode === 'test'
                         ? 'border-editorial-warning/40 bg-editorial-textbox text-editorial-ink'
                         : 'border-editorial-border bg-editorial-bg text-editorial-muted'
-                    }`}
-                    title={t('pipeline.runChunkCount', { count: runChunkCount })}
-                  >
-                    {runChunkCount}
-                  </div>
+                        }`}
+                    >
+                      {runChunkCount}
+                    </div>
+                  </Tooltip>
                   <IconButton
                     size="md"
                     tone="charcoal"
@@ -406,14 +523,13 @@ export function PipelineSidebar({
                 )}
               </div>
               {pipelines.length === 0 ? (
-                <div
-                  className="flex items-center justify-center"
-                  title={t('pipeline.pipelineNumber', { number: 1 })}
-                >
-                  <span className="inline-flex h-10 w-10 items-center justify-center rounded-full bg-editorial-accent text-xs font-black text-white opacity-55">
-                    1
-                  </span>
-                </div>
+                <Tooltip label={t('pipeline.pipelineNumber', { number: 1 })} side="right">
+                  <div className="flex items-center justify-center">
+                    <span className="inline-flex h-10 w-10 items-center justify-center rounded-full bg-editorial-accent text-xs font-black text-white opacity-55">
+                      1
+                    </span>
+                  </div>
+                </Tooltip>
               ) : (
                 <div className="flex flex-col items-center gap-2">
                   {pipelines.map((pipeline, i) => {
@@ -436,15 +552,17 @@ export function PipelineSidebar({
                           )}
                         </IconButton>
                         {pipelines.length > 1 && !isPipelineRunning && (
-                          <button
-                            type="button"
-                            onClick={() => void handleDeletePipeline(pipeline.id, pipeline.name)}
+                          <IconButton
+                            size="sm"
+                            tone="muted"
+                            onClick={() => {
+                              void handleDeletePipeline(pipeline.id, pipeline.name);
+                            }}
                             title={t('pipeline.deletePipeline')}
-                            aria-label={t('pipeline.deletePipeline')}
-                            className="absolute -right-1 -top-1 z-10 hidden h-4 w-4 items-center justify-center rounded-full border border-editorial-border bg-white text-editorial-muted transition-colors hover:border-editorial-accent/60 hover:text-editorial-accent group-hover:flex"
-                          >
-                            <Minus size={10} />
-                          </button>
+                            tooltipSide="right"
+                            className="absolute -right-1 -top-1 z-10 hidden h-4 w-4 bg-editorial-bg p-0 group-hover:flex"
+                          > -
+                          </IconButton>
                         )}
                       </div>
                     );
diff --git a/src/components/layout/PipelineStrip.tsx b/src/components/layout/PipelineStrip.tsx
index 680a8ee..4a8d4a0 100644
--- a/src/components/layout/PipelineStrip.tsx
+++ b/src/components/layout/PipelineStrip.tsx
@@ -46,11 +46,10 @@ export function PipelineStrip() {
                   onClick={() => switchPipeline(pipeline.id)}
                   title={pipeline.name}
                   aria-label={pipeline.name}
-                  className={`relative flex h-9 w-9 items-center justify-center rounded-[6px] text-xs font-black transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${
-                    isActive
-                      ? 'bg-editorial-accent text-white'
-                      : 'border border-editorial-border bg-editorial-textbox text-editorial-muted hover:border-editorial-accent/60 hover:text-editorial-accent'
-                  }`}
+                  className={`relative flex h-9 w-9 items-center justify-center rounded-[6px] text-xs font-black transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${isActive
+                    ? 'bg-editorial-accent text-white'
+                    : 'border border-editorial-border bg-editorial-textbox text-editorial-muted hover:border-editorial-accent/60 hover:text-editorial-accent'
+                    }`}
                 >
                   {isPipelineRunning ? (
                     <span className="h-4 w-4 animate-spin rounded-full border-2 border-transparent border-t-white" />
@@ -89,11 +88,10 @@ export function PipelineStrip() {
           onClick={() => setShowConfigDrawer(!showConfigDrawer)}
           title={t('pipeline.configurePipeline')}
           aria-label={t('pipeline.configurePipeline')}
-          className={`flex h-8 w-8 items-center justify-center rounded-full border transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${
-            showConfigDrawer
-              ? 'border-editorial-accent bg-editorial-accent text-white'
-              : 'border-editorial-border bg-editorial-textbox text-editorial-muted hover:border-editorial-accent/60 hover:text-editorial-accent'
-          }`}
+          className={`flex h-8 w-8 items-center justify-center rounded-full border transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${showConfigDrawer
+            ? 'border-editorial-accent bg-editorial-accent text-white'
+            : 'border-editorial-border bg-editorial-textbox text-editorial-muted hover:border-editorial-accent/60 hover:text-editorial-accent'
+            }`}
         >
           <Settings2 size={14} />
         </button>
diff --git a/src/components/library/LibraryPanel.tsx b/src/components/library/LibraryPanel.tsx
index 5a2dc46..a57126d 100644
--- a/src/components/library/LibraryPanel.tsx
+++ b/src/components/library/LibraryPanel.tsx
@@ -1,5 +1,5 @@
 import { useEffect } from 'react';
-import { BookMarked, BookOpenText } from 'lucide-react';
+import { BookMarked, BookOpenText, Brain } from 'lucide-react';
 import { motion, AnimatePresence } from 'motion/react';
 import { useTranslation } from 'react-i18next';
 import { toast } from 'sonner';
@@ -7,14 +7,23 @@ import { useLibraryStore, type LibraryTab } from '../../stores/libraryStore';
 import { useFocusTrap } from '../../hooks/useFocusTrap';
 import { confirm } from '../../stores/confirmStore';
 import { DictionariesTab } from './DictionariesTab';
+import { MemoriesTab } from './MemoriesTab';
 import { PromptTemplatesTab } from './PromptTemplatesTab';
 import { EditorialModalShell } from '../common';
+import { IconButton } from '../ui';
 
 const TABS: { id: LibraryTab; labelKey: string }[] = [
   { id: 'dictionaries', labelKey: 'library.tabDictionaries' },
   { id: 'templates', labelKey: 'library.tabTemplates' },
+  { id: 'memories', labelKey: 'library.tabMemories' },
 ];
 
+function tabIcon(tab: LibraryTab) {
+  if (tab === 'dictionaries') return <BookMarked size={16} />;
+  if (tab === 'templates') return <BookOpenText size={16} />;
+  return <Brain size={16} />;
+}
+
 export function LibraryPanel() {
   const { t } = useTranslation();
   const {
@@ -97,23 +106,21 @@ export function LibraryPanel() {
             >
               <div className="flex h-full flex-col">
                 <div className="border-b border-editorial-border px-6 py-3 md:px-8">
-                  <div className="flex gap-2" role="tablist">
+                  <div className="flex gap-2" role="tablist" aria-label={t('library.title')}>
                     {TABS.map((tab) => (
-                      <button
+                      <IconButton
                         key={tab.id}
+                        id={`library-tab-${tab.id}`}
                         role="tab"
                         aria-selected={activeTab === tab.id}
+                        aria-controls={`library-panel-${tab.id}`}
+                        size="lg"
+                        tone={activeTab === tab.id ? 'accent' : 'default'}
                         onClick={() => useLibraryStore.getState().setShowLibraryPanel(true, tab.id)}
-                        className={`rounded-full border p-2.5 transition-colors focus:outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent ${
-                          activeTab === tab.id
-                            ? 'border-editorial-accent bg-editorial-accent text-white'
-                            : 'border-editorial-border text-editorial-muted hover:border-editorial-accent/40 hover:text-editorial-accent'
-                        }`}
                         title={t(tab.labelKey)}
-                        aria-label={t(tab.labelKey)}
-                        >
-                          {tab.id === 'dictionaries' ? <BookMarked size={16} /> : <BookOpenText size={16} />}
-                        </button>
+                      >
+                        {tabIcon(tab.id)}
+                      </IconButton>
                     ))}
                     <span className="mx-1 h-4 w-px self-center bg-editorial-border/70" aria-hidden="true" />
                     <span className="self-center font-display text-sm italic text-editorial-ink">
@@ -124,6 +131,7 @@ export function LibraryPanel() {
                 <div className="flex-1 overflow-y-auto px-6 py-6 md:px-8 custom-scrollbar [scrollbar-gutter:stable]">
                   {activeTab === 'dictionaries' && <DictionariesTab />}
                   {activeTab === 'templates' && <PromptTemplatesTab />}
+                  {activeTab === 'memories' && <MemoriesTab />}
                 </div>
               </div>
             </EditorialModalShell>
diff --git a/src/components/library/MemoriesTab.tsx b/src/components/library/MemoriesTab.tsx
new file mode 100644
index 0000000..ad8212e
--- /dev/null
+++ b/src/components/library/MemoriesTab.tsx
@@ -0,0 +1,307 @@
+import { useCallback, useEffect, useState } from 'react';
+import { Brain, Check, Loader2, Pencil, RefreshCcw, Trash2, X } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { toast } from 'sonner';
+import {
+  deletePhraseMemoryEntry,
+  listPhraseMemoryEntries,
+  updatePhraseMemoryEntry,
+  type PhraseMemoryEntry,
+} from '../../services/phraseMemoryService';
+import { useWorkspaceStore } from '../../stores/workspaceStore';
+import { confirm } from '../../stores/confirmStore';
+import { IconButton, SectionLabel } from '../ui';
+import type { Workspace } from '../../types';
+
+export function MemoriesTab() {
+  const { t } = useTranslation();
+  const activeWorkspace = useWorkspaceStore((s) => s.activeWorkspace);
+  const workspaces = useWorkspaceStore((s) => s.workspaces);
+  const [entries, setEntries] = useState<PhraseMemoryEntry[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [workspaceFilter, setWorkspaceFilter] = useState<string>('all');
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [draftSource, setDraftSource] = useState('');
+  const [draftTarget, setDraftTarget] = useState('');
+  const [busyId, setBusyId] = useState<string | null>(null);
+
+  const loadEntries = useCallback(async () => {
+    if (workspaces.length === 0) {
+      setEntries([]);
+      return;
+    }
+    setIsLoading(true);
+    setEditingId(null);
+    try {
+      const targetWorkspaces =
+        workspaceFilter === 'all'
+          ? workspaces
+          : workspaces.filter((workspace) => workspace.id === workspaceFilter);
+      const results = await Promise.all(
+        targetWorkspaces.map((workspace) => listPhraseMemoryEntries(workspace.id)),
+      );
+      setEntries(
+        results
+          .flat()
+          .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()),
+      );
+    } catch (err: unknown) {
+      toast.error(t('library.memoryLoadError'), {
+        description: err instanceof Error ? err.message : String(err),
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  }, [t, workspaceFilter, workspaces]);
+
+  useEffect(() => {
+    void loadEntries();
+  }, [loadEntries]);
+
+  const startEdit = (entry: PhraseMemoryEntry) => {
+    setEditingId(entry.id);
+    setDraftSource(entry.sourcePhrase);
+    setDraftTarget(entry.targetPhrase);
+  };
+
+  const closeEdit = () => {
+    setEditingId(null);
+    setDraftSource('');
+    setDraftTarget('');
+  };
+
+  const handleSave = async (entry: PhraseMemoryEntry) => {
+    const workspace = workspaces.find((item) => item.id === entry.workspaceId) ?? activeWorkspace;
+    if (!workspace || !draftSource.trim() || !draftTarget.trim()) return;
+    setBusyId(entry.id);
+    try {
+      await updatePhraseMemoryEntry({
+        workspaceId: entry.workspaceId,
+        phraseMemoryId: entry.id,
+        embeddingModel: workspace.embeddingModel,
+        sourcePhrase: draftSource,
+        targetPhrase: draftTarget,
+      });
+      closeEdit();
+      await loadEntries();
+      toast.success(t('library.memoryUpdated'));
+    } catch (err: unknown) {
+      toast.error(t('library.memoryUpdateError'), {
+        description: err instanceof Error ? err.message : String(err),
+      });
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  const handleDelete = async (entry: PhraseMemoryEntry) => {
+    const ok = await confirm({
+      title: t('library.memoryDeleteTitle'),
+      message: t('library.memoryDeleteMessage'),
+      confirmLabel: t('common.delete'),
+      danger: true,
+    });
+    if (!ok) return;
+
+    setBusyId(entry.id);
+    try {
+      await deletePhraseMemoryEntry(entry.workspaceId, entry.id);
+      setEntries((current) => current.filter((item) => item.id !== entry.id));
+      toast.success(t('library.memoryDeleted'));
+    } catch (err: unknown) {
+      toast.error(t('library.memoryDeleteError'), {
+        description: err instanceof Error ? err.message : String(err),
+      });
+    } finally {
+      setBusyId(null);
+    }
+  };
+
+  return (
+    <div
+      id="library-panel-memories"
+      role="tabpanel"
+      aria-labelledby="library-tab-memories"
+      className="space-y-5"
+    >
+      <div className="flex items-center justify-between gap-3">
+        <div className="flex flex-col gap-1">
+          <SectionLabel icon={Brain} label={t('library.tabMemories')} />
+          <span className="font-display text-sm italic text-editorial-muted">
+            {t('library.memoriesCount', { count: entries.length })}
+          </span>
+        </div>
+        <div className="flex items-center gap-2">
+          <label className="flex items-center gap-2">
+            <span className="text-[10px] font-bold uppercase tracking-[0.28em] text-editorial-muted">
+              {t('library.workspaceFilter')}
+            </span>
+            <select
+              value={workspaceFilter}
+              onChange={(event) => setWorkspaceFilter(event.target.value)}
+              className="max-w-[220px] rounded-full border border-editorial-border bg-editorial-bg px-3 py-2 text-xs text-editorial-ink outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent"
+            >
+              <option value="all">{t('library.allWorkspaces')}</option>
+              {workspaces.map((workspace) => (
+                <option key={workspace.id} value={workspace.id}>
+                  {workspace.name}
+                </option>
+              ))}
+            </select>
+          </label>
+          <IconButton
+            size="md"
+            onClick={() => void loadEntries()}
+            title={t('common.refresh')}
+            disabled={isLoading}
+          >
+            {isLoading ? <Loader2 size={14} className="animate-spin" /> : <RefreshCcw size={14} />}
+          </IconButton>
+        </div>
+      </div>
+
+      {isLoading ? (
+        <div className="flex items-center justify-center gap-2 rounded-[20px] border border-editorial-border bg-editorial-textbox/15 px-4 py-8 text-xs text-editorial-muted">
+          <Loader2 size={14} className="animate-spin" />
+          {t('common.loading')}
+        </div>
+      ) : entries.length === 0 ? (
+        <div className="flex flex-col items-center justify-center gap-3 rounded-[22px] border border-dashed border-editorial-border/70 bg-editorial-paper/45 px-5 py-12 text-center">
+          <Brain size={28} className="text-editorial-border" />
+          <p className="font-display text-lg italic text-editorial-muted">
+            {t('library.noMemories')}
+          </p>
+        </div>
+      ) : (
+        <div className="space-y-3">
+          {entries.map((entry) => {
+            const isEditing = editingId === entry.id;
+            const isBusy = busyId === entry.id;
+            return (
+              <article
+                key={entry.id}
+                className="rounded-[22px] border border-editorial-border bg-editorial-paper/60 p-4 shadow-[inset_0_1px_0_rgba(255,255,255,0.45)] transition-colors hover:border-editorial-accent/35"
+              >
+                <div className="mb-3 flex items-start justify-between gap-3">
+                  <div className="min-w-0">
+                    <p className="font-mono text-xs uppercase tracking-[0.16em] text-editorial-muted">
+                      {entry.sourceLanguage} → {entry.targetLanguage}
+                    </p>
+                    <p className="mt-1 truncate text-xs text-editorial-muted/80">
+                      {workspaceName(entry.workspaceId, workspaces)} · {formatDate(entry.createdAt)}
+                    </p>
+                  </div>
+                  <div className="flex shrink-0 items-center gap-1.5">
+                    {isEditing ? (
+                      <>
+                        <IconButton
+                          size="sm"
+                          tone="accent"
+                          onClick={() => void handleSave(entry)}
+                          title={t('common.save')}
+                          disabled={isBusy || !draftSource.trim() || !draftTarget.trim()}
+                        >
+                          {isBusy ? <Loader2 size={13} className="animate-spin" /> : <Check size={13} />}
+                        </IconButton>
+                        <IconButton
+                          size="sm"
+                          onClick={closeEdit}
+                          title={t('common.cancel')}
+                          disabled={isBusy}
+                        >
+                          <X size={13} />
+                        </IconButton>
+                      </>
+                    ) : (
+                      <>
+                        <IconButton
+                          size="sm"
+                          onClick={() => startEdit(entry)}
+                          title={t('common.edit')}
+                          disabled={busyId !== null}
+                        >
+                          <Pencil size={13} />
+                        </IconButton>
+                        <IconButton
+                          size="sm"
+                          tone="muted"
+                          onClick={() => void handleDelete(entry)}
+                          title={t('common.delete')}
+                          disabled={busyId !== null}
+                        >
+                          {isBusy ? <Loader2 size={13} className="animate-spin" /> : <Trash2 size={13} />}
+                        </IconButton>
+                      </>
+                    )}
+                  </div>
+                </div>
+
+                {isEditing ? (
+                  <div className="grid gap-3">
+                    <MemoryTextarea
+                      label={t('memory.sourcePhraseLabel')}
+                      value={draftSource}
+                      onChange={setDraftSource}
+                      autoFocus
+                    />
+                    <MemoryTextarea
+                      label={t('glossary.translation')}
+                      value={draftTarget}
+                      onChange={setDraftTarget}
+                    />
+                  </div>
+                ) : (
+                  <div className="grid gap-3">
+                    <div className="rounded-[16px] bg-editorial-textbox/45 px-4 py-3 text-sm leading-relaxed text-editorial-ink">
+                      {entry.sourcePhrase}
+                    </div>
+                    <div className="rounded-[16px] border border-editorial-border/60 bg-editorial-bg/70 px-4 py-3 text-sm leading-relaxed text-editorial-ink">
+                      {entry.targetPhrase}
+                    </div>
+                  </div>
+                )}
+              </article>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function MemoryTextarea({
+  label,
+  value,
+  onChange,
+  autoFocus = false,
+}: {
+  label: string;
+  value: string;
+  onChange: (value: string) => void;
+  autoFocus?: boolean;
+}) {
+  return (
+    <label className="grid gap-1.5">
+      <span className="text-[10px] font-bold uppercase tracking-[0.28em] text-editorial-muted">
+        {label}
+      </span>
+      <textarea
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+        rows={3}
+        autoFocus={autoFocus}
+        className="w-full resize-y rounded-[16px] border border-editorial-border bg-editorial-bg/80 px-4 py-3 text-sm leading-relaxed text-editorial-ink outline-none focus-visible:ring-2 focus-visible:ring-editorial-accent"
+      />
+    </label>
+  );
+}
+
+function formatDate(value: string) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+
+function workspaceName(workspaceId: string, workspaces: Workspace[]) {
+  return workspaces.find((workspace) => workspace.id === workspaceId)?.name ?? workspaceId;
+}
diff --git a/src/components/ui/IconButton.tsx b/src/components/ui/IconButton.tsx
index 3a35816..ad4f1dd 100644
--- a/src/components/ui/IconButton.tsx
+++ b/src/components/ui/IconButton.tsx
@@ -1,5 +1,5 @@
 import { cva, type VariantProps } from 'class-variance-authority';
-import type { ButtonHTMLAttributes, ReactNode } from 'react';
+import { forwardRef, type ButtonHTMLAttributes, type ReactNode } from 'react';
 import { Tooltip, type TooltipSide } from './Tooltip';
 
 const iconButton = cva(
@@ -12,7 +12,7 @@ const iconButton = cva(
         lg: 'p-2.5',
       },
       tone: {
-        default:  'border-editorial-border text-editorial-muted hover:border-editorial-accent/60 hover:text-editorial-accent',
+        default:  'border-editorial-border text-editorial-muted hover:border-editorial-accent/40 hover:text-editorial-accent',
         accent:   'border-editorial-accent bg-editorial-accent text-white',
         success:  'border-editorial-success/50 bg-editorial-success/10 text-editorial-success',
         charcoal: 'border-editorial-border text-editorial-muted hover:border-editorial-charcoal/60 hover:text-editorial-charcoal',
@@ -37,7 +37,7 @@ type IconButtonProps = VariantProps<typeof iconButton> &
     tooltipSide?: TooltipSide;
   };
 
-export function IconButton({
+export const IconButton = forwardRef<HTMLButtonElement, IconButtonProps>(function IconButton({
   onClick,
   children,
   title,
@@ -49,10 +49,11 @@ export function IconButton({
   className,
   tooltipSide,
   ...rest
-}: IconButtonProps) {
+}, ref) {
   return (
     <Tooltip label={title} side={tooltipSide}>
       <button
+        ref={ref}
         type="button"
         onClick={onClick}
         disabled={disabled}
@@ -65,4 +66,4 @@ export function IconButton({
       </button>
     </Tooltip>
   );
-}
+});
diff --git a/src/components/workspace/WorkspaceWizard.tsx b/src/components/workspace/WorkspaceWizard.tsx
index f478c05..a71c3c9 100644
--- a/src/components/workspace/WorkspaceWizard.tsx
+++ b/src/components/workspace/WorkspaceWizard.tsx
@@ -27,7 +27,7 @@ export function WorkspaceWizard() {
     'w-full rounded-[18px] border border-editorial-border bg-editorial-textbox/30 px-4 py-3 text-sm text-editorial-ink outline-none transition-colors focus:border-editorial-accent focus-visible:ring-2 focus-visible:ring-editorial-accent';
 
   return (
-    <div className="flex min-h-screen flex-col items-center justify-center gap-6 p-8">
+    <div className="flex min-h-dvh min-h-[var(--app-min-height)] min-w-[var(--app-min-width)] flex-col items-center justify-center gap-6 p-8">
       <div className="flex flex-col items-center gap-2">
         <h1 className="text-2xl font-semibold text-editorial-ink">
           Crea il tuo primo workspace
diff --git a/src/hooks/usePanelScrollSync.ts b/src/hooks/usePanelScrollSync.ts
index e85a08c..f417dd8 100644
--- a/src/hooks/usePanelScrollSync.ts
+++ b/src/hooks/usePanelScrollSync.ts
@@ -1,8 +1,23 @@
 import { useEffect, useRef } from 'react';
 
+const SCROLL_TARGET_SELECTOR = '[data-scroll-sync="true"], [data-scroll], textarea, .custom-scrollbar';
+const PROGRAMMATIC_SCROLL_IGNORE_MS = 180;
+
+function isScrollable(el: HTMLElement): boolean {
+  return el.scrollHeight - el.clientHeight > 1;
+}
+
 function getScrollTarget(container: HTMLElement): HTMLElement | null {
-  if (container.scrollHeight > container.clientHeight) return container;
-  return container.querySelector<HTMLElement>('textarea, [data-scroll], .custom-scrollbar') ?? null;
+  if (isScrollable(container)) return container;
+  const candidates = Array.from(container.querySelectorAll<HTMLElement>(SCROLL_TARGET_SELECTOR));
+  return candidates.find(isScrollable) ?? candidates[0] ?? null;
+}
+
+function getEventScrollTarget(eventTarget: EventTarget | null, boundary: HTMLElement): HTMLElement | null {
+  if (!(eventTarget instanceof HTMLElement) || !boundary.contains(eventTarget)) {
+    return getScrollTarget(boundary);
+  }
+  return isScrollable(eventTarget) ? eventTarget : getScrollTarget(boundary);
 }
 
 function scrollRatio(el: HTMLElement): number {
@@ -10,6 +25,14 @@ function scrollRatio(el: HTMLElement): number {
   return range > 0 ? el.scrollTop / range : 0;
 }
 
+function applyScrollRatio(from: HTMLElement, to: HTMLElement) {
+  const targetRange = to.scrollHeight - to.clientHeight;
+  if (targetRange <= 0) return;
+  const nextTop = scrollRatio(from) * targetRange;
+  if (Math.abs(to.scrollTop - nextTop) < 1) return;
+  to.scrollTop = nextTop;
+}
+
 export function usePanelScrollSync(enabled: boolean): {
   sourceRef: React.RefObject<HTMLDivElement | null>;
   translationRef: React.RefObject<HTMLDivElement | null>;
@@ -17,6 +40,7 @@ export function usePanelScrollSync(enabled: boolean): {
   const sourceRef = useRef<HTMLDivElement | null>(null);
   const translationRef = useRef<HTMLDivElement | null>(null);
   const isSyncing = useRef(false);
+  const ignoredTargetRef = useRef<{ el: HTMLElement; until: number } | null>(null);
 
   useEffect(() => {
     if (!enabled) return;
@@ -25,20 +49,27 @@ export function usePanelScrollSync(enabled: boolean): {
     const translationCtr = translationRef.current;
     if (!sourceCtr || !translationCtr) return;
 
-    const syncFrom = (toCtr: HTMLElement) => (e: Event) => {
+    const syncFrom = (toCtr: HTMLElement, fromCtr: HTMLElement) => (e: Event) => {
       if (isSyncing.current) return;
-      const from = e.target as HTMLElement;
-      if (from.scrollHeight <= from.clientHeight) return;
+      const from = getEventScrollTarget(e.target, fromCtr);
+      if (!from || !isScrollable(from)) return;
+      const ignored = ignoredTargetRef.current;
+      if (ignored && ignored.el === from && performance.now() < ignored.until) return;
       const to = getScrollTarget(toCtr);
       if (!to) return;
       isSyncing.current = true;
-      const ratio = scrollRatio(from);
-      to.scrollTop = ratio * (to.scrollHeight - to.clientHeight);
-      requestAnimationFrame(() => { isSyncing.current = false; });
+      ignoredTargetRef.current = {
+        el: to,
+        until: performance.now() + PROGRAMMATIC_SCROLL_IGNORE_MS,
+      };
+      applyScrollRatio(from, to);
+      window.setTimeout(() => {
+        isSyncing.current = false;
+      }, 0);
     };
 
-    const onSourceScroll = syncFrom(translationCtr);
-    const onTranslationScroll = syncFrom(sourceCtr);
+    const onSourceScroll = syncFrom(translationCtr, sourceCtr);
+    const onTranslationScroll = syncFrom(sourceCtr, translationCtr);
 
     sourceCtr.addEventListener('scroll', onSourceScroll, { capture: true, passive: true });
     translationCtr.addEventListener('scroll', onTranslationScroll, { capture: true, passive: true });
@@ -46,6 +77,7 @@ export function usePanelScrollSync(enabled: boolean): {
     return () => {
       sourceCtr.removeEventListener('scroll', onSourceScroll, { capture: true });
       translationCtr.removeEventListener('scroll', onTranslationScroll, { capture: true });
+      ignoredTargetRef.current = null;
     };
   }, [enabled]);
 
diff --git a/src/hooks/useSaveToMemory.test.ts b/src/hooks/useSaveToMemory.test.ts
index 2c93258..a5793fa 100644
--- a/src/hooks/useSaveToMemory.test.ts
+++ b/src/hooks/useSaveToMemory.test.ts
@@ -19,7 +19,7 @@ vi.mock('../services/phraseMemoryService', () => ({
 }));
 
 vi.mock('../utils/logger', () => ({
-  logger: { warn: vi.fn() },
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn() },
 }));
 
 const mockListPresets = vi.mocked(listPresets);
@@ -42,7 +42,7 @@ describe('useSaveToMemory', () => {
         createdAt: '2026-01-01T00:00:00.000Z',
       },
     ]);
-    mockSaveSelectedPhrases.mockResolvedValue(undefined);
+    mockSaveSelectedPhrases.mockResolvedValue(1);
 
     useWorkspaceStore.setState({
       activeWorkspace: {
@@ -112,6 +112,19 @@ describe('useSaveToMemory', () => {
     }));
   });
 
+  it('ritorna il numero reale di frasi salvate dal service', async () => {
+    mockSaveSelectedPhrases.mockResolvedValueOnce(3);
+    const { result } = renderHook(() => useSaveToMemory());
+    let savedCount = 0;
+
+    await act(async () => {
+      savedCount = await result.current.saveToMemory(['c1']);
+    });
+
+    expect(savedCount).toBe(3);
+    expect(usePhraseMemoryStore.getState().jobStatus).toEqual({ kind: 'done', totalPhrases: 3 });
+  });
+
   it('non salva chunk locked o completed se non sono selezionati', async () => {
     const { result } = renderHook(() => useSaveToMemory());
 
diff --git a/src/hooks/useSaveToMemory.ts b/src/hooks/useSaveToMemory.ts
index f278ef8..010b682 100644
--- a/src/hooks/useSaveToMemory.ts
+++ b/src/hooks/useSaveToMemory.ts
@@ -24,6 +24,12 @@ export function useSaveToMemory() {
     const selected = chunks.filter(
       (c) => selectedIds.has(c.id) && c.sourceProcessingText?.trim() && c.currentDraft?.trim(),
     );
+    logger.debug('phrase_memory.save_hook.selection', {
+      requestedChunkCount: chunkIds.length,
+      selectedChunkCount: selected.length,
+      workspaceId: activeWorkspace.id,
+      projectId: currentProjectId,
+    });
     if (selected.length === 0) return 0;
 
     const presets = await listPresets(activeWorkspace.id);
@@ -38,7 +44,7 @@ export function useSaveToMemory() {
     });
 
     try {
-      await saveSelectedPhrases({
+      const savedPhraseCount = await saveSelectedPhrases({
         workspaceId: activeWorkspace.id,
         projectId: currentProjectId,
         embeddingModel: activeWorkspace.embeddingModel,
@@ -59,9 +65,15 @@ export function useSaveToMemory() {
         },
       });
       usePhraseMemoryStore.getState().setJobStatus({
-        kind: 'done', totalPhrases: selected.length,
+        kind: 'done', totalPhrases: savedPhraseCount,
+      });
+      logger.info('phrase_memory.save_hook.done', {
+        workspaceId: activeWorkspace.id,
+        projectId: currentProjectId,
+        selectedChunkCount: selected.length,
+        savedPhraseCount,
       });
-      return selected.length;
+      return savedPhraseCount;
     } catch (err: unknown) {
       logger.warn('saveToMemory failed', { error: String(err) });
       usePhraseMemoryStore.getState().setJobStatus({ kind: 'idle' });
diff --git a/src/i18n/en.json b/src/i18n/en.json
index 110340d..c59aac1 100644
--- a/src/i18n/en.json
+++ b/src/i18n/en.json
@@ -96,8 +96,8 @@
     "inputPlaceholder": "Paste source material here...",
     "stageContent": "Stage Content to Stream",
     "unit": "Chunk",
-    "originalSource": "Original Source",
-    "candidateTranslation": "Candidate Translation",
+    "originalSource": "Source",
+    "candidateTranslation": "Candidate",
     "candidatePlaceholder": "Output will appear here. Edit manually before auditing...",
     "newStage": "New Stage",
     "stagePromptPlaceholder": "Stage specific prompt...",
@@ -498,6 +498,9 @@
     "cancel": "Cancel",
     "close": "Close",
     "delete": "Delete",
+    "edit": "Edit",
+    "loading": "Loading",
+    "refresh": "Refresh",
     "save": "Save",
     "all": "All",
     "clear": "Clear",
@@ -693,6 +696,7 @@
     "textLarge": "Larger text",
     "inlineLabel": "Text",
     "structureLabel": "Structure",
+    "markdownHelpTooltip": "Markdown tools: formatting, preview and text size. Click to open the guide.",
     "bold": "Bold",
     "italic": "Italic",
     "heading1": "Heading 1",
@@ -765,6 +769,10 @@
     "insightsTabIndex": "Index",
     "insightsTabSearch": "Search",
     "searchPlaceholder": "Search document…",
+    "searchChunkPlaceholder": "Search this chunk…",
+    "searchInSource": "Search source",
+    "searchInTranslation": "Search candidate",
+    "clearPaneSearch": "Clear search",
     "searchEmptyTitle": "Document search",
     "searchEmptyBody": "Type a word or phrase to search across all chunks — source text, translation, and audit findings.",
     "searchNoResults": "No results found.",
@@ -888,6 +896,8 @@
       "documentWorkspaceDesc": "The primary mode of the app. After importing a document, the workspace shows the current chunk with source and translation side by side, a top action bar to navigate and run the pipeline, and — on the right — the Insights panel with index, stats, audit, and logs. The mode is activated automatically when you load a document.",
       "documentToolsTitle": "Editor tools",
       "documentToolsDesc": "Source and translation editors have a compact toolbar that can be collapsed when you want to read the clean text. On the candidate translation, the green tick locks it as final; each stage status badge opens a modal with the full output of that stage (trace), useful to see what the model actually produced.",
+      "markdownToolsTitle": "Markdown toolbar",
+      "markdownToolsDesc": "The ? button in the editors opens this guide. The toolbar handles writing, preview, split view, text size, and essential Markdown formatting.",
       "insightsTitle": "Insights panel",
       "insightsDesc": "Slides in from the right via the panel icon in the header. Two levels: the Document panel (Index, Search, Stats, Coherence, Glossary) for whole-document metrics and search, and the Chunk panel (Audit, Notes, Operations) for the selected chunk. Selecting a chunk in the index automatically opens the Chunk level.",
       "statsTitle": "Session stats",
@@ -1065,6 +1075,7 @@
       "openHelp": "Open this guide — header",
       "openInsights": "Open the Insights panel",
       "toggleEditorTools": "Show / hide the editor toolbars",
+      "markdownHelp": "Question mark — opens the Markdown toolbar guide",
       "lockTranslation": "Lock / unlock the candidate translation as final",
       "phraseMemory": "Memory — shows found matches, lets you select which ones to use, and explicitly saves the current chunk",
       "openStageTrace": "Open the modal with a stage's full output",
@@ -1095,6 +1106,7 @@
     "title": "Library",
     "tabDictionaries": "Dictionaries",
     "tabTemplates": "Prompt Templates",
+    "tabMemories": "Memories",
     "dictionariesDesc": "Manage reusable term dictionaries across projects.",
     "newDictionary": "New",
     "dictionaryNamePlaceholder": "Dictionary name...",
@@ -1149,7 +1161,20 @@
     "csvImportSuccess": "{{count}} terms imported",
     "glossaryHighlightToggle": "Highlight terms",
     "glossaryMatchBadge": "{{match}}/{{total}} terms",
-    "glossaryNoGlossary": "No dictionary assigned"
+    "glossaryNoGlossary": "No dictionary assigned",
+    "memoriesCount_one": "{{count}} memory",
+    "memoriesCount_other": "{{count}} memories",
+    "memoriesCount": "{{count}} memories",
+    "workspaceFilter": "Workspace",
+    "allWorkspaces": "All",
+    "noMemories": "No memories stored yet.",
+    "memoryLoadError": "Error loading memories",
+    "memoryUpdated": "Memory updated",
+    "memoryUpdateError": "Update error",
+    "memoryDeleted": "Memory deleted",
+    "memoryDeleteTitle": "Delete this memory?",
+    "memoryDeleteMessage": "The selected memory will be removed from this workspace.",
+    "memoryDeleteError": "Delete error"
   },
   "cost": {
     "free": "Free",
@@ -1228,8 +1253,8 @@
     "termExtracted": "Term added to glossary",
     "prelaunchWarning": "{{count}} chunks have memory matches found but not selected",
     "saveToMemoryButton": "Save chunk to memory",
-    "savedToMemory": "Chunk saved to memory",
-    "nothingToSave": "No ready translation to save in the current chunk",
+    "savedToMemory": "{{count}} phrases saved to memory",
+    "nothingToSave": "No valid phrase to save in the current chunk",
     "saveToMemoryFailed": "Error saving to memory",
     "searching": "Searching memory",
     "searchFailed": "Memory search failed",
diff --git a/src/i18n/it.json b/src/i18n/it.json
index 41dde8a..7ab26d0 100644
--- a/src/i18n/it.json
+++ b/src/i18n/it.json
@@ -96,8 +96,8 @@
     "inputPlaceholder": "Incolla il materiale sorgente qui...",
     "stageContent": "Prepara Contenuto",
     "unit": "Unità",
-    "originalSource": "Testo Originale",
-    "candidateTranslation": "Traduzione Candidata",
+    "originalSource": "Originale",
+    "candidateTranslation": "Candidata",
     "candidatePlaceholder": "Il risultato apparirà qui. Modifica manualmente prima dell'audit...",
     "newStage": "Nuova Fase",
     "stagePromptPlaceholder": "Prompt specifico per la fase...",
@@ -498,6 +498,9 @@
     "cancel": "Annulla",
     "close": "Chiudi",
     "delete": "Elimina",
+    "edit": "Modifica",
+    "loading": "Caricamento",
+    "refresh": "Aggiorna",
     "save": "Salva",
     "all": "Tutti",
     "clear": "Cancella",
@@ -693,6 +696,7 @@
     "textLarge": "Testo più grande",
     "inlineLabel": "Testo",
     "structureLabel": "Struttura",
+    "markdownHelpTooltip": "Strumenti Markdown: formattazione, anteprima e dimensione testo. Clic per aprire la guida.",
     "bold": "Grassetto",
     "italic": "Corsivo",
     "heading1": "Titolo 1",
@@ -765,6 +769,10 @@
     "insightsTabIndex": "Indice",
     "insightsTabSearch": "Cerca",
     "searchPlaceholder": "Cerca nel documento…",
+    "searchChunkPlaceholder": "Cerca nel chunk…",
+    "searchInSource": "Cerca nel sorgente",
+    "searchInTranslation": "Cerca nella candidata",
+    "clearPaneSearch": "Cancella ricerca",
     "searchEmptyTitle": "Ricerca nel documento",
     "searchEmptyBody": "Digita una parola o frase per cercare in tutti i chunk, sia nel testo originale che nella traduzione e nell'audit.",
     "searchNoResults": "Nessun risultato trovato.",
@@ -888,6 +896,8 @@
       "documentWorkspaceDesc": "È la modalità principale dell'app. Dopo aver importato un documento, il workspace mostra il chunk corrente con sorgente e traduzione affiancati, una barra azioni superiore per navigare e lanciare la pipeline, e — sulla destra — il pannello Insight per indice, statistiche, audit e log. La modalità si attiva automaticamente quando carichi un documento.",
       "documentToolsTitle": "Strumenti dell'editor",
       "documentToolsDesc": "Gli editor sorgente e traduzione hanno una toolbar compatta che si può collassare quando vuoi leggere il testo pulito. Sulla traduzione candidata, la spunta verde la blocca come definitiva; il badge di stato di ogni stage apre una modale con l'output completo di quello stage (trace), utile per capire cosa ha effettivamente prodotto il modello.",
+      "markdownToolsTitle": "Toolbar Markdown",
+      "markdownToolsDesc": "Il pulsante ? negli editor apre questa guida. La toolbar gestisce scrittura, anteprima, vista divisa, dimensione testo e formattazione Markdown essenziale.",
       "insightsTitle": "Pannello Insight",
       "insightsDesc": "Si apre dalla destra con l'icona pannello nell'header. Ha due livelli: il pannello Documento (Indice, Cerca, Statistiche, Coerenza, Glossario) per metriche e ricerca su tutto il documento, e il pannello Chunk (Audit, Note, Operazioni) per il chunk selezionato. La selezione di un chunk nell'indice apre automaticamente il livello Chunk.",
       "statsTitle": "Statistiche di sessione",
@@ -1065,6 +1075,7 @@
       "openHelp": "Apri questa guida — header",
       "openInsights": "Apri il pannello Insight",
       "toggleEditorTools": "Mostra / nasconde la toolbar degli editor",
+      "markdownHelp": "Punto interrogativo — apre la guida della toolbar Markdown",
       "lockTranslation": "Blocca / sblocca la traduzione candidata come definitiva",
       "phraseMemory": "Memoria — mostra i match trovati, seleziona quelli da usare e salva esplicitamente il chunk corrente",
       "openStageTrace": "Apri la modale con l'output completo di uno stage",
@@ -1095,6 +1106,7 @@
     "title": "Libreria",
     "tabDictionaries": "Dizionari",
     "tabTemplates": "Modelli Prompt",
+    "tabMemories": "Memorie",
     "dictionariesDesc": "Gestisci i dizionari di termini riusabili tra i progetti.",
     "newDictionary": "Nuovo",
     "dictionaryNamePlaceholder": "Nome dizionario...",
@@ -1149,7 +1161,20 @@
     "csvImportSuccess": "{{count}} termini importati",
     "glossaryHighlightToggle": "Evidenzia termini",
     "glossaryMatchBadge": "{{match}}/{{total}} termini",
-    "glossaryNoGlossary": "Nessun dizionario assegnato"
+    "glossaryNoGlossary": "Nessun dizionario assegnato",
+    "memoriesCount_one": "{{count}} memoria",
+    "memoriesCount_other": "{{count}} memorie",
+    "memoriesCount": "{{count}} memorie",
+    "workspaceFilter": "Workspace",
+    "allWorkspaces": "Tutti",
+    "noMemories": "Nessuna memoria immagazzinata.",
+    "memoryLoadError": "Errore nel caricamento delle memorie",
+    "memoryUpdated": "Memoria aggiornata",
+    "memoryUpdateError": "Errore nell'aggiornamento",
+    "memoryDeleted": "Memoria eliminata",
+    "memoryDeleteTitle": "Eliminare questa memoria?",
+    "memoryDeleteMessage": "La memoria selezionata verrà rimossa dal workspace.",
+    "memoryDeleteError": "Errore nell'eliminazione"
   },
   "cost": {
     "free": "Gratuito",
@@ -1228,8 +1253,8 @@
     "termExtracted": "Termine aggiunto al glossario",
     "prelaunchWarning": "{{count}} chunk hanno match di memoria trovati ma non selezionati",
     "saveToMemoryButton": "Salva chunk in memoria",
-    "savedToMemory": "Chunk salvato in memoria",
-    "nothingToSave": "Nessuna traduzione pronta da salvare nel chunk corrente",
+    "savedToMemory": "{{count}} frasi salvate in memoria",
+    "nothingToSave": "Nessuna frase valida da salvare nel chunk corrente",
     "saveToMemoryFailed": "Errore nel salvataggio in memoria",
     "searching": "Ricerca memoria in corso",
     "searchFailed": "Ricerca memoria non riuscita",
diff --git a/src/index.css b/src/index.css
index 488c965..113c1ab 100644
--- a/src/index.css
+++ b/src/index.css
@@ -95,6 +95,8 @@
 
 /* Highlight color tokens — overridden at runtime by App.tsx */
 :root {
+  --app-min-width: 1080px;
+  --app-min-height: 680px;
   --hl-source-term-color: #3b82f6;
   --hl-match-bg: rgba(34, 197, 94, 0.18);
   --hl-mismatch-bg: rgba(239, 68, 68, 0.15);
@@ -102,6 +104,20 @@
   --hl-audit-bg: rgba(249, 115, 22, 0.25);
 }
 
+html,
+body,
+#root {
+  min-width: var(--app-min-width);
+  min-height: var(--app-min-height);
+  height: 100%;
+}
+
+body {
+  margin: 0;
+  overflow: hidden;
+  background: var(--color-editorial-bg);
+}
+
 mark.hl-source-term {
   background: transparent;
   text-decoration: underline;
diff --git a/src/services/__tests__/phraseMemoryService.test.ts b/src/services/__tests__/phraseMemoryService.test.ts
index 7ebf02e..52500f4 100644
--- a/src/services/__tests__/phraseMemoryService.test.ts
+++ b/src/services/__tests__/phraseMemoryService.test.ts
@@ -10,12 +10,15 @@ vi.mock('../embeddingService', () => ({
 import { invoke } from '@tauri-apps/api/core';
 import { fetchEmbeddings } from '../embeddingService';
 import {
+  deletePhraseMemoryEntry,
+  listPhraseMemoryEntries,
   splitPhrases,
   runEmbeddingJob,
   searchPhraseMemory,
   searchPhraseMemoryBatch,
   saveSelectedPhrases,
   savePhrasePairs,
+  updatePhraseMemoryEntry,
 } from '../phraseMemoryService';
 
 const mockInvoke = vi.mocked(invoke);
@@ -162,15 +165,83 @@ describe('searchPhraseMemoryBatch', () => {
   });
 });
 
+describe('phrase memory entry management', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('mappa le entry salvate da snake_case a camelCase', async () => {
+    mockInvoke.mockResolvedValueOnce([
+      {
+        id: 'pm-1',
+        workspace_id: 'ws-1',
+        source_phrase: 'ciao',
+        target_phrase: 'hello',
+        source_language: 'Italian',
+        target_language: 'English',
+        author: null,
+        work: null,
+        domain: null,
+        tags: null,
+        notes: null,
+        chunk_id: 'c1',
+        project_id: 'p1',
+        created_at: '2026-01-01T00:00:00Z',
+      },
+    ]);
+
+    const result = await listPhraseMemoryEntries('ws-1');
+
+    expect(mockInvoke).toHaveBeenCalledWith('vec_list_phrase_memory', { workspaceId: 'ws-1' });
+    expect(result[0]).toMatchObject({
+      id: 'pm-1',
+      workspaceId: 'ws-1',
+      sourcePhrase: 'ciao',
+      targetPhrase: 'hello',
+    });
+  });
+
+  it('elimina una entry workspace-scoped', async () => {
+    mockInvoke.mockResolvedValueOnce(1);
+
+    await deletePhraseMemoryEntry('ws-1', 'pm-1');
+
+    expect(mockInvoke).toHaveBeenCalledWith('vec_delete_phrase_memory', {
+      workspaceId: 'ws-1',
+      phraseMemoryId: 'pm-1',
+    });
+  });
+
+  it('rigenera embedding quando aggiorna una entry', async () => {
+    mockFetchEmbeddings.mockResolvedValueOnce([[0.1, 0.2]]);
+    mockInvoke.mockResolvedValueOnce(undefined);
+
+    await updatePhraseMemoryEntry({
+      workspaceId: 'ws-1',
+      phraseMemoryId: 'pm-1',
+      embeddingModel: 'text-embedding-3-small',
+      sourcePhrase: ' ciao ',
+      targetPhrase: ' hello ',
+    });
+
+    expect(mockFetchEmbeddings).toHaveBeenCalledWith(['ciao'], 'text-embedding-3-small');
+    expect(mockInvoke).toHaveBeenCalledWith('vec_update_phrase_memory', {
+      workspaceId: 'ws-1',
+      phraseMemoryId: 'pm-1',
+      sourcePhrase: 'ciao',
+      targetPhrase: 'hello',
+      embedding: [0.1, 0.2],
+    });
+  });
+});
+
 describe('saveSelectedPhrases', () => {
   beforeEach(() => vi.clearAllMocks());
 
   it('salva solo i chunk passati esplicitamente e aggiorna il progress', async () => {
     mockFetchEmbeddings.mockResolvedValue([[0.1, 0.2]]);
-    mockInvoke.mockResolvedValue(undefined);
+    mockInvoke.mockResolvedValue(1);
     const onProgress = vi.fn();
 
-    await saveSelectedPhrases({
+    const savedCount = await saveSelectedPhrases({
       workspaceId: 'ws-1',
       projectId: 'proj-1',
       embeddingModel: 'text-embedding-3-small',
@@ -196,6 +267,7 @@ describe('saveSelectedPhrases', () => {
     );
     expect(onProgress).toHaveBeenCalledWith(1, 2);
     expect(onProgress).toHaveBeenCalledWith(2, 2);
+    expect(savedCount).toBe(2);
   });
 });
 
@@ -206,7 +278,7 @@ describe('savePhrasePairs', () => {
     mockFetchEmbeddings.mockResolvedValue([[0.1, 0.2]]);
     mockInvoke.mockResolvedValueOnce(1);
 
-    await savePhrasePairs({
+    const savedCount = await savePhrasePairs({
       workspaceId: 'ws-1',
       projectId: 'proj-1',
       chunkId: 'c1',
@@ -223,5 +295,29 @@ describe('savePhrasePairs', () => {
       'vec_save_locked_phrases',
       expect.objectContaining({ workspaceId: 'ws-1', projectId: 'proj-1', chunkId: 'c1' }),
     );
+    expect(savedCount).toBe(1);
+  });
+
+  it('non salva coppie senza embedding valido', async () => {
+    mockFetchEmbeddings.mockResolvedValue([]);
+
+    const savedCount = await savePhrasePairs({
+      workspaceId: 'ws-1',
+      projectId: 'proj-1',
+      chunkId: 'c1',
+      embeddingModel: 'text-embedding-3-small',
+      splitter: 'regex',
+      sourceText: 'Ciao mondo.',
+      targetText: 'Hello world.',
+      minPhraseLength: 3,
+      sourceLanguage: 'it',
+      targetLanguage: 'en',
+    });
+
+    expect(savedCount).toBe(0);
+    expect(mockInvoke).not.toHaveBeenCalledWith(
+      'vec_save_locked_phrases',
+      expect.anything(),
+    );
   });
 });
diff --git a/src/services/dbService.test.ts b/src/services/dbService.test.ts
index 02936c0..b9943ee 100644
--- a/src/services/dbService.test.ts
+++ b/src/services/dbService.test.ts
@@ -3,25 +3,54 @@ import { invoke } from '@tauri-apps/api/core';
 
 const dbState = vi.hoisted(() => {
   let failRollback = false;
+  let schemaVersion: string | null = null;
+  let workspaceCount = 0;
+  const userObjects = new Set<string>();
   const columnsByTable = new Map<string, string[]>([
     ['pipeline_configs', ['id', 'project_id', 'stages', 'judge_prompt', 'judge_model', 'judge_provider', 'use_chunking']],
     ['translations', ['id', 'project_id', 'original_text', 'final_translation', 'stage_results', 'judge_issues', 'created_at']],
     ['prompt_templates', []],
   ]);
 
-  const execute = vi.fn(async (query: string) => {
+  const execute = vi.fn(async (query: string, params?: unknown[]) => {
     if (query.trim() === 'ROLLBACK' && failRollback) {
       throw new Error('rollback failed');
     }
+    const createMatch = query.match(/CREATE TABLE IF NOT EXISTS (\w+)/);
+    if (createMatch) {
+      userObjects.add(createMatch[1]);
+    }
+    const dropMatch = query.match(/DROP TABLE IF EXISTS (\w+)/);
+    if (dropMatch) {
+      userObjects.delete(dropMatch[1]);
+    }
     const alterMatch = query.match(/^ALTER TABLE (\w+) ADD COLUMN (\w+) /);
     if (alterMatch) {
       const [, table, column] = alterMatch;
       const current = columnsByTable.get(table) ?? [];
       columnsByTable.set(table, [...current, column]);
     }
+    if (query.includes("VALUES ('schema_version', $1)") && params?.[0]) {
+      schemaVersion = String(params[0]);
+    }
   });
 
-  const select = vi.fn(async (query: string) => {
+  const select = vi.fn(async (query: string, params?: unknown[]) => {
+    if (query.includes('FROM sqlite_master') && query.includes("name = $1")) {
+      return [{ count: userObjects.has(String(params?.[0])) ? 1 : 0 }];
+    }
+    if (query.includes('FROM sqlite_master') && query.includes("type IN ('table', 'view')")) {
+      return [{ count: userObjects.size }];
+    }
+    if (query.includes("FROM app_settings WHERE key = 'schema_version'")) {
+      return schemaVersion ? [{ value: schemaVersion }] : [];
+    }
+    if (query.includes('FROM workspaces')) {
+      return [{ count: workspaceCount }];
+    }
+    if (query.includes("FROM app_settings WHERE key = 'active_workspace_id'")) {
+      return [{ count: 0 }];
+    }
     const pragmaMatch = query.match(/^PRAGMA table_info\((\w+)\)$/);
     if (!pragmaMatch) return [];
     const table = pragmaMatch[1];
@@ -33,6 +62,16 @@ const dbState = vi.hoisted(() => {
     setFailRollback: (value: boolean) => {
       failRollback = value;
     },
+    setExistingObjects: (objects: string[]) => {
+      userObjects.clear();
+      objects.forEach((object) => userObjects.add(object));
+    },
+    setSchemaVersion: (value: string | null) => {
+      schemaVersion = value;
+    },
+    setWorkspaceCount: (value: number) => {
+      workspaceCount = value;
+    },
     db: { execute, select },
     load: vi.fn(async () => ({ execute, select })),
   };
@@ -49,6 +88,9 @@ describe('runInTransaction', () => {
     vi.resetModules();
     vi.clearAllMocks();
     dbState.setFailRollback(false);
+    dbState.setExistingObjects([]);
+    dbState.setSchemaVersion(null);
+    dbState.setWorkspaceCount(0);
   });
 
   it('executes callback statements through the native transaction command', async () => {
@@ -114,11 +156,44 @@ describe('initDatabase migrations', () => {
   beforeEach(() => {
     vi.resetModules();
     vi.clearAllMocks();
+    dbState.setExistingObjects([]);
+    dbState.setSchemaVersion(null);
+    dbState.setWorkspaceCount(0);
     dbState.columnsByTable.set('pipeline_configs', ['id', 'project_id', 'stages', 'judge_prompt', 'judge_model', 'judge_provider', 'use_chunking']);
     dbState.columnsByTable.set('translations', ['id', 'project_id', 'original_text', 'final_translation', 'stage_results', 'judge_issues', 'created_at']);
     dbState.columnsByTable.set('prompt_templates', []);
   });
 
+  it('backs up and resets a beta database with an old schema version', async () => {
+    dbState.setExistingObjects(['app_settings', 'projects', 'translations']);
+    dbState.setSchemaVersion('1');
+    vi.mocked(invoke).mockResolvedValueOnce('/tmp/glossa.legacy.db.bak');
+    const { initDatabase } = await import('./dbService');
+
+    await initDatabase();
+
+    expect(invoke).toHaveBeenCalledWith('backup_database_file', {
+      reason: 'schema-1-to-2026-06-05-beta-reset',
+    });
+    expect(dbState.db.execute).toHaveBeenCalledWith('PRAGMA wal_checkpoint(FULL)');
+    expect(dbState.db.execute).toHaveBeenCalledWith('DROP TABLE IF EXISTS projects');
+    expect(dbState.db.execute).toHaveBeenCalledWith('DROP TABLE IF EXISTS translations');
+    expect(dbState.db.execute).toHaveBeenCalledWith(
+      expect.stringContaining('CREATE TABLE IF NOT EXISTS projects'),
+    );
+  });
+
+  it('does not reset a database with the current beta schema version', async () => {
+    dbState.setExistingObjects(['app_settings', 'projects', 'workspaces']);
+    dbState.setSchemaVersion('2026-06-05-beta-reset');
+    const { initDatabase } = await import('./dbService');
+
+    await initDatabase();
+
+    expect(invoke).not.toHaveBeenCalledWith('backup_database_file', expect.anything());
+    expect(dbState.db.execute).not.toHaveBeenCalledWith('DROP TABLE IF EXISTS projects');
+  });
+
   it('adds new pipeline and translation columns for existing databases', async () => {
     const { initDatabase } = await import('./dbService');
 
@@ -218,14 +293,20 @@ describe('initDatabase migrations', () => {
     );
   });
 
-  it('does not auto-create a default workspace', async () => {
+  it('creates a default workspace and backfills old projects', async () => {
     const { initDatabase } = await import('./dbService');
 
     await initDatabase();
 
-    const calls = (dbState.db.execute.mock.calls as unknown as [string, unknown[]][]).filter(
+    const workspaceInsertCalls = (dbState.db.execute.mock.calls as unknown as [string, unknown[]][]).filter(
       ([q]) => q.includes('INSERT') && q.includes('workspaces') && !q.includes('phrase_memory'),
     );
-    expect(calls).toHaveLength(0);
+    expect(workspaceInsertCalls).toHaveLength(1);
+    expect(dbState.db.execute).toHaveBeenCalledWith(
+      expect.stringContaining("SET workspace_id = 'ws_default'"),
+    );
+    expect(dbState.db.execute).toHaveBeenCalledWith(
+      expect.stringContaining("SET value = 'ws_default'"),
+    );
   });
 });
diff --git a/src/services/dbService.ts b/src/services/dbService.ts
index 8cf2914..cd9f3af 100644
--- a/src/services/dbService.ts
+++ b/src/services/dbService.ts
@@ -3,6 +3,27 @@ import { invoke } from '@tauri-apps/api/core';
 
 let db: Database | null = null;
 const DB_URL = 'sqlite:glossa.db';
+const CURRENT_SCHEMA_VERSION = '2026-06-05-beta-reset';
+
+const RESETTABLE_OBJECTS = [
+  'technique_tags',
+  'historical_techniques',
+  'source_phrase_embeddings',
+  'phrase_memory',
+  'phrase_memory_presets',
+  'operation_logs',
+  'translations',
+  'macro_blocks',
+  'project_glossaries',
+  'glossary_entries',
+  'glossaries',
+  'pipelines',
+  'pipeline_configs',
+  'prompt_templates',
+  'projects',
+  'workspaces',
+  'app_settings',
+];
 
 export async function getDb(): Promise<Database> {
   if (!db) {
@@ -100,6 +121,72 @@ export async function ensureColumn(table: string, column: string, definition: st
   await conn.execute(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
 
+async function tableExists(conn: Database, table: string): Promise<boolean> {
+  const rows = await conn.select<Array<{ count: number }>>(
+    `SELECT COUNT(*) as count FROM sqlite_master WHERE type = 'table' AND name = $1`,
+    [table],
+  );
+  return (rows[0]?.count ?? 0) > 0;
+}
+
+async function getStoredSchemaVersion(conn: Database): Promise<string | null> {
+  if (!(await tableExists(conn, 'app_settings'))) {
+    return null;
+  }
+  try {
+    const rows = await conn.select<Array<{ value: string }>>(
+      `SELECT value FROM app_settings WHERE key = 'schema_version'`,
+    );
+    return rows[0]?.value ?? null;
+  } catch (error) {
+    console.warn('[Glossa] Could not read schema_version', error);
+    return null;
+  }
+}
+
+async function hasExistingUserDatabase(conn: Database): Promise<boolean> {
+  const rows = await conn.select<Array<{ count: number }>>(
+    `SELECT COUNT(*) as count
+     FROM sqlite_master
+     WHERE type IN ('table', 'view')
+       AND name NOT LIKE 'sqlite_%'`,
+  );
+  return (rows[0]?.count ?? 0) > 0;
+}
+
+async function resetDatabaseForCurrentSchema(conn: Database, reason: string): Promise<void> {
+  await conn.execute('PRAGMA wal_checkpoint(FULL)');
+  const backupPath = await invoke<string | null>('backup_database_file', { reason });
+  if (backupPath) {
+    console.warn(`[Glossa] Database schema reset: previous DB backed up to ${backupPath}`);
+  } else {
+    console.warn('[Glossa] Database schema reset: no existing DB file to back up');
+  }
+
+  await conn.execute('PRAGMA foreign_keys=OFF');
+  for (const objectName of RESETTABLE_OBJECTS) {
+    await conn.execute(`DROP TABLE IF EXISTS ${objectName}`);
+  }
+  await conn.execute('PRAGMA foreign_keys=ON');
+}
+
+async function resetOutdatedBetaDatabase(conn: Database): Promise<void> {
+  const existingDatabase = await hasExistingUserDatabase(conn);
+  if (!existingDatabase) {
+    return;
+  }
+
+  const storedVersion = await getStoredSchemaVersion(conn);
+  if (storedVersion === CURRENT_SCHEMA_VERSION) {
+    return;
+  }
+
+  await resetDatabaseForCurrentSchema(
+    conn,
+    storedVersion ? `schema-${storedVersion}-to-${CURRENT_SCHEMA_VERSION}` : `schema-missing-to-${CURRENT_SCHEMA_VERSION}`,
+  );
+}
+
 /** Run migrations on app startup */
 export async function initDatabase(): Promise<void> {
   const conn = await getDb();
@@ -112,6 +199,7 @@ export async function initDatabase(): Promise<void> {
   for (let i = 0; i < 8; i++) {
     await execute('PRAGMA busy_timeout=10000');
   }
+  await resetOutdatedBetaDatabase(conn);
 
   await conn.execute(`
     CREATE TABLE IF NOT EXISTS projects (
@@ -477,7 +565,10 @@ export async function initDatabase(): Promise<void> {
   }
 
   await conn.execute(
-    "INSERT OR IGNORE INTO app_settings (key, value) VALUES ('schema_version', '1')"
+    `INSERT INTO app_settings (key, value)
+     VALUES ('schema_version', $1)
+     ON CONFLICT(key) DO UPDATE SET value = $1`,
+    [CURRENT_SCHEMA_VERSION],
   );
 
   // ── Phrase Memory schema ─────────────────────────────────────────────
@@ -606,6 +697,26 @@ export async function initDatabase(): Promise<void> {
     );
   }
 
+  const workspaceCheck = await conn.select<Array<{ count: number }>>(
+    `SELECT COUNT(*) as count FROM workspaces`
+  );
+  if ((workspaceCheck[0]?.count ?? 0) === 0) {
+    await conn.execute(`
+      INSERT OR IGNORE INTO workspaces (id, name, description, embedding_model, created_at)
+      VALUES ('ws_default', 'Default', NULL, 'text-embedding-3-small', datetime('now'))
+    `);
+    await conn.execute(`
+      UPDATE projects
+      SET workspace_id = 'ws_default'
+      WHERE workspace_id IS NULL OR workspace_id = ''
+    `);
+    await conn.execute(`
+      UPDATE app_settings
+      SET value = 'ws_default'
+      WHERE key = 'active_workspace_id' AND (value IS NULL OR value = '')
+    `);
+  }
+
   const { seedBuiltinPresets } = await import('./phraseMemoryPresetService');
   await seedBuiltinPresets(conn);
 
diff --git a/src/services/phraseMemoryService.ts b/src/services/phraseMemoryService.ts
index 10a8762..ff3c121 100644
--- a/src/services/phraseMemoryService.ts
+++ b/src/services/phraseMemoryService.ts
@@ -92,6 +92,40 @@ type RawPhraseMatch = {
   distance: number;
 };
 
+type RawPhraseMemoryEntry = {
+  id: string;
+  workspace_id: string;
+  source_phrase: string;
+  target_phrase: string;
+  source_language: string;
+  target_language: string;
+  author: string | null;
+  work: string | null;
+  domain: string | null;
+  tags: string | null;
+  notes: string | null;
+  chunk_id: string | null;
+  project_id: string | null;
+  created_at: string;
+};
+
+export interface PhraseMemoryEntry {
+  id: string;
+  workspaceId: string;
+  sourcePhrase: string;
+  targetPhrase: string;
+  sourceLanguage: string;
+  targetLanguage: string;
+  author: string | null;
+  work: string | null;
+  domain: string | null;
+  tags: string | null;
+  notes: string | null;
+  chunkId: string | null;
+  projectId: string | null;
+  createdAt: string;
+}
+
 export async function searchPhraseMemory(options: SearchOptions): Promise<PhraseMatch[]> {
   const { workspaceId, embeddingModel, queryText, threshold, maxResults } = options;
   const [queryEmbedding] = await fetchEmbeddings([queryText], embeddingModel);
@@ -109,6 +143,64 @@ export async function searchPhraseMemory(options: SearchOptions): Promise<Phrase
   }));
 }
 
+function toPhraseMemoryEntry(raw: RawPhraseMemoryEntry): PhraseMemoryEntry {
+  return {
+    id: raw.id,
+    workspaceId: raw.workspace_id,
+    sourcePhrase: raw.source_phrase,
+    targetPhrase: raw.target_phrase,
+    sourceLanguage: raw.source_language,
+    targetLanguage: raw.target_language,
+    author: raw.author,
+    work: raw.work,
+    domain: raw.domain,
+    tags: raw.tags,
+    notes: raw.notes,
+    chunkId: raw.chunk_id,
+    projectId: raw.project_id,
+    createdAt: raw.created_at,
+  };
+}
+
+export async function listPhraseMemoryEntries(workspaceId: string): Promise<PhraseMemoryEntry[]> {
+  const raw = await invoke<RawPhraseMemoryEntry[]>('vec_list_phrase_memory', { workspaceId });
+  return raw.map(toPhraseMemoryEntry);
+}
+
+export async function deletePhraseMemoryEntry(
+  workspaceId: string,
+  phraseMemoryId: string,
+): Promise<void> {
+  await invoke('vec_delete_phrase_memory', { workspaceId, phraseMemoryId });
+}
+
+export async function updatePhraseMemoryEntry(options: {
+  workspaceId: string;
+  phraseMemoryId: string;
+  embeddingModel: EmbeddingModel;
+  sourcePhrase: string;
+  targetPhrase: string;
+}): Promise<void> {
+  const sourcePhrase = options.sourcePhrase.trim();
+  const targetPhrase = options.targetPhrase.trim();
+  if (!sourcePhrase || !targetPhrase) {
+    throw new Error('Source and target phrases are required.');
+  }
+
+  const [embedding] = await fetchEmbeddings([sourcePhrase], options.embeddingModel);
+  if (!embedding) {
+    throw new Error('Embedding generation failed.');
+  }
+
+  await invoke('vec_update_phrase_memory', {
+    workspaceId: options.workspaceId,
+    phraseMemoryId: options.phraseMemoryId,
+    sourcePhrase,
+    targetPhrase,
+    embedding,
+  });
+}
+
 // ── Batch search pre-pipeline ────────────────────────────────────────
 
 export interface BatchSearchOptions {
@@ -162,21 +254,47 @@ export interface SaveSelectedPhrasesOptions {
   onProgress?: (done: number, total: number) => void;
 }
 
-export async function saveSelectedPhrases(options: SaveSelectedPhrasesOptions): Promise<void> {
+export async function saveSelectedPhrases(options: SaveSelectedPhrasesOptions): Promise<number> {
   const {
     workspaceId, projectId, embeddingModel, splitter, minPhraseLength,
     sourceLanguage, targetLanguage, chunks, onProgress,
   } = options;
+  logger.debug('phrase_memory.save_selected.start', {
+    workspaceId,
+    projectId,
+    chunkCount: chunks.length,
+    embeddingModel,
+    splitter,
+    minPhraseLength,
+    sourceLanguage,
+    targetLanguage,
+  });
   const total = chunks.length;
+  let savedTotal = 0;
   for (let i = 0; i < chunks.length; i++) {
     const chunk = chunks[i];
-    await savePhrasePairs({
+    const savedForChunk = await savePhrasePairs({
       workspaceId, projectId, chunkId: chunk.id, embeddingModel,
       splitter, sourceText: chunk.sourceText, targetText: chunk.targetText,
       minPhraseLength, sourceLanguage, targetLanguage,
     });
+    savedTotal += savedForChunk;
+    logger.debug('phrase_memory.save_selected.chunk_done', {
+      workspaceId,
+      projectId,
+      chunkId: chunk.id,
+      savedForChunk,
+      savedTotal,
+    });
     onProgress?.(i + 1, total);
   }
+  logger.info('phrase_memory.save_selected.done', {
+    workspaceId,
+    projectId,
+    chunkCount: chunks.length,
+    savedTotal,
+  });
+  return savedTotal;
 }
 
 // ── Save phrase pairs ────────────────────────────────────────────────
@@ -194,7 +312,7 @@ export interface SavePhrasePairsOptions {
   targetLanguage: string;
 }
 
-export async function savePhrasePairs(options: SavePhrasePairsOptions): Promise<void> {
+export async function savePhrasePairs(options: SavePhrasePairsOptions): Promise<number> {
   const {
     workspaceId, projectId, chunkId, embeddingModel, splitter,
     sourceText, targetText, minPhraseLength, sourceLanguage, targetLanguage,
@@ -203,23 +321,77 @@ export async function savePhrasePairs(options: SavePhrasePairsOptions): Promise<
   const sourcePhrases = await splitPhrases(sourceText, splitter);
   const targetPhrases = await splitPhrases(targetText, splitter);
   const pairCount = Math.min(sourcePhrases.length, targetPhrases.length);
-  if (pairCount === 0) return;
+  logger.debug('phrase_memory.save_pairs.split', {
+    workspaceId,
+    projectId,
+    chunkId,
+    splitter,
+    sourcePhraseCount: sourcePhrases.length,
+    targetPhraseCount: targetPhrases.length,
+    pairCount,
+  });
+  if (pairCount === 0) return 0;
 
   const paired = sourcePhrases
     .slice(0, pairCount)
     .map((sp, i) => ({ sourcePhrase: sp, targetPhrase: targetPhrases[i] }))
     .filter((p) => p.sourcePhrase.length >= minPhraseLength);
 
-  if (paired.length === 0) return;
+  logger.debug('phrase_memory.save_pairs.filtered', {
+    workspaceId,
+    projectId,
+    chunkId,
+    candidatePairCount: paired.length,
+    minPhraseLength,
+  });
 
+  if (paired.length === 0) return 0;
+
+  logger.debug('phrase_memory.save_pairs.embedding_start', {
+    workspaceId,
+    projectId,
+    chunkId,
+    embeddingModel,
+    candidatePairCount: paired.length,
+  });
   const sourceVectors = await fetchEmbeddings(paired.map((p) => p.sourcePhrase), embeddingModel);
-  const pairs = paired.map((p, i) => ({
-    sourcePhrase: p.sourcePhrase,
-    targetPhrase: p.targetPhrase,
-    sourceEmbedding: sourceVectors[i] ?? [],
-  }));
+  if (sourceVectors.length !== paired.length) {
+    logger.warn('phrase_memory.save_pairs.embedding_count_mismatch', {
+      workspaceId,
+      projectId,
+      chunkId,
+      expected: paired.length,
+      received: sourceVectors.length,
+    });
+  }
+  const pairs = paired.flatMap((p, i) => {
+    const sourceEmbedding = sourceVectors[i];
+    return sourceEmbedding?.length
+      ? [{ sourcePhrase: p.sourcePhrase, targetPhrase: p.targetPhrase, sourceEmbedding }]
+      : [];
+  });
 
-  await invoke('vec_save_locked_phrases', {
+  if (pairs.length === 0) {
+    logger.warn('phrase_memory.save_pairs.no_valid_embeddings', {
+      workspaceId,
+      projectId,
+      chunkId,
+      candidatePairCount: paired.length,
+      embeddingCount: sourceVectors.length,
+    });
+    return 0;
+  }
+
+  const savedCount = await invoke<number>('vec_save_locked_phrases', {
     workspaceId, projectId, chunkId, pairs, minPhraseLength, sourceLanguage, targetLanguage,
   });
+  logger.info('phrase_memory.save_pairs.insert_done', {
+    workspaceId,
+    projectId,
+    chunkId,
+    candidatePairCount: paired.length,
+    embeddingCount: sourceVectors.length,
+    savedCount,
+  });
+  return savedCount;
 }
diff --git a/src/stores/libraryStore.ts b/src/stores/libraryStore.ts
index e059d9c..2298916 100644
--- a/src/stores/libraryStore.ts
+++ b/src/stores/libraryStore.ts
@@ -11,7 +11,7 @@ import {
   upsertGlossaryEntries,
 } from '../services/glossaryService';
 
-export type LibraryTab = 'dictionaries' | 'templates';
+export type LibraryTab = 'dictionaries' | 'templates' | 'memories';
 
 interface LibraryState {
   showLibraryPanel: boolean;
diff --git a/src/stores/uiStore.ts b/src/stores/uiStore.ts
index 6f69f53..25cdc5f 100644
--- a/src/stores/uiStore.ts
+++ b/src/stores/uiStore.ts
@@ -10,6 +10,7 @@ export type InsightsDrawerTab = 'index' | 'search' | 'stats' | 'coherence' | 'gl
 export type ChunkDrawerTab = 'audit' | 'notes' | 'operations' | 'memory';
 export type RunPhase = 'test' | 'production';
 export type DocumentPaneFocus = 'both' | 'source' | 'translation';
+export type HelpSection = 'overview' | 'pipeline' | 'features' | 'context' | 'audit' | 'projects' | 'providers' | 'ollama' | 'glossary' | 'shortcuts' | 'troubleshooting' | 'design';
 
 interface UiState {
   viewMode: ViewMode;
@@ -19,6 +20,7 @@ interface UiState {
   selectedChunkId: string | null;
   showSettings: boolean;
   showHelp: boolean;
+  helpSection: HelpSection;
   showConfigDrawer: boolean;
   showDocumentDrawer: boolean;
   documentDrawerTab: InsightsDrawerTab;
@@ -69,7 +71,7 @@ interface UiState {
   setSyncScrollEnabled: (enabled: boolean) => void;
   setSelectedChunkId: (chunkId: string | null) => void;
   setShowSettings: (show: boolean) => void;
-  setShowHelp: (show: boolean) => void;
+  setShowHelp: (show: boolean, section?: HelpSection) => void;
   setShowConfigDrawer: (show: boolean) => void;
   setShowDocumentDrawer: (show: boolean, tab?: InsightsDrawerTab) => void;
   setDocumentDrawerTab: (tab: InsightsDrawerTab) => void;
@@ -99,6 +101,7 @@ export const useUiStore = create<UiState>()(
   selectedChunkId: null,
   showSettings: false,
   showHelp: false,
+  helpSection: 'overview',
   showConfigDrawer: false,
   showDocumentDrawer: false,
   documentDrawerTab: 'index',
@@ -151,11 +154,12 @@ export const useUiStore = create<UiState>()(
           }
         : { showSettings: false, showHelp: state.showHelp },
     ),
-  setShowHelp: (show) =>
+  setShowHelp: (show, section) =>
     set((state) =>
       show
         ? {
             showHelp: true,
+            helpSection: section ?? 'overview',
             showSettings: false,
             showConfigDrawer: false,
             showDocumentDrawer: false,