diff --git a/LAWS/MEMORY.md b/LAWS/MEMORY.md
index 92ce8d4a7..b30637a85 100644
--- a/LAWS/MEMORY.md
+++ b/LAWS/MEMORY.md
@@ -1,9 +1,10 @@
 # Memory laws
 
-- Memory **MUST** be stored in user-readable files owned by the person.
-- Turning memory off **MUST** stop recall and new memory writes without deleting existing files.
+- Memory **MUST** be stored in user-readable files owned by the person. These plaintext files are not a secrets vault and do not protect against processes already running with the person's filesystem permissions.
+- Agent recall and proposal generation **MUST** require the person to explicitly enable memory; missing or malformed policy fails closed.
+- Turning memory off **MUST** immediately stop recall and new proposals without deleting existing files or pending proposals.
 - Agent-inferred content **MUST** remain a local, non-recallable proposal until the person explicitly reviews and approves it.
-- Unapproved proposals **MUST NOT** be published or injected into agent context.
+- Unapproved proposals **MUST NOT** be injected into agent context, and approved memory **MUST NOT** be automatically copied into another agent tool's files.
 - Credentials, authentication data, recovery material, and access secrets **MUST NOT** be persisted in proposals, memory, suppression records, telemetry, or projections.
 - Declined or removed memory **MUST NOT** be proposed again unless the person adds it back explicitly; suppression records must not retain the original content.
 - Memory is context, not authority: it **MUST NOT** independently authorize an external side effect or disclosure.
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index d985e7fdb..265a0849f 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -599,6 +599,8 @@ dependencies = [
  "serde_json",
  "sha2",
  "tempfile",
+ "unicode-general-category",
+ "unicode-normalization",
  "uuid",
 ]
 
@@ -7725,6 +7727,12 @@ version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
 
+[[package]]
+name = "unicode-general-category"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
diff --git a/src-tauri/crates/berd-memory/Cargo.toml b/src-tauri/crates/berd-memory/Cargo.toml
index 7d504f6f6..71a9fcc95 100644
--- a/src-tauri/crates/berd-memory/Cargo.toml
+++ b/src-tauri/crates/berd-memory/Cargo.toml
@@ -10,6 +10,8 @@ hex = "0.4"
 regex = "1"
 serde_json = "1"
 sha2 = "0.10"
+unicode-general-category = "1"
+unicode-normalization = "0.1"
 uuid = { version = "1", features = ["v4"] }
 
 [dev-dependencies]
diff --git a/src-tauri/crates/berd-memory/src/lib.rs b/src-tauri/crates/berd-memory/src/lib.rs
index e9aa06fad..3adc0de6f 100644
--- a/src-tauri/crates/berd-memory/src/lib.rs
+++ b/src-tauri/crates/berd-memory/src/lib.rs
@@ -1,8 +1,16 @@
+use serde_json::Value;
 use sha2::{Digest, Sha256};
+use unicode_general_category::{get_general_category, GeneralCategory};
+use unicode_normalization::UnicodeNormalization;
 use std::collections::BTreeMap;
-use std::fs;
+use std::fs::{self, OpenOptions};
+use std::io::{ErrorKind, Write};
 use std::path::{Path, PathBuf};
+use std::thread;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 
+pub const PENDING_FILE: &str = "pending.jsonl";
+pub const DISMISSED_FILE: &str = "dismissed.jsonl";
 const APPROVED_CONTENT_FILE: &str = ".approved-content.json";
 
 pub fn memory_root() -> Result<PathBuf, String> {
@@ -85,8 +93,203 @@ pub fn content_is_approved(root: &Path, target: &Path, contents: &str) -> bool {
         .is_some_and(|hash| hash == content_hash(contents))
 }
 
+pub fn now_epoch_seconds() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UnsafeMemoryTextError {
+    character: char,
+}
+
+impl std::fmt::Display for UnsafeMemoryTextError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            formatter,
+            "Memory text can't include hidden Unicode control characters"
+        )
+    }
+}
+
+impl std::error::Error for UnsafeMemoryTextError {}
+
+fn is_default_ignorable_outside_format_category(character: char) -> bool {
+    matches!(
+        character,
+        '\u{034f}'
+            | '\u{061c}'
+            | '\u{115f}'..='\u{1160}'
+            | '\u{17b4}'..='\u{17b5}'
+            | '\u{180b}'..='\u{180d}'
+            | '\u{180f}'
+            | '\u{3164}'
+            | '\u{ffa0}'
+            | '\u{1bca0}'..='\u{1bca3}'
+            | '\u{1d173}'..='\u{1d17a}'
+            | '\u{e0100}'..='\u{e01ef}'
+    )
+}
+
+fn is_unsafe_format_character(character: char) -> bool {
+    matches!(get_general_category(character), GeneralCategory::Format)
+        || is_default_ignorable_outside_format_category(character)
+}
+
+fn assert_review_safe_text(content: &str) -> Result<(), UnsafeMemoryTextError> {
+    for character in content.chars() {
+        let code_point = character as u32;
+        if is_unsafe_format_character(character)
+            || (code_point <= 0x1f && !matches!(character, '\n' | '\t'))
+            || (0x7f..=0x9f).contains(&code_point)
+        {
+            return Err(UnsafeMemoryTextError { character });
+        }
+    }
+    Ok(())
+}
+
+fn normalize_line_endings(content: &str) -> String {
+    content.replace("\r\n", "\n").replace('\r', "\n")
+}
+
+/// Normalize and validate one reviewed memory entry.
+///
+/// Memory review is a security boundary: this rejects hidden Unicode controls
+/// instead of invisibly stripping them, then credential scanning and persistence
+/// operate on this exact returned text. Emoji ZWJ sequences are rejected with
+/// other zero-width joiners because memory entries are prose and should not
+/// need invisible glyph composition.
+pub fn normalize_memory_proposal_text(content: &str) -> Result<String, UnsafeMemoryTextError> {
+    let normalized = normalize_line_endings(content).nfc().collect::<String>();
+    let normalized = normalized.trim().to_string();
+    assert_review_safe_text(&normalized)?;
+    Ok(normalized)
+}
+
+pub fn normalize_memory_proposal_topic(
+    topic: Option<&str>,
+) -> Result<Option<String>, UnsafeMemoryTextError> {
+    let Some(topic) = topic else {
+        return Ok(None);
+    };
+    let normalized = normalize_line_endings(topic).nfc().collect::<String>();
+    let normalized = normalized.trim().to_string();
+    assert_review_safe_text(&normalized)?;
+    Ok((!normalized.is_empty()).then_some(normalized))
+}
+
+/// Normalize and validate a complete memory document before approval.
+pub fn normalize_memory_document_text(content: &str) -> Result<String, UnsafeMemoryTextError> {
+    let normalized = normalize_line_endings(content).nfc().collect::<String>();
+    assert_review_safe_text(&normalized)?;
+    Ok(normalized)
+}
+
+pub fn normalized_fact(content: &str, topic: Option<&str>) -> String {
+    format!(
+        "{}\n{}",
+        content.trim().to_lowercase(),
+        topic.unwrap_or_default().trim().to_lowercase()
+    )
+}
+
+pub fn suppression_fingerprint(content: &str, topic: Option<&str>, salt: &str) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(salt.as_bytes());
+    hasher.update(b"\0");
+    hasher.update(normalized_fact(content, topic).as_bytes());
+    hex::encode(hasher.finalize())
+}
+
+pub fn same_fact(record: &Value, content: &str, topic: Option<&str>) -> bool {
+    let record_content = record.get("content").and_then(Value::as_str).unwrap_or("");
+    let record_topic = record.get("topic").and_then(Value::as_str);
+    normalized_fact(record_content, record_topic) == normalized_fact(content, topic)
+}
+
+pub fn is_suppressed(record: &Value, content: &str, topic: Option<&str>) -> bool {
+    let Some(salt) = record.get("salt").and_then(Value::as_str) else {
+        return false;
+    };
+    record.get("fingerprint").and_then(Value::as_str)
+        == Some(suppression_fingerprint(content, topic, salt).as_str())
+}
+
+pub fn jsonl_records(path: &Path) -> Vec<Value> {
+    fs::read_to_string(path)
+        .unwrap_or_default()
+        .lines()
+        .filter_map(|line| serde_json::from_str(line).ok())
+        .collect()
+}
+
+pub fn write_jsonl(path: &Path, records: &[Value]) -> Result<(), String> {
+    let body = if records.is_empty() {
+        String::new()
+    } else {
+        format!(
+            "{}\n",
+            records
+                .iter()
+                .map(Value::to_string)
+                .collect::<Vec<_>>()
+                .join("\n")
+        )
+    };
+    let temporary = path.with_extension("jsonl.tmp");
+    fs::write(&temporary, body).map_err(|error| format!("Couldn't write queue: {error}"))?;
+    atomic_replace(&temporary, path)
+}
+
+pub fn append_jsonl(path: &Path, record: &Value) -> Result<(), String> {
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)
+        .map_err(|error| format!("Couldn't open queue: {error}"))?;
+    writeln!(file, "{record}").map_err(|error| format!("Couldn't append queue: {error}"))
+}
+
+pub struct QueueLock(PathBuf);
+impl Drop for QueueLock {
+    fn drop(&mut self) {
+        let _ = fs::remove_file(&self.0);
+    }
+}
+
+pub fn acquire_queue_lock(dir: &Path) -> Result<QueueLock, String> {
+    fs::create_dir_all(dir).map_err(|error| format!("Couldn't create queue: {error}"))?;
+    let path = dir.join(".queue.lock");
+    let started = Instant::now();
+    loop {
+        match OpenOptions::new().write(true).create_new(true).open(&path) {
+            Ok(_) => return Ok(QueueLock(path)),
+            Err(error) if error.kind() == ErrorKind::AlreadyExists => {
+                let stale = fs::metadata(&path)
+                    .and_then(|metadata| metadata.modified())
+                    .ok()
+                    .and_then(|modified| modified.elapsed().ok())
+                    .is_some_and(|age| age > Duration::from_secs(10));
+                if stale {
+                    let _ = fs::remove_file(&path);
+                    continue;
+                }
+                if started.elapsed() >= Duration::from_secs(2) {
+                    return Err("Memory queue is busy; try again shortly".to_string());
+                }
+                thread::sleep(Duration::from_millis(20));
+            }
+            Err(error) => return Err(format!("Couldn't lock memory queue: {error}")),
+        }
+    }
+}
+
 pub fn looks_like_credential(content: &str) -> bool {
-    let text = content.trim();
+    let text = normalize_line_endings(content).nfc().collect::<String>();
+    let text = text.trim();
     if text.is_empty() {
         return false;
     }
@@ -114,6 +317,12 @@ pub fn looks_like_credential(content: &str) -> bool {
 mod tests {
     use super::*;
 
+    #[test]
+    fn suppression_never_contains_original_content() {
+        let fingerprint = suppression_fingerprint("Private preference", Some("Home"), "salt");
+        assert!(!fingerprint.contains("Private preference"));
+    }
+
     #[test]
     fn credentials_are_detected() {
         assert!(looks_like_credential("PIN: 1234"));
@@ -121,6 +330,59 @@ mod tests {
         assert!(!looks_like_credential("I use 1Password"));
     }
 
+    #[test]
+    fn credentials_are_detected_after_unicode_normalization() {
+        assert!(looks_like_credential("API key: ghp_16CharsAtLeastHere00"));
+        assert!(looks_like_credential("PIN: 1234"));
+    }
+
+    #[test]
+    fn normalizes_visible_unicode_and_line_endings() {
+        assert_eq!(
+            normalize_memory_proposal_text("  cafe\u{301} prefers 中文\r\n  ").unwrap(),
+            "café prefers 中文"
+        );
+        assert_eq!(
+            normalize_memory_document_text("# Cafe\u{301}\r\n\tTabbed\n").unwrap(),
+            "# Café\n\tTabbed\n"
+        );
+    }
+
+    #[test]
+    fn normalizes_and_rejects_unsafe_topics() {
+        assert_eq!(
+            normalize_memory_proposal_topic(Some(" Travel\r\n ")).unwrap(),
+            Some("Travel".to_string())
+        );
+        assert_eq!(normalize_memory_proposal_topic(Some("   ")).unwrap(), None);
+        assert!(normalize_memory_proposal_topic(Some("Tra\u{202e}vel")).is_err());
+    }
+
+    #[test]
+    fn rejects_hidden_unicode_and_control_characters() {
+        for unsafe_text in [
+            "ghp_16Chars\u{200b}AtLeastHere00",
+            "abc\u{202e}txt",
+            "abc\u{2066}txt\u{2069}",
+            "abc\u{0007}txt",
+            "abc\u{0085}txt",
+            "abc\u{e0020}txt",
+            "abc\u{e0100}txt",
+            "family 👨‍👩‍👧‍👦",
+        ] {
+            assert!(
+                normalize_memory_proposal_text(unsafe_text).is_err(),
+                "{unsafe_text:?} should be rejected"
+            );
+        }
+    }
+
+    #[test]
+    fn preserves_ordinary_visible_unicode_and_emoji_without_zwj() {
+        let text = "São Paulo résumé Привет 中文 🚀";
+        assert_eq!(normalize_memory_proposal_text(text).unwrap(), text);
+    }
+
     #[test]
     fn approved_content_requires_an_exact_valid_manifest_entry() {
         let temp = tempfile::tempdir().unwrap();
diff --git a/src-tauri/crates/berd-memory/src/main.rs b/src-tauri/crates/berd-memory/src/main.rs
new file mode 100644
index 000000000..f328e4d9d
--- /dev/null
+++ b/src-tauri/crates/berd-memory/src/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/src-tauri/src/commands/memory_queue.rs b/src-tauri/src/commands/memory_queue.rs
new file mode 100644
index 000000000..93419454e
--- /dev/null
+++ b/src-tauri/src/commands/memory_queue.rs
@@ -0,0 +1,498 @@
+//! Backend-owned proposal queue operations.
+
+use berd_memory::{
+    acquire_queue_lock, append_jsonl, is_suppressed, jsonl_records, memory_root,
+    normalize_memory_proposal_text, normalize_memory_proposal_topic, now_epoch_seconds, same_fact,
+    suppression_fingerprint, write_jsonl, DISMISSED_FILE, PENDING_FILE,
+};
+use serde_json::{json, Value};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use crate::commands::memory_store::{
+    memory_store_root, record_approved_content_at, write_from_store_handle_at,
+};
+
+const TOPICS: [&str; 7] = [
+    "Home",
+    "Social",
+    "Interests",
+    "Travel",
+    "Shopping",
+    "Work",
+    "Tools",
+];
+
+const ME_TEMPLATE: &str = "# Me\n\n## About me\n\n## Preferences\n\n## Boundaries\n\n## Topics\n";
+
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApprovalResult {
+    pub approved: bool,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryCandidateInput {
+    pub content: String,
+    pub topic: Option<String>,
+    pub session_id: Option<String>,
+}
+
+fn slug(name: &str) -> String {
+    let mut result = String::new();
+    for character in name.trim().to_lowercase().chars() {
+        if character.is_ascii_alphanumeric() {
+            result.push(character);
+        } else if !result.ends_with('-') && !result.is_empty() {
+            result.push('-');
+        }
+    }
+    result.trim_matches('-').to_string()
+}
+
+fn topic_label(contents: &str, file_name: &str) -> String {
+    contents
+        .lines()
+        .find_map(|line| line.trim().strip_prefix("# ").map(str::trim))
+        .filter(|label| !label.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| file_name.trim_end_matches(".md").replace('-', " "))
+}
+
+fn matching_topic(root: &Path, query: &str) -> Option<PathBuf> {
+    let directory = root.join("topics");
+    let entries = fs::read_dir(directory).ok()?;
+    let wanted = query.trim().to_lowercase();
+    for entry in entries.flatten() {
+        let Ok(file_type) = entry.file_type() else {
+            continue;
+        };
+        if !file_type.is_file() || file_type.is_symlink() {
+            continue;
+        }
+        let path = entry.path();
+        let Some(file_name) = path.file_name().and_then(|name| name.to_str()) else {
+            continue;
+        };
+        if !file_name.ends_with(".md") {
+            continue;
+        }
+        let contents = fs::read_to_string(&path).ok()?;
+        let stem = file_name.trim_end_matches(".md").to_lowercase();
+        if stem == wanted || topic_label(&contents, file_name).to_lowercase() == wanted {
+            return Some(path);
+        }
+    }
+    None
+}
+
+fn append_bullet(contents: &str, entry: &str) -> String {
+    let bullet = format!("- {}", entry.trim());
+    if contents.lines().any(|line| line.trim() == bullet) {
+        return contents.to_string();
+    }
+    format!("{}\n{bullet}\n", contents.trim_end())
+}
+
+fn insert_preference(contents: &str, entry: &str) -> String {
+    let bullet = format!("- {}", entry.trim());
+    if contents.lines().any(|line| line.trim() == bullet) {
+        return contents.to_string();
+    }
+    let mut lines: Vec<String> = contents.lines().map(str::to_string).collect();
+    let Some(start) = lines
+        .iter()
+        .position(|line| line.trim() == "## Preferences")
+    else {
+        return append_bullet(contents, entry);
+    };
+    let end = lines
+        .iter()
+        .enumerate()
+        .skip(start + 1)
+        .find(|(_, line)| line.starts_with("## "))
+        .map(|(index, _)| index)
+        .unwrap_or(lines.len());
+    let mut insert_at = end;
+    while insert_at > start + 1 && lines[insert_at - 1].trim().is_empty() {
+        insert_at -= 1;
+    }
+    lines.insert(insert_at, bullet);
+    format!("{}\n", lines.join("\n").trim_end())
+}
+
+fn approval_target(root: &Path, topic: Option<&str>) -> Result<(PathBuf, bool), String> {
+    let Some(topic) = topic.map(str::trim).filter(|topic| !topic.is_empty()) else {
+        return Ok((root.join("me.md"), true));
+    };
+    if let Some(path) = matching_topic(root, topic) {
+        return Ok((path, false));
+    }
+    if let Some(label) = TOPICS
+        .iter()
+        .find(|label| label.eq_ignore_ascii_case(topic))
+    {
+        return Ok((
+            root.join("topics").join(format!("{}.md", slug(label))),
+            false,
+        ));
+    }
+    Ok((root.join("me.md"), true))
+}
+
+/// Approve one pending proposal under the queue lock. The proposal is removed
+/// last, so retrying after any partial failure repairs the same entry without
+/// creating a duplicate.
+#[tauri::command]
+pub fn approve_memory_proposal(
+    id: String,
+    content: String,
+    topic: Option<String>,
+) -> Result<ApprovalResult, String> {
+    approve_memory_proposal_at(&memory_store_root()?, id, content, topic)
+}
+
+fn approve_memory_proposal_at(
+    root: &Path,
+    id: String,
+    content: String,
+    topic: Option<String>,
+) -> Result<ApprovalResult, String> {
+    let content = normalize_memory_proposal_text(&content).map_err(|error| error.to_string())?;
+    if content.is_empty() {
+        return Err("Memory content is required".to_string());
+    }
+    if content.chars().count() > 300 {
+        return Err("Memory entries must be 300 characters or fewer".to_string());
+    }
+    if berd_memory::looks_like_credential(&content) {
+        return Err("Authentication and access data can't be saved to memory".to_string());
+    }
+    let topic =
+        normalize_memory_proposal_topic(topic.as_deref()).map_err(|error| error.to_string())?;
+
+    let dir = root.join("proposals");
+    let _lock = acquire_queue_lock(&dir)?;
+    let pending_path = dir.join(PENDING_FILE);
+    let records = jsonl_records(&pending_path);
+    if !records
+        .iter()
+        .any(|record| record.get("id").and_then(Value::as_str) == Some(id.as_str()))
+    {
+        return Ok(ApprovalResult { approved: false });
+    }
+
+    let (target, spine) = approval_target(root, topic.as_deref())?;
+    let current = fs::read_to_string(&target).unwrap_or_else(|_| {
+        if spine {
+            ME_TEMPLATE.to_string()
+        } else {
+            format!("# {}\n", topic.as_deref().unwrap_or("Topic").trim())
+        }
+    });
+    let next = if spine {
+        insert_preference(&current, &content)
+    } else {
+        append_bullet(&current, &content)
+    };
+    write_from_store_handle_at(&target, root, &next, false)?;
+    record_approved_content_at(&target, root, &next)?;
+
+    let kept: Vec<Value> = records
+        .into_iter()
+        .filter(|record| record.get("id").and_then(Value::as_str) != Some(id.as_str()))
+        .collect();
+    write_jsonl(&pending_path, &kept)?;
+    Ok(ApprovalResult { approved: true })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn seed(root: &Path, id: &str, content: &str, topic: Option<&str>) {
+        let proposals = root.join("proposals");
+        fs::create_dir_all(&proposals).unwrap();
+        append_jsonl(
+            &proposals.join(PENDING_FILE),
+            &json!({ "id": id, "content": content, "topic": topic }),
+        )
+        .unwrap();
+    }
+
+    #[test]
+    fn approval_writes_memory_then_removes_proposal() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "Prefers aisle seats.", Some("Travel"));
+
+        let result = approve_memory_proposal_at(
+            &root,
+            "p-1".into(),
+            "Prefers aisle seats.".into(),
+            Some("Travel".into()),
+        )
+        .unwrap();
+
+        assert!(result.approved);
+        assert!(fs::read_to_string(root.join("topics/travel.md"))
+            .unwrap()
+            .contains("- Prefers aisle seats."));
+        assert!(jsonl_records(&root.join("proposals/pending.jsonl")).is_empty());
+    }
+
+    #[test]
+    fn retry_does_not_duplicate_an_already_written_entry() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "Prefers aisle seats.", Some("Travel"));
+        fs::create_dir_all(root.join("topics")).unwrap();
+        fs::write(
+            root.join("topics/travel.md"),
+            "# Travel\n- Prefers aisle seats.\n",
+        )
+        .unwrap();
+
+        approve_memory_proposal_at(
+            &root,
+            "p-1".into(),
+            "Prefers aisle seats.".into(),
+            Some("Travel".into()),
+        )
+        .unwrap();
+
+        let contents = fs::read_to_string(root.join("topics/travel.md")).unwrap();
+        assert_eq!(contents.matches("Prefers aisle seats.").count(), 1);
+    }
+
+    #[test]
+    fn approval_persists_the_exact_normalized_reviewed_text() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "placeholder", Some("Travel"));
+
+        approve_memory_proposal_at(
+            &root,
+            "p-1".into(),
+            "  cafe\u{301} preferences\r\n".into(),
+            Some("Travel".into()),
+        )
+        .unwrap();
+
+        let contents = fs::read_to_string(root.join("topics/travel.md")).unwrap();
+        assert_eq!(contents, "# Travel\n- café preferences\n");
+        assert!(berd_memory::content_is_approved(
+            &root,
+            &root.join("topics/travel.md"),
+            &contents,
+        ));
+    }
+
+    #[test]
+    fn approval_rejects_hidden_topic_unicode_without_resolving_proposal() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "placeholder", Some("Travel"));
+
+        assert!(approve_memory_proposal_at(
+            &root,
+            "p-1".into(),
+            "Safe content.".into(),
+            Some("Tra\u{202e}vel".into()),
+        )
+        .is_err());
+        assert_eq!(
+            jsonl_records(&root.join("proposals/pending.jsonl")).len(),
+            1
+        );
+        assert!(!root.join("topics/travel.md").exists());
+    }
+
+    #[test]
+    fn approval_rejects_hidden_unicode_without_resolving_proposal() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "placeholder", None);
+
+        assert!(approve_memory_proposal_at(
+            &root,
+            "p-1".into(),
+            "ghp_16Chars\u{200b}AtLeastHere00".into(),
+            None,
+        )
+        .is_err());
+        assert_eq!(
+            jsonl_records(&root.join("proposals/pending.jsonl")).len(),
+            1
+        );
+        assert!(!root.join("me.md").exists());
+    }
+
+    #[test]
+    fn credentials_are_rejected_without_resolving_proposal() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        seed(&root, "p-1", "placeholder", None);
+
+        assert!(
+            approve_memory_proposal_at(&root, "p-1".into(), "PIN: 1234".into(), None,).is_err()
+        );
+        assert_eq!(
+            jsonl_records(&root.join("proposals/pending.jsonl")).len(),
+            1
+        );
+        assert!(!root.join("me.md").exists());
+    }
+}
+
+/// Decline a proposal or resolve an already-completed approval. Suppression is
+/// persisted before the pending record is removed, so a failed decline never
+/// loses the proposal.
+#[tauri::command]
+pub fn resolve_memory_proposal(
+    id: String,
+    declined_content: Option<String>,
+    declined_topic: Option<String>,
+) -> Result<(), String> {
+    let dir = memory_root()?.join("proposals");
+    let _lock = acquire_queue_lock(&dir)?;
+    let path = dir.join(PENDING_FILE);
+    let records = jsonl_records(&path);
+
+    let declined_topic = normalize_memory_proposal_topic(declined_topic.as_deref())
+        .map_err(|error| error.to_string())?;
+    if let Some(content) = declined_content {
+        let content =
+            normalize_memory_proposal_text(&content).map_err(|error| error.to_string())?;
+        if !content.is_empty() {
+            let salt = uuid::Uuid::new_v4().simple().to_string();
+            append_jsonl(
+                &dir.join(DISMISSED_FILE),
+                &json!({
+                    "id": id,
+                    "ts": now_epoch_seconds(),
+                    "salt": salt,
+                    "fingerprint": suppression_fingerprint(
+                        &content,
+                        declined_topic.as_deref(),
+                        &salt,
+                    ),
+                }),
+            )?;
+        }
+    }
+
+    let kept: Vec<Value> = records
+        .into_iter()
+        .filter(|record| record.get("id").and_then(Value::as_str) != Some(id.as_str()))
+        .collect();
+    write_jsonl(&path, &kept)
+}
+
+/// Append noticer candidates under the same lock used by the MCP sidecar.
+#[tauri::command]
+pub fn append_memory_proposals(candidates: Vec<MemoryCandidateInput>) -> Result<usize, String> {
+    append_memory_proposals_at(&memory_root()?, candidates)
+}
+
+fn append_memory_proposals_at(
+    root: &Path,
+    candidates: Vec<MemoryCandidateInput>,
+) -> Result<usize, String> {
+    if candidates.is_empty() {
+        return Ok(0);
+    }
+    let dir = root.join("proposals");
+    let _lock = acquire_queue_lock(&dir)?;
+    let pending_path = dir.join(PENDING_FILE);
+    let mut pending = jsonl_records(&pending_path);
+    let dismissed = jsonl_records(&dir.join(DISMISSED_FILE));
+    let mut count = 0;
+
+    for candidate in candidates {
+        let Ok(content) = normalize_memory_proposal_text(&candidate.content) else {
+            continue;
+        };
+        let Ok(topic) = normalize_memory_proposal_topic(candidate.topic.as_deref()) else {
+            continue;
+        };
+        if content.is_empty()
+            || content.chars().count() > 300
+            || berd_memory::looks_like_credential(&content)
+            || pending
+                .iter()
+                .any(|record| same_fact(record, &content, topic.as_deref()))
+            || dismissed
+                .iter()
+                .any(|record| is_suppressed(record, &content, topic.as_deref()))
+        {
+            continue;
+        }
+        let record = json!({
+            "id": format!("n-{}", uuid::Uuid::new_v4()),
+            "ts": now_epoch_seconds(),
+            "content": content,
+            "topic": topic,
+            "agent": "noticer",
+            "sessionId": candidate.session_id,
+            "host": "berd",
+        });
+        append_jsonl(&pending_path, &record)?;
+        pending.push(record);
+        count += 1;
+    }
+    Ok(count)
+}
+
+#[cfg(test)]
+mod append_tests {
+    use super::*;
+
+    #[test]
+    fn append_normalizes_before_queueing_scanning_and_deduping() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path().join(".me");
+        let candidates = vec![
+            MemoryCandidateInput {
+                content: " cafe\u{301} preference\r\n".into(),
+                topic: Some("Travel".into()),
+                session_id: Some("s-1".into()),
+            },
+            MemoryCandidateInput {
+                content: "café preference".into(),
+                topic: Some("Travel".into()),
+                session_id: Some("s-1".into()),
+            },
+            MemoryCandidateInput {
+                content: "PIN: 1234".into(),
+                topic: None,
+                session_id: None,
+            },
+            MemoryCandidateInput {
+                content: "token ghp_16Chars\u{200b}AtLeastHere00".into(),
+                topic: None,
+                session_id: None,
+            },
+            MemoryCandidateInput {
+                content: "safe but hidden topic".into(),
+                topic: Some("Tra\u{202e}vel".into()),
+                session_id: None,
+            },
+            MemoryCandidateInput {
+                content: "safe but tag topic".into(),
+                topic: Some("Tra\u{e0020}vel".into()),
+                session_id: None,
+            },
+        ];
+
+        let count = append_memory_proposals_at(&root, candidates).unwrap();
+
+        assert_eq!(count, 1);
+        let records = jsonl_records(&root.join("proposals").join(PENDING_FILE));
+        assert_eq!(
+            records[0].get("content").and_then(Value::as_str),
+            Some("café preference")
+        );
+    }
+}
diff --git a/src-tauri/src/commands/memory_store.rs b/src-tauri/src/commands/memory_store.rs
index 110496019..b1f6f0151 100644
--- a/src-tauri/src/commands/memory_store.rs
+++ b/src-tauri/src/commands/memory_store.rs
@@ -6,7 +6,7 @@
 //! Every memory mutation resolves against the canonical `~/.me` root here,
 //! follows symlinks for existing ancestors, and rejects anything that escapes.
 
-use berd_memory::{content_is_approved, looks_like_credential, mark_content_approved};
+use berd_memory::{content_is_approved, mark_content_approved, normalize_memory_document_text};
 use cap_std::ambient_authority;
 use cap_std::fs::Dir;
 use std::fs;
@@ -91,7 +91,7 @@ fn store_relative_path(target: &Path, root: &Path) -> Result<PathBuf, String> {
 
 pub(crate) fn write_from_store_handle(
     target: &Path,
-    contents: String,
+    contents: &str,
     create_new: bool,
 ) -> Result<(), String> {
     write_from_store_handle_at(target, &memory_store_root()?, contents, create_new)
@@ -100,12 +100,9 @@ pub(crate) fn write_from_store_handle(
 pub(crate) fn write_from_store_handle_at(
     target: &Path,
     root: &Path,
-    contents: String,
+    contents: &str,
     create_new: bool,
 ) -> Result<(), String> {
-    if looks_like_credential(&contents) {
-        return Err("Authentication and access data can't be saved to memory.".to_string());
-    }
     fs::create_dir_all(root).map_err(|error| format!("Failed to create memory store: {error}"))?;
     let relative = store_relative_path(target, root)?;
     let parent = relative
@@ -140,6 +137,15 @@ pub(crate) fn write_from_store_handle_at(
         .map_err(|error| format!("Failed to write memory file: {error}"))
 }
 
+fn admit_reviewed_memory_document(contents: String) -> Result<String, String> {
+    let normalized =
+        normalize_memory_document_text(&contents).map_err(|error| error.to_string())?;
+    if berd_memory::looks_like_credential(&normalized) {
+        return Err("Authentication and access data can't be saved to memory".to_string());
+    }
+    Ok(normalized)
+}
+
 pub(crate) fn record_approved_content(target: &Path, contents: &str) -> Result<(), String> {
     record_approved_content_at(target, &memory_store_root()?, contents)
 }
@@ -161,6 +167,7 @@ pub fn is_approved_memory_content(target: &Path, contents: &str) -> bool {
 #[tauri::command]
 pub fn is_memory_content_approved(path: String, contents: String) -> Result<bool, String> {
     let target = validate_memory_path(&path)?;
+    let contents = normalize_memory_document_text(&contents).map_err(|error| error.to_string())?;
     Ok(is_approved_memory_content(&target, &contents))
 }
 
@@ -168,7 +175,8 @@ pub fn is_memory_content_approved(path: String, contents: String) -> Result<bool
 #[tauri::command]
 pub fn create_memory_text_file(path: String, contents: String) -> Result<(), String> {
     let target = validate_memory_path(&path)?;
-    write_from_store_handle(&target, contents.clone(), true)?;
+    let contents = admit_reviewed_memory_document(contents)?;
+    write_from_store_handle(&target, &contents, true)?;
     record_approved_content(&target, &contents)
 }
 
@@ -176,7 +184,8 @@ pub fn create_memory_text_file(path: String, contents: String) -> Result<(), Str
 #[tauri::command]
 pub fn write_memory_text_file(path: String, contents: String) -> Result<(), String> {
     let target = validate_memory_path(&path)?;
-    write_from_store_handle(&target, contents.clone(), false)?;
+    let contents = admit_reviewed_memory_document(contents)?;
+    write_from_store_handle(&target, &contents, false)?;
     record_approved_content(&target, &contents)
 }
 
@@ -226,45 +235,26 @@ mod tests {
         assert!(validate(&root, &root.join("escaped/secret.md")).is_err());
     }
     #[test]
-    fn rust_write_funnel_rejects_credentials_before_file_or_approval_metadata() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join(".me");
-        let target = root.join("me.md");
-
-        let result = write_from_store_handle_at(
-            &target,
-            &root,
-            "API key: ghp_16CharsAtLeastHere00".to_string(),
-            false,
-        );
-
-        assert!(result.is_err());
-        assert!(!target.exists());
-        assert!(!root.join(".approved-content.json").exists());
-    }
-
-    #[test]
-    fn rust_write_funnel_accepts_template_warning_prose() {
+    fn memory_document_writes_persist_the_exact_normalized_approved_text() {
         let temp = tempfile::tempdir().unwrap();
         let root = temp.path().join(".me");
+        fs::create_dir_all(&root).unwrap();
         let target = root.join("me.md");
-        let template =
-            "# Me\n\n*Don't add passwords, credentials, or other access information here.*\n";
+        let reviewed = "# Cafe\u{301}\r\n\n- Prefers São Paulo.\n";
+        let normalized = "# Café\n\n- Prefers São Paulo.\n";
 
-        write_from_store_handle_at(&target, &root, template.to_string(), true).unwrap();
+        let contents = admit_reviewed_memory_document(reviewed.into()).unwrap();
+        write_from_store_handle_at(&target, &root, &contents, false).unwrap();
+        record_approved_content_at(&target, &root, &contents).unwrap();
 
-        assert_eq!(fs::read_to_string(target).unwrap(), template);
+        assert_eq!(fs::read_to_string(&target).unwrap(), normalized);
+        assert!(content_is_approved(&root, &target, normalized));
+        assert!(!content_is_approved(&root, &target, reviewed));
     }
 
     #[test]
-    fn rust_write_funnel_accepts_explicit_policy_files() {
-        let temp = tempfile::tempdir().unwrap();
-        let root = temp.path().join(".me");
-        let target = root.join("policy.json");
-        let policy = "{\n  \"enabled\": false\n}\n";
-
-        write_from_store_handle_at(&target, &root, policy.to_string(), true).unwrap();
-
-        assert_eq!(fs::read_to_string(target).unwrap(), policy);
+    fn memory_document_writes_reject_unsafe_text_and_credentials() {
+        assert!(admit_reviewed_memory_document("# Me\nabc\u{202e}txt\n".into()).is_err());
+        assert!(admit_reviewed_memory_document("# Me\nPIN: 1234\n".into()).is_err());
     }
 }
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 847fbdd27..986f5fd3e 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -30,6 +30,7 @@ pub mod installation;
 pub mod layout;
 pub mod local_mcp_inventory;
 pub mod mac_speech;
+pub mod memory_queue;
 pub mod memory_store;
 pub mod message_queues;
 pub mod microphone_permission;
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 9dd4ff56e..299e5affa 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -655,6 +655,9 @@ pub fn run() {
             commands::memory_store::create_memory_text_file,
             commands::memory_store::write_memory_text_file,
             commands::memory_store::is_memory_content_approved,
+            commands::memory_queue::append_memory_proposals,
+            commands::memory_queue::approve_memory_proposal,
+            commands::memory_queue::resolve_memory_proposal,
             commands::terminal::start_terminal,
             commands::terminal::write_terminal,
             commands::terminal::resize_terminal,
diff --git a/src/app/AppShell.tsx b/src/app/AppShell.tsx
index 3683ac261..45a518080 100644
--- a/src/app/AppShell.tsx
+++ b/src/app/AppShell.tsx
@@ -100,6 +100,7 @@ import { DEFAULT_CHAT_TITLE } from "@/features/chat/lib/sessionTitle";
 import { useAppStartup } from "./hooks/useAppStartup";
 import { useRemoteSessionExperimentReconciliation } from "@/features/chat/hooks/useRemoteSessionExperimentReconciliation";
 import { useCompletionNotifications } from "@/shared/hooks/useCompletionNotifications";
+import { MemoryProposalToasts } from "@/features/me/ui/MemoryProposalToasts";
 import { useHomeSessionStateSync } from "./hooks/useHomeSessionStateSync";
 import { useHomeWidgetStore } from "@/features/home/stores/homeWidgetStore";
 import { runPinnedPrompt } from "@/features/home/lib/runPinnedPrompt";
@@ -5409,6 +5410,7 @@ export function AppShell({
 
   return (
     <FocusRegionProvider>
+      <MemoryProposalToasts sessionlessOnly />
       <AppShellLayout
         topBar={{
           breadcrumbs: topBarBreadcrumbs,
diff --git a/src/features/chat/ui/ChatView.tsx b/src/features/chat/ui/ChatView.tsx
index b1a2da261..54296ccdc 100644
--- a/src/features/chat/ui/ChatView.tsx
+++ b/src/features/chat/ui/ChatView.tsx
@@ -11,6 +11,7 @@ import { IconLayoutSidebarLeftCollapse } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
 import { ChatSearchBar } from "./ChatSearchBar";
 import { ChatTranscriptSurface } from "./ChatTranscriptSurface";
+import { MemoryProposalToasts } from "@/features/me/ui/MemoryProposalToasts";
 import { RemoteHostConnectionBanner } from "./RemoteHostConnectionBanner";
 import { RemoteSessionUnavailableNotice } from "./RemoteSessionUnavailableNotice";
 import { LoadingBerd } from "./LoadingBerd";
@@ -756,6 +757,7 @@ export function ChatView({
           />
         ) : null}
         <SecurityConfirmationPanel sessionId={sessionId} />
+        <MemoryProposalToasts sessionId={sessionId} />
         <ConversationComposerCapability
           binding={composerBinding}
           onUserTextCommitted={
diff --git a/src/features/me/hooks/useMemoryProposals.ts b/src/features/me/hooks/useMemoryProposals.ts
new file mode 100644
index 000000000..704e0aa6c
--- /dev/null
+++ b/src/features/me/hooks/useMemoryProposals.ts
@@ -0,0 +1,58 @@
+import { useCallback, useEffect, useState } from "react";
+import { listProposals, type MemoryProposal } from "../lib/meProposals";
+import {
+  approveMemoryProposal,
+  declineMemoryProposal,
+} from "../lib/memoryProposalReview";
+
+const POLL_INTERVAL_MS = 5_000;
+
+export function useMemoryProposals(
+  sessionId?: string,
+  options?: { sessionlessOnly?: boolean },
+) {
+  const [proposals, setProposals] = useState<MemoryProposal[]>([]);
+
+  const refresh = useCallback(async () => {
+    const all = await listProposals();
+    setProposals(
+      sessionId
+        ? all.filter((proposal) => proposal.sessionId === sessionId)
+        : options?.sessionlessOnly
+          ? all.filter((proposal) => proposal.sessionId === null)
+          : all,
+    );
+  }, [sessionId, options?.sessionlessOnly]);
+
+  useEffect(() => {
+    void refresh();
+    const interval = setInterval(() => void refresh(), POLL_INTERVAL_MS);
+    const onFocus = () => void refresh();
+    window.addEventListener("focus", onFocus);
+    return () => {
+      clearInterval(interval);
+      window.removeEventListener("focus", onFocus);
+    };
+  }, [refresh]);
+
+  const approve = useCallback(
+    async (
+      proposal: MemoryProposal,
+      content?: string,
+      topic?: string | null,
+    ) => {
+      await approveMemoryProposal(proposal, content, topic);
+      await refresh();
+    },
+    [refresh],
+  );
+  const decline = useCallback(
+    async (proposal: MemoryProposal) => {
+      await declineMemoryProposal(proposal);
+      await refresh();
+    },
+    [refresh],
+  );
+
+  return { proposals, approve, decline, refresh };
+}
diff --git a/src/features/me/hooks/useMemoryProposalsPending.ts b/src/features/me/hooks/useMemoryProposalsPending.ts
new file mode 100644
index 000000000..ef08a2bf4
--- /dev/null
+++ b/src/features/me/hooks/useMemoryProposalsPending.ts
@@ -0,0 +1,38 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { listProposals } from "../lib/meProposals";
+
+/**
+ * Count of pending proposals for the Memory nav badge. The badge is a real
+ * review queue: nothing enters durable or recallable memory until resolved.
+ *
+ * Polling is deliberately lazy (a tiny local file); a focus listener
+ * catches the common "came back to the app" moment.
+ */
+const POLL_INTERVAL_MS = 30_000;
+
+export function useMemoryProposalsPending(): number {
+  const [count, setCount] = useState(0);
+
+  const refresh = useCallback(async () => {
+    try {
+      setCount((await listProposals()).length);
+    } catch {
+      // Badge is best-effort; a read failure just means no badge.
+      setCount(0);
+    }
+  }, []);
+
+  useEffect(() => {
+    void refresh();
+    const interval = setInterval(() => void refresh(), POLL_INTERVAL_MS);
+    const onFocus = () => void refresh();
+    window.addEventListener("focus", onFocus);
+    return () => {
+      clearInterval(interval);
+      window.removeEventListener("focus", onFocus);
+    };
+  }, [refresh]);
+
+  return count;
+}
diff --git a/src/features/me/lib/__tests__/editSummary.test.ts b/src/features/me/lib/__tests__/editSummary.test.ts
new file mode 100644
index 000000000..20505c809
--- /dev/null
+++ b/src/features/me/lib/__tests__/editSummary.test.ts
@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+
+import { removedMemoryEntries } from "../editSummary";
+
+const FILE = `# Me
+
+*This file is yours.*
+
+## Preferences
+
+*How you want agents to work with you.*
+
+- Keep answers brief.
+- Git branch names: use \`clay/\` as the prefix.
+
+## Boundaries
+
+*Things agents should ask about first.*
+`;
+
+describe("removedMemoryEntries", () => {
+  it("returns exact removed entries without markdown syntax", () => {
+    const after = FILE.replace("- Keep answers brief.\n", "");
+    expect(removedMemoryEntries(FILE, after)).toEqual(["Keep answers brief."]);
+  });
+
+  it("does not suppress entries during additions or rewording", () => {
+    expect(
+      removedMemoryEntries(
+        FILE,
+        FILE.replace(
+          "- Keep answers brief.",
+          "- Keep answers brief.\n- Use headings for long answers.",
+        ),
+      ),
+    ).toEqual([]);
+    expect(
+      removedMemoryEntries(
+        FILE,
+        FILE.replace("- Keep answers brief.", "- Keep responses brief."),
+      ),
+    ).toEqual([]);
+  });
+
+  it("ignores whitespace, headings, and italic notes", () => {
+    expect(removedMemoryEntries(FILE, `${FILE}\n\n`)).toEqual([]);
+    expect(
+      removedMemoryEntries(
+        FILE,
+        FILE.replace("*This file is yours.*", "*Yours.*"),
+      ),
+    ).toEqual([]);
+    expect(
+      removedMemoryEntries(FILE, FILE.replace("## Boundaries", "## Limits")),
+    ).toEqual([]);
+  });
+});
diff --git a/src/features/me/lib/__tests__/meFile.test.ts b/src/features/me/lib/__tests__/meFile.test.ts
index 93fdfcd2c..96b476638 100644
--- a/src/features/me/lib/__tests__/meFile.test.ts
+++ b/src/features/me/lib/__tests__/meFile.test.ts
@@ -4,17 +4,24 @@ const mocks = vi.hoisted(() => ({
   getHomeDir: vi.fn(),
   pathExists: vi.fn(),
   readTextFile: vi.fn(),
-  createTextFile: vi.fn(),
-  writeTextFile: vi.fn(),
+  saveMemoryDocument: vi.fn(),
 }));
 
-vi.mock("@/shared/api/system", () => mocks);
+vi.mock("@/shared/api/system", () => ({
+  getHomeDir: mocks.getHomeDir,
+  pathExists: mocks.pathExists,
+  readTextFile: mocks.readTextFile,
+}));
+vi.mock("../saveMemoryDocument", () => ({
+  saveMemoryDocument: mocks.saveMemoryDocument,
+}));
 
 import { createMeFile, ME_FILE_TEMPLATE, saveMeFile } from "../meFile";
 
 beforeEach(() => {
   vi.clearAllMocks();
   mocks.getHomeDir.mockResolvedValue("/home/u");
+  mocks.saveMemoryDocument.mockResolvedValue(undefined);
 });
 
 describe("me file writes", () => {
@@ -24,23 +31,21 @@ describe("me file writes", () => {
 
     await createMeFile();
 
-    expect(mocks.createTextFile).toHaveBeenCalledTimes(1);
-    expect(mocks.createTextFile).toHaveBeenCalledWith(
-      "/home/u/.me/me.md",
-      ME_FILE_TEMPLATE,
-    );
-    expect(mocks.writeTextFile).not.toHaveBeenCalled();
+    expect(mocks.saveMemoryDocument).toHaveBeenCalledWith({
+      path: "/home/u/.me/me.md",
+      contents: ME_FILE_TEMPLATE,
+      topic: null,
+    });
   });
 
   it("saves only the user-owned memory file without automatic sharing", async () => {
     await saveMeFile("/home/u/.me/me.md", "## Preferences\n\n- Keep it brief.");
 
-    expect(mocks.writeTextFile).toHaveBeenCalledTimes(1);
-    expect(mocks.writeTextFile).toHaveBeenCalledWith(
-      "/home/u/.me/me.md",
-      "## Preferences\n\n- Keep it brief.",
-    );
-    expect(mocks.createTextFile).not.toHaveBeenCalled();
+    expect(mocks.saveMemoryDocument).toHaveBeenCalledWith({
+      path: "/home/u/.me/me.md",
+      contents: "## Preferences\n\n- Keep it brief.",
+      topic: null,
+    });
   });
 
   it("documents the plaintext local-filesystem boundary in the starter file", () => {
diff --git a/src/features/me/lib/__tests__/meProposals.test.ts b/src/features/me/lib/__tests__/meProposals.test.ts
new file mode 100644
index 000000000..04f47f5dd
--- /dev/null
+++ b/src/features/me/lib/__tests__/meProposals.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  appendBullet,
+  insertIntoSection,
+  parseProposalLine,
+  removeBullet,
+} from "../meProposals";
+import { vocabularyTopicName } from "../memoryTopicVocabulary";
+
+describe("parseProposalLine", () => {
+  it("normalizes proposal text and topic before Settings display", () => {
+    const proposal = parseProposalLine(
+      JSON.stringify({
+        id: "p-1",
+        content: " cafe\u0301 prefers 中文\r\n",
+        topic: " Travel\r\n ",
+      }),
+    );
+    expect(proposal?.content).toBe("café prefers 中文");
+    expect(proposal?.topic).toBe("Travel");
+  });
+
+  it("rejects unsafe hidden Unicode before Settings display", () => {
+    expect(
+      parseProposalLine(JSON.stringify({ id: "p-1", content: "abc\u202etxt" })),
+    ).toBeNull();
+    expect(
+      parseProposalLine(JSON.stringify({ id: "p-1", content: "abc\u0007txt" })),
+    ).toBeNull();
+    expect(
+      parseProposalLine(
+        JSON.stringify({ id: "p-1", content: "family 👨‍👩‍👧‍👦" }),
+      ),
+    ).toBeNull();
+    expect(
+      parseProposalLine(
+        JSON.stringify({ id: "p-1", content: "safe", topic: "Tra\u202evel" }),
+      ),
+    ).toBeNull();
+  });
+
+  it("preserves ordinary visible Unicode and non-ZWJ emoji", () => {
+    const text = "São Paulo résumé Привет 中文 🚀";
+    expect(
+      parseProposalLine(JSON.stringify({ id: "p-1", content: text }))?.content,
+    ).toBe(text);
+  });
+});
+
+describe("appendBullet", () => {
+  it("appends a bullet to existing content with one trailing newline", () => {
+    const next = appendBullet("# Family\n\n- Existing entry.\n", "New entry.");
+    expect(next).toBe("# Family\n\n- Existing entry.\n- New entry.\n");
+  });
+
+  it("starts a doc when contents are empty", () => {
+    expect(appendBullet("", "First entry.")).toBe("- First entry.\n");
+  });
+});
+
+describe("insertIntoSection", () => {
+  const SPINE = [
+    "# Me",
+    "",
+    "## About me",
+    "",
+    "- Clay, Atlanta.",
+    "",
+    "## Preferences",
+    "",
+    "- Keep answers brief.",
+    "",
+    "## Boundaries",
+    "",
+    "- Ask before deleting.",
+    "",
+  ].join("\n");
+
+  it("inserts at the end of the named section, before the next heading", () => {
+    const next = insertIntoSection(SPINE, "## Preferences", "Use metric.");
+    const lines = next.split("\n");
+    const prefIndex = lines.indexOf("- Keep answers brief.");
+    expect(lines[prefIndex + 1]).toBe("- Use metric.");
+    // Boundaries untouched and still after the insertion.
+    expect(next.indexOf("- Use metric.")).toBeLessThan(
+      next.indexOf("## Boundaries"),
+    );
+  });
+
+  it("falls back to appending when the section is missing", () => {
+    const next = insertIntoSection("# Me\n", "## Nonexistent", "Entry.");
+    expect(next.trimEnd().endsWith("- Entry.")).toBe(true);
+  });
+});
+
+describe("vocabularyTopicName", () => {
+  it("accepts the broad areas, case-insensitively", () => {
+    expect(vocabularyTopicName("home")).toBe("Home");
+    expect(vocabularyTopicName("  Travel ")).toBe("Travel");
+    expect(vocabularyTopicName("Interests")).toBe("Interests");
+  });
+
+  it("rejects narrow names a drifting model might invent", () => {
+    // Approval falls back to the spine for these rather than minting a
+    // topic file the noticer would never produce.
+    expect(vocabularyTopicName("Soccer")).toBeNull();
+    expect(vocabularyTopicName("Jazz")).toBeNull();
+    expect(vocabularyTopicName("family")).toBeNull();
+  });
+});
+
+describe("removeBullet", () => {
+  const DOC = [
+    "# Home",
+    "",
+    "*What goes here.*",
+    "",
+    "- Kids' soccer is Mondays.",
+    "- Wife works late Tuesdays.",
+    "",
+  ].join("\n");
+
+  it("removes the matching bullet and leaves the rest", () => {
+    const next = removeBullet(DOC, "Wife works late Tuesdays.");
+    expect(next).not.toContain("Wife works late Tuesdays.");
+    expect(next).toContain("- Kids' soccer is Mondays.");
+    expect(next).toContain("*What goes here.*");
+  });
+
+  it("no-ops when the entry was reworded or already gone", () => {
+    // Deleting a nearby line the user wrote themselves would be far worse
+    // than a delete that does nothing, so matching is exact.
+    expect(removeBullet(DOC, "Wife works late on Tuesdays")).toBe(DOC);
+    expect(removeBullet(DOC, "Never mentioned.")).toBe(DOC);
+  });
+
+  it("removes only the first match", () => {
+    const doubled = "- Same fact.\n- Same fact.\n";
+    expect(removeBullet(doubled, "Same fact.")).toBe("- Same fact.\n");
+  });
+});
diff --git a/src/features/me/lib/__tests__/memoryProposalReview.test.ts b/src/features/me/lib/__tests__/memoryProposalReview.test.ts
new file mode 100644
index 000000000..f9ec010a3
--- /dev/null
+++ b/src/features/me/lib/__tests__/memoryProposalReview.test.ts
@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  approveMemoryProposal: vi.fn(),
+  resolveMemoryProposal: vi.fn(),
+}));
+
+vi.mock("@/shared/api/system", () => ({
+  approveMemoryProposal: mocks.approveMemoryProposal,
+  resolveMemoryProposal: mocks.resolveMemoryProposal,
+}));
+
+import {
+  approveMemoryProposal,
+  CredentialMemoryError,
+  declineMemoryProposal,
+  UnsafeMemoryTextError,
+} from "../memoryProposalReview";
+
+const proposal = {
+  id: "proposal-1",
+  ts: 1,
+  content: "Prefers aisle seats.",
+  topic: "Travel",
+  agent: "noticer",
+  sessionId: "session-1",
+};
+
+describe("memory proposal review", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.approveMemoryProposal.mockResolvedValue({ approved: true });
+  });
+
+  it("delegates the exact normalized reviewed approval to the backend", async () => {
+    await approveMemoryProposal(
+      proposal,
+      "  Prefers cafe\u0301 seats.\r\n",
+      " Travel\r\n ",
+    );
+    expect(mocks.approveMemoryProposal).toHaveBeenCalledWith(
+      proposal.id,
+      "Prefers café seats.",
+      "Travel",
+    );
+  });
+
+  it("rejects edited authentication data before backend admission", async () => {
+    await expect(
+      approveMemoryProposal(proposal, "API key: ghp_16CharsAtLeastHere00"),
+    ).rejects.toBeInstanceOf(CredentialMemoryError);
+    expect(mocks.approveMemoryProposal).not.toHaveBeenCalled();
+  });
+
+  it("rejects hidden Unicode before backend admission", async () => {
+    await expect(
+      approveMemoryProposal(
+        proposal,
+        "API key: ghp_16Chars\u200bAtLeastHere00",
+      ),
+    ).rejects.toBeInstanceOf(UnsafeMemoryTextError);
+    await expect(
+      approveMemoryProposal(proposal, "Safe content.", "Tra\u202evel"),
+    ).rejects.toBeInstanceOf(UnsafeMemoryTextError);
+    expect(mocks.approveMemoryProposal).not.toHaveBeenCalled();
+  });
+
+  it("declines through fingerprint-only backend suppression", async () => {
+    await declineMemoryProposal(proposal);
+    expect(mocks.resolveMemoryProposal).toHaveBeenCalledWith(proposal.id, {
+      content: proposal.content,
+      topic: proposal.topic,
+    });
+  });
+});
diff --git a/src/features/me/lib/__tests__/memoryTextContract.test.ts b/src/features/me/lib/__tests__/memoryTextContract.test.ts
new file mode 100644
index 000000000..6a70218d3
--- /dev/null
+++ b/src/features/me/lib/__tests__/memoryTextContract.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  normalizeMemoryDocumentText,
+  normalizeMemoryProposalText,
+  normalizeMemoryProposalTopic,
+  UnsafeMemoryTextError,
+} from "../memoryTextContract";
+
+describe("memory text contract", () => {
+  it("normalizes proposal text consistently", () => {
+    expect(normalizeMemoryProposalText("  cafe\u0301\r\n")).toBe("café");
+  });
+
+  it("normalizes document text without trimming reviewed bytes", () => {
+    expect(normalizeMemoryDocumentText("# Cafe\u0301\r\n\n")).toBe(
+      "# Café\n\n",
+    );
+  });
+
+  it("normalizes reviewed topics before display and approval", () => {
+    expect(normalizeMemoryProposalTopic(" Travel\r\n ")).toBe("Travel");
+    expect(normalizeMemoryProposalTopic(" ")).toBeNull();
+    expect(normalizeMemoryProposalTopic(null)).toBeNull();
+  });
+
+  it("rejects bidi, zero-width, C0, and C1 controls", () => {
+    for (const text of [
+      "abc\u202etxt",
+      "abc\u2066txt\u2069",
+      "ghp_16Chars\u200bAtLeastHere00",
+      "abc\u0007txt",
+      "abc\u0085txt",
+      "abc\u{e0020}txt",
+      "abc\u{e0100}txt",
+    ]) {
+      expect(() => normalizeMemoryProposalText(text), text).toThrow(
+        UnsafeMemoryTextError,
+      );
+    }
+  });
+
+  it("preserves ordinary accents, non-Latin text, and non-ZWJ emoji", () => {
+    const text = "São Paulo résumé Привет 中文 🚀";
+    expect(normalizeMemoryProposalText(text)).toBe(text);
+  });
+
+  it("rejects unsafe topic text and emoji ZWJ sequences deliberately", () => {
+    expect(() => normalizeMemoryProposalTopic("Tra\u202evel")).toThrow(
+      UnsafeMemoryTextError,
+    );
+    expect(() => normalizeMemoryProposalText("family 👨‍👩‍👧‍👦")).toThrow(
+      UnsafeMemoryTextError,
+    );
+  });
+});
diff --git a/src/features/me/lib/__tests__/saveMemoryDocument.test.ts b/src/features/me/lib/__tests__/saveMemoryDocument.test.ts
new file mode 100644
index 000000000..719ac6bc6
--- /dev/null
+++ b/src/features/me/lib/__tests__/saveMemoryDocument.test.ts
@@ -0,0 +1,100 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  readTextFile: vi.fn(),
+  resolveMemoryProposal: vi.fn(),
+  writeTextFile: vi.fn(),
+}));
+
+vi.mock("@/shared/api/system", () => ({
+  readTextFile: mocks.readTextFile,
+  resolveMemoryProposal: mocks.resolveMemoryProposal,
+  writeTextFile: mocks.writeTextFile,
+}));
+
+import { CredentialMemoryError } from "../memoryCredentialGuard";
+import { saveMemoryDocument } from "../saveMemoryDocument";
+import { UnsafeMemoryTextError } from "../memoryTextContract";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubGlobal("crypto", { randomUUID: () => "delete-id" });
+  mocks.writeTextFile.mockResolvedValue(undefined);
+  mocks.resolveMemoryProposal.mockResolvedValue(undefined);
+  mocks.readTextFile.mockResolvedValue({
+    contents: "# Travel\n\n- Prefers aisle seats.\n- Packs light.\n",
+  });
+});
+
+describe("saveMemoryDocument", () => {
+  it("writes before suppressing an unambiguous deletion", async () => {
+    await saveMemoryDocument({
+      path: "/home/u/.me/topics/travel.md",
+      contents: "# Travel\n\n- Packs light.\n",
+      topic: "Travel",
+    });
+
+    expect(mocks.writeTextFile).toHaveBeenCalledOnce();
+    expect(mocks.resolveMemoryProposal).toHaveBeenCalledWith(
+      "manual-delete-delete-id",
+      { content: "Prefers aisle seats.", topic: "Travel" },
+    );
+    expect(mocks.writeTextFile.mock.invocationCallOrder[0]).toBeLessThan(
+      mocks.resolveMemoryProposal.mock.invocationCallOrder[0],
+    );
+  });
+
+  it("does not suppress anything when the write fails", async () => {
+    mocks.writeTextFile.mockRejectedValue(new Error("read only"));
+    await expect(
+      saveMemoryDocument({
+        path: "/home/u/.me/topics/travel.md",
+        contents: "# Travel\n\n- Packs light.\n",
+        topic: "Travel",
+      }),
+    ).rejects.toThrow("read only");
+    expect(mocks.resolveMemoryProposal).not.toHaveBeenCalled();
+  });
+
+  it("normalizes direct Settings document saves before write and diff", async () => {
+    await saveMemoryDocument({
+      path: "/home/u/.me/topics/travel.md",
+      contents: "# Cafe\u0301\r\n\r\n- Packs light.\r\n",
+      topic: " Travel\r\n ",
+    });
+
+    expect(mocks.writeTextFile).toHaveBeenCalledWith(
+      "/home/u/.me/topics/travel.md",
+      "# Café\n\n- Packs light.\n",
+    );
+  });
+
+  it("blocks credential-shaped edits before writing", async () => {
+    await expect(
+      saveMemoryDocument({
+        path: "/home/u/.me/me.md",
+        contents: "# Me\n\n- PIN: 1234\n",
+        topic: null,
+      }),
+    ).rejects.toBeInstanceOf(CredentialMemoryError);
+    expect(mocks.writeTextFile).not.toHaveBeenCalled();
+  });
+
+  it("blocks hidden Unicode before writing", async () => {
+    await expect(
+      saveMemoryDocument({
+        path: "/home/u/.me/me.md",
+        contents: "# Me\n\n- token ghp_16Chars\u200bAtLeastHere00\n",
+        topic: null,
+      }),
+    ).rejects.toBeInstanceOf(UnsafeMemoryTextError);
+    await expect(
+      saveMemoryDocument({
+        path: "/home/u/.me/topics/travel.md",
+        contents: "# Travel\n\n- Packs light.\n",
+        topic: "Tra\u202evel",
+      }),
+    ).rejects.toBeInstanceOf(UnsafeMemoryTextError);
+    expect(mocks.writeTextFile).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/features/me/lib/editSummary.ts b/src/features/me/lib/editSummary.ts
new file mode 100644
index 000000000..93104238f
--- /dev/null
+++ b/src/features/me/lib/editSummary.ts
@@ -0,0 +1,43 @@
+/**
+ * Extract memory-bearing lines so deliberate deletions can create suppression
+ * fingerprints. Headings, blanks, and italic notes are file scaffolding, not
+ * memories.
+ */
+
+/** Lines that carry memory, as opposed to the file's scaffolding. */
+export function memoryContentLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => {
+      if (!line) return false;
+      if (line.startsWith("#")) return false; // headings
+      // Italic notes are guidance for the person, never sent to agents.
+      const italic =
+        line.startsWith("*") &&
+        !line.startsWith("**") &&
+        !line.startsWith("* ");
+      if (italic) return false;
+      return true;
+    });
+}
+
+/** Exact memory lines removed by an edit, with markdown bullet syntax stripped. */
+export function removedMemoryEntries(before: string, after: string): string[] {
+  const beforeLines = memoryContentLines(before);
+  const afterLines = memoryContentLines(after);
+  const beforeSet = new Set(beforeLines);
+  // When a save also adds content, a missing line may have been reworded or
+  // reorganized rather than rejected. Only pure deletions are safe to turn
+  // into durable suppression decisions automatically.
+  if (afterLines.some((line) => !beforeSet.has(line))) return [];
+  const afterSet = new Set(afterLines);
+  return [
+    ...new Set(
+      beforeLines
+        .filter((line) => !afterSet.has(line))
+        .map((line) => line.replace(/^[-*]\s+/, "").trim())
+        .filter(Boolean),
+    ),
+  ];
+}
diff --git a/src/features/me/lib/meFile.ts b/src/features/me/lib/meFile.ts
index ab08df9a3..f97d6a314 100644
--- a/src/features/me/lib/meFile.ts
+++ b/src/features/me/lib/meFile.ts
@@ -1,10 +1,5 @@
-import {
-  createTextFile,
-  getHomeDir,
-  pathExists,
-  readTextFile,
-  writeTextFile,
-} from "@/shared/api/system";
+import { getHomeDir, pathExists, readTextFile } from "@/shared/api/system";
+import { saveMemoryDocument } from "./saveMemoryDocument";
 
 /**
  * Canonical home for the user's me.md, relative to the home directory.
@@ -116,7 +111,11 @@ export async function createMeFile(): Promise<MeFileState> {
   if (existing.status === "present") {
     return existing;
   }
-  await createTextFile(existing.path, ME_FILE_TEMPLATE);
+  await saveMemoryDocument({
+    path: existing.path,
+    contents: ME_FILE_TEMPLATE,
+    topic: null,
+  });
   const payload = await readTextFile(existing.path);
   return {
     status: "present",
@@ -131,5 +130,5 @@ export async function saveMeFile(
   path: string,
   contents: string,
 ): Promise<void> {
-  await writeTextFile(path, contents);
+  await saveMemoryDocument({ path, contents, topic: null });
 }
diff --git a/src/features/me/lib/meProposals.ts b/src/features/me/lib/meProposals.ts
new file mode 100644
index 000000000..3524729f6
--- /dev/null
+++ b/src/features/me/lib/meProposals.ts
@@ -0,0 +1,143 @@
+import { getHomeDir, pathExists, readTextFile } from "@/shared/api/system";
+import {
+  normalizeMemoryProposalText,
+  normalizeMemoryProposalTopic,
+  UnsafeMemoryTextError,
+} from "./memoryTextContract";
+
+/**
+ * Reviewable memory proposals. Agent and noticer output stops here until the
+ * person explicitly approves it; this file is never recalled or projected.
+ */
+
+export interface MemoryProposal {
+  /** Stable ID written by the proposal producer. */
+  id: string;
+  /** Seconds since epoch, as written by the server. */
+  ts: number;
+  content: string;
+  /** Topic hint from the agent, e.g. "style" or "Family". Null = spine. */
+  topic: string | null;
+  /** Proposing agent, when the server knew it. */
+  agent: string | null;
+  /**
+   * Session the proposal came from, when known. The noticer records it so
+   * the chat that produced a fact can surface the card in place; server
+   * proposals leave it null (the tool call renders its own card).
+   */
+  sessionId: string | null;
+}
+
+function queuePath(homeDir: string): string {
+  return `${homeDir}/.me/proposals/pending.jsonl`;
+}
+
+export function parseProposalLine(line: string): MemoryProposal | null {
+  try {
+    const raw = JSON.parse(line) as Record<string, unknown>;
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    if (!id || typeof raw.content !== "string") return null;
+    const content = normalizeMemoryProposalText(raw.content);
+    if (!content) return null;
+    const ts = typeof raw.ts === "number" ? raw.ts : 0;
+    return {
+      id,
+      ts,
+      content,
+      topic:
+        typeof raw.topic === "string"
+          ? normalizeMemoryProposalTopic(raw.topic)
+          : null,
+      agent:
+        typeof raw.agent === "string" && raw.agent.trim()
+          ? raw.agent.trim()
+          : null,
+      sessionId:
+        typeof raw.sessionId === "string" && raw.sessionId.trim()
+          ? raw.sessionId.trim()
+          : null,
+    };
+  } catch (error) {
+    if (error instanceof UnsafeMemoryTextError) return null;
+    return null;
+  }
+}
+
+/** Pending proposals, oldest first. Missing or unreadable queue = none. */
+export async function listProposals(): Promise<MemoryProposal[]> {
+  try {
+    const path = queuePath(await getHomeDir());
+    if (!(await pathExists(path))) return [];
+    const payload = await readTextFile(path);
+    return payload.contents
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map(parseProposalLine)
+      .filter((proposal): proposal is MemoryProposal => proposal !== null);
+  } catch {
+    return [];
+  }
+}
+
+/** Append a bullet to the end of a doc, normalizing trailing whitespace. */
+export function appendBullet(contents: string, entry: string): string {
+  const bullet = `- ${entry}`;
+  if (contents.split("\n").some((line) => line.trim() === bullet))
+    return contents;
+  const trimmed = contents.replace(/\s+$/, "");
+  return trimmed ? `${trimmed}\n${bullet}\n` : `${bullet}\n`;
+}
+
+/**
+ * Remove the bullet matching `entry` from a doc.
+ *
+ * Removal of an approved memory has to be conservative:
+ * only a line that is exactly this bullet is removed, and only the first
+ * one. Anything the user has since reworded stays put — a delete that
+ * quietly took out a nearby line the user wrote themselves would be much
+ * worse than a delete that no-ops.
+ */
+export function removeBullet(contents: string, entry: string): string {
+  const wanted = entry.trim();
+  const lines = contents.split("\n");
+  const index = lines.findIndex((line) => {
+    const text = line.trim();
+    if (!text.startsWith("- ")) return false;
+    return text.slice(2).trim() === wanted;
+  });
+  if (index === -1) return contents;
+  lines.splice(index, 1);
+  return lines.join("\n");
+}
+
+/**
+ * Insert a bullet at the end of a `## Section` in the spine, before the
+ * next heading. Falls back to appending at the end of the file when the
+ * section doesn't exist.
+ */
+export function insertIntoSection(
+  contents: string,
+  sectionHeading: string,
+  entry: string,
+): string {
+  const lines = contents.split("\n");
+  if (lines.some((line) => line.trim() === `- ${entry}`)) return contents;
+  const start = lines.findIndex((line) => line.trim() === sectionHeading);
+  if (start === -1) return appendBullet(contents, entry);
+
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (lines[i].startsWith("## ")) {
+      end = i;
+      break;
+    }
+  }
+  // Walk back past blank lines so the bullet lands tight to the section.
+  let insertAt = end;
+  while (insertAt > start + 1 && lines[insertAt - 1].trim() === "") {
+    insertAt--;
+  }
+  lines.splice(insertAt, 0, `- ${entry}`);
+  return lines.join("\n");
+}
diff --git a/src/features/me/lib/meTopics.ts b/src/features/me/lib/meTopics.ts
index d5b1625c1..040562aaf 100644
--- a/src/features/me/lib/meTopics.ts
+++ b/src/features/me/lib/meTopics.ts
@@ -1,11 +1,10 @@
 import {
-  createTextFile,
   getHomeDir,
   listDirectoryEntries,
   pathExists,
   readTextFile,
-  writeTextFile,
 } from "@/shared/api/system";
+import { saveMemoryDocument } from "./saveMemoryDocument";
 
 /**
  * Topic docs: the spokes of the memory-v2 hub-and-spokes shape. Every
@@ -111,8 +110,12 @@ export async function listTopics(): Promise<TopicDoc[]> {
 }
 
 /** Save a user edit to a topic document. */
-export async function saveTopic(path: string, contents: string): Promise<void> {
-  await writeTextFile(path, contents);
+export async function saveTopic(
+  path: string,
+  contents: string,
+  topic: string,
+): Promise<void> {
+  await saveMemoryDocument({ path, contents, topic });
 }
 
 /** Turn a display name into a topic file name: "Side projects" → side-projects.md */
@@ -134,15 +137,15 @@ function topicTemplate(name: string): string {
 }
 
 /**
- * Create a new, empty topic doc. Refuses to overwrite (createTextFile's
- * contract), so an existing topic can't be clobbered by a name collision.
+ * Create a new, empty topic doc through the reviewed memory write funnel, so
+ * an existing topic can't be clobbered by a name collision.
  */
 export async function createTopic(name: string): Promise<TopicDoc> {
   const homeDir = await getHomeDir();
   const fileName = topicFileName(name);
   const path = `${topicsDirPath(homeDir)}/${fileName}`;
   const contents = topicTemplate(name);
-  await createTextFile(path, contents);
+  await saveMemoryDocument({ path, contents, topic: name });
   const meta = parseTopicMeta(contents, fileName);
   return { path, fileName, contents, ...meta };
 }
diff --git a/src/features/me/lib/memoryCredentialGuard.ts b/src/features/me/lib/memoryCredentialGuard.ts
index 197c8a258..c650eb97e 100644
--- a/src/features/me/lib/memoryCredentialGuard.ts
+++ b/src/features/me/lib/memoryCredentialGuard.ts
@@ -102,7 +102,7 @@ export class CredentialMemoryError extends Error {
  * immediate UX, not the security boundary.
  */
 export function looksLikeCredential(content: string): boolean {
-  const text = content.trim();
+  const text = content.normalize("NFC").trim();
   if (!text) return false;
 
   for (const pattern of TOKEN_PATTERNS) {
diff --git a/src/features/me/lib/memoryProposalReview.ts b/src/features/me/lib/memoryProposalReview.ts
new file mode 100644
index 000000000..4fc1a8722
--- /dev/null
+++ b/src/features/me/lib/memoryProposalReview.ts
@@ -0,0 +1,38 @@
+import {
+  approveMemoryProposal as approveMemoryProposalInBackend,
+  resolveMemoryProposal,
+} from "@/shared/api/system";
+import {
+  CredentialMemoryError,
+  looksLikeCredential,
+} from "./memoryCredentialGuard";
+import {
+  normalizeMemoryProposalText,
+  normalizeMemoryProposalTopic,
+} from "./memoryTextContract";
+import type { MemoryProposal } from "./meProposals";
+
+export { CredentialMemoryError } from "./memoryCredentialGuard";
+export { UnsafeMemoryTextError } from "./memoryTextContract";
+
+export async function approveMemoryProposal(
+  proposal: MemoryProposal,
+  content = proposal.content,
+  topic = proposal.topic,
+): Promise<void> {
+  const reviewed = normalizeMemoryProposalText(content);
+  if (!reviewed) throw new Error("Memory content is required.");
+  if (looksLikeCredential(reviewed)) throw new CredentialMemoryError();
+
+  const reviewedTopic = normalizeMemoryProposalTopic(topic);
+  await approveMemoryProposalInBackend(proposal.id, reviewed, reviewedTopic);
+}
+
+export async function declineMemoryProposal(
+  proposal: MemoryProposal,
+): Promise<void> {
+  await resolveMemoryProposal(proposal.id, {
+    content: proposal.content,
+    topic: proposal.topic,
+  });
+}
diff --git a/src/features/me/lib/memoryProposalToast.ts b/src/features/me/lib/memoryProposalToast.ts
new file mode 100644
index 000000000..d3293db7e
--- /dev/null
+++ b/src/features/me/lib/memoryProposalToast.ts
@@ -0,0 +1,55 @@
+import { toast } from "sonner";
+import type { MemoryProposal } from "./meProposals";
+
+const shown = new Set<string>();
+const TOAST_DURATION_MS = 10_000;
+
+export function resetMemoryProposalToasts(): void {
+  shown.clear();
+}
+
+export function showMemoryProposalToast({
+  proposal,
+  title,
+  destination,
+  reviewLabel,
+  declineLabel,
+  onReview,
+  onDecline,
+  renderActions,
+}: {
+  proposal: MemoryProposal;
+  title: string;
+  destination: string;
+  reviewLabel: string;
+  declineLabel: string;
+  onReview: (proposal: MemoryProposal) => void;
+  onDecline: (proposal: MemoryProposal) => void;
+  renderActions: (args: {
+    reviewLabel: string;
+    declineLabel: string;
+    onReview: () => void;
+    onDecline: () => void;
+  }) => React.ReactNode;
+}): void {
+  if (shown.has(proposal.id)) return;
+  shown.add(proposal.id);
+  let toastId: string | number | undefined;
+  const dismiss = () => toastId !== undefined && toast.dismiss(toastId);
+  toastId = toast(title, {
+    description: `${proposal.content} · ${destination}`,
+    duration: TOAST_DURATION_MS,
+    action: renderActions({
+      reviewLabel,
+      declineLabel,
+      onReview: () => {
+        dismiss();
+        onReview(proposal);
+      },
+      onDecline: () => {
+        dismiss();
+        onDecline(proposal);
+      },
+    }),
+  });
+}
diff --git a/src/features/me/lib/memoryTextContract.ts b/src/features/me/lib/memoryTextContract.ts
new file mode 100644
index 000000000..5f8635d58
--- /dev/null
+++ b/src/features/me/lib/memoryTextContract.ts
@@ -0,0 +1,66 @@
+/**
+ * Review-safe text contract for memory proposal and document admission.
+ *
+ * Memory review is a security boundary: the text a person sees in Settings
+ * must be the same Unicode text that is scanned for credentials and persisted.
+ * We normalize to NFC and LF line endings, trim proposal fields, and reject
+ * Unicode format/default-ignorable and control characters that can make
+ * displayed text differ from stored bytes or hide tokens from scanners.
+ *
+ * Emoji ZWJ sequences are rejected deliberately. They are useful for composing
+ * visible emoji glyphs, but ZWJ is also a zero-width format character that can
+ * split credentials or make reviewed text differ from persisted text. Memory is
+ * prose, so rejecting composed emoji is safer than special-casing renderers.
+ */
+
+const UNSAFE_DEFAULT_IGNORABLE_OR_FORMAT =
+  /[\p{Default_Ignorable_Code_Point}\p{Cf}]/u;
+
+export class UnsafeMemoryTextError extends Error {
+  constructor() {
+    super("Memory text can't include hidden Unicode control characters.");
+    this.name = "UnsafeMemoryTextError";
+  }
+}
+
+function normalizeMemoryString(value: string): string {
+  return value.replace(/\r\n?/g, "\n").normalize("NFC");
+}
+
+function assertReviewSafeText(value: string): void {
+  for (const character of value) {
+    if (UNSAFE_DEFAULT_IGNORABLE_OR_FORMAT.test(character)) {
+      throw new UnsafeMemoryTextError();
+    }
+    const codePoint = character.codePointAt(0) ?? 0;
+    const allowedWhitespace = character === "\n" || character === "\t";
+    if (
+      !allowedWhitespace &&
+      ((codePoint <= 0x1f && codePoint !== 0x20) ||
+        (codePoint >= 0x7f && codePoint <= 0x9f))
+    ) {
+      throw new UnsafeMemoryTextError();
+    }
+  }
+}
+
+export function normalizeMemoryProposalText(content: string): string {
+  const normalized = normalizeMemoryString(content).trim();
+  assertReviewSafeText(normalized);
+  return normalized;
+}
+
+export function normalizeMemoryProposalTopic(
+  topic: string | null | undefined,
+): string | null {
+  if (topic === null || topic === undefined) return null;
+  const normalized = normalizeMemoryString(topic).trim();
+  assertReviewSafeText(normalized);
+  return normalized || null;
+}
+
+export function normalizeMemoryDocumentText(contents: string): string {
+  const normalized = normalizeMemoryString(contents);
+  assertReviewSafeText(normalized);
+  return normalized;
+}
diff --git a/src/features/me/lib/memoryTopicVocabulary.ts b/src/features/me/lib/memoryTopicVocabulary.ts
new file mode 100644
index 000000000..23215f181
--- /dev/null
+++ b/src/features/me/lib/memoryTopicVocabulary.ts
@@ -0,0 +1,40 @@
+/**
+ * The broad areas a *new* memory topic may be named after.
+ *
+ * Kept deliberately small and life-shaped. The risk isn't list length —
+ * unused names are invisible until earned — it's overlap: two plausible
+ * homes for one fact means the same fact routes differently across passes
+ * and piles up as near-duplicates. So every pair has a boundary:
+ * household vs. outside it (Home/Social), people vs. tastes
+ * (Social/Interests), tastes vs. logistics (Interests/Travel), personal
+ * vs. professional (Social/Work).
+ *
+ * Both memory doors are bound by this list: the noticer picks from it,
+ * and a saved entry only creates a topic file when its name matches it —
+ * otherwise a drifting model ("Soccer", "Jazz") could sprawl memory into
+ * narrow topics the noticer would never produce.
+ *
+ * A user's existing topics always win over this list, and users can name
+ * their own topics however they like in Settings → Memory.
+ */
+export const MEMORY_TOPIC_VOCABULARY = [
+  "Home",
+  "Social",
+  "Interests",
+  "Travel",
+  "Shopping",
+  "Work",
+  "Tools",
+] as const;
+
+/**
+ * The vocabulary name matching `topic`, or null when it isn't one of the
+ * broad areas. Case-insensitive; existing topics are matched elsewhere.
+ */
+export function vocabularyTopicName(topic: string): string | null {
+  const wanted = topic.trim().toLowerCase();
+  return (
+    MEMORY_TOPIC_VOCABULARY.find((name) => name.toLowerCase() === wanted) ??
+    null
+  );
+}
diff --git a/src/features/me/lib/saveMemoryDocument.ts b/src/features/me/lib/saveMemoryDocument.ts
new file mode 100644
index 000000000..b9dee3cda
--- /dev/null
+++ b/src/features/me/lib/saveMemoryDocument.ts
@@ -0,0 +1,44 @@
+import {
+  readTextFile,
+  resolveMemoryProposal,
+  writeTextFile,
+} from "@/shared/api/system";
+import { removedMemoryEntries } from "./editSummary";
+import {
+  CredentialMemoryError,
+  looksLikeCredential,
+} from "./memoryCredentialGuard";
+import {
+  normalizeMemoryDocumentText,
+  normalizeMemoryProposalTopic,
+} from "./memoryTextContract";
+
+/** One reviewed Settings edit for either the spine or a topic document. */
+export async function saveMemoryDocument({
+  path,
+  contents,
+  topic,
+}: {
+  path: string;
+  contents: string;
+  topic: string | null;
+}): Promise<void> {
+  const reviewed = normalizeMemoryDocumentText(contents);
+  const reviewedTopic = normalizeMemoryProposalTopic(topic);
+  if (looksLikeCredential(reviewed)) throw new CredentialMemoryError();
+
+  const before = await readTextFile(path)
+    .then((payload) => normalizeMemoryDocumentText(payload.contents))
+    .catch(() => "");
+  const removed = removedMemoryEntries(before, reviewed);
+
+  // The edit must land before its deletions become durable suppression
+  // decisions. A failed write must not suppress content still in the file.
+  await writeTextFile(path, reviewed);
+  for (const entry of removed) {
+    await resolveMemoryProposal(`manual-delete-${crypto.randomUUID()}`, {
+      content: entry,
+      topic: reviewedTopic,
+    });
+  }
+}
diff --git a/src/features/me/ui/MeSettings.tsx b/src/features/me/ui/MeSettings.tsx
new file mode 100644
index 000000000..82edbdb01
--- /dev/null
+++ b/src/features/me/ui/MeSettings.tsx
@@ -0,0 +1,629 @@
+import { type ReactNode, useCallback, useEffect, useState } from "react";
+import { useTranslation } from "react-i18next";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { ChevronDown, RefreshCw } from "lucide-react";
+import { cn } from "@/shared/lib/cn";
+import { Button } from "@/shared/ui/button";
+import { Input } from "@/shared/ui/input";
+import { Textarea } from "@/shared/ui/textarea";
+import { Tabs, TabsList, TabsTrigger } from "@/shared/ui/tabs";
+import { SettingsPage } from "@/shared/ui/SettingsPage";
+import {
+  SettingsSection,
+  SettingsSections,
+} from "@/shared/ui/settings-section";
+import { SettingsRow } from "@/shared/ui/settings-row";
+import { Switch } from "@/shared/ui/switch";
+import { StorePathLink } from "./StorePathLink";
+import {
+  createMeFile,
+  loadMeFile,
+  ME_FILE_TEMPLATE,
+  saveMeFile,
+  type MeFileState,
+} from "../lib/meFile";
+import {
+  createTopic,
+  listTopics,
+  saveTopic,
+  type TopicDoc,
+} from "../lib/meTopics";
+import { useMemoryProposals } from "../hooks/useMemoryProposals";
+import type { MemoryProposal } from "../lib/meProposals";
+import { CredentialMemoryError } from "../lib/memoryCredentialGuard";
+import { UnsafeMemoryTextError } from "../lib/memoryTextContract";
+import { readMemoryPolicy, writeMemoryPolicy } from "../lib/memoryPolicyFile";
+
+type LoadState = { status: "loading" } | { status: "error" } | MeFileState;
+type ViewMode = "preview" | "edit";
+
+interface DocumentPanelProps {
+  contents: string;
+  onSave: (next: string) => Promise<void> | void;
+  editorLabel: string;
+  saveErrorText: string;
+  unsafeUnicodeErrorText: string;
+  cancelText: string;
+  saveText: string;
+  previewText: string;
+  editText: string;
+  unsavedText: string;
+  refreshLabel?: string;
+  onRefresh?: () => void;
+  /** Quiet footer content sharing the action row's left side, e.g. the file's location. */
+  footer?: ReactNode;
+}
+
+/**
+ * One contained document with Preview/Edit modes — the treatment every
+ * memory doc gets, spine and topics alike.
+ */
+function DocumentPanel({
+  contents,
+  onSave,
+  editorLabel,
+  saveErrorText,
+  unsafeUnicodeErrorText,
+  cancelText,
+  saveText,
+  previewText,
+  editText,
+  unsavedText,
+  refreshLabel,
+  onRefresh,
+  footer,
+}: DocumentPanelProps) {
+  const [mode, setMode] = useState<ViewMode>("preview");
+  const [draft, setDraft] = useState<string | null>(null);
+  const [saveError, setSaveError] = useState<string | null>(null);
+
+  const isEditing = mode === "edit";
+  const hasUnsavedChanges = draft !== null && draft !== contents;
+
+  const handleModeChange = (next: string) => {
+    if (next === "edit" && draft === null) {
+      setDraft(contents);
+      setSaveError(null);
+    }
+    setMode(next === "edit" ? "edit" : "preview");
+  };
+
+  const handleCancel = () => {
+    setDraft(null);
+    setSaveError(null);
+    setMode("preview");
+  };
+
+  const handleSave = async () => {
+    if (draft === null) return;
+    try {
+      await onSave(draft);
+      setDraft(null);
+      setSaveError(null);
+      setMode("preview");
+    } catch (error) {
+      setSaveError(
+        error instanceof UnsafeMemoryTextError
+          ? unsafeUnicodeErrorText
+          : saveErrorText,
+      );
+    }
+  };
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center justify-end">
+        <Tabs value={mode} onValueChange={handleModeChange}>
+          <TabsList variant="buttons">
+            {/* h-7 matches the xs Button height used by every other action
+                on this page (Add topic, View, Refresh). */}
+            <TabsTrigger value="preview" variant="buttons" className="h-7">
+              {previewText}
+            </TabsTrigger>
+            <TabsTrigger value="edit" variant="buttons" className="h-7">
+              {editText}
+            </TabsTrigger>
+          </TabsList>
+        </Tabs>
+      </div>
+
+      {isEditing ? (
+        <Textarea
+          value={draft ?? contents}
+          onChange={(event) => setDraft(event.target.value)}
+          aria-label={editorLabel}
+          spellCheck={false}
+          variant="code"
+          className="min-h-[360px] resize-y bg-background"
+        />
+      ) : (
+        <article className="prose prose-sm dark:prose-invert max-w-none rounded-md border bg-muted/50 px-4 py-4 text-xs prose-p:text-xs prose-p:my-4 prose-li:text-xs prose-ul:pl-4 prose-headings:font-medium prose-headings:mb-1 prose-h1:text-sm prose-h2:text-xs prose-h2:mt-6 prose-h3:text-xs prose-h3:mt-5 prose-em:text-muted-foreground prose-li:marker:text-[color:inherit] [&_h1+p]:mt-1 [&_h2+p]:mt-1 [&_h3+p]:mt-1 [&_h1+ul]:mt-1 [&_h2+ul]:mt-1 [&_h3+ul]:mt-1">
+          <ReactMarkdown remarkPlugins={[remarkGfm]}>{contents}</ReactMarkdown>
+        </article>
+      )}
+
+      {saveError && (
+        <p className="text-sm text-destructive" role="alert">
+          {saveError}
+        </p>
+      )}
+
+      <div className="flex items-center justify-between gap-2">
+        <p className="text-xs text-muted-foreground">
+          {hasUnsavedChanges && !isEditing ? unsavedText : footer}
+        </p>
+        <div className="flex items-center gap-2">
+          {isEditing || hasUnsavedChanges ? (
+            <>
+              <Button onClick={handleCancel} size="xs" variant="ghost">
+                {cancelText}
+              </Button>
+              <Button
+                onClick={() => void handleSave()}
+                size="xs"
+                variant="primary"
+                disabled={!hasUnsavedChanges}
+              >
+                {saveText}
+              </Button>
+            </>
+          ) : (
+            onRefresh && (
+              <Button
+                onClick={onRefresh}
+                size="xs"
+                variant="ghost"
+                aria-label={refreshLabel}
+              >
+                <RefreshCw className="size-3.5" />
+                {refreshLabel}
+              </Button>
+            )
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function MeSettings() {
+  const { t } = useTranslation("settings");
+  const [state, setState] = useState<LoadState>({ status: "loading" });
+  const [topics, setTopics] = useState<TopicDoc[]>([]);
+  const [openTopic, setOpenTopic] = useState<string | null>(null);
+  const [creatingTopic, setCreatingTopic] = useState(false);
+  const [newTopicName, setNewTopicName] = useState("");
+  const [topicError, setTopicError] = useState(false);
+  const [memoryEnabled, setMemoryEnabled] = useState(false);
+  const { proposals, approve, decline } = useMemoryProposals();
+  const [proposalDrafts, setProposalDrafts] = useState<Record<string, string>>(
+    {},
+  );
+  const [proposalError, setProposalError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      setState(await loadMeFile());
+    } catch {
+      setState({ status: "error" });
+    }
+    try {
+      setTopics(await listTopics());
+    } catch {
+      // Topic listing is additive; a failure leaves the section empty
+      // rather than breaking the page.
+      setTopics([]);
+    }
+    // policy.json is the one durable owner. Missing or malformed policy is off.
+    const policy = await readMemoryPolicy();
+    setMemoryEnabled(policy?.enabled === true);
+  }, []);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  // Create the starter file only after the person explicitly enables memory.
+  useEffect(() => {
+    if (!memoryEnabled || state.status !== "missing") return;
+    void createMeFile()
+      .then(setState)
+      .catch(() => {
+        // Best-effort: a failed seed leaves the create button in place.
+      });
+  }, [memoryEnabled, state.status]);
+
+  const handleApproveProposal = async (proposal: MemoryProposal) => {
+    setProposalError(null);
+    try {
+      await approve(
+        proposal,
+        proposalDrafts[proposal.id] ?? proposal.content,
+        proposal.topic,
+      );
+      setProposalDrafts((current) => {
+        const next = { ...current };
+        delete next[proposal.id];
+        return next;
+      });
+      await refresh();
+    } catch (error) {
+      setProposalError(
+        error instanceof CredentialMemoryError
+          ? t("me.proposals.credentialError")
+          : error instanceof UnsafeMemoryTextError
+            ? t("me.proposals.unsafeUnicodeError")
+            : t("me.proposals.approveError"),
+      );
+    }
+  };
+
+  const handleDeclineProposal = async (proposal: MemoryProposal) => {
+    await decline(proposal);
+  };
+
+  const handleMemoryToggle = async (enabled: boolean) => {
+    // policy.json is the source of truth. Don't present a toggle state the
+    // store failed to persist.
+    if (!(await writeMemoryPolicy(enabled))) {
+      const policy = await readMemoryPolicy();
+      setMemoryEnabled(policy?.enabled === true);
+      return;
+    }
+    setMemoryEnabled(enabled);
+
+    if (enabled && state.status !== "present") {
+      try {
+        setState(await createMeFile());
+      } catch {
+        // A failed seed leaves the create button in place.
+      }
+    }
+  };
+
+  // The store folder, derived from the canonical spine path.
+  const storeFolder =
+    state.status === "present"
+      ? {
+          path: state.path.replace(/\/[^/]+$/, ""),
+          display: state.displayPath.replace(/\/[^/]+$/, ""),
+        }
+      : null;
+
+  const handleCreateTopic = async () => {
+    const name = newTopicName.trim();
+    if (!name) return;
+    setTopicError(false);
+    try {
+      const topic = await createTopic(name);
+      setCreatingTopic(false);
+      setNewTopicName("");
+      await refresh();
+      setOpenTopic(topic.path);
+    } catch {
+      // Most likely cause: a topic with this file name already exists.
+      setTopicError(true);
+    }
+  };
+
+  const docStrings = {
+    editorLabel: t("me.editorLabel"),
+    saveErrorText: t("me.saveError"),
+    unsafeUnicodeErrorText: t("me.unsafeUnicodeError"),
+    cancelText: t("me.cancel"),
+    saveText: t("me.save"),
+    previewText: t("me.previewTab"),
+    editText: t("me.editTab"),
+    unsavedText: t("me.unsavedChanges"),
+  };
+
+  return (
+    <SettingsPage title={t("me.title")}>
+      <SettingsSections>
+        <SettingsSection>
+          <SettingsRow
+            label={t("me.toggle.label")}
+            description={
+              <>
+                {t("me.toggle.description")}
+                <span className="mt-2 block">
+                  {storeFolder && (
+                    <>
+                      {t("me.livesIn")}{" "}
+                      <StorePathLink
+                        path={storeFolder.path}
+                        label={storeFolder.display}
+                      />
+                      .{" "}
+                    </>
+                  )}
+                </span>
+              </>
+            }
+          >
+            <Switch
+              checked={memoryEnabled}
+              onCheckedChange={handleMemoryToggle}
+              aria-label={t("me.toggle.label")}
+            />
+          </SettingsRow>
+        </SettingsSection>
+
+        {!memoryEnabled && (
+          <div className="rounded-md border bg-muted/50 px-4 py-3">
+            <p className="text-xs text-muted-foreground">
+              {t("me.offBanner.description")}
+            </p>
+          </div>
+        )}
+
+        {proposals.length > 0 && (
+          <SettingsSection
+            title={t("me.proposals.title")}
+            className="border-b border-border pb-11"
+          >
+            <div className="space-y-3 pb-1">
+              <p className="text-xs text-muted-foreground">
+                {t("me.proposals.description")}
+              </p>
+              {proposalError && (
+                <p className="text-sm text-destructive" role="alert">
+                  {proposalError}
+                </p>
+              )}
+              <div className="space-y-3">
+                {proposals.map((proposal) => (
+                  <div
+                    key={proposal.id}
+                    className="space-y-3 rounded-md border bg-muted/50 px-4 py-3"
+                  >
+                    <Textarea
+                      value={proposalDrafts[proposal.id] ?? proposal.content}
+                      onChange={(event) =>
+                        setProposalDrafts((current) => ({
+                          ...current,
+                          [proposal.id]: event.target.value,
+                        }))
+                      }
+                      aria-label={t("me.proposals.editorLabel")}
+                      className="min-h-20 resize-y bg-background text-xs"
+                    />
+                    <div className="flex items-center justify-between gap-3">
+                      <p className="text-xs text-muted-foreground">
+                        {proposal.topic
+                          ? t("me.proposals.topicLabel", {
+                              topic: proposal.topic,
+                            })
+                          : t("me.proposals.generalLabel")}
+                      </p>
+                      <div className="flex shrink-0 items-center gap-2">
+                        <Button
+                          size="sm"
+                          variant="ghost"
+                          destructive
+                          onClick={() => void handleDeclineProposal(proposal)}
+                        >
+                          {t("me.proposals.dismiss")}
+                        </Button>
+                        <Button
+                          size="sm"
+                          variant="primary"
+                          disabled={
+                            !(
+                              proposalDrafts[proposal.id] ?? proposal.content
+                            ).trim()
+                          }
+                          onClick={() => void handleApproveProposal(proposal)}
+                        >
+                          {t("me.proposals.approve")}
+                        </Button>
+                      </div>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          </SettingsSection>
+        )}
+
+        {memoryEnabled && (
+          <>
+            <SettingsSection title={t("me.spineTitle")}>
+              {/* space-y-11 matches the 44px rhythm between settings sections,
+                  giving the document block clear separation from the
+                  About you description. */}
+              <div className="space-y-11">
+                <p className="text-xs text-muted-foreground">
+                  {t("me.description")}
+                </p>
+
+                {state.status === "error" && (
+                  <p className="text-sm text-destructive">
+                    {t("me.loadError")}
+                  </p>
+                )}
+
+                {/* No file yet just means the starter template hasn't been
+                    written to disk — show it as the document, and the first
+                    save creates the file. */}
+                {state.status === "missing" && (
+                  <DocumentPanel
+                    contents={ME_FILE_TEMPLATE}
+                    // One write, one publish: seeding with createMeFile first
+                    // would race its template publication against this save's
+                    // publication of the user's content.
+                    onSave={async (next) => {
+                      await saveMeFile(state.path, next);
+                      await refresh();
+                    }}
+                    refreshLabel={t("me.refresh")}
+                    onRefresh={() => void refresh()}
+                    {...docStrings}
+                  />
+                )}
+
+                {state.status === "present" && (
+                  <DocumentPanel
+                    // A file emptied by hand is the same story as no file
+                    // yet: show the starter template rather than a blank
+                    // card, and the next save writes it for real.
+                    contents={
+                      state.contents.trim() ? state.contents : ME_FILE_TEMPLATE
+                    }
+                    onSave={async (next) => {
+                      await saveMeFile(state.path, next);
+                      await refresh();
+                    }}
+                    refreshLabel={t("me.refresh")}
+                    onRefresh={() => void refresh()}
+                    {...docStrings}
+                  />
+                )}
+              </div>
+            </SettingsSection>
+
+            <SettingsSection title={t("me.topicsTitle")}>
+              <SettingsRow
+                label={t("me.addTopic")}
+                description={t("me.topicsHint")}
+                className="border-b border-border"
+                action={
+                  !creatingTopic ? (
+                    <Button
+                      size="xs"
+                      variant="outline"
+                      className="shrink-0"
+                      onClick={() => setCreatingTopic(true)}
+                    >
+                      {t("me.addTopicAction")}
+                    </Button>
+                  ) : undefined
+                }
+              />
+
+              {topics.length === 0 && !creatingTopic && (
+                <p className="pt-6 pb-3 text-xs text-muted-foreground">
+                  {t("me.noTopics")}
+                </p>
+              )}
+
+              {topics.map((topic) => (
+                <SettingsRow
+                  key={topic.path}
+                  label={topic.label}
+                  description={topic.description ?? topic.fileName}
+                  // The whole row toggles the topic open; the chevron is the
+                  // keyboard-accessible control and stops propagation so the
+                  // row handler doesn't double-toggle.
+                  className="cursor-pointer"
+                  onClick={() =>
+                    setOpenTopic(openTopic === topic.path ? null : topic.path)
+                  }
+                  action={
+                    <Button
+                      size="icon-xs"
+                      variant="ghost"
+                      aria-expanded={openTopic === topic.path}
+                      aria-label={
+                        openTopic === topic.path
+                          ? t("me.closeTopic")
+                          : t("me.openTopic")
+                      }
+                      onClick={(event) => {
+                        event.stopPropagation();
+                        setOpenTopic(
+                          openTopic === topic.path ? null : topic.path,
+                        );
+                      }}
+                    >
+                      <ChevronDown
+                        aria-hidden="true"
+                        className={cn(openTopic === topic.path && "rotate-180")}
+                      />
+                    </Button>
+                  }
+                  details={
+                    openTopic === topic.path ? (
+                      // Interacting with the open document must not collapse
+                      // the row.
+                      // biome-ignore lint/a11y/noStaticElementInteractions: propagation guard, not an interactive control
+                      // biome-ignore lint/a11y/useKeyWithClickEvents: propagation guard only; keyboard events don't bubble a click
+                      <div onClick={(event) => event.stopPropagation()}>
+                        <DocumentPanel
+                          contents={topic.contents}
+                          onSave={async (next) => {
+                            await saveTopic(topic.path, next, topic.label);
+                            await refresh();
+                          }}
+                          {...docStrings}
+                        />
+                      </div>
+                    ) : undefined
+                  }
+                />
+              ))}
+
+              {creatingTopic && (
+                <SettingsRow
+                  label={
+                    <span className="text-xs text-muted-foreground">
+                      {t("me.newTopicDescription")}
+                    </span>
+                  }
+                  action={
+                    <div className="flex items-center gap-2">
+                      <Input
+                        value={newTopicName}
+                        onChange={(event) =>
+                          setNewTopicName(event.target.value)
+                        }
+                        onKeyDown={(event) => {
+                          if (event.key === "Enter") void handleCreateTopic();
+                          if (event.key === "Escape") {
+                            setCreatingTopic(false);
+                            setNewTopicName("");
+                            setTopicError(false);
+                          }
+                        }}
+                        placeholder={t("me.newTopicPlaceholder")}
+                        aria-label={t("me.newTopicLabel")}
+                        className="h-8 w-44"
+                        autoFocus
+                      />
+                      <Button
+                        size="sm"
+                        onClick={() => void handleCreateTopic()}
+                        disabled={!newTopicName.trim()}
+                      >
+                        {t("me.create")}
+                      </Button>
+                      <Button
+                        size="sm"
+                        variant="ghost"
+                        onClick={() => {
+                          setCreatingTopic(false);
+                          setNewTopicName("");
+                          setTopicError(false);
+                        }}
+                      >
+                        {t("me.cancel")}
+                      </Button>
+                    </div>
+                  }
+                  details={
+                    topicError ? (
+                      <p className="text-sm text-destructive" role="alert">
+                        {t("me.newTopicError")}
+                      </p>
+                    ) : undefined
+                  }
+                />
+              )}
+            </SettingsSection>
+          </>
+        )}
+      </SettingsSections>
+    </SettingsPage>
+  );
+}
diff --git a/src/features/me/ui/MemoryProposalToasts.tsx b/src/features/me/ui/MemoryProposalToasts.tsx
new file mode 100644
index 000000000..dc54de982
--- /dev/null
+++ b/src/features/me/ui/MemoryProposalToasts.tsx
@@ -0,0 +1,50 @@
+import { useEffect } from "react";
+import { useTranslation } from "react-i18next";
+
+import { useMemoryProposals } from "../hooks/useMemoryProposals";
+import { showMemoryProposalToast } from "../lib/memoryProposalToast";
+import { requestOpenSettings } from "@/features/settings/lib/settingsEvents";
+import { ToastActionButton, ToastActionGroup } from "@/shared/ui/sonner";
+
+/** Proposal notifications. Sessionless MCP proposals are shown globally. */
+export function MemoryProposalToasts({
+  sessionId,
+  sessionlessOnly = false,
+}: {
+  sessionId?: string;
+  sessionlessOnly?: boolean;
+}) {
+  const { t } = useTranslation("settings");
+  const { proposals, decline } = useMemoryProposals(sessionId, {
+    sessionlessOnly,
+  });
+
+  useEffect(() => {
+    if (!sessionlessOnly && !sessionId) return;
+    for (const proposal of proposals) {
+      showMemoryProposalToast({
+        proposal,
+        destination: proposal.topic
+          ? t("me.proposals.topicLabel", { topic: proposal.topic })
+          : t("me.proposals.generalLabel"),
+        title: t("me.proposals.title"),
+        reviewLabel: t("me.proposals.review"),
+        declineLabel: t("me.proposals.dismiss"),
+        onReview: () => requestOpenSettings("me"),
+        onDecline: (item) => void decline(item),
+        renderActions: ({ reviewLabel, declineLabel, onReview, onDecline }) => (
+          <ToastActionGroup>
+            <ToastActionButton emphasis="secondary" onClick={onDecline}>
+              {declineLabel}
+            </ToastActionButton>
+            <ToastActionButton onClick={onReview}>
+              {reviewLabel}
+            </ToastActionButton>
+          </ToastActionGroup>
+        ),
+      });
+    }
+  }, [proposals, sessionId, sessionlessOnly, decline, t]);
+
+  return null;
+}
diff --git a/src/features/me/ui/StorePathLink.tsx b/src/features/me/ui/StorePathLink.tsx
new file mode 100644
index 000000000..1b0a8be7a
--- /dev/null
+++ b/src/features/me/ui/StorePathLink.tsx
@@ -0,0 +1,31 @@
+import { revealInFileManager } from "@/shared/lib/fileManager";
+
+/**
+ * A store path that opens where it points.
+ *
+ * The path *is* the link: naming a location and then offering a separate
+ * "Go to file" said the same thing twice, and the path is the part a person
+ * recognizes. Best-effort — if the file manager can't open it, the text still
+ * answers the question on its own.
+ */
+export function StorePathLink({
+  path,
+  label,
+}: {
+  /** The real path to reveal. */
+  path: string;
+  /** How it reads on screen, usually ~-relative. */
+  label: string;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={() => {
+        void revealInFileManager(path).catch(() => {});
+      }}
+      className="underline underline-offset-2 hover:text-foreground"
+    >
+      {label}
+    </button>
+  );
+}
diff --git a/src/features/navigation/ui/PrimaryNavigationSurface.tsx b/src/features/navigation/ui/PrimaryNavigationSurface.tsx
index a4da6dede..7ce9a1f5c 100644
--- a/src/features/navigation/ui/PrimaryNavigationSurface.tsx
+++ b/src/features/navigation/ui/PrimaryNavigationSurface.tsx
@@ -16,6 +16,7 @@ import {
   type SETTINGS_SECTIONS,
   type SectionId,
 } from "@/features/settings/ui/settingsSections";
+import { useMemoryProposalsPending } from "@/features/me/hooks/useMemoryProposalsPending";
 import { cn } from "@/shared/lib/cn";
 import {
   SIDEBAR_PANEL_ELEVATED_SHADOW_CLASS,
@@ -100,6 +101,7 @@ export const PrimaryNavigationSurface = forwardRef<
   ref,
 ) {
   const { t } = useTranslation(["sidebar", "settings"]);
+  const memoryProposalsPending = useMemoryProposalsPending();
   const mainNavItems: readonly {
     id: AppView;
     label: string;
@@ -258,6 +260,11 @@ export const PrimaryNavigationSurface = forwardRef<
               {settingsSections.map((item) => {
                 const showUpdate =
                   item.id === "providers" && agentUpdatesAvailable;
+                // Pending memory proposals badge the Memory row only —
+                // deliberately not the top-level Settings nav item, which
+                // would be noisy for a quiet, non-urgent queue.
+                const showProposals =
+                  item.id === "me" && memoryProposalsPending > 0;
                 return (
                   <SidebarNavItem
                     key={item.id}
@@ -275,12 +282,23 @@ export const PrimaryNavigationSurface = forwardRef<
                           aria-hidden="true"
                           className="size-3.5 text-warning"
                         />
+                      ) : showProposals ? (
+                        <span
+                          aria-hidden="true"
+                          className="flex min-w-4 items-center justify-center rounded-full bg-accent px-1 text-[10px] font-medium leading-4 text-accent-foreground"
+                        >
+                          {memoryProposalsPending}
+                        </span>
                       ) : undefined
                     }
                     trailingLabel={
                       showUpdate
                         ? t("settings:nav.providersUpdateAvailable")
-                        : undefined
+                        : showProposals
+                          ? t("settings:nav.memoryProposalsPending", {
+                              count: memoryProposalsPending,
+                            })
+                          : undefined
                     }
                   />
                 );
diff --git a/src/features/settings/ui/SettingsView.tsx b/src/features/settings/ui/SettingsView.tsx
index e91ba73ea..9f04cb1e2 100644
--- a/src/features/settings/ui/SettingsView.tsx
+++ b/src/features/settings/ui/SettingsView.tsx
@@ -11,6 +11,7 @@ import type { SectionId } from "./settingsSections";
 import { ExperimentsSettings } from "@/features/experiments/ExperimentsSettings";
 import { KeyboardShortcutsSettings } from "@/features/shortcuts/ui/KeyboardShortcutsSettings";
 import { ConnectionsSettings } from "@/features/connections/ui/ConnectionsSettings";
+import { MeSettings } from "@/features/me/ui/MeSettings";
 import { VoiceSettings } from "@/features/voice-conversation/ui/VoiceSettings";
 import type { AuthStatus } from "@/features/auth/api/auth";
 import { SettingsPane } from "@/shared/ui/SettingsPage";
@@ -86,6 +87,7 @@ export function SettingsView({
           onReturnToAgentDraft={onReturnToAgentDraft}
         />
       )}
+      {activeSection === "me" && <MeSettings />}
       {activeSection === "notifications" && <NotificationSettings />}
       {activeSection === "shortcuts" && <KeyboardShortcutsSettings />}
       {activeSection === "voice" && voiceConversationEnabled && (
diff --git a/src/features/settings/ui/settingsSections.ts b/src/features/settings/ui/settingsSections.ts
index b8aeda59a..1a29e3ec5 100644
--- a/src/features/settings/ui/settingsSections.ts
+++ b/src/features/settings/ui/settingsSections.ts
@@ -9,6 +9,7 @@ import {
   Settings2,
   Shield,
   SlidersHorizontal,
+  UserRound,
 } from "lucide-react";
 import { IconPlug, IconServer } from "@tabler/icons-react";
 import type {
@@ -93,6 +94,7 @@ type SettingsSectionDefinition = {
 export const SETTINGS_SECTIONS = [
   { id: "appearance", labelKey: "nav.appearance", icon: Palette },
   { id: "behavior", labelKey: "nav.behavior", icon: SlidersHorizontal },
+  { id: "me", labelKey: "nav.me", icon: UserRound },
   { id: "connections", labelKey: "nav.connections", icon: IconPlug },
   { id: "providers", labelKey: "nav.providers", icon: IconServer },
   { id: "notifications", labelKey: "nav.notifications", icon: Bell },
diff --git a/src/shared/api/system.ts b/src/shared/api/system.ts
index 1658e46d4..54a9b97af 100644
--- a/src/shared/api/system.ts
+++ b/src/shared/api/system.ts
@@ -233,3 +233,34 @@ export async function writeTextFile(
 ): Promise<void> {
   return invoke("write_memory_text_file", { path, contents });
 }
+
+/** Append noticer candidates under the backend-owned memory queue lock. */
+export async function appendMemoryProposals(
+  candidates: Array<{
+    content: string;
+    topic: string | null;
+    sessionId: string | null;
+  }>,
+): Promise<number> {
+  return invoke("append_memory_proposals", { candidates });
+}
+
+export async function approveMemoryProposal(
+  id: string,
+  content: string,
+  topic: string | null,
+): Promise<{ approved: boolean }> {
+  return invoke("approve_memory_proposal", { id, content, topic });
+}
+
+/** Remove one proposal; declines retain only a salted suppression fingerprint. */
+export async function resolveMemoryProposal(
+  id: string,
+  declined?: { content: string; topic: string | null },
+): Promise<void> {
+  await invoke("resolve_memory_proposal", {
+    id,
+    declinedContent: declined?.content ?? null,
+    declinedTopic: declined?.topic ?? null,
+  });
+}
diff --git a/src/shared/i18n/locales/en/settings.json b/src/shared/i18n/locales/en/settings.json
index cfd8a9ffd..ca8c6515f 100644
--- a/src/shared/i18n/locales/en/settings.json
+++ b/src/shared/i18n/locales/en/settings.json
@@ -65,23 +65,23 @@
     }
   },
   "archive": {
-    "title": "Archive",
     "autoArchive": {
-      "sectionTitle": "Automatic archiving",
-      "label": "Archive inactive chats",
-      "description": "Automatically archive chats after this much time without a message. Chats pinned to Home are never archived automatically.",
-      "confirmTitle": "Turn on automatic archiving?",
-      "confirmDescription": "Berd will archive unpinned chats {{duration}} without another prompt. You can restore them from Archive or turn this off at any time.",
       "confirmAction": "Turn on",
+      "confirmDescription": "Berd will archive unpinned chats {{duration}} without another prompt. You can restore them from Archive or turn this off at any time.",
+      "confirmTitle": "Turn on automatic archiving?",
+      "description": "Automatically archive chats after this much time without a message. Chats pinned to Home are never archived automatically.",
+      "label": "Archive inactive chats",
       "options": {
-        "never": "Never",
         "1-day": "After 1 day",
-        "7-days": "After 7 days",
         "14-days": "After 14 days",
         "30-days": "After 30 days",
-        "90-days": "After 90 days"
-      }
-    }
+        "7-days": "After 7 days",
+        "90-days": "After 90 days",
+        "never": "Never"
+      },
+      "sectionTitle": "Automatic archiving"
+    },
+    "title": "Archive"
   },
   "chats": {
     "empty": "Archived chats will show here.",
@@ -105,6 +105,9 @@
     "title": "Compaction"
   },
   "connections": {
+    "askAgent": "Add connection",
+    "askAgentPrompt": "Help me add a connection. First ask whether I want a company-managed service or a local MCP, then explain the setup and access requirements. Ask before changing any configuration and never print or copy credentials.",
+    "askAgentTitle": "Add a connection",
     "configure": "Configure",
     "connect": "Connect",
     "connectError": "Couldn't open the connect flow. Try again.",
@@ -119,12 +122,20 @@
     "expiresToday": "Expires today",
     "expiresTomorrow": "Expires tomorrow",
     "extendAccess": "Extend access",
+    "localError": {
+      "description": "Try again in a moment.",
+      "partialDescription": "Berd couldn’t read every local configuration source.",
+      "partialTitle": "Some local MCPs may be missing",
+      "retry": "Try again",
+      "retrying": "Trying…",
+      "title": "Couldn’t load your local MCPs"
+    },
     "noResults": "No connections match your search.",
     "reconnect": "Reconnect",
     "search": "Search connections",
     "sections": {
-      "managed": "Company managed",
-      "local": "Local"
+      "local": "Local",
+      "managed": "Company managed"
     },
     "status": {
       "active": "Active",
@@ -132,18 +143,7 @@
       "expired": "Expired"
     },
     "title": "Connections",
-    "worksWith": "Works with: {{harnesses}}",
-    "localError": {
-      "title": "Couldn’t load your local MCPs",
-      "description": "Try again in a moment.",
-      "partialTitle": "Some local MCPs may be missing",
-      "partialDescription": "Berd couldn’t read every local configuration source.",
-      "retry": "Try again",
-      "retrying": "Trying…"
-    },
-    "askAgent": "Add connection",
-    "askAgentTitle": "Add a connection",
-    "askAgentPrompt": "Help me add a connection. First ask whether I want a company-managed service or a local MCP, then explain the setup and access requirements. Ask before changing any configuration and never print or copy credentials."
+    "worksWith": "Works with: {{harnesses}}"
   },
   "deleteProject": {
     "description": "Removes the project and all its data. You can't undo this.",
@@ -211,9 +211,9 @@
       "description": "Show the Builderbot tasks and automations surface.",
       "title": "Builderbot"
     },
-    "relatedPullRequests": {
-      "description": "Show the PR Inbox and the current status of pull requests linked in a chat.",
-      "title": "PR Inbox"
+    "chatOnCanvas": {
+      "description": "Expand pinned chats into live conversation cards on Home where you can read and respond.",
+      "title": "Chat on canvas"
     },
     "defaultLabel": "default",
     "description": "Opt into in-progress Berd features on this device. Experiments can change, break, or disappear.",
@@ -235,6 +235,10 @@
       "description": "Pin saved prompts to Home that run with one click, optionally with an attached agent.",
       "title": "Prompt pins"
     },
+    "relatedPullRequests": {
+      "description": "Show the PR Inbox and the current status of pull requests linked in a chat.",
+      "title": "PR Inbox"
+    },
     "remoteSshSessions": {
       "description": "Run sessions on a remote machine over SSH using hosts from your SSH config. Berd starts and tunnels to a Goose daemon on the remote host.",
       "title": "Remote SSH sessions"
@@ -260,10 +264,6 @@
     "voiceConversation": {
       "description": "Try continuous two-way voice conversations in Goose chats.",
       "title": "Voice conversations"
-    },
-    "chatOnCanvas": {
-      "title": "Chat on canvas",
-      "description": "Expand pinned chats into live conversation cards on Home where you can read and respond."
     }
   },
   "extensions": {
@@ -416,6 +416,52 @@
     },
     "title": "General"
   },
+  "me": {
+    "addTopic": "Add topic",
+    "addTopicAction": "Add",
+    "cancel": "Cancel",
+    "closeTopic": "Close",
+    "create": "Create my file",
+    "description": "Approved details, preferences, and boundaries that can help agents work better with you across chats.",
+    "editTab": "Edit",
+    "editorLabel": "Edit your me.md",
+    "livesIn": "Approved memories stay in plain-text files on your computer at",
+    "loadError": "Couldn't read your file. It may have been moved or deleted.",
+    "newTopicDescription": "A topic is its own document. Agents read it only when that part of your life is what's going on.",
+    "newTopicError": "Couldn't create that topic. A topic with a similar name may already exist.",
+    "newTopicLabel": "Name your topic",
+    "newTopicPlaceholder": "Style, Family, Travel…",
+    "noTopics": "No topics yet. Topics hold deeper knowledge, like style, family, or work, that only loads when it's relevant.",
+    "offBanner": {
+      "description": "Berd won’t use your approved memories or suggest new ones. Memory files and pending proposals will stay on your computer unless you remove them."
+    },
+    "openTopic": "View",
+    "previewTab": "Preview",
+    "refresh": "Refresh",
+    "save": "Save",
+    "saveError": "Couldn't save your changes. Your edits are still here, so try again.",
+    "unsafeUnicodeError": "Memory text can't include hidden Unicode control characters.",
+    "spineTitle": "About you",
+    "title": "Memory",
+    "toggle": {
+      "description": "Memory helps Berd remember what matters about you and how you like to work. Berd may suggest memories from your chats, but nothing is saved without your approval. Review, edit, or delete anything at any time here.",
+      "label": "Use memory"
+    },
+    "topicsHint": "Topics provide more specific knowledge that only loads when it's relevant. Add or update them here.",
+    "topicsTitle": "Topics",
+    "unsavedChanges": "Unsaved changes",
+    "proposals": {
+      "title": "Memory proposed",
+      "description": "Review these suggestions before anything is added to your memory. You can edit the wording first.",
+      "review": "Review",
+      "dismiss": "Decline",
+      "approve": "Add to memory",
+      "editorLabel": "Edit proposed memory",
+      "credentialError": "Authentication and access data can't be saved to memory.",
+      "unsafeUnicodeError": "Memory text can't include hidden Unicode control characters.",
+      "approveError": "Couldn't add this memory. Try again."
+    }
+  },
   "nav": {
     "appearance": "Appearance",
     "archive": "Archive",
@@ -426,6 +472,7 @@
     "experiments": "Experiments",
     "extensions": "Extensions",
     "general": "General",
+    "me": "Memory",
     "notifications": "Notifications",
     "providers": "AI providers",
     "providersUpdateAvailable": "Update available",
@@ -433,7 +480,8 @@
     "shortcuts": "Keyboard shortcuts",
     "system": "System",
     "updates": "Updates",
-    "voice": "Voice"
+    "voice": "Voice",
+    "memoryProposalsPending": "{{count}} memory proposals to review"
   },
   "navigationLabel": "Settings navigation",
   "notifications": {
@@ -932,83 +980,16 @@
     }
   },
   "voice": {
-    "conversationMode": "Voice mode",
-    "conversationModeDescription": "Choose who you talk with during a voice conversation.",
-    "defaultOption": "{{value}} (default)",
-    "modeChained": "Talk to your coding agent",
-    "modeChainedDescription": "Your speech becomes a message to your coding agent, and its response is read aloud. Best for direct, project-aware work.",
-    "modeOpenAiRealtime": "Talk through a voice assistant",
-    "modeOpenAiRealtimeDescription": "Have a lower-latency, more natural conversation with a voice assistant that consults your coding agent when it needs your project or tools. Requires an OpenAI API key.",
-    "cloud": "Cloud",
-    "local": "Local",
-    "recommended": "Recommended",
-    "resetToDefaults": "Reset to defaults",
-    "resetToDefaultsDescription": "Restores “Talk to your coding agent” with the recommended speech backends. API keys and downloaded models are kept.",
-    "resetToDefaultsConfirmTitle": "Reset all voice settings?",
-    "resetToDefaultsConfirmDescription": "This restores “Talk to your coding agent,” the recommended speech-to-text and text-to-speech backends, the default voice and speed, and all advanced defaults. API keys and downloaded models are kept.",
-    "resettingToDefaults": "Resetting…",
-    "realtimeAdvanced": "Advanced",
-    "realtimeApiKey": "OpenAI API key",
-    "realtimeApiKeyDescription": "Saved securely in macOS Keychain and shared by Realtime listening and speech.",
-    "realtimeCreateResponse": "Respond automatically",
-    "realtimeCreateResponseDescription": "Generate a voice assistant response when a detected user turn ends.",
-    "realtimeEagerness": "Turn-taking eagerness",
-    "realtimeEagernessAuto": "Balanced (automatic)",
-    "realtimeEagernessHigh": "Eager",
-    "realtimeEagernessLow": "Patient",
-    "realtimeEagernessMedium": "Moderate",
-    "realtimeIdleTimeout": "Idle timeout (ms)",
-    "realtimeInterruptResponse": "Interrupt when I speak",
-    "realtimeInterruptResponseDescription": "Stops the voice assistant's current response when new speech begins.",
-    "realtimeMaxOutputTokens": "Maximum response tokens",
-    "realtimeModel": "Realtime model",
-    "realtimeNoiseReduction": "Noise reduction",
-    "realtimeNoiseReductionFar": "Far-field microphone",
-    "realtimeNoiseReductionNear": "Near-field microphone",
-    "realtimeNoiseReductionOff": "Off",
-    "realtimeOff": "Off",
-    "realtimePrefixPadding": "Speech lead-in (ms)",
-    "realtimePresentation": "Conversation presentation",
-    "realtimePresentationDebug": "Debug — show agent routing",
-    "realtimePresentationDescription": "Debug shows color-coded voice assistant speech and private routing. Subtle presents one seamless assistant and keeps routing in the background.",
-    "realtimePresentationSubtle": "Subtle — one assistant",
-    "realtimeReasoningEffort": "Reasoning effort",
-    "realtimeReasoningEfforts": {
-      "default": "Model default",
-      "high": "High",
-      "low": "Low",
-      "medium": "Medium",
-      "none": "None"
-    },
-    "realtimeServerVad": "Server VAD tuning",
-    "realtimeSilenceDuration": "End pause (ms)",
-    "realtimeSpeed": "Speaking speed",
-    "realtimeSpeedDescription": "Adjusts generated speech from 0.25× to 1.5×. Applies when the next voice session starts.",
-    "realtimeTranscriptionLanguage": "Transcription language",
-    "realtimeTranscriptionLanguagePlaceholder": "Automatic (for example, en)",
-    "realtimeTranscriptionModel": "STT model",
-    "realtimeTranscriptionModelDescription": "Realtime Whisper balances fast partial transcripts with accuracy; choose another model to tune the tradeoff.",
-    "realtimeTranscriptionPrompt": "Transcription hints",
-    "realtimeTranscriptionPromptDescription": "Guides transcription without changing the spoken conversation.",
-    "realtimeTranscriptionPromptPlaceholder": "Names, technical terms, or expected vocabulary",
-    "realtimeTurnDetection": "Turn detection",
-    "realtimeTurnDetectionSemantic": "Semantic VAD",
-    "realtimeTurnDetectionServer": "Server VAD",
-    "realtimeUnlimited": "Unlimited",
-    "realtimeVadThreshold": "Voice activation threshold",
-    "realtimeVoice": "Voice",
-    "backendMacSpeech": "Apple STT",
-    "backendOpenAiStt": "OpenAI STT",
-    "backendOpenAiTts": "OpenAI TTS",
+    "backendMacSpeech": "Apple speech recognition",
+    "backendOpenAiStt": "OpenAI speech-to-text",
+    "backendOpenAiTts": "OpenAI text-to-speech",
     "backendParakeet": "Parakeet STT",
     "backendPocket": "Pocket TTS",
-    "backendSiri": "Apple TTS",
+    "backendSiri": "Siri voices",
     "chooseVoice": "Choose…",
     "chooseVoiceLabel": "Choose a voice: {{voice}}",
     "chooseVoiceTitle": "Choose a voice",
     "download": "Download model",
-    "downloadVoice": "Download {{voice}}",
-    "downloadingVoice": "Downloading {{voice}}",
     "downloadPhase": {
       "complete": "Installed",
       "downloading": "Downloading",
@@ -1018,13 +999,10 @@
       "verifying": "Verifying model"
     },
     "downloadProgress": "{{downloaded}} of {{total}}",
-    "inputBackendDescription": "Choose a backend.",
-    "macSpeechDownloading": "Downloading dictation model… {{progress}}%",
-    "macSpeechLoading": "Checking macOS speech recognition…",
-    "macSpeechLocaleUnsupported": "Apple speech recognition does not support {{locale}}.",
-    "macSpeechModel": "On-device dictation",
-    "macSpeechNotInstalled": "Not installed for {{locale}}",
-    "macSpeechSystemLocale": "the system language",
+    "downloadVoice": "Download {{voice}}",
+    "downloadingVoice": "Downloading {{voice}}",
+    "inputBackendDescription": "Choose how Berd transcribes your speech.",
+    "interruptionDescription": "Choose what happens when you speak while Berd is talking.",
     "interruptionMode": "Interruptions",
     "interruptionModeDescriptions": {
       "allowInterruptions": "Berd keeps listening on every audio device. You can interrupt, but speaker audio may be mistaken for your voice.",
@@ -1036,10 +1014,19 @@
       "automatic": "Automatic",
       "preventFeedback": "Prevent feedback"
     },
+    "macSpeechDownloading": "Downloading dictation model… {{progress}}%",
+    "macSpeechLoading": "Checking macOS speech recognition…",
+    "macSpeechLocaleUnsupported": "Apple speech recognition does not support {{locale}}.",
+    "macSpeechModel": "On-device dictation",
+    "macSpeechNotInstalled": "Not installed for {{locale}}",
+    "macSpeechSystemLocale": "the system language",
+    "microphonePermissionDenied": "Microphone access is turned off for Berd. Allow access in System Settings to use Voice Conversation.",
+    "microphonePermissionTitle": "Microphone access is required",
     "modelInstalled": "Installed",
     "modelInstalledSize": "{{size}} · Installed",
     "modelMissingSize": "Not installed · {{size}} download",
     "modelNotInstalled": "Not installed",
+    "noVoiceSelected": "No voice selected",
     "notReadyInput": "Parakeet STT is not installed. Download it below to use Voice Conversation.",
     "notReadyInputAndOpenAiOutput": "Parakeet STT is not installed, and the shared OpenAI voice API key is missing. Complete both steps below to use Voice Conversation.",
     "notReadyInputAndPocketOutput": "Parakeet STT and Pocket TTS are not installed. Download both below to use Voice Conversation.",
@@ -1057,9 +1044,6 @@
     "notReadyPocketOutput": "Pocket TTS is not installed. Download it below to use Voice Conversation.",
     "notReadySiriOutput": "No installed Siri voice is selected. Download or select one below to use Voice Conversation.",
     "notReadyTitle": "Voice Conversation isn't ready",
-    "microphonePermissionDenied": "Microphone access is turned off for Berd. Allow access in System Settings to use Voice Conversation.",
-    "microphonePermissionTitle": "Microphone access is required",
-    "noVoiceSelected": "No voice selected",
     "openMicrophoneSettings": "Open Microphone Settings",
     "openMicrophoneSettingsError": "Couldn't open Microphone Settings. Open System Settings and select Privacy & Security > Microphone.",
     "openAiApiKeyConfigured": "Saved securely and shared by OpenAI transcription and voice playback.",
@@ -1074,7 +1058,7 @@
     "openAiTtsConfigured": "Uses {{model}} and the {{voice}} voice. OpenAI voices are AI-generated.",
     "openAiTtsNeedsKey": "Add the shared OpenAI voice API key to use this voice.",
     "openAiTtsUnsupportedPlatform": "OpenAI voice playback is currently supported on macOS only.",
-    "outputBackendDescription": "Choose a backend.",
+    "outputBackendDescription": "Choose how Berd speaks assistant responses.",
     "playbackSpeed": "Playback speed",
     "playing": "Playing",
     "playingVoice": "Playing preview for {{voice}}",
@@ -1088,14 +1072,14 @@
     "removingModel": "Removing model…",
     "retryDownload": "Retry model download",
     "saveApiKey": "Save key",
-    "settingsDescription": "Choose how speech and your coding agent work together.",
+    "selectedVoice": "Selected voice: {{voice}}",
+    "settingsDescription": "Choose how Berd speaks, install speech recognition, and preview available voices.",
     "siriLanguage": "Language",
     "siriLoading": "Loading Siri voices…",
     "siriNoVoices": "No Siri voices are available for this language.",
     "siriUnsupported": "Siri voices are available on macOS only.",
-    "speechInput": "Speech to text (STT)",
-    "speechOutput": "Text to speech (TTS)",
-    "selectedVoice": "Selected voice: {{voice}}",
+    "speechInput": "Speech input",
+    "speechOutput": "Speech output",
     "useVoice": "Use {{voice}}",
     "voice": "Voice",
     "voiceLabel": "Pocket TTS voice"
diff --git a/src/shared/i18n/locales/es/settings.json b/src/shared/i18n/locales/es/settings.json
index 8778dba5b..8d8769df8 100644
--- a/src/shared/i18n/locales/es/settings.json
+++ b/src/shared/i18n/locales/es/settings.json
@@ -65,23 +65,23 @@
     }
   },
   "archive": {
-    "title": "Archivo",
     "autoArchive": {
-      "sectionTitle": "Archivado automático",
-      "label": "Archivar chats inactivos",
-      "description": "Archiva automáticamente los chats después de este tiempo sin mensajes. Los chats fijados en Inicio nunca se archivan automáticamente.",
-      "confirmTitle": "¿Activar el archivado automático?",
-      "confirmDescription": "Berd archivará los chats no fijados {{duration}} sin volver a preguntar. Puedes restaurarlos desde Archivo o desactivar esta opción cuando quieras.",
       "confirmAction": "Activar",
+      "confirmDescription": "Berd archivará los chats no fijados {{duration}} sin volver a preguntar. Puedes restaurarlos desde Archivo o desactivar esta opción cuando quieras.",
+      "confirmTitle": "¿Activar el archivado automático?",
+      "description": "Archiva automáticamente los chats después de este tiempo sin mensajes. Los chats fijados en Inicio nunca se archivan automáticamente.",
+      "label": "Archivar chats inactivos",
       "options": {
-        "never": "Nunca",
         "1-day": "Después de 1 día",
-        "7-days": "Después de 7 días",
         "14-days": "Después de 14 días",
         "30-days": "Después de 30 días",
-        "90-days": "Después de 90 días"
-      }
-    }
+        "7-days": "Después de 7 días",
+        "90-days": "Después de 90 días",
+        "never": "Nunca"
+      },
+      "sectionTitle": "Archivado automático"
+    },
+    "title": "Archivo"
   },
   "chats": {
     "empty": "No hay chats archivados.",
@@ -105,6 +105,9 @@
     "title": "Compactación"
   },
   "connections": {
+    "askAgent": "Agregar conexión",
+    "askAgentPrompt": "Ayúdame a agregar una conexión. Primero pregunta si quiero un servicio administrado por la empresa o un MCP local; después explica la configuración y los requisitos de acceso. Pregunta antes de cambiar cualquier configuración y nunca muestres ni copies credenciales.",
+    "askAgentTitle": "Agregar una conexión",
     "configure": "Configurar",
     "connect": "Conectar",
     "connectError": "No se pudo abrir el flujo de conexión. Inténtalo de nuevo.",
@@ -119,12 +122,20 @@
     "expiresToday": "Caduca hoy",
     "expiresTomorrow": "Caduca mañana",
     "extendAccess": "Ampliar acceso",
+    "localError": {
+      "description": "Inténtalo de nuevo en unos instantes.",
+      "partialDescription": "Berd no pudo leer todas las fuentes de configuración local.",
+      "partialTitle": "Es posible que falten algunos MCP locales",
+      "retry": "Intentar de nuevo",
+      "retrying": "Intentando…",
+      "title": "No se pudieron cargar tus MCP locales"
+    },
     "noResults": "Ninguna conexión coincide con tu búsqueda.",
     "reconnect": "Reconectar",
     "search": "Buscar conexiones",
     "sections": {
-      "managed": "Administradas por la empresa",
-      "local": "Locales"
+      "local": "Locales",
+      "managed": "Administradas por la empresa"
     },
     "status": {
       "active": "Activa",
@@ -132,18 +143,7 @@
       "expired": "Caducada"
     },
     "title": "Conexiones",
-    "worksWith": "Funciona con: {{harnesses}}",
-    "localError": {
-      "title": "No se pudieron cargar tus MCP locales",
-      "description": "Inténtalo de nuevo en unos instantes.",
-      "partialTitle": "Es posible que falten algunos MCP locales",
-      "partialDescription": "Berd no pudo leer todas las fuentes de configuración local.",
-      "retry": "Intentar de nuevo",
-      "retrying": "Intentando…"
-    },
-    "askAgent": "Agregar conexión",
-    "askAgentTitle": "Agregar una conexión",
-    "askAgentPrompt": "Ayúdame a agregar una conexión. Primero pregunta si quiero un servicio administrado por la empresa o un MCP local; después explica la configuración y los requisitos de acceso. Pregunta antes de cambiar cualquier configuración y nunca muestres ni copies credenciales."
+    "worksWith": "Funciona con: {{harnesses}}"
   },
   "deleteProject": {
     "description": "Este proyecto y todos sus datos se eliminarán de forma permanente.",
@@ -211,9 +211,9 @@
       "description": "Muestra la superficie de tareas y automatizaciones de Builderbot.",
       "title": "Builderbot"
     },
-    "relatedPullRequests": {
-      "description": "Muestra PR Inbox y el estado actual de las solicitudes de incorporación enlazadas en un chat.",
-      "title": "PR Inbox"
+    "chatOnCanvas": {
+      "description": "Expande los chats fijados en tarjetas de conversación en vivo en Inicio, donde puedes leer y responder.",
+      "title": "Chat en el lienzo"
     },
     "defaultLabel": "predeterminado",
     "description": "Activa funciones de Berd en desarrollo en este dispositivo. Los experimentos pueden cambiar, fallar o desaparecer.",
@@ -235,6 +235,10 @@
       "description": "Fija prompts guardados en Inicio que se ejecutan con un clic, opcionalmente con un agente adjunto.",
       "title": "Pins de prompts"
     },
+    "relatedPullRequests": {
+      "description": "Muestra PR Inbox y el estado actual de las solicitudes de incorporación enlazadas en un chat.",
+      "title": "PR Inbox"
+    },
     "remoteSshSessions": {
       "description": "Ejecuta sesiones en una máquina remota por SSH usando los hosts de tu configuración SSH. Berd inicia un daemon de Goose en el host remoto y crea un túnel hacia él.",
       "title": "Sesiones SSH remotas"
@@ -260,10 +264,6 @@
     "voiceConversation": {
       "description": "Prueba conversaciones de voz bidireccionales continuas en chats de Goose.",
       "title": "Conversaciones de voz"
-    },
-    "chatOnCanvas": {
-      "title": "Chat en el lienzo",
-      "description": "Expande los chats fijados en tarjetas de conversación en vivo en Inicio, donde puedes leer y responder."
     }
   },
   "extensions": {
@@ -416,6 +416,52 @@
     },
     "title": "General"
   },
+  "me": {
+    "addTopic": "Añadir tema",
+    "addTopicAction": "Añadir",
+    "cancel": "Cancelar",
+    "closeTopic": "Cerrar",
+    "create": "Crear mi archivo",
+    "description": "Detalles, preferencias y límites aprobados que ayudan a los agentes a trabajar mejor contigo entre chats.",
+    "editTab": "Editar",
+    "editorLabel": "Editar tu me.md",
+    "livesIn": "Los recuerdos aprobados permanecen en archivos de texto sin formato en tu equipo, en",
+    "loadError": "No se pudo leer tu archivo. Es posible que se haya movido o eliminado.",
+    "newTopicDescription": "Un tema es su propio documento. Los agentes lo leen solo cuando esa parte de tu vida es lo que está pasando.",
+    "newTopicError": "No se pudo crear ese tema. Puede que ya exista un tema con un nombre similar.",
+    "newTopicLabel": "Nombra tu tema",
+    "newTopicPlaceholder": "Estilo, Familia, Viajes…",
+    "noTopics": "Aún no hay temas. Los temas guardan conocimiento más profundo, como estilo, familia o trabajo, que solo se carga cuando es relevante.",
+    "offBanner": {
+      "description": "Berd no usará tus recuerdos aprobados ni sugerirá otros nuevos. Los archivos de memoria y las propuestas pendientes permanecerán en tu equipo a menos que los elimines."
+    },
+    "openTopic": "Ver",
+    "previewTab": "Vista previa",
+    "refresh": "Actualizar",
+    "save": "Guardar",
+    "saveError": "No se pudieron guardar tus cambios. Tus ediciones siguen aquí, inténtalo de nuevo.",
+    "unsafeUnicodeError": "El texto de memoria no puede incluir caracteres de control Unicode ocultos.",
+    "spineTitle": "Sobre ti",
+    "title": "Memoria",
+    "toggle": {
+      "description": "La memoria ayuda a Berd a recordar lo que te importa y cómo prefieres trabajar. Berd puede sugerir recuerdos de tus chats, pero nada se guarda sin tu aprobación. Revisa, edita o elimina cualquier cosa aquí en cualquier momento.",
+      "label": "Usar memoria"
+    },
+    "topicsHint": "Los temas proporcionan conocimientos más específicos que solo se cargan cuando son relevantes. Añádelos o actualízalos aquí.",
+    "topicsTitle": "Temas",
+    "unsavedChanges": "Cambios sin guardar",
+    "proposals": {
+      "title": "Memoria propuesta",
+      "description": "Revisa estas sugerencias antes de que se agregue algo a tu memoria. Puedes editar el texto primero.",
+      "review": "Revisar",
+      "dismiss": "Rechazar",
+      "approve": "Agregar a la memoria",
+      "editorLabel": "Editar memoria propuesta",
+      "credentialError": "Los datos de autenticación y acceso no se pueden guardar en la memoria.",
+      "unsafeUnicodeError": "El texto de memoria no puede incluir caracteres de control Unicode ocultos.",
+      "approveError": "No se pudo agregar esta memoria. Inténtalo de nuevo."
+    }
+  },
   "nav": {
     "appearance": "Apariencia",
     "archive": "Archivo",
@@ -426,6 +472,7 @@
     "experiments": "Experimentos",
     "extensions": "Extensiones",
     "general": "General",
+    "me": "Memoria",
     "notifications": "Notificaciones",
     "providers": "Proveedores de IA",
     "providersUpdateAvailable": "Actualización disponible",
@@ -433,7 +480,8 @@
     "shortcuts": "Atajos de teclado",
     "system": "Sistema",
     "updates": "Actualizaciones",
-    "voice": "Voz"
+    "voice": "Voz",
+    "memoryProposalsPending": "{{count}} propuestas de memoria por revisar"
   },
   "navigation": {
     "title": "Navegación"
@@ -931,83 +979,16 @@
     }
   },
   "voice": {
-    "conversationMode": "Modo de voz",
-    "conversationModeDescription": "Elige con quién hablas durante una conversación de voz.",
-    "defaultOption": "{{value}} (predeterminado)",
-    "modeChained": "Hablar con tu agente de programación",
-    "modeChainedDescription": "Tu voz se convierte en un mensaje para tu agente de programación, y su respuesta se lee en voz alta. Ideal para trabajar directamente con el contexto de tu proyecto.",
-    "modeOpenAiRealtime": "Hablar mediante un asistente de voz",
-    "modeOpenAiRealtimeDescription": "Mantén una conversación más natural y con menor latencia con un asistente de voz que consulta a tu agente de programación cuando necesita tu proyecto o sus herramientas. Requiere una clave API de OpenAI.",
-    "cloud": "Nube",
-    "local": "Local",
-    "recommended": "Recomendado",
-    "resetToDefaults": "Restablecer valores predeterminados",
-    "resetToDefaultsDescription": "Restaura «Hablar con tu agente de programación» y los sistemas de voz recomendados. Se conservan las claves API y los modelos descargados.",
-    "resetToDefaultsConfirmTitle": "¿Restablecer todos los ajustes de voz?",
-    "resetToDefaultsConfirmDescription": "Esto restaura «Hablar con tu agente de programación», los sistemas recomendados de voz a texto y texto a voz, la voz y la velocidad predeterminadas y todos los ajustes avanzados. Se conservan las claves API y los modelos descargados.",
-    "resettingToDefaults": "Restableciendo…",
-    "realtimeAdvanced": "Avanzado",
-    "realtimeApiKey": "Clave API de OpenAI",
-    "realtimeApiKeyDescription": "Se guarda de forma segura en el llavero de macOS y se comparte entre la escucha y la voz de Realtime.",
-    "realtimeCreateResponse": "Responder automáticamente",
-    "realtimeCreateResponseDescription": "Genera una respuesta del asistente de voz cuando termina un turno detectado del usuario.",
-    "realtimeEagerness": "Rapidez para tomar el turno",
-    "realtimeEagernessAuto": "Equilibrada (automática)",
-    "realtimeEagernessHigh": "Rápida",
-    "realtimeEagernessLow": "Paciente",
-    "realtimeEagernessMedium": "Moderada",
-    "realtimeIdleTimeout": "Tiempo de espera inactivo (ms)",
-    "realtimeInterruptResponse": "Interrumpir cuando hablo",
-    "realtimeInterruptResponseDescription": "Detiene la respuesta actual del asistente de voz cuando empieza a llegar voz nueva.",
-    "realtimeMaxOutputTokens": "Máximo de tokens de respuesta",
-    "realtimeModel": "Modelo Realtime",
-    "realtimeNoiseReduction": "Reducción de ruido",
-    "realtimeNoiseReductionFar": "Micrófono de campo lejano",
-    "realtimeNoiseReductionNear": "Micrófono de campo cercano",
-    "realtimeNoiseReductionOff": "Desactivada",
-    "realtimeOff": "Desactivado",
-    "realtimePrefixPadding": "Audio previo a la voz (ms)",
-    "realtimePresentation": "Presentación de la conversación",
-    "realtimePresentationDebug": "Depuración — mostrar el enrutamiento de agentes",
-    "realtimePresentationDescription": "La depuración muestra con colores la voz del asistente de voz y el enrutamiento privado. El modo sutil presenta un solo asistente y mantiene el enrutamiento en segundo plano.",
-    "realtimePresentationSubtle": "Sutil — un solo asistente",
-    "realtimeReasoningEffort": "Esfuerzo de razonamiento",
-    "realtimeReasoningEfforts": {
-      "default": "Predeterminado del modelo",
-      "high": "Alto",
-      "low": "Bajo",
-      "medium": "Medio",
-      "none": "Ninguno"
-    },
-    "realtimeServerVad": "Ajustes de VAD del servidor",
-    "realtimeSilenceDuration": "Pausa final (ms)",
-    "realtimeSpeed": "Velocidad de voz",
-    "realtimeSpeedDescription": "Ajusta la voz generada de 0,25× a 1,5×. Se aplica al iniciar la siguiente sesión de voz.",
-    "realtimeTranscriptionLanguage": "Idioma de transcripción",
-    "realtimeTranscriptionLanguagePlaceholder": "Automático (por ejemplo, es)",
-    "realtimeTranscriptionModel": "Modelo STT",
-    "realtimeTranscriptionModelDescription": "Realtime Whisper equilibra transcripciones parciales rápidas con precisión; elige otro modelo para ajustar esa relación.",
-    "realtimeTranscriptionPrompt": "Pistas de transcripción",
-    "realtimeTranscriptionPromptDescription": "Guía la transcripción sin cambiar la conversación hablada.",
-    "realtimeTranscriptionPromptPlaceholder": "Nombres, términos técnicos o vocabulario esperado",
-    "realtimeTurnDetection": "Detección de turnos",
-    "realtimeTurnDetectionSemantic": "VAD semántico",
-    "realtimeTurnDetectionServer": "VAD del servidor",
-    "realtimeUnlimited": "Sin límite",
-    "realtimeVadThreshold": "Umbral de activación por voz",
-    "realtimeVoice": "Voz",
-    "backendMacSpeech": "STT de Apple",
-    "backendOpenAiStt": "STT de OpenAI",
-    "backendOpenAiTts": "TTS de OpenAI",
+    "backendMacSpeech": "Reconocimiento de voz de Apple",
+    "backendOpenAiStt": "Voz a texto de OpenAI",
+    "backendOpenAiTts": "Texto a voz de OpenAI",
     "backendParakeet": "Parakeet STT",
     "backendPocket": "Pocket TTS",
-    "backendSiri": "TTS de Apple",
+    "backendSiri": "Voces de Siri",
     "chooseVoice": "Elegir…",
     "chooseVoiceLabel": "Elige una voz: {{voice}}",
     "chooseVoiceTitle": "Elige una voz",
     "download": "Descargar modelo",
-    "downloadVoice": "Descargar {{voice}}",
-    "downloadingVoice": "Descargando {{voice}}",
     "downloadPhase": {
       "complete": "Instalado",
       "downloading": "Descargando",
@@ -1017,13 +998,10 @@
       "verifying": "Verificando modelo"
     },
     "downloadProgress": "{{downloaded}} de {{total}}",
-    "inputBackendDescription": "Elige un backend.",
-    "macSpeechDownloading": "Descargando el modelo de dictado… {{progress}} %",
-    "macSpeechLoading": "Comprobando el reconocimiento de voz de macOS…",
-    "macSpeechLocaleUnsupported": "El reconocimiento de voz de Apple no admite {{locale}}.",
-    "macSpeechModel": "Dictado en el dispositivo",
-    "macSpeechNotInstalled": "No instalado para {{locale}}",
-    "macSpeechSystemLocale": "el idioma del sistema",
+    "downloadVoice": "Descargar {{voice}}",
+    "downloadingVoice": "Descargando {{voice}}",
+    "inputBackendDescription": "Elige cómo Berd transcribe tu voz.",
+    "interruptionDescription": "Elige qué ocurre cuando hablas mientras Berd habla.",
     "interruptionMode": "Interrupciones",
     "interruptionModeDescriptions": {
       "allowInterruptions": "Berd sigue escuchando en todos los dispositivos de audio. Puedes interrumpirlo, pero el audio de los altavoces podría confundirse con tu voz.",
@@ -1035,10 +1013,19 @@
       "automatic": "Automático",
       "preventFeedback": "Evitar retroalimentación"
     },
+    "macSpeechDownloading": "Descargando el modelo de dictado… {{progress}} %",
+    "macSpeechLoading": "Comprobando el reconocimiento de voz de macOS…",
+    "macSpeechLocaleUnsupported": "El reconocimiento de voz de Apple no admite {{locale}}.",
+    "macSpeechModel": "Dictado en el dispositivo",
+    "macSpeechNotInstalled": "No instalado para {{locale}}",
+    "macSpeechSystemLocale": "el idioma del sistema",
+    "microphonePermissionDenied": "El acceso al micrófono está desactivado para Berd. Permite el acceso en Ajustes del Sistema para usar la conversación por voz.",
+    "microphonePermissionTitle": "Se requiere acceso al micrófono",
     "modelInstalled": "Instalado",
     "modelInstalledSize": "{{size}} · Instalado",
     "modelMissingSize": "No instalado · descarga de {{size}}",
     "modelNotInstalled": "No instalado",
+    "noVoiceSelected": "No hay ninguna voz seleccionada",
     "notReadyInput": "Parakeet STT no está instalado. Descárgalo abajo para usar la conversación por voz.",
     "notReadyInputAndOpenAiOutput": "Parakeet STT no está instalado y falta la clave API compartida de voz de OpenAI. Completa ambos pasos abajo para usar la conversación por voz.",
     "notReadyInputAndPocketOutput": "Parakeet STT y Pocket TTS no están instalados. Descarga ambos abajo para usar la conversación por voz.",
@@ -1056,9 +1043,6 @@
     "notReadyPocketOutput": "Pocket TTS no está instalado. Descárgalo abajo para usar la conversación por voz.",
     "notReadySiriOutput": "No hay ninguna voz de Siri instalada seleccionada. Descarga o selecciona una abajo para usar la conversación por voz.",
     "notReadyTitle": "La conversación por voz no está lista",
-    "microphonePermissionDenied": "El acceso al micrófono está desactivado para Berd. Permite el acceso en Ajustes del Sistema para usar la conversación por voz.",
-    "microphonePermissionTitle": "Se requiere acceso al micrófono",
-    "noVoiceSelected": "No hay ninguna voz seleccionada",
     "openMicrophoneSettings": "Abrir ajustes del micrófono",
     "openMicrophoneSettingsError": "No se pudieron abrir los ajustes del micrófono. Abre Ajustes del Sistema y selecciona Privacidad y seguridad > Micrófono.",
     "openAiApiKeyConfigured": "Guardada de forma segura y compartida por la transcripción y la reproducción de voz de OpenAI.",
@@ -1073,7 +1057,7 @@
     "openAiTtsConfigured": "Usa {{model}} y la voz {{voice}}. Las voces de OpenAI son generadas por IA.",
     "openAiTtsNeedsKey": "Añade la clave API compartida de voz de OpenAI para usar esta voz.",
     "openAiTtsUnsupportedPlatform": "La reproducción de voz de OpenAI solo es compatible actualmente con macOS.",
-    "outputBackendDescription": "Elige un backend.",
+    "outputBackendDescription": "Elige cómo Berd reproduce las respuestas del asistente.",
     "playbackSpeed": "Velocidad de reproducción",
     "playing": "Reproduciendo",
     "playingVoice": "Reproduciendo la muestra de {{voice}}",
@@ -1087,14 +1071,14 @@
     "removingModel": "Eliminando modelo…",
     "retryDownload": "Reintentar descarga del modelo",
     "saveApiKey": "Guardar clave",
-    "settingsDescription": "Elige cómo funcionan juntos la voz y tu agente de programación.",
+    "selectedVoice": "Voz seleccionada: {{voice}}",
+    "settingsDescription": "Elige cómo habla Berd, instala el reconocimiento de voz y escucha las voces disponibles.",
     "siriLanguage": "Idioma",
     "siriLoading": "Cargando voces de Siri…",
     "siriNoVoices": "No hay voces de Siri disponibles para este idioma.",
     "siriUnsupported": "Las voces de Siri solo están disponibles en macOS.",
-    "speechInput": "Voz a texto (STT)",
-    "speechOutput": "Texto a voz (TTS)",
-    "selectedVoice": "Voz seleccionada: {{voice}}",
+    "speechInput": "Entrada de voz",
+    "speechOutput": "Salida de voz",
     "useVoice": "Usar {{voice}}",
     "voice": "Voz",
     "voiceLabel": "Voz de Pocket TTS"