diff --git a/src-tauri/src/commands/memory_queue.rs b/src-tauri/src/commands/memory_queue.rs
new file mode 100644
index 000000000..4fc95aa9f
--- /dev/null
+++ b/src-tauri/src/commands/memory_queue.rs
@@ -0,0 +1,369 @@
+//! Backend-owned proposal queue operations.
+
+use berd_memory::{
+    acquire_queue_lock, append_jsonl, is_suppressed, jsonl_records, memory_root, 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,
+    pub refresh_projection: 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 = content.trim();
+    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 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,
+            refresh_projection: 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.clone(), 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,
+        refresh_projection: 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 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);
+
+    if let Some(content) = declined_content.filter(|content| !content.trim().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> {
+    if candidates.is_empty() {
+        return Ok(0);
+    }
+    let dir = memory_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 content = candidate.content.trim();
+        if content.is_empty()
+            || content.chars().count() > 300
+            || berd_memory::looks_like_credential(content)
+            || pending
+                .iter()
+                .any(|record| same_fact(record, content, candidate.topic.as_deref()))
+            || dismissed
+                .iter()
+                .any(|record| is_suppressed(record, content, candidate.topic.as_deref()))
+        {
+            continue;
+        }
+        let record = json!({
+            "id": format!("n-{}", uuid::Uuid::new_v4()),
+            "ts": now_epoch_seconds(),
+            "content": content,
+            "topic": candidate.topic,
+            "agent": "noticer",
+            "sessionId": candidate.session_id,
+            "host": "berd",
+        });
+        append_jsonl(&pending_path, &record)?;
+        pending.push(record);
+        count += 1;
+    }
+    Ok(count)
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 286b86887..3cfd30ca3 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 42244ab3f..7f41b56e0 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -644,6 +644,9 @@ pub fn run() {
             commands::memory_store::write_memory_text_file,
             commands::memory_store::is_memory_content_approved,
             commands::memory_store::write_memory_agents_projection,
+            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 ea701fc71..7defd493b 100644
--- a/src/app/AppShell.tsx
+++ b/src/app/AppShell.tsx
@@ -99,6 +99,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";
@@ -5380,6 +5381,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 8df4f6359..15a959e1c 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 { LoadingBerd } from "./LoadingBerd";
 import { ChatRightRail } from "./ChatRightRail";
@@ -701,6 +702,7 @@ export function ChatView({
           />
         ) : null}
         <SecurityConfirmationPanel sessionId={sessionId} />
+        <MemoryProposalToasts sessionId={sessionId} />
         <ConversationComposerCapability
           binding={composerBinding}
           renderingPolicy={{
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__/meProposals.test.ts b/src/features/me/lib/__tests__/meProposals.test.ts
new file mode 100644
index 000000000..d2d9f0324
--- /dev/null
+++ b/src/features/me/lib/__tests__/meProposals.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, it } from "vitest";
+
+import { appendBullet, insertIntoSection, removeBullet } from "../meProposals";
+import { vocabularyTopicName } from "../memoryTopicVocabulary";
+
+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..2ff59ef1a
--- /dev/null
+++ b/src/features/me/lib/__tests__/memoryProposalReview.test.ts
@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  approveMemoryProposal: vi.fn(),
+  resolveMemoryProposal: vi.fn(),
+  loadMeFile: vi.fn(),
+  publishMeFile: vi.fn(),
+}));
+
+vi.mock("@/shared/api/system", () => ({
+  approveMemoryProposal: mocks.approveMemoryProposal,
+  resolveMemoryProposal: mocks.resolveMemoryProposal,
+}));
+vi.mock("../meFile", () => ({ loadMeFile: mocks.loadMeFile }));
+vi.mock("../mePublish", () => ({ publishMeFile: mocks.publishMeFile }));
+
+import {
+  approveMemoryProposal,
+  CredentialMemoryError,
+  declineMemoryProposal,
+} 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,
+      refreshProjection: true,
+    });
+    mocks.loadMeFile.mockResolvedValue({ status: "missing" });
+  });
+
+  it("delegates edited approval to the backend", async () => {
+    await approveMemoryProposal(proposal, "Prefers window seats.");
+    expect(mocks.approveMemoryProposal).toHaveBeenCalledWith(
+      proposal.id,
+      "Prefers window 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("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__/saveMemoryDocument.test.ts b/src/features/me/lib/__tests__/saveMemoryDocument.test.ts
new file mode 100644
index 000000000..c0b16e9e8
--- /dev/null
+++ b/src/features/me/lib/__tests__/saveMemoryDocument.test.ts
@@ -0,0 +1,68 @@
+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";
+
+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("blocks credential-shaped edits before writing", async () => {
+    await expect(
+      saveMemoryDocument({
+        path: "/home/u/.me/me.md",
+        contents: "# Me\n\n- API key: ghp_16CharsAtLeastHere00\n",
+        topic: null,
+      }),
+    ).rejects.toBeInstanceOf(CredentialMemoryError);
+    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/meProposals.ts b/src/features/me/lib/meProposals.ts
new file mode 100644
index 000000000..ec311a1c5
--- /dev/null
+++ b/src/features/me/lib/meProposals.ts
@@ -0,0 +1,136 @@
+import { getHomeDir, pathExists, readTextFile } from "@/shared/api/system";
+
+/**
+ * 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 content = typeof raw.content === "string" ? raw.content.trim() : "";
+    const id = typeof raw.id === "string" ? raw.id.trim() : "";
+    if (!id || !content) return null;
+    const ts = typeof raw.ts === "number" ? raw.ts : 0;
+    return {
+      id,
+      ts,
+      content,
+      topic:
+        typeof raw.topic === "string" && raw.topic.trim()
+          ? raw.topic.trim()
+          : 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 {
+    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 040c2eaa9..566a40f2d 100644
--- a/src/features/me/lib/meTopics.ts
+++ b/src/features/me/lib/meTopics.ts
@@ -4,8 +4,8 @@ import {
   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
@@ -112,8 +112,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 */
diff --git a/src/features/me/lib/memoryProposalReview.ts b/src/features/me/lib/memoryProposalReview.ts
new file mode 100644
index 000000000..7fb19cbf8
--- /dev/null
+++ b/src/features/me/lib/memoryProposalReview.ts
@@ -0,0 +1,46 @@
+import {
+  approveMemoryProposal as approveMemoryProposalInBackend,
+  resolveMemoryProposal,
+} from "@/shared/api/system";
+import {
+  CredentialMemoryError,
+  looksLikeCredential,
+} from "./memoryCredentialGuard";
+import type { MemoryProposal } from "./meProposals";
+import { loadMeFile } from "./meFile";
+import { publishMeFile } from "./mePublish";
+
+export { CredentialMemoryError } from "./memoryCredentialGuard";
+
+export async function approveMemoryProposal(
+  proposal: MemoryProposal,
+  content = proposal.content,
+  topic = proposal.topic,
+): Promise<void> {
+  const edited = content.trim();
+  if (!edited) throw new Error("Memory content is required.");
+  if (looksLikeCredential(edited)) throw new CredentialMemoryError();
+
+  const result = await approveMemoryProposalInBackend(
+    proposal.id,
+    edited,
+    topic?.trim() || null,
+  );
+  if (result.approved && result.refreshProjection) {
+    // Projection is derived output. Approval remains complete if this
+    // best-effort refresh fails and will be repaired by the next refresh.
+    const state = await loadMeFile();
+    if (state.status === "present") {
+      await publishMeFile(state.contents).catch(() => {});
+    }
+  }
+}
+
+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/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..9f036d67d
--- /dev/null
+++ b/src/features/me/lib/saveMemoryDocument.ts
@@ -0,0 +1,38 @@
+import {
+  readTextFile,
+  resolveMemoryProposal,
+  writeTextFile,
+} from "@/shared/api/system";
+import { removedMemoryEntries } from "./editSummary";
+import {
+  CredentialMemoryError,
+  looksLikeCredential,
+} from "./memoryCredentialGuard";
+
+/** 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> {
+  if (looksLikeCredential(contents)) throw new CredentialMemoryError();
+
+  const before = await readTextFile(path)
+    .then((payload) => payload.contents)
+    .catch(() => "");
+  const removed = removedMemoryEntries(before, contents);
+
+  // 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, contents);
+  for (const entry of removed) {
+    await resolveMemoryProposal(`manual-delete-${crypto.randomUUID()}`, {
+      content: entry,
+      topic,
+    });
+  }
+}
diff --git a/src/features/me/ui/MeSettings.tsx b/src/features/me/ui/MeSettings.tsx
new file mode 100644
index 000000000..d08a18081
--- /dev/null
+++ b/src/features/me/ui/MeSettings.tsx
@@ -0,0 +1,642 @@
+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 { readMemoryPolicy, writeMemoryPolicy } from "../lib/memoryPolicyFile";
+import { publishMeFile } from "../lib/mePublish";
+import {
+  isMemoryContentApproved,
+  writeMemoryAgentsProjection,
+} from "@/shared/api/system";
+
+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;
+  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,
+  cancelText,
+  saveText,
+  previewText,
+  editText,
+  unsavedText,
+  refreshLabel,
+  onRefresh,
+  footer,
+}: DocumentPanelProps) {
+  const [mode, setMode] = useState<ViewMode>("preview");
+  const [draft, setDraft] = useState<string | null>(null);
+  const [saveFailed, setSaveFailed] = useState(false);
+
+  const isEditing = mode === "edit";
+  const hasUnsavedChanges = draft !== null && draft !== contents;
+
+  const handleModeChange = (next: string) => {
+    if (next === "edit" && draft === null) {
+      setDraft(contents);
+      setSaveFailed(false);
+    }
+    setMode(next === "edit" ? "edit" : "preview");
+  };
+
+  const handleCancel = () => {
+    setDraft(null);
+    setSaveFailed(false);
+    setMode("preview");
+  };
+
+  const handleSave = async () => {
+    if (draft === null) return;
+    try {
+      await onSave(draft);
+      setDraft(null);
+      setSaveFailed(false);
+      setMode("preview");
+    } catch {
+      setSaveFailed(true);
+    }
+  };
+
+  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>
+      )}
+
+      {saveFailed && (
+        <p className="text-sm text-destructive" role="alert">
+          {saveErrorText}
+        </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(true);
+  const { proposals, approve, decline } = useMemoryProposals();
+  const [proposalDrafts, setProposalDrafts] = useState<Record<string, string>>(
+    {},
+  );
+  const [proposalError, setProposalError] = useState<string | null>(null);
+
+  const refresh = useCallback(async () => {
+    try {
+      const loaded = await loadMeFile();
+      setState(loaded);
+      if (
+        loaded.status === "present" &&
+        !(await isMemoryContentApproved(loaded.path, loaded.contents))
+      ) {
+        // A same-user process may have bypassed Berd's approval boundary.
+        // Remove the stale projection until the person explicitly saves.
+        await writeMemoryAgentsProjection(null);
+      }
+    } 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 policy defaults on.
+    const policy = await readMemoryPolicy();
+    setMemoryEnabled(policy?.enabled ?? true);
+  }, []);
+
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+
+  // Memory is on by default, so most people arrive here without ever having
+  // touched the switch. Seed the store on first visit for the same reason the
+  // toggle does: the file existing is the normal state, and asking for a
+  // decision the rest of the system makes silently is the odd one.
+  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")
+          : 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);
+
+    let contents = state.status === "present" ? state.contents : "";
+    if (enabled && state.status !== "present") {
+      try {
+        const created = await createMeFile();
+        setState(created);
+        if (created.status === "present") contents = created.contents;
+      } catch {
+        // A failed seed leaves the create button in place.
+      }
+    }
+    // Off removes the managed projection; on restores it.
+    await publishMeFile(contents);
+  };
+
+  // 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"),
+    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}
+                      />
+                      .{" "}
+                    </>
+                  )}
+                  {t("me.projectionHint")}
+                </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>
+        )}
+
+        {memoryEnabled && 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/i18n/locales/en/settings.json b/src/shared/i18n/locales/en/settings.json
index f663baca6..e621b36c1 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,51 @@
     },
     "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",
+    "projectionHint": "Berd also makes memories available to compatible agent tools through a local file at ~/.agents/AGENTS.md.",
+    "refresh": "Refresh",
+    "save": "Save",
+    "saveError": "Couldn't save your changes. Your edits are still here, so try again.",
+    "spineTitle": "About you",
+    "title": "Memory",
+    "toggle": {
+      "description": "Memory helps Berd and other agent tools 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. Agents can add or update topics as they get to know you.",
+    "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.",
+      "approveError": "Couldn't add this memory. Try again."
+    }
+  },
   "nav": {
     "appearance": "Appearance",
     "archive": "Archive",
@@ -426,6 +471,7 @@
     "experiments": "Experiments",
     "extensions": "Extensions",
     "general": "General",
+    "me": "Memory",
     "notifications": "Notifications",
     "providers": "AI providers",
     "providersUpdateAvailable": "Update available",
@@ -433,7 +479,8 @@
     "shortcuts": "Keyboard shortcuts",
     "system": "System",
     "updates": "Updates",
-    "voice": "Voice"
+    "voice": "Voice",
+    "memoryProposalsPending": "{{count}} memory proposals to review"
   },
   "navigationLabel": "Settings navigation",
   "notifications": {
@@ -942,8 +989,6 @@
     "chooseVoiceLabel": "Choose a voice: {{voice}}",
     "chooseVoiceTitle": "Choose a voice",
     "download": "Download model",
-    "downloadVoice": "Download {{voice}}",
-    "downloadingVoice": "Downloading {{voice}}",
     "downloadPhase": {
       "complete": "Installed",
       "downloading": "Downloading",
@@ -953,13 +998,9 @@
       "verifying": "Verifying model"
     },
     "downloadProgress": "{{downloaded}} of {{total}}",
+    "downloadVoice": "Download {{voice}}",
+    "downloadingVoice": "Downloading {{voice}}",
     "inputBackendDescription": "Choose how Berd transcribes your speech.",
-    "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",
     "interruptionDescription": "Choose what happens when you speak while Berd is talking.",
     "interruptionMode": "Interruptions",
     "interruptionModeDescriptions": {
@@ -972,10 +1013,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.",
@@ -993,9 +1043,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.",
@@ -1024,6 +1071,7 @@
     "removingModel": "Removing model…",
     "retryDownload": "Retry model download",
     "saveApiKey": "Save key",
+    "selectedVoice": "Selected voice: {{voice}}",
     "settingsDescription": "Choose how Berd speaks, install speech recognition, and preview available voices.",
     "siriLanguage": "Language",
     "siriLoading": "Loading Siri voices…",
@@ -1031,7 +1079,6 @@
     "siriUnsupported": "Siri voices are available on macOS only.",
     "speechInput": "Speech input",
     "speechOutput": "Speech output",
-    "selectedVoice": "Selected voice: {{voice}}",
     "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 faf64a5e5..f9c04e9b0 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,51 @@
     },
     "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",
+    "projectionHint": "Berd también pone los recuerdos a disposición de herramientas de agentes compatibles mediante un archivo local en ~/.agents/AGENTS.md.",
+    "refresh": "Actualizar",
+    "save": "Guardar",
+    "saveError": "No se pudieron guardar tus cambios. Tus ediciones siguen aquí, inténtalo de nuevo.",
+    "spineTitle": "Sobre ti",
+    "title": "Memoria",
+    "toggle": {
+      "description": "La memoria ayuda a Berd y a otras herramientas de agentes a recordar lo que te importa y cómo prefieres trabajar. Berd puede sugerir recuerdos de tus chats, pero no se guarda nada sin tu aprobación. Revisa, edita o elimina cualquier cosa aquí en cualquier momento.",
+      "label": "Usar memoria"
+    },
+    "topicsHint": "Los temas aportan conocimiento más específico que solo se carga cuando es relevante. Los agentes pueden agregar o actualizar temas al conocerte.",
+    "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.",
+      "approveError": "No se pudo agregar esta memoria. Inténtalo de nuevo."
+    }
+  },
   "nav": {
     "appearance": "Apariencia",
     "archive": "Archivo",
@@ -426,6 +471,7 @@
     "experiments": "Experimentos",
     "extensions": "Extensiones",
     "general": "General",
+    "me": "Memoria",
     "notifications": "Notificaciones",
     "providers": "Proveedores de IA",
     "providersUpdateAvailable": "Actualización disponible",
@@ -433,7 +479,8 @@
     "shortcuts": "Atajos de teclado",
     "system": "Sistema",
     "updates": "Actualizaciones",
-    "voice": "Voz"
+    "voice": "Voz",
+    "memoryProposalsPending": "{{count}} propuestas de memoria por revisar"
   },
   "navigation": {
     "title": "Navegación"
@@ -941,8 +988,6 @@
     "chooseVoiceLabel": "Elige una voz: {{voice}}",
     "chooseVoiceTitle": "Elige una voz",
     "download": "Descargar modelo",
-    "downloadVoice": "Descargar {{voice}}",
-    "downloadingVoice": "Descargando {{voice}}",
     "downloadPhase": {
       "complete": "Instalado",
       "downloading": "Descargando",
@@ -952,13 +997,9 @@
       "verifying": "Verificando modelo"
     },
     "downloadProgress": "{{downloaded}} de {{total}}",
+    "downloadVoice": "Descargar {{voice}}",
+    "downloadingVoice": "Descargando {{voice}}",
     "inputBackendDescription": "Elige cómo Berd transcribe tu voz.",
-    "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",
     "interruptionDescription": "Elige qué ocurre cuando hablas mientras Berd habla.",
     "interruptionMode": "Interrupciones",
     "interruptionModeDescriptions": {
@@ -971,10 +1012,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.",
@@ -992,9 +1042,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.",
@@ -1023,6 +1070,7 @@
     "removingModel": "Eliminando modelo…",
     "retryDownload": "Reintentar descarga del modelo",
     "saveApiKey": "Guardar clave",
+    "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…",
@@ -1030,7 +1078,6 @@
     "siriUnsupported": "Las voces de Siri solo están disponibles en macOS.",
     "speechInput": "Entrada de voz",
     "speechOutput": "Salida de voz",
-    "selectedVoice": "Voz seleccionada: {{voice}}",
     "useVoice": "Usar {{voice}}",
     "voice": "Voz",
     "voiceLabel": "Voz de Pocket TTS"