From 5076e0ddba31b829679d9160da54f44c10771a0c Mon Sep 17 00:00:00 2001
From: Maik Roland Damm <maik.damm@bluewave-tech.de>
Date: Tue, 26 May 2026 22:20:44 +0200
Subject: [PATCH 1/8] feat: enhance terminal and browser functionality

- Updated terminal selection background color for improved visibility.
- Added right-click context menu functionality in terminal for copy/paste actions.
- Increased terminal scrollback buffer to 5000 lines.
- Refactored browser navigation commands to run on the main thread for better performance.
- Improved error handling for empty URLs in browser tabs.
- Enhanced PTY manager to handle null-terminated strings in working directory paths.
- Added support for file paths in tool activity metrics for better tracking.
- Introduced a new sidebar graph height constant for layout adjustments.
- Improved sidebar resizer logic to account for dynamic height adjustments.
- Added a settings button in the right panel for easier access to application settings.
- Updated CSS for better styling of tool paths and scrollbar visibility.
---
 ...244t_eb\342\206\222tauri_4c9226e7.plan.md" | 286 ++++++++++++++++++
 .blxcode/tasks/index.json                     |  16 +-
 .cargo/config.toml                            |   6 +
 public/terminal_bootstrap.mjs                 |  32 +-
 src-tauri/src/browser_host.rs                 |  18 +-
 src-tauri/src/commands.rs                     |  52 +++-
 src-tauri/src/pty_host.rs                     |  22 +-
 src/config/app.config.rs                      |   3 +
 src/workbench/agent_panel/mod.rs              |  21 +-
 src/workbench/agent_panel/timeline.rs         | 233 ++++++++++++--
 .../turn_metrics_bar/turn_metrics_bar.css     |  40 ++-
 src/workbench/agent_timeline.rs               |  38 +++
 src/workbench/browser_tab.rs                  |  10 +-
 .../file_diff_section/file-diff-section.css   |   4 -
 src/workbench/mod.rs                          |   5 +-
 src/workbench/right_panel.rs                  |  34 ++-
 src/workbench/sidebar.rs                      |  42 ++-
 src/workbench/sidebar_resizer/mod.rs          |  22 +-
 src/workbench/state.rs                        |   6 +-
 styles.css                                    | 107 ++++++-
 20 files changed, 883 insertions(+), 114 deletions(-)
 create mode 100644 ".agents/.cursor/plans/memory_parit\303\244t_eb\342\206\222tauri_4c9226e7.plan.md"

diff --git "a/.agents/.cursor/plans/memory_parit\303\244t_eb\342\206\222tauri_4c9226e7.plan.md" "b/.agents/.cursor/plans/memory_parit\303\244t_eb\342\206\222tauri_4c9226e7.plan.md"
new file mode 100644
index 0000000..f580d05
--- /dev/null
+++ "b/.agents/.cursor/plans/memory_parit\303\244t_eb\342\206\222tauri_4c9226e7.plan.md"
@@ -0,0 +1,286 @@
+---
+name: Memory Parität EB→Tauri
+overview: "BLXCode-eb definiert das Zielbild: Dual-Scope (Workspace + Global unter `~/.blxcode/`), Unterordner als Kategorien, Category-Hubs im Graph, Frontmatter und scope-präfixierte Wikilinks. BLXCode hat bereits workspace-scoped Kategorien und einen ähnlichen Memory-Tab, fehlt aber fast die gesamte Global-/Scope-Schicht — die soll 1:1 nach dem EB-Referenzcode portiert werden."
+todos:
+  - id: backend-scope-types
+    content: memory.rs in Module splitten; MemoryScope, Global-Roots, erweiterte NoteMeta/MemoryListResponse, memory_status/bootstrap
+    status: pending
+  - id: backend-crud-graph
+    content: Alle memory_* Commands mit scope; frontmatter + wikilinks + graph Hubs/crossScope portieren
+    status: pending
+  - id: bridge-ipc
+    content: tauri_bridge + invoke-Args für scope; note_key/parse_note_key; memory_list Response anpassen
+    status: pending
+  - id: ui-files-sidebar
+    content: "workbench/memory/ EB-Struktur; Dual-Scope-Sidebar, useMemory-äquivalent, scope:path, Bootstrap Global"
+    status: pending
+  - id: remove-legacy-migration
+    content: migrate_legacy_memory aus agents_layout entfernen; Tests/Doku anpassen
+    status: pending
+  - id: ui-graph-search
+    content: "memory_graph: Hub-Nodes, scope-aware Klicks; Search-Filter workspace:cat / global:cat"
+    status: pending
+  - id: agent-export
+    content: Agent-Tools/Prompt/Context mit scope; Export/Import/Pointer-UI; i18n + Tests + Doku
+    status: pending
+isProject: false
+---
+
+# Memory-System: Parität BLXCode-eb → BLXCode (Tauri)
+
+## Referenz (Source of Truth)
+
+BLXCode-eb implementiert das vollständige Modell. Diese Dateien sind die Spezifikation zum Portieren:
+
+| Bereich | EB-Referenz |
+|---------|-------------|
+| Typen/Konstanten | [`src/shared/memory.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/shared/memory.ts) |
+| Pfade & Scopes | [`src/bun/memory/paths.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/paths.ts) |
+| CRUD/List/Graph | [`src/bun/memory/store.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/store.ts) |
+| Graph-Builder | [`src/bun/memory/graph.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/graph.ts) |
+| Wikilinks | [`src/bun/memory/wikilinks.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/wikilinks.ts) |
+| Frontmatter | [`src/bun/memory/frontmatter.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/frontmatter.ts) |
+| UI-Sidebar/Kategorien | [`src/views/.../Memory/files/MemorySidebar.tsx`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/files/MemorySidebar.tsx), [`memoryScopeCategories.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/memoryScopeCategories.ts) |
+| Graph-UI | [`MemoryGraphView.tsx`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/graph/MemoryGraphView.tsx) |
+
+## Ist-Zustand BLXCode (Gap-Analyse)
+
+```mermaid
+flowchart LR
+  subgraph eb [BLXCode-eb]
+    WS["workspace\n.agents/memory"]
+    GL["global\n~/.blxcode/memory"]
+    EBList["memoryList\nnotes + subcategories x2"]
+    EBGraph["Graph + CategoryHubs\ncrossScope edges"]
+  end
+  subgraph blx [BLXCode heute]
+    WSonly["nur workspace"]
+    CatOK["Unterordner = Kategorien\nmemory_list_categories"]
+    GraphSimple["Graph ohne Hubs\nkein scope auf Nodes"]
+  end
+```
+
+**Bereits vorhanden (behalten/erweitern):**
+- Workspace-Roots: `.agents/memory/`, `.agents/learnings/` ([`memory.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/memory.rs))
+- Dynamische Kategorien via Unterordner + `.gitkeep` (`memory_list_categories`, `memory_create_category`)
+- Memory-Tab mit Files / Graph / Search ([`memory_panel.rs`](c:/Users/quork/Entwicklung/BLXCode/src/workbench/memory_panel.rs))
+- `graph_category_for` identisch zu EB (erster Pfadsegment = Kategorie)
+
+**Fehlt für 1:1-Parität:**
+
+| Feature | EB | BLXCode |
+|---------|----|---------|
+| `MemoryScope` (`workspace` \| `global`) | überall | fehlt |
+| Global-Roots `~/.blxcode/{memory,learnings}` | ja | nein |
+| `memoryList` → `{ notes, memorySubcategories }` pro Scope | ja | getrennte Calls, nur workspace |
+| `NoteMeta`: `scope`, `title`, `enabled`, `tags`, `category`, `isLearning`, `isOverview` | ja | nur `path`, `name`, `size`, `modified`, `isTemplate` |
+| Frontmatter (`title`, `enabled`, `tags`) | ja | nein |
+| Wikilinks `[[global:…]]` / `[[workspace:…]]` | ja | nur basename/pfad |
+| Graph: Category-Hub-Knoten (`hub:cat`), `crossScope`, `hubScopes` | ja | nein |
+| Sidebar: zwei Sektionen (Projekt / Global) | ja | eine flache Kategorie-Liste |
+| Note-Keys `scope:path` | ja | nur `path` |
+| `memory_bootstrap` / `memory_status` (global) | ja | nur `workspace_ensure_agents` |
+| Export/Import/Pointers mit Scope-Auswahl | UI + RPC | Backend teils da, UI fehlt |
+
+---
+
+## Entscheidungen (abgestimmt)
+
+| Thema | Entscheidung |
+|-------|----------------|
+| Workspace-Legacy `<projekt>/.blxcode/memory/` | **Entfernen** — keine automatische Migration mehr nach `.agents/memory/` |
+| Global Memory | **1:1 EB:** `~/.blxcode/memory` + `~/.blxcode/learnings` (User-Home, nicht im Projektordner) |
+| `memory_list` API | **Breaking Change** — nur noch `{ notes, memorySubcategories }`, alle Aufrufer anpassen |
+| UI-Struktur | **Volle EB-Parität** — `src/workbench/memory/` mit Untermodulen (panel, files/, graph/, search/, dialogs) statt monolithischem `memory_panel.rs` |
+| Kategorie-Einstellungen | Alte Keys `decisions` → **`workspace:decisions`** beim Laden; Global-Keys `global:…` |
+
+---
+
+## Ziel-Architektur
+
+```mermaid
+flowchart TB
+  subgraph storage [Dateisystem]
+    WSM["workspace/.agents/memory"]
+    WSL["workspace/.agents/learnings"]
+    GLM["~/.blxcode/memory"]
+    GLL["~/.blxcode/learnings"]
+  end
+  subgraph tauri [src-tauri/src/memory/]
+    paths[paths.rs]
+    store[store.rs]
+    graph[graph.rs]
+    wikilinks[wikilinks.rs]
+    frontmatter[frontmatter.rs]
+  end
+  subgraph ui [src/workbench/memory/]
+    panel[memory_panel / useMemory-äquivalent]
+    sidebar[Scope-Sektionen + Kategorien]
+    graphUi[memory_graph mit Hubs]
+  end
+  WSM --> paths
+  WSL --> paths
+  GLM --> paths
+  GLL --> paths
+  paths --> store
+  store --> graph
+  wikilinks --> graph
+  store --> panel
+  graph --> graphUi
+```
+
+**Pfad-Regeln (wie EB):**
+- API-Pfad `learnings/foo.md` → Kategorie `learnings`, Scope je nach Root
+- `decisions/note.md` unter memory → Kategorie `decisions`
+- Root-`.md` → Kategorie `memory`
+- Unterordner von `.agents/memory` (ohne `_templates`, ohne `.`) → `memorySubcategories`
+- Node-IDs: `{scope}:{apiPath}`; Hub-IDs: `hub:{category}`
+
+---
+
+## Implementierung (Phasen)
+
+### Phase 1 — Backend: Scope & Typen
+
+**Refactor** [`src-tauri/src/memory.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/memory.rs) in Module (analog EB):
+
+- `memory/paths.rs` — `get_global_roots()`, `get_workspace_roots()`, `list_memory_subcategories()`, `graph_category_for()`, `node_id`/`parse_node_id`, `validate_category_name`
+- `memory/types.rs` — Serde-Structs spiegeln [`shared/memory.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/shared/memory.ts): `MemoryScope`, `NoteMeta`, `MemoryListResponse`, `GraphNode` (+ `isCategoryHub`, `hubScopes`), `GraphEdge` (+ `crossScope`), `SearchHit` (+ `scope`, `category`), `MemoryStatusResponse`
+
+**Neue/erweiterte Commands** in [`lib.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/lib.rs):
+
+- `memory_status(workspace_cwd?)` → workspace + global Ordner-Status
+- `memory_bootstrap(target, workspace_cwd?)` — `workspace` | `global` | `all` (Seed README in memory/learnings wie EB `store.ts`)
+- `memory_list` → `{ notes, memorySubcategories: { workspace, global } }` (ersetzt flaches `Vec<NoteMeta>`)
+- Alle bestehenden Commands um Parameter `scope: MemoryScope` erweitern (`memory_read`, `write`, `create`, `delete`, `rename`, `create_category`, `graph`, `search`, `backlinks`, `export`, `import`)
+
+**`collect_notes`:** Notizen aus beiden Roots sammeln, `scope` setzen, Frontmatter parsen, `category`/`isLearning`/`isOverview`/`enabled`/`title`/`tags` befüllen (Logik aus EB `collectNotes` in `store.ts`).
+
+**Kompatibilität:** Bestehende Workspace-Dateien unter `.agents/` bleiben unverändert; Global wird bei erstem Bootstrap unter `~/.blxcode/` angelegt.
+
+**Legacy entfernen:** `migrate_legacy_memory` und `LEGACY_MEMORY_REL` aus [`agents_layout.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/agents_layout.rs) streichen; Test `memory_list_includes_learnings_and_legacy_migrates` ersetzen. Nutzer mit altem `<projekt>/.blxcode/memory/` müssen Inhalt **manuell** nach `.agents/memory/` verschieben (einmalig, in Doku erwähnen).
+
+### Phase 2 — Graph, Wikilinks, Suche
+
+Port aus EB:
+
+- [`graph.rs`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/graph.ts): Hub-Knoten, Note→Hub-Kanten, Wikilink-Auflösung, `orphan`, `crossScope`
+- [`wikilinks.rs`](c:/Users/quork/Entwicklung/BLXCode-eb/src/bun/memory/wikilinks.ts): `global:`/`workspace:`-Prefix, Auflösung über `scopePaths`-Map beider Scopes
+- `memory_graph(workspace_cwd)` nutzt dieselbe Hub-Map-Logik wie `memoryGraph` in `store.ts` (Zeilen 434–496)
+
+`memory_backlinks` → `Vec<{ scope, path }>` statt nur Pfad-Strings.
+
+`memory_search` → Treffer mit `scope` + `category` für Filter `workspace:decisions` etc.
+
+### Phase 3 — Tauri-Bridge & Frontend-Typen
+
+[`src/tauri_bridge.rs`](c:/Users/quork/Entwicklung/BLXCode/src/tauri_bridge.rs):
+
+- Alle `memory_*`-Wrapper um `scope` ergänzen
+- `memory_list` → neues Response-Struct
+- Hilfsfunktionen wie EB [`memoryRpc.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/lib/memoryRpc.ts): `note_key(scope, path)`, `parse_note_key`
+
+Optional kleines Rust→WASM-geteiltes Modul oder Duplikat der Konstanten in [`src/config/app.config.rs`](c:/Users/quork/Entwicklung/BLXCode/src/config/app.config.rs): `CATEGORY_HUB_PREFIX`, `MEMORY_GRAPH_MODE_KEY` (bereits vorhanden prüfen).
+
+### Phase 4 — Memory-UI (Files-Tab)
+
+**Neue Modulstruktur** (analog EB `SidePanel/Memory/`), Leptos statt React:
+
+```
+src/workbench/memory/
+  mod.rs              — MemoryPanel, TabBar (files|graph|search)
+  use_memory.rs       — State, load/save, bootstrap (≈ useMemory.ts)
+  scope_categories.rs — build_scope_categories (≈ memoryScopeCategories.ts)
+  files/
+    sidebar.rs        — Dual-Scope-Sektionen + Kategorie-Gruppen
+    editor.rs
+    new_category_dialog.rs
+  graph/              — ggf. memory_graph/ hierher ziehen oder re-export
+  search/
+  dialogs/            — export, import, pointers, no-folder
+```
+
+[`memory_panel.rs`](c:/Users/quork/Entwicklung/BLXCode/src/workbench/memory_panel.rs) wird auf dünnen Re-Export reduziert oder entfernt.
+
+1. **State:** `memorySubcategories: Record<Scope, Vec<String>>`, `activeKey: Option<String>` (`scope:path`), Bootstrap beim Panel-Mount (`memory_bootstrap("all")`)
+2. **`build_scope_categories`** — Port von [`memoryScopeCategories.ts`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/memoryScopeCategories.ts): learnings immer, + Unterordner + Kategorien aus Notizen
+3. **Sidebar:** Zwei collapsible Sektionen „Projekt“ / „Global“ (i18n-Keys neu in [`src/i18n/`](c:/Users/quork/Entwicklung/BLXCode/src/i18n/)), pro Scope:
+   - Root-Notizen (`category == "memory"`)
+   - Collapsible Gruppen pro Kategorie (`groups_open` Key: `scope:category`)
+   - „Neue Kategorie“ pro Scope
+   - Global-Sektion: „Global Memory anlegen“ wenn noch nicht gebootstrappt (wie `MemoryNoFolderState` / `showCreateGlobal` in EB)
+4. **Editor:** Frontmatter-aware Titel, `enabled`-Toggle, Wikilink-Klick mit Scope-Auflösung (`memory_resolve_link` neu, analog EB)
+5. **`memory_note_groups`:** um `scope` erweitern oder durch EB-äquivalente Gruppierung ersetzen
+
+### Phase 5 — Graph-Tab
+
+[`src/workbench/memory_graph/mod.rs`](c:/Users/quork/Entwicklung/BLXCode/src/workbench/memory_graph/mod.rs):
+
+- Node-IDs als `scope:path`; Hub-Klicks → `overviewPathForCategory` + `preferredScopeForHub` (Port aus `shared/memory.ts`)
+- `GraphNode.category` + Hub-Styling (Farben aus bestehenden `memory_category_settings`, Key ggf. `global:decisions`)
+- `graph_selected_node` / Preview / Handoff: Scope mitgeben
+- 2D/3D: Hub-Knoten visuell unterscheiden (EB trennt Hub vs. Note)
+
+### Phase 6 — Search-Tab
+
+- Scope-/Kategorie-Filter-Chips (`all` | `workspace:cat` | `global:cat`) wie [`MemorySearchView.tsx`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/search/MemorySearchView.tsx)
+- Treffer-Öffnen mit korrektem Scope
+
+### Phase 7 — Agent-Integration
+
+- **Tools** [`src-tauri/src/agent/tools.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/agent/tools.rs): `scope`-Parameter bei allen Memory-Tools; Pfade als `global:learnings/…` oder absoluter Workspace-Pfad dokumentieren
+- **Client tools** [`client_tools.rs`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/agent/client_tools.rs): Kontext-Items mit Scope-Prefix in `paths`/`source`
+- **System prompt** + [`harness_skills/memory.md`](c:/Users/quork/Entwicklung/BLXCode/src-tauri/src/agent/harness_skills/memory.md): Global vs. Workspace, Kategorien, Hub-Graph
+- **Deep links** [`state.rs`](c:/Users/quork/Entwicklung/BLXCode/src/workbench/state.rs): `pending_memory_note` → `(scope, path)`
+
+### Phase 8 — Export/Import/Pointer-UI
+
+Backend existiert teils; ergänzen:
+
+- Bridge-Wrapper für `memory_export` / `memory_import` (falls noch `dead_code`)
+- Dialoge analog EB [`MemoryExportDialog.tsx`](c:/Users/quork/Entwicklung/BLXCode-eb/src/views/app/layout/SidePanel/Memory/MemoryExportDialog.tsx) / Import + Pointer-Installer im Memory-Panel-Menü
+
+### Phase 9 — Tests & Doku
+
+- Rust-Tests in `memory/`: Scope-Trennung, `list_memory_subcategories`, Hub-Graph, cross-scope Wikilink, bootstrap global
+- [`docs/user/memory-and-tasks.md`](c:/Users/quork/Entwicklung/BLXCode/docs/user/memory-and-tasks.md) + [`docs/developer/tauri-ipc.md`](c:/Users/quork/Entwicklung/BLXCode/docs/developer/tauri-ipc.md) aktualisieren
+
+---
+
+## Wichtige Portierungs-Details (nicht vergessen)
+
+1. **Learnings** bleiben separater Root (nicht Unterordner von memory), API-Prefix `learnings/` — in beiden Repos gleich.
+2. **Reservierte Kategorien:** `_templates`, `memory`, `learnings` — keine neuen Ordner mit diesen Namen.
+3. **Overview-Notizen:** `README.md` in Kategorie-Ordner → `isOverview`, Hub-Label im Graph.
+4. **Learning-Dateinamen:** `learning-<slug>.md` (EB validiert in `validateLearningName`).
+5. **Kategorie-Einstellungen:** Beim Deserialisieren/Lesen alte Keys ohne `:` → `workspace:<key>`; neue Keys immer `workspace:…` oder `global:…`.
+
+---
+
+## Zwei verschiedene `.blxcode`-Pfade (häufige Verwechslung)
+
+| Pfad | Bedeutung | Nach Umsetzung |
+|------|-----------|----------------|
+| `<projekt>/.blxcode/memory/` | **Altes** projekt-lokales Memory (frühere BLXCode-Generation) | **Nicht mehr** automatisch gelesen/migriert — manuell nach `.agents/memory/` verschieben |
+| `~/.blxcode/memory/` + `~/.blxcode/learnings/` | **Global Memory** (EB-Modell, app-weit) | Neuer Scope `global` in UI/Graph/Agent |
+
+Global Memory liegt absichtlich **nicht** im Workspace, sondern im Home-Verzeichnis — wie in EB.
+
+---
+
+## Nicht im Scope (bewusst)
+
+- Semantische Suche / Embeddings
+- Rules/Skills/Plans in Memory-Graph (EB schließt das ebenfalls aus)
+- Automatische Migration von `<projekt>/.blxcode/memory/` (bewusst entfernt, siehe Entscheidungen)
+
+---
+
+## Empfohlene Reihenfolge & Risiko
+
+1. Backend + Legacy-Entfernung + `memory_list` Breaking Change  
+2. Bridge  
+3. Neues `workbench/memory/`-Modul (Files → Graph → Search)  
+4. Agent, Export/Import, Doku  
+
+Größter Aufwand: UI-Neustrukturierung + Scope durchgängig; dafür kein paralleles Pflegen von Alt-`memory_panel.rs`.
diff --git a/.blxcode/tasks/index.json b/.blxcode/tasks/index.json
index 5c83a3e..f73b1d6 100644
--- a/.blxcode/tasks/index.json
+++ b/.blxcode/tasks/index.json
@@ -1,17 +1,5 @@
 {
   "version": 1,
-  "tasks": [
-    {
-      "id": "task-1779295993-1",
-      "title": "Demo task",
-      "description": "A placeholder demo task created by BLXCode Agent. You can edit the title, description, or status anytime.",
-      "status": "pending",
-      "position": 0,
-      "createdAt": 1779295993,
-      "updatedAt": 1779295993,
-      "completedAt": null,
-      "parentId": null,
-      "notes": null
-    }
-  ]
+  "tasks": [],
+  "activePlanPath": null
 }
\ No newline at end of file
diff --git a/.cargo/config.toml b/.cargo/config.toml
index 6576a4e..5d5a432 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -4,3 +4,9 @@ linker = "aarch64-linux-gnu-gcc"
 
 [target.x86_64-unknown-linux-gnu]
 linker = "x86_64-linux-gnu-gcc"
+
+# Faster linking on Windows — rust-lld is bundled with rustup and significantly
+# faster than the default MSVC link.exe for the native Tauri backend.
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld.exe"
+rustflags = ["-C", "linker=rust-lld.exe"]
diff --git a/public/terminal_bootstrap.mjs b/public/terminal_bootstrap.mjs
index b59a207..9e9c322 100644
--- a/public/terminal_bootstrap.mjs
+++ b/public/terminal_bootstrap.mjs
@@ -20,7 +20,7 @@ function xtermThemeFromDom() {
     foreground: readCssVar("--term-fg", "#f1f2f5"),
     cursor: readCssVar("--term-cursor", "#58a6ff"),
     cursorAccent: readCssVar("--term-cursor", "#58a6ff"),
-    selectionBackground: readCssVar("--accent-soft", "rgba(88, 166, 255, 0.16)"),
+    selectionBackground: readCssVar("--accent-soft", "rgba(88, 166, 255, 0.30)"),
     black: readCssVar("--bg-app", "#090a0d"),
     red: readCssVar("--danger", "#f85149"),
     green: readCssVar("--success", "#3fb950"),
@@ -226,6 +226,8 @@ window.__blxcodeTerminal = {
       allowTransparency: true,
       theme: xtermThemeFromDom(),
       disableStdin: false,
+      rightClickSelectsWord: false,
+      scrollback: 5000,
     });
     const fit = new FitAddon();
     term.loadAddon(fit);
@@ -241,6 +243,34 @@ window.__blxcodeTerminal = {
     });
     term.loadAddon(webLinks);
     term.open(container);
+
+    // Windows CMD-style right-click: copy selection if text is selected,
+    // otherwise paste from clipboard. xterm.js swallows contextmenu by
+    // default so we need our own handler on the rendered element.
+    const attachContextMenu = () => {
+      const el = term.element;
+      if (!el) return;
+      el.addEventListener("contextmenu", (e) => {
+        e.preventDefault();
+        const sel = term.getSelection();
+        if (sel && sel.length > 0) {
+          navigator.clipboard.writeText(sel).catch(() => {});
+          term.clearSelection();
+        } else {
+          navigator.clipboard
+            .readText()
+            .then((text) => { if (text) term.paste(text); })
+            .catch(() => {});
+        }
+      });
+    };
+    // term.element is available after open() but guard with rAF to be safe
+    if (term.element) {
+      attachContextMenu();
+    } else {
+      requestAnimationFrame(attachContextMenu);
+    }
+
     const rec = {
       term,
       fit,
diff --git a/src-tauri/src/browser_host.rs b/src-tauri/src/browser_host.rs
index 457c159..6105a97 100644
--- a/src-tauri/src/browser_host.rs
+++ b/src-tauri/src/browser_host.rs
@@ -9,7 +9,6 @@ use tauri::webview::WebviewBuilder;
 use tauri::{AppHandle, LogicalPosition, LogicalSize, Manager, WebviewUrl};
 use url::Url;
 
-pub const DEFAULT_HOME_URL: &str = "https://blxcode.com";
 
 /// Child-WebViews mit SPA-gestützten Bounds funktionieren zuverlässig nur dort,
 /// wo das Tauri-/wry-Backend eine echte Unter-WebView einpasst (Windows: HWND-Child,
@@ -84,11 +83,13 @@ impl BrowserHost {
         let label = label_for(tab_id);
 
         // Webview für aktiven Tab anlegen falls noch nicht vorhanden.
+        // Kein nativer Child für leere URLs (neuer Tab) — die Leptos-Komponente
+        // zeigt in dem Fall die New-Tab-Seite ohne überlagernde Webview.
         if !state.tabs.contains_key(&tab_id) {
-            let start = navigate_to
-                .map(str::trim)
-                .filter(|s| !s.is_empty())
-                .unwrap_or(DEFAULT_HOME_URL);
+            let start = match navigate_to.map(str::trim).filter(|s| !s.is_empty()) {
+                Some(url) => url,
+                None => return Ok(()),
+            };
             let u = Url::parse(start).map_err(|e| format!("URL: {e}"))?;
             let builder = WebviewBuilder::new(&label, WebviewUrl::External(u));
             let window = app
@@ -104,9 +105,10 @@ impl BrowserHost {
             state.tabs.insert(tab_id, Some(start.to_string()));
         }
 
-        let wv = app
-            .get_webview(&label)
-            .ok_or_else(|| format!("webview {label}"))?;
+        // Tab exists but still has no webview yet (URL was empty at creation time).
+        let Some(wv) = app.get_webview(&label) else {
+            return Ok(());
+        };
 
         wv.set_position(LogicalPosition::new(rect.x, rect.y))
             .map_err(|e| e.to_string())?;
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
index 6b4cdd9..787091f 100644
--- a/src-tauri/src/commands.rs
+++ b/src-tauri/src/commands.rs
@@ -467,44 +467,70 @@ pub struct BrowserBoundsPayload {
     pub visible: bool,
 }
 
+/// Dispatches `f` to the Tauri main thread and awaits the result.
+/// Required for any WebView2 / wry API call on Windows (add_child, navigate,
+/// show, hide, eval, …) — those must run on the UI message-pump thread.
+async fn dispatch_on_main<F, T>(app: tauri::AppHandle, f: F) -> Result<T, String>
+where
+    F: FnOnce(tauri::AppHandle) -> Result<T, String> + Send + 'static,
+    T: Send + 'static,
+{
+    let (tx, rx) = tokio::sync::oneshot::channel::<Result<T, String>>();
+    app.clone()
+        .run_on_main_thread(move || {
+            let _ = tx.send(f(app));
+        })
+        .map_err(|e| e.to_string())?;
+    rx.await.map_err(|_| "main thread channel dropped".to_string())?
+}
+
 #[tauri::command]
-pub fn browser_sync_bounds(
+pub async fn browser_sync_bounds(
     app: tauri::AppHandle,
-    host: State<'_, BrowserHost>,
     active_tab_id: Option<u64>,
     rect: BrowserBoundsPayload,
     url_optional: Option<String>,
 ) -> Result<(), String> {
-    host.sync_bounds(&app, active_tab_id, rect, url_optional.as_deref())
+    dispatch_on_main(app, move |app| {
+        app.state::<BrowserHost>()
+            .sync_bounds(&app, active_tab_id, rect, url_optional.as_deref())
+    })
+    .await
 }
 
 #[tauri::command]
-pub fn browser_run_js(
-    app: AppHandle,
-    host: State<'_, BrowserHost>,
+pub async fn browser_run_js(
+    app: tauri::AppHandle,
     tab_id: u64,
     script: String,
 ) -> Result<(), String> {
-    host.eval_embedded(&app, tab_id, script)
+    dispatch_on_main(app, move |app| {
+        app.state::<BrowserHost>().eval_embedded(&app, tab_id, script)
+    })
+    .await
 }
 
 #[tauri::command]
-pub fn browser_navigate(
+pub async fn browser_navigate(
     app: tauri::AppHandle,
-    host: State<'_, BrowserHost>,
     tab_id: u64,
     url: String,
 ) -> Result<(), String> {
-    host.navigate(&app, tab_id, &url)
+    dispatch_on_main(app, move |app| {
+        app.state::<BrowserHost>().navigate(&app, tab_id, &url)
+    })
+    .await
 }
 
 #[tauri::command]
-pub fn browser_close_tab(
+pub async fn browser_close_tab(
     app: tauri::AppHandle,
-    host: State<'_, BrowserHost>,
     tab_id: u64,
 ) -> Result<(), String> {
-    host.close_tab(&app, tab_id)
+    dispatch_on_main(app, move |app| {
+        app.state::<BrowserHost>().close_tab(&app, tab_id)
+    })
+    .await
 }
 
 #[tauri::command]
diff --git a/src-tauri/src/pty_host.rs b/src-tauri/src/pty_host.rs
index 6baf345..6babc27 100644
--- a/src-tauri/src/pty_host.rs
+++ b/src-tauri/src/pty_host.rs
@@ -56,7 +56,7 @@ impl PtyManager {
         cwd: String,
         extra_env: Vec<(String, String)>,
     ) -> Result<u64, String> {
-        let cwd = PathBuf::from(cwd.trim());
+        let cwd = PathBuf::from(cwd.trim().trim_matches('\0'));
         if cwd.as_os_str().is_empty() {
             return Err("cwd empty".into());
         }
@@ -73,9 +73,18 @@ impl PtyManager {
         };
         let pair = pty_system.openpty(size).map_err(|e| e.to_string())?;
 
-        let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string());
+        #[cfg(windows)]
+        let (shell, login_args): (String, &[&str]) = (
+            std::env::var("COMSPEC").unwrap_or_else(|_| "cmd.exe".into()),
+            &[],
+        );
+        #[cfg(not(windows))]
+        let (shell, login_args): (String, &[&str]) = (
+            std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".into()),
+            &["-l"],
+        );
         let mut cmd = CommandBuilder::new(&shell);
-        cmd.args(["-l"]);
+        cmd.args(login_args);
         cmd.cwd(&cwd);
         cmd.env("TERM", "xterm-256color");
         cmd.env("COLORTERM", "truecolor");
@@ -282,7 +291,10 @@ fn drain_queue(q: &mut VecDeque<Vec<u8>>, cap: usize) -> Vec<u8> {
 }
 
 fn home_dir_string() -> Option<String> {
-    std::env::var("HOME").ok().filter(|s| !s.is_empty())
+    std::env::var("HOME")
+        .or_else(|_| std::env::var("USERPROFILE"))
+        .ok()
+        .filter(|s| !s.is_empty())
 }
 
 /// Safe `cd`-style navigation: only `cd` with one argument (or `cd` / `cd ~`), plus empty line = pwd.
@@ -326,7 +338,7 @@ fn resolve_cd_path(base: &Path, arg: &str) -> Result<PathBuf, String> {
     let joined = if let Some(stripped) = arg.strip_prefix("~/") {
         let h = home_dir_string().ok_or_else(|| "HOME not set".to_string())?;
         Path::new(&h).join(stripped)
-    } else if arg.starts_with('/') {
+    } else if Path::new(arg).is_absolute() {
         PathBuf::from(arg)
     } else if arg == ".." {
         base.join("..")
diff --git a/src/config/app.config.rs b/src/config/app.config.rs
index e9917bd..30740eb 100644
--- a/src/config/app.config.rs
+++ b/src/config/app.config.rs
@@ -88,6 +88,9 @@ pub const SIDEBAR_DIFF_HEIGHT_PCT_DEFAULT: f64 = 30.0;
 pub const SIDEBAR_DIFF_HEIGHT_PCT_MIN: f64 = 12.0;
 pub const SIDEBAR_DIFF_HEIGHT_PCT_MAX: f64 = 76.0;
 
+/// Minimum height reserved for the Git Graph (commits) slot when stacked with other sections.
+pub const SIDEBAR_GRAPH_HEIGHT_PCT_MIN: f64 = 12.0;
+
 /// `localStorage` key for sidebar width in pixels.
 pub const SIDEBAR_WIDTH_PX_KEY: &str = "blxcode_sidebar_width_px_v1";
 
diff --git a/src/workbench/agent_panel/mod.rs b/src/workbench/agent_panel/mod.rs
index 0782b91..fa12a05 100644
--- a/src/workbench/agent_panel/mod.rs
+++ b/src/workbench/agent_panel/mod.rs
@@ -59,6 +59,15 @@ pub fn AgentPanelDock() -> impl IntoView {
     let image_mode = RwSignal::new(false);
     let chat_maximized = RwSignal::new(false);
     let chat_scroll_ref = NodeRef::<html::Div>::new();
+    let compose_input_ref = NodeRef::<html::Input>::new();
+    // Refocus the compose input whenever the agent finishes (busy → false).
+    Effect::new(move |_| {
+        if !busy.get() {
+            if let Some(el) = compose_input_ref.get() {
+                let _ = el.focus();
+            }
+        }
+    });
     let voice_handle = VoiceOrbHandle::new();
     let task_snapshot = RwSignal::new(TaskSnapshot {
         tasks: Vec::new(),
@@ -290,13 +299,6 @@ pub fn AgentPanelDock() -> impl IntoView {
                     <h3>{move || i18n.tr(I18nKey::AgChatHeading)()}</h3>
                     <SessionCostChip wb=wb />
                     <div class="agent-chat-head__actions">
-                        <span>{move || {
-                            if timeline.get().is_empty() {
-                                i18n.tr(I18nKey::AgBadgeReady)().to_string()
-                            } else {
-                                i18n.tr(I18nKey::AgBadgeLive)().to_string()
-                            }
-                        }}</span>
                         <button
                             type="button"
                             class=move || {
@@ -372,6 +374,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                                             draft.set(String::new());
                                             wb.set_workspace_agent_timeline(ws_id, Vec::new());
                                             wb.set_workspace_agent_compose_draft(ws_id, String::new());
+                                            wb.clear_chat_usage(ws_id);
                                             status_line.set(None);
                                         }
                                         Err(msg) => status_line.set(Some(msg)),
@@ -418,7 +421,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                                     .into_iter()
                                     .enumerate()
                                     .map(|(idx, entry)| {
-                                        view! { <TimelineRow idx=idx entry=entry i18n=i18n thinking_open=thinking_open voice_handle=voice_handle on_redo=on_redo timeline=timeline /> }
+                                        view! { <TimelineRow idx=idx entry=entry i18n=i18n thinking_open=thinking_open voice_handle=voice_handle on_redo=on_redo timeline=timeline wb=wb workspace_id=wb.active_id().get_untracked() /> }
                                     })
                                     .collect_view()
                             }}
@@ -436,6 +439,7 @@ pub fn AgentPanelDock() -> impl IntoView {
             >
                 <input
                     type="text"
+                    node_ref=compose_input_ref
                     class="workbench-agent-input workbench-agent-input--single"
                     placeholder=move || i18n.tr(I18nKey::AgPromptPh)()
                     prop:value=move || draft.get()
@@ -464,6 +468,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                         type="submit"
                         class="workbench-mini-btn workbench-mini-btn--primary agent-send-btn"
                         prop:disabled=move || busy.get()
+                        on:mousedown=|ev| ev.prevent_default()
                     >
                         <LxIcon icon=icondata::LuSparkles width="0.9rem" height="0.9rem" />
                         <span>{move || i18n.tr(I18nKey::AgSend)()}</span>
diff --git a/src/workbench/agent_panel/timeline.rs b/src/workbench/agent_panel/timeline.rs
index 1375855..83e77ea 100644
--- a/src/workbench/agent_panel/timeline.rs
+++ b/src/workbench/agent_panel/timeline.rs
@@ -30,9 +30,12 @@ pub enum DisplayTimelineItem {
         metrics: TurnMetrics,
     },
     Tool(ToolActivity),
-    /// Synthetic row for a tool-only model round — renders nothing but a
-    /// `TurnMetricsBar` so the round's cost still surfaces.
-    ModelDecision { metrics: TurnMetrics },
+    /// A tool-only model round: LLM inference metrics + the tool calls the
+    /// model issued in that round, grouped into one timeline block.
+    ModelRound {
+        metrics: TurnMetrics,
+        tools: Vec<ToolActivity>,
+    },
     SubagentGroup(SubagentGroup),
     Thinking { text: String, done: bool },
     GeneratedImage {
@@ -187,20 +190,11 @@ fn attach_main_model_round(rows: &mut Vec<TimelineItem>, metrics: TurnMetrics) {
         m.merge(&metrics);
         return;
     }
-    // Walk back over a trailing run of Tool rows to find where the
-    // tool-only round started.
-    let mut insert_at = rows.len();
-    while insert_at > 0 {
-        match &rows[insert_at - 1] {
-            TimelineItem::Tool(_) => insert_at -= 1,
-            _ => break,
-        }
-    }
-    if insert_at < rows.len() {
-        rows.insert(insert_at, TimelineItem::ModelDecision { metrics });
-    } else {
-        rows.push(TimelineItem::ModelDecision { metrics });
-    }
+    // Tool-only round: the backend pushes TurnUsage(ModelRound) *before*
+    // dispatching tools, so ToolCall events for this round always arrive
+    // *after* this event. Appending here lets those pushes land naturally
+    // after the ModelDecision row — no walk-back needed.
+    rows.push(TimelineItem::ModelDecision { metrics });
 }
 
 /// Attach `ToolExec` metrics for a main-agent tool. Walks backwards for
@@ -354,6 +348,8 @@ pub fn apply_agent_event(
                         detail: message.clone().filter(|m| !m.is_empty()),
                         call_id: None,
                         metrics: TurnMetrics::default(),
+                        paths: Vec::new(),
+                        merged_count: 1,
                     }));
                 }
             });
@@ -658,11 +654,87 @@ fn synthesize_completion_message(rows: &[TimelineItem]) -> Option<String> {
     Some(message)
 }
 
+/// Merge consecutive `ModelRound` display items when they each contain only a
+/// single (already-grouped) tool of the same type. This collapses e.g. three
+/// separate `rules_read` rounds into one entry the user can expand to see all
+/// files read, instead of forcing them to scroll past N nearly-identical rows.
+fn merge_consecutive_model_rounds(items: Vec<DisplayTimelineItem>) -> Vec<DisplayTimelineItem> {
+    let mut out: Vec<DisplayTimelineItem> = Vec::new();
+    for item in items {
+        if let DisplayTimelineItem::ModelRound {
+            metrics,
+            mut tools,
+        } = item
+        {
+            // Only collapse single-tool rounds with the same tool name as the
+            // previous round.
+            if tools.len() == 1 {
+                let incoming_tool = tools.remove(0);
+                if let Some(DisplayTimelineItem::ModelRound {
+                    metrics: prev_metrics,
+                    tools: prev_tools,
+                }) = out.last_mut()
+                {
+                    if prev_tools.len() == 1
+                        && prev_tools[0].tool == incoming_tool.tool
+                    {
+                        let prev = &mut prev_tools[0];
+                        prev.paths.extend(incoming_tool.paths);
+                        prev.metrics.merge(&incoming_tool.metrics);
+                        prev.merged_count += incoming_tool.merged_count;
+                        if incoming_tool.status == ActivityStatus::Fail {
+                            prev.status = ActivityStatus::Fail;
+                        } else if prev.status == ActivityStatus::Ok
+                            && incoming_tool.status == ActivityStatus::Pending
+                        {
+                            prev.status = ActivityStatus::Pending;
+                        }
+                        prev_metrics.merge(&metrics);
+                        continue;
+                    }
+                }
+                // Not merged — restore the tool and push as new entry.
+                tools.push(incoming_tool);
+            }
+            out.push(DisplayTimelineItem::ModelRound { metrics, tools });
+        } else {
+            out.push(item);
+        }
+    }
+    out
+}
+
+/// Merge consecutive tool rows with the same tool name into a single entry.
+/// Paths are accumulated; metrics are summed; status is the worst seen.
+fn group_consecutive_tools(tools: Vec<ToolActivity>) -> Vec<ToolActivity> {
+    let mut out: Vec<ToolActivity> = Vec::new();
+    for t in tools {
+        if let Some(last) = out.last_mut() {
+            if last.tool == t.tool {
+                last.paths.extend(t.paths);
+                last.metrics.merge(&t.metrics);
+                last.merged_count += t.merged_count;
+                if t.status == ActivityStatus::Fail {
+                    last.status = ActivityStatus::Fail;
+                } else if last.status == ActivityStatus::Ok
+                    && t.status == ActivityStatus::Pending
+                {
+                    last.status = ActivityStatus::Pending;
+                }
+                continue;
+            }
+        }
+        out.push(t);
+    }
+    out
+}
+
 pub fn compact_timeline(items: Vec<TimelineItem>) -> Vec<DisplayTimelineItem> {
     let mut out = Vec::with_capacity(items.len());
     let mut last_user_text: Option<String> = None;
+    let mut iter = items.into_iter().peekable();
 
-    for item in items {
+    while let Some(item) = iter.next() {
         match item {
             TimelineItem::User { text } => {
                 last_user_text = Some(text.clone());
@@ -676,9 +748,22 @@ pub fn compact_timeline(items: Vec<TimelineItem>) -> Vec<DisplayTimelineItem> {
                 });
             }
             TimelineItem::ModelDecision { metrics } => {
-                out.push(DisplayTimelineItem::ModelDecision { metrics });
+                // Collect the tool calls that follow this model round into a
+                // single grouped block instead of emitting separate Tool rows.
+                let mut tools = Vec::new();
+                while iter.peek().is_some_and(|x| matches!(x, TimelineItem::Tool(_))) {
+                    if let Some(TimelineItem::Tool(t)) = iter.next() {
+                        tools.push(t);
+                    }
+                }
+                out.push(DisplayTimelineItem::ModelRound {
+                    metrics,
+                    tools: group_consecutive_tools(tools),
+                });
             }
             TimelineItem::Tool(tool) => {
+                // Standalone tool not preceded by a ModelDecision (e.g. a
+                // text+tool round where metrics merged into the Assistant row).
                 out.push(DisplayTimelineItem::Tool(tool));
             }
             TimelineItem::Thinking { text, done } => {
@@ -724,7 +809,12 @@ pub fn compact_timeline(items: Vec<TimelineItem>) -> Vec<DisplayTimelineItem> {
         }
     }
 
-    out
+    merge_consecutive_model_rounds(out)
+}
+
+/// Returns the last path component of a workspace-relative path for display.
+fn path_tail(p: &str) -> String {
+    p.rsplit(['/', '\\']).next().unwrap_or(p).to_owned()
 }
 
 fn tool_icon(tool: &str) -> icondata::Icon {
@@ -818,6 +908,8 @@ pub fn TimelineRow(
     voice_handle: VoiceOrbHandle,
     on_redo: Callback<String>,
     timeline: RwSignal<Vec<TimelineItem>>,
+    wb: WorkbenchService,
+    workspace_id: Option<u64>,
 ) -> impl IntoView {
     let line_no = format!("{:02}", idx + 1);
     match entry {
@@ -900,14 +992,111 @@ pub fn TimelineRow(
             <ToolActivityRow line_no=line_no tool=tool voice_handle=voice_handle />
         }
         .into_any(),
-        DisplayTimelineItem::ModelDecision { metrics } => {
+        DisplayTimelineItem::ModelRound { metrics, tools } => {
             let loc = i18n.locale().get_untracked();
             let label = lookup(loc, I18nKey::AgMetricsModelRound).to_string();
             view! {
-                <li class="agent-chat-line agent-chat-line--decision">
+                <li class="agent-chat-line agent-chat-line--model-round">
                     <ChatLineIndexColumn line_no=line_no.clone() tts_text=None voice_handle=voice_handle />
                     <div class="agent-chat-body">
                         <span class="agent-chat-decision-label">{label}</span>
+                        <ul class="model-round-tools">
+                            {tools.into_iter().map(|tool| {
+                                let status_class = match tool.status {
+                                    ActivityStatus::Ok => "agent-tool-row--ok",
+                                    ActivityStatus::Fail => "agent-tool-row--fail",
+                                    ActivityStatus::Pending => "agent-tool-row--pending",
+                                };
+                                let status_icon = match tool.status {
+                                    ActivityStatus::Ok => icondata::LuCheck,
+                                    ActivityStatus::Fail => icondata::LuTriangleAlert,
+                                    ActivityStatus::Pending => icondata::LuLoader,
+                                };
+                                let tool_icon_val = tool_icon(&tool.tool);
+                                let label = tool.label.clone();
+                                // For grouped calls: show "×N" count instead of single-arg summary
+                                let merged_count = tool.merged_count;
+                                let summary = if merged_count > 1 {
+                                    String::new()
+                                } else {
+                                    tool.args_summary.clone()
+                                };
+                                let count_badge = if merged_count > 1 {
+                                    format!("×{merged_count}")
+                                } else {
+                                    String::new()
+                                };
+                                let tool_name = tool.tool.clone();
+                                let has_paths = !tool.paths.is_empty();
+                                let has_detail = has_paths
+                                    || tool.detail.as_ref().is_some_and(|s| !s.is_empty());
+                                let detail_text = tool.detail.clone().unwrap_or_default();
+                                let paths_sv = StoredValue::new(tool.paths.clone());
+                                let detail_open = RwSignal::new(false);
+                                view! {
+                                    <li class="model-round-tool-item">
+                                        <div class=format!("agent-tool-row {status_class}") title=tool_name>
+                                            <button
+                                                type="button"
+                                                class="agent-tool-row__head"
+                                                aria-expanded=move || detail_open.get().to_string()
+                                                prop:disabled=move || !has_detail
+                                                on:click=move |_| {
+                                                    if has_detail { detail_open.update(|o| *o = !*o); }
+                                                }
+                                            >
+                                                <span class="agent-tool-row__icon" aria-hidden="true">
+                                                    <LxIcon icon=tool_icon_val width="0.82rem" height="0.82rem" />
+                                                </span>
+                                                <span class="agent-tool-row__label">{label}</span>
+                                                <Show when={let s = summary.clone(); move || !s.is_empty()}>
+                                                    <span class="agent-tool-row__arg">{summary.clone()}</span>
+                                                </Show>
+                                                <Show when={let b = count_badge.clone(); move || !b.is_empty()}>
+                                                    <span class="agent-tool-row__count">{count_badge.clone()}</span>
+                                                </Show>
+                                                <span class="agent-tool-row__status" aria-hidden="true">
+                                                    <LxIcon icon=status_icon width="0.78rem" height="0.78rem" />
+                                                </span>
+                                            </button>
+                                            {move || {
+                                                if !has_detail || !detail_open.get() {
+                                                    return view! { <></> }.into_any();
+                                                }
+                                                if has_paths {
+                                                    view! {
+                                                        <ul class="tool-row-paths">
+                                                            {paths_sv.get_value().into_iter().map(|p| {
+                                                                let display = path_tail(&p);
+                                                                let p_open = p.clone();
+                                                                view! {
+                                                                    <li>
+                                                                        <button
+                                                                            type="button"
+                                                                            class="tool-row-path-btn"
+                                                                            title=p.clone()
+                                                                            on:click=move |_| {
+                                                                                if let Some(ws_id) = workspace_id {
+                                                                                    wb.open_center_file_tab(ws_id, p_open.clone());
+                                                                                }
+                                                                            }
+                                                                        >{display}</button>
+                                                                    </li>
+                                                                }
+                                                            }).collect_view()}
+                                                        </ul>
+                                                    }.into_any()
+                                                } else {
+                                                    view! {
+                                                        <pre class="agent-tool-row__detail">{detail_text.clone()}</pre>
+                                                    }.into_any()
+                                                }
+                                            }}
+                                        </div>
+                                    </li>
+                                }
+                            }).collect_view()}
+                        </ul>
                         <TurnMetricsBar metrics=metrics context=BarContext::Main />
                     </div>
                 </li>
diff --git a/src/workbench/agent_panel/turn_metrics_bar/turn_metrics_bar.css b/src/workbench/agent_panel/turn_metrics_bar/turn_metrics_bar.css
index 46224ba..c276ff6 100644
--- a/src/workbench/agent_panel/turn_metrics_bar/turn_metrics_bar.css
+++ b/src/workbench/agent_panel/turn_metrics_bar/turn_metrics_bar.css
@@ -3,22 +3,23 @@
    not compete with the row's primary content. */
 
 .turn-metrics-bar {
-    display: inline-flex;
+    display: flex;
     flex-wrap: wrap;
-    align-items: center;
+    align-items: baseline;
     gap: 0.4rem;
     margin-top: 0.25rem;
     padding: 0.1rem 0;
     font-family: ui-monospace, "SF Mono", "Menlo", "Consolas", monospace;
     font-size: 0.7rem;
-    line-height: 1.2;
+    line-height: 1;
     color: var(--text-muted);
 }
 
 .turn-metrics-bar__cell {
     display: inline-flex;
-    align-items: center;
+    align-items: baseline;
     gap: 0.2rem;
+    line-height: 1;
 }
 
 .turn-metrics-bar__cell strong {
@@ -43,21 +44,32 @@
     font-size: 0.66rem;
 }
 
-/* The new synthetic "decision" row for tool-only model rounds —
-   essentially just the metrics bar with a tiny prefix. */
-.agent-chat-line--decision {
-    padding-left: 0;
-}
-
-.agent-chat-line--decision .agent-chat-body {
-    padding: 0.05rem 0 0.05rem 0.1rem;
+/* Model-round row: inference metrics + tool calls grouped in one block. */
+.agent-chat-line--model-round .agent-chat-body {
+    padding-top: 0.15rem;
+    padding-bottom: 0.2rem;
 }
 
 .agent-chat-decision-label {
-    display: inline-block;
+    display: block;
     font-size: 0.65rem;
     text-transform: uppercase;
     letter-spacing: 0.06em;
     color: var(--text-muted);
-    margin-right: 0.4rem;
+    margin-bottom: 0.25rem;
+}
+
+/* Tool list nested inside the model-round block. */
+.model-round-tools {
+    list-style: none;
+    margin: 0.3rem 0 0 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+}
+
+.model-round-tool-item {
+    display: flex;
+    flex-direction: column;
 }
diff --git a/src/workbench/agent_timeline.rs b/src/workbench/agent_timeline.rs
index 40e2113..8ee742a 100644
--- a/src/workbench/agent_timeline.rs
+++ b/src/workbench/agent_timeline.rs
@@ -29,10 +29,23 @@ pub struct ToolActivity {
     /// Per-row metrics — populated by a matching `TurnUsage` event.
     #[serde(default)]
     pub metrics: TurnMetrics,
+    /// Workspace-relative paths accessed by this tool call (file-reading tools
+    /// only). Populated from tool args at call time; accumulates entries when
+    /// consecutive same-tool calls are grouped in a ModelRound.
+    #[serde(default)]
+    pub paths: Vec<String>,
+    /// Number of individual tool calls merged into this row (1 = ungrouped).
+    #[serde(default = "default_merged_count")]
+    pub merged_count: usize,
+}
+
+fn default_merged_count() -> usize {
+    1
 }
 
 impl ToolActivity {
     pub fn from_call(tool: &str, args: Option<&Value>, loc: Locale) -> Self {
+        let paths = file_arg_path(tool, args).into_iter().collect();
         Self {
             tool: tool.to_owned(),
             label: tool_label(tool, loc),
@@ -41,6 +54,8 @@ impl ToolActivity {
             detail: None,
             call_id: None,
             metrics: TurnMetrics::default(),
+            paths,
+            merged_count: 1,
         }
     }
 
@@ -288,6 +303,7 @@ fn summarize_args(tool: &str, args: Option<&Value>) -> String {
         "git_show" => Some("rev"),
         "git_commit" => Some("message"),
         "web_fetch" => Some("url"),
+        "rules_read" | "skills_read" => Some("name"),
         _ => None,
     };
     if let Some(key) = pick {
@@ -302,3 +318,25 @@ fn summarize_args(tool: &str, args: Option<&Value>) -> String {
     }
     String::new()
 }
+
+/// Returns the workspace-relative path that a file-reading tool accesses,
+/// constructed from its arguments. Returns `None` for non-file tools.
+fn file_arg_path(tool: &str, args: Option<&Value>) -> Option<String> {
+    let args = args?;
+    match tool {
+        "rules_read" => {
+            let name = args.get("name")?.as_str()?;
+            Some(format!(".agents/rules/{name}"))
+        }
+        "skills_read" => {
+            let name = args.get("name")?.as_str()?;
+            Some(format!(".agents/skills/{name}/SKILL.md"))
+        }
+        "read_workspace_file" | "memory_read" | "memory_create" | "memory_write"
+        | "memory_delete" | "memory_backlinks" | "list_workspace_files" => {
+            args.get("path")?.as_str().map(|s| s.to_owned())
+        }
+        "memory_rename" => args.get("newPath")?.as_str().map(|s| s.to_owned()),
+        _ => None,
+    }
+}
diff --git a/src/workbench/browser_tab.rs b/src/workbench/browser_tab.rs
index 0b9924b..f92c6ab 100644
--- a/src/workbench/browser_tab.rs
+++ b/src/workbench/browser_tab.rs
@@ -534,7 +534,15 @@ pub fn BrowserTabDock() -> impl IntoView {
                         aria-label=move || i18n.tr(I18nKey::BrNativeAria)()
                     >
                         <Show
-                            when=move || active_tab_url(wb).trim().is_empty()
+                            when=move || {
+                                let aid = wb.embedded_browser_active_id().get();
+                                wb.embedded_browser_tabs().with(|tabs| {
+                                    tabs.iter()
+                                        .find(|t| t.id == aid)
+                                        .map(|t| t.url.trim().is_empty())
+                                        .unwrap_or(true)
+                                })
+                            }
                             fallback=move || ().into_any()
                         >
                             <BrowserNewTabPane wb surface />
diff --git a/src/workbench/file_diff_section/file-diff-section.css b/src/workbench/file_diff_section/file-diff-section.css
index b320c95..45b6725 100644
--- a/src/workbench/file_diff_section/file-diff-section.css
+++ b/src/workbench/file_diff_section/file-diff-section.css
@@ -1,8 +1,4 @@
 .sidebar-view-section--sb-diff {
-  flex: 0 0 auto;
-}
-
-.sidebar-view-section--sb-diff.sidebar-view-section--open {
   flex: 1 1 auto;
   min-height: 0;
 }
diff --git a/src/workbench/mod.rs b/src/workbench/mod.rs
index 4e21805..f38ac01 100644
--- a/src/workbench/mod.rs
+++ b/src/workbench/mod.rs
@@ -56,8 +56,9 @@ pub use right_panel::RightPanel;
 pub use sidebar::Sidebar;
 pub use skills_rules_panel::SkillsRulesService;
 pub use state::{
-    AgentImageContextStatus, BrowserEmbedSurface, HarnessUiService, LegacyStorageMigration,
-    RightPanelTab, WorkbenchService, WorkbenchSnapshot, WorkspaceAgentImage,
+    AgentImageContextStatus, BrowserEmbedSurface, HarnessSettingsCategory, HarnessUiService,
+    LegacyStorageMigration, RightPanelTab, WorkbenchService, WorkbenchSnapshot,
+    WorkspaceAgentImage,
 };
 pub use workspace_panel::WorkspacePanel;
 
diff --git a/src/workbench/right_panel.rs b/src/workbench/right_panel.rs
index 8ef9618..09e7dd6 100644
--- a/src/workbench/right_panel.rs
+++ b/src/workbench/right_panel.rs
@@ -3,7 +3,8 @@ use crate::i18n::I18nKey;
 use crate::service::I18nService;
 use crate::workbench::skills_rules_panel::{RulesTabDock, SkillsTabDock};
 use crate::workbench::{
-    AgentPanelDock, BrowserTabDock, MemoryPanel, PlansPanel, RightPanelTab, WorkbenchService,
+    AgentPanelDock, BrowserTabDock, HarnessSettingsCategory, MemoryPanel, PlansPanel,
+    RightPanelTab, WorkbenchService,
 };
 use leptos::leptos_dom::helpers::window_event_listener_untyped;
 use leptos::prelude::*;
@@ -54,6 +55,32 @@ fn PlansTabDock() -> impl IntoView {
     }
 }
 
+#[component]
+fn RightPanelSettingsButton(#[prop(default = "")] extra_class: &'static str) -> impl IntoView {
+    let wb = expect_context::<WorkbenchService>();
+    let i18n = expect_context::<I18nService>();
+    view! {
+        <button
+            type="button"
+            class=move || {
+                let mut c = String::from("workbench-icon-btn workbench-right-settings-btn");
+                if !extra_class.is_empty() {
+                    c.push(' ');
+                    c.push_str(extra_class);
+                }
+                c
+            }
+            aria-label=move || i18n.tr(I18nKey::CmdSetTitle)()
+            title=move || i18n.tr(I18nKey::CmdSetTitle)()
+            on:click=move |_| wb.open_center_settings_tab(HarnessSettingsCategory::App)
+        >
+            <span class="workbench-right-settings-btn__icon" aria-hidden="true">
+                <LxIcon icon=icondata::LuSettings width="1rem" height="1rem" />
+            </span>
+        </button>
+    }
+}
+
 #[component]
 pub fn RightPanel() -> impl IntoView {
     let wb = expect_context::<WorkbenchService>();
@@ -264,6 +291,9 @@ pub fn RightPanel() -> impl IntoView {
                         </span>
                     </button>
                 </div>
+                <footer class="workbench-right-rail__footer">
+                    <RightPanelSettingsButton extra_class="workbench-right-rail-settings-btn" />
+                </footer>
             </div>
             <div
                 class="workbench-splitter"
@@ -387,7 +417,9 @@ pub fn RightPanel() -> impl IntoView {
                                 </span>
                                 <span class="workbench-right-tab__label">{move || i18n.tr(I18nKey::TabSkills)()}</span>
                             </button>
+                            
                         </div>
+                        <RightPanelSettingsButton />
                     </div>
                 </header>
                 <div id="blx-right-panel-body" class="workbench-right__body">
diff --git a/src/workbench/sidebar.rs b/src/workbench/sidebar.rs
index a2ade64..01e2635 100644
--- a/src/workbench/sidebar.rs
+++ b/src/workbench/sidebar.rs
@@ -2,9 +2,10 @@ use crate::config::{
     SIDEBAR_DIFF_HEIGHT_PCT_DEFAULT, SIDEBAR_DIFF_HEIGHT_PCT_KEY, SIDEBAR_DIFF_HEIGHT_PCT_MAX,
     SIDEBAR_DIFF_HEIGHT_PCT_MIN, SIDEBAR_EXPLORER_HEIGHT_PCT_DEFAULT,
     SIDEBAR_EXPLORER_HEIGHT_PCT_KEY, SIDEBAR_EXPLORER_HEIGHT_PCT_MAX,
-    SIDEBAR_EXPLORER_HEIGHT_PCT_MIN, SIDEBAR_PANELS_HEIGHT_PCT_DEFAULT,
-    SIDEBAR_PANELS_HEIGHT_PCT_KEY, SIDEBAR_PANELS_HEIGHT_PCT_MAX, SIDEBAR_PANELS_HEIGHT_PCT_MIN,
-    SIDEBAR_WIDTH_PX_DEFAULT, SIDEBAR_WIDTH_PX_MIN,
+    SIDEBAR_EXPLORER_HEIGHT_PCT_MIN, SIDEBAR_GRAPH_HEIGHT_PCT_MIN,
+    SIDEBAR_PANELS_HEIGHT_PCT_DEFAULT, SIDEBAR_PANELS_HEIGHT_PCT_KEY,
+    SIDEBAR_PANELS_HEIGHT_PCT_MAX, SIDEBAR_PANELS_HEIGHT_PCT_MIN, SIDEBAR_WIDTH_PX_DEFAULT,
+    SIDEBAR_WIDTH_PX_MIN,
 };
 use crate::i18n::I18nKey;
 use crate::service::I18nService;
@@ -454,6 +455,8 @@ pub fn Sidebar() -> impl IntoView {
                         <ProjectExplorerSection />
                     </div>
                     <Show when=move || {
+                        let _ = wb.workspaces().get();
+                        let _ = wb.active_id().get();
                         wb.active_sidebar_explorer_open()
                             && (wb.active_sidebar_diff_open()
                                 || wb.active_sidebar_graph_open())
@@ -464,6 +467,21 @@ pub fn Sidebar() -> impl IntoView {
                             height_pct=explorer_height_pct
                             container_selector=".workbench-sidebar__panels"
                             aria_key=I18nKey::SbExplorerResizeAria
+                            clamp_max=Some(Signal::derive(move || {
+                                let diff_visible = wb.active_sidebar_diff_open()
+                                    && git_repo_available.get_untracked() == Some(true);
+                                let graph_visible = wb.active_sidebar_graph_open();
+                                let reserved = if diff_visible && graph_visible {
+                                    diff_height_pct.get() + SIDEBAR_GRAPH_HEIGHT_PCT_MIN
+                                } else if diff_visible {
+                                    diff_height_pct.get()
+                                } else if graph_visible {
+                                    SIDEBAR_GRAPH_HEIGHT_PCT_MIN
+                                } else {
+                                    0.0
+                                };
+                                (100.0 - reserved).max(SIDEBAR_EXPLORER_HEIGHT_PCT_MIN)
+                            }))
                         />
                     </Show>
                     <div
@@ -493,6 +511,8 @@ pub fn Sidebar() -> impl IntoView {
                         <FileDiffSection git_repo_available=git_repo_available.read_only() />
                     </div>
                     <Show when=move || {
+                        let _ = wb.workspaces().get();
+                        let _ = wb.active_id().get();
                         wb.active_sidebar_diff_open()
                             && wb.active_sidebar_graph_open()
                             && git_repo_available.get() == Some(true)
@@ -502,6 +522,22 @@ pub fn Sidebar() -> impl IntoView {
                             container_selector=".workbench-sidebar__panels"
                             clamp=SidebarResizerClamp::DiffInPanels
                             aria_key=I18nKey::SbDiffResizeAria
+                            subtract_pct=Some(Signal::derive(move || {
+                                if wb.active_sidebar_explorer_open() {
+                                    explorer_height_pct.get()
+                                } else {
+                                    0.0
+                                }
+                            }))
+                            clamp_max=Some(Signal::derive(move || {
+                                let explorer_pct = if wb.active_sidebar_explorer_open() {
+                                    explorer_height_pct.get()
+                                } else {
+                                    0.0
+                                };
+                                (100.0 - explorer_pct - SIDEBAR_GRAPH_HEIGHT_PCT_MIN)
+                                    .max(SIDEBAR_DIFF_HEIGHT_PCT_MIN)
+                            }))
                         />
                     </Show>
                     <div
diff --git a/src/workbench/sidebar_resizer/mod.rs b/src/workbench/sidebar_resizer/mod.rs
index c544565..84e07bd 100644
--- a/src/workbench/sidebar_resizer/mod.rs
+++ b/src/workbench/sidebar_resizer/mod.rs
@@ -51,6 +51,16 @@ pub fn SidebarResizer(
     aria_key: I18nKey,
     #[prop(default = "")]
     extra_class: &'static str,
+    /// Subtract this percentage from the raw Y-from-top value before storing.
+    /// Used when the resizer sits below another fixed-size slot (e.g. diff resizer
+    /// must subtract explorer_pct so `height_pct` stores the section height, not
+    /// the absolute boundary position).
+    #[prop(default = None)]
+    subtract_pct: Option<Signal<f64>>,
+    /// Dynamic ceiling that overrides the static clamp max — used to reserve space
+    /// for sections below (e.g. ensure the graph slot never collapses to zero).
+    #[prop(default = None)]
+    clamp_max: Option<Signal<f64>>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let dragging = RwSignal::new(false);
@@ -82,12 +92,20 @@ pub fn SidebarResizer(
             return;
         }
         let offset = f64::from(pe.client_y()) - rect.top();
-        let pct = if measure_from_bottom {
+        let raw_pct = if measure_from_bottom {
             ((height - offset) / height) * 100.0
         } else {
             (offset / height) * 100.0
         };
-        let (min_pct, max_pct) = clamp.min_max();
+        let pct = match subtract_pct {
+            Some(sub) => raw_pct - sub.get_untracked(),
+            None => raw_pct,
+        };
+        let (min_pct, static_max) = clamp.min_max();
+        let max_pct = match clamp_max {
+            Some(s) => s.get_untracked().min(static_max),
+            None => static_max,
+        };
         height_pct.set(pct.max(min_pct).min(max_pct));
     });
 
diff --git a/src/workbench/state.rs b/src/workbench/state.rs
index 77dd865..44cd974 100644
--- a/src/workbench/state.rs
+++ b/src/workbench/state.rs
@@ -195,7 +195,11 @@ pub struct ChatUsageStats {
     /// belong to a turn that was cancelled by `agent_clear_conversation`.
     /// Bumped locally on chat reset as well so we don't credit anything
     /// emitted before the reset to the fresh chat.
-    #[serde(default)]
+    ///
+    /// Not persisted: the backend resets its own generation to 0 on every
+    /// app launch, so persisting this value would cause all first-session
+    /// events to be dropped after any prior-session reset.
+    #[serde(skip)]
     pub current_turn_generation: u64,
 }
 
diff --git a/styles.css b/styles.css
index 4f86673..e154e65 100644
--- a/styles.css
+++ b/styles.css
@@ -23,6 +23,34 @@
   box-sizing: border-box;
 }
 
+/* ── Global thin scrollbars ──────────────────────────────────────────────── */
+* {
+  scrollbar-width: thin;
+  scrollbar-color: var(--border-strong) transparent;
+}
+
+*::-webkit-scrollbar {
+  width: 4px;
+  height: 4px;
+}
+
+*::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+*::-webkit-scrollbar-thumb {
+  background: var(--border-strong);
+  border-radius: 2px;
+}
+
+*::-webkit-scrollbar-thumb:hover {
+  background: var(--text-muted);
+}
+
+*::-webkit-scrollbar-corner {
+  background: transparent;
+}
+
 html {
   height: 100%;
   overflow: hidden;
@@ -620,6 +648,18 @@ body {
   min-height: 0;
 }
 
+.workbench-sidebar__diff-slot {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.workbench-sidebar__diff-slot > .sidebar-view-section {
+  flex: 1 1 auto;
+  min-height: 0;
+}
+
 .workbench-sidebar__graph-slot {
   flex: 1 1 auto;
   min-height: 0;
@@ -1718,6 +1758,27 @@ button.workbench-shortcut-row--action:focus-visible {
   display: block;
 }
 
+.workbench-right-rail__footer {
+  flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.35rem 0 0.5rem;
+  border-top: 1px solid var(--border);
+}
+
+.workbench-right-rail-settings-btn {
+  width: 2rem;
+  height: 2rem;
+  flex-shrink: 0;
+}
+
+.workbench-right-settings-btn__icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
 .workbench-right-slot--resizing,
 .workbench-right-slot--resizing * {
   cursor: col-resize !important;
@@ -3239,6 +3300,36 @@ button.workbench-shortcut-row--action:focus-visible {
   word-break: break-word;
 }
 
+.tool-row-paths {
+  list-style: none;
+  margin: 0;
+  padding: 0.1rem 0.52rem 0.48rem 1.9rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.18rem;
+}
+
+.tool-row-path-btn {
+  display: inline-flex;
+  align-items: center;
+  padding: 0;
+  border: none;
+  background: transparent;
+  font-family: var(--font-mono);
+  font-size: 0.66rem;
+  color: var(--accent);
+  cursor: pointer;
+  text-decoration: underline;
+  text-underline-offset: 2px;
+  text-decoration-color: transparent;
+  transition: color 120ms ease, text-decoration-color 120ms ease;
+}
+
+.tool-row-path-btn:hover {
+  color: var(--accent);
+  text-decoration-color: var(--accent);
+}
+
 .agent-tool-row__count {
   display: inline-flex;
   align-items: center;
@@ -4794,8 +4885,6 @@ button.workbench-shortcut-row--action:focus-visible {
   flex: 1;
   overflow: auto;
   padding: 0.875rem 1.25rem 1rem;
-  scrollbar-width: thin;
-  scrollbar-color: var(--border-strong) transparent;
 }
 
 .eula-scroll.eula-md {
@@ -4896,18 +4985,6 @@ button.workbench-shortcut-row--action:focus-visible {
   color: inherit;
 }
 
-.eula-scroll::-webkit-scrollbar {
-  width: 6px;
-}
-
-.eula-scroll::-webkit-scrollbar-thumb {
-  background: var(--border-strong);
-  border-radius: 3px;
-}
-
-.eula-scroll::-webkit-scrollbar-track {
-  background: transparent;
-}
 
 .eula-actions {
   position: relative;
@@ -5203,7 +5280,6 @@ button {
   gap: 0.18rem;
   min-width: 0;
   overflow-x: auto;
-  scrollbar-width: thin;
 }
 
 .workspace-center-tab {
@@ -6347,6 +6423,7 @@ button {
   background: transparent !important;
 }
 
+
 .harness-sheet--wizard {
   margin-top: 3vh;
   width: min(96vw, 52rem);

From 19b5b004ba748d21087d5dba243d8ee30cf20022 Mon Sep 17 00:00:00 2001
From: Maik Roland Damm <maik.damm@bluewave-tech.de>
Date: Tue, 26 May 2026 23:43:35 +0200
Subject: [PATCH 2/8] Refactor workspace module imports and clean up code
 structure

- Rearranged module imports in `mod.rs` for better organization.
- Consolidated and simplified function signatures in `plans_panel/mod.rs`.
- Removed unnecessary whitespace in `right_panel.rs` and `sidebar_resizer/mod.rs`.
- Improved readability by adjusting formatting in `skills_rules_panel/install_dialog.rs`.
- Enhanced clarity in `state.rs` by restructuring enum definitions.
- Streamlined terminal cell imports in `terminal_cell.rs`.
- Optimized theme service function in `theme_service.rs`.
- Adjusted function signatures for consistency in `voice_app_controls/mod.rs`.
- Cleaned up layout logic in `workspace_panel.rs`.
- Refined workspace settings pane structure in `workspace_settings_pane/mod.rs`.
- Added new styles for memory files section in `styles.css`.
---
 .../plans/phase5-6-handoff-for-codex.md       |  327 +++++
 .agents/learnings/LEARNINGS.md                |   12 -
 .agents/learnings/README.md                   |   28 +
 .agents/memory/README.md                      |   28 +
 .agents/memory/Test.md                        |    2 +
 frontend-js/graph3d_entry.mjs                 |   38 +-
 src-tauri/Cargo.toml                          |    1 +
 src-tauri/src/agent/anthropic.rs              |   39 +-
 src-tauri/src/agent/git_agent.rs              |   14 +-
 src-tauri/src/agent/mod.rs                    |    4 +-
 src-tauri/src/agent/openrouter.rs             |   14 +-
 src-tauri/src/agent/pricing.rs                |   26 +-
 src-tauri/src/agent/session_orchestrator.rs   |    6 +-
 src-tauri/src/agent/shell_exec.rs             |   21 +-
 src-tauri/src/agent/subagent_prompts.rs       |   68 +-
 src-tauri/src/agent/subagent_runner.rs        |  105 +-
 src-tauri/src/agent/subagents.rs              |   10 +-
 src-tauri/src/agent/system_prompt.rs          |    7 +-
 src-tauri/src/agent/tool_groups.rs            |   28 +-
 src-tauri/src/agent/tools.rs                  |   34 +-
 src-tauri/src/agent/web_settings.rs           |   23 +-
 src-tauri/src/agent/web_tools.rs              |    6 +-
 src-tauri/src/agent/workspace_agent.rs        |   10 +-
 src-tauri/src/agent_settings.rs               |    9 +-
 src-tauri/src/agents_layout.rs                |   65 +-
 src-tauri/src/api_keys.rs                     |    7 +-
 src-tauri/src/browser_host.rs                 |    1 -
 src-tauri/src/commands.rs                     |   24 +-
 src-tauri/src/fs_entries.rs                   |   64 +-
 src-tauri/src/git_graph.rs                    |    9 +-
 src-tauri/src/gitignore.rs                    |    4 +-
 src-tauri/src/image/generate.rs               |   39 +-
 src-tauri/src/image/settings.rs               |    7 +-
 src-tauri/src/lib.rs                          |    7 +-
 src-tauri/src/memory.rs                       | 1276 -----------------
 src-tauri/src/memory/frontmatter.rs           |   87 ++
 src-tauri/src/memory/graph.rs                 |  153 ++
 src-tauri/src/memory/mod.rs                   |  178 +++
 src-tauri/src/memory/paths.rs                 |  153 ++
 src-tauri/src/memory/store.rs                 | 1092 ++++++++++++++
 src-tauri/src/memory/types.rs                 |  128 ++
 src-tauri/src/memory/wikilinks.rs             |  253 ++++
 src-tauri/src/plans.rs                        |   21 +-
 src-tauri/src/skills_rules/commands.rs        |    4 +-
 src-tauri/src/skills_rules/install.rs         |    9 +-
 src-tauri/src/skills_rules/store.rs           |   43 +-
 src-tauri/src/skills_rules/types.rs           |   10 +-
 src-tauri/src/voice/settings.rs               |    9 +-
 src-tauri/src/voice/stt.rs                    |    3 +-
 src/i18n/keys.rs                              |    3 +
 src/i18n/locales/de_de.rs                     |    3 +
 src/i18n/locales/en_us.rs                     |    3 +
 src/i18n/locales/es_es.rs                     |    3 +
 src/i18n/locales/fr_fr.rs                     |    3 +
 src/i18n/locales/hu_hu.rs                     |    3 +
 src/i18n/locales/it_it.rs                     |    3 +
 src/i18n/locales/ja_jp.rs                     |    3 +
 src/i18n/locales/ko_kr.rs                     |    3 +
 src/i18n/locales/pl_pl.rs                     |    3 +
 src/i18n/locales/pt_br.rs                     |    3 +
 src/i18n/locales/ru_ru.rs                     |    3 +
 src/i18n/locales/zh_cn.rs                     |    3 +
 src/i18n/locales/zh_tw.rs                     |    3 +
 src/main.rs                                   |    2 +-
 src/tauri_bridge.rs                           |  180 ++-
 src/theme/catalog.rs                          |    6 +-
 src/theme/mod.rs                              |    4 +-
 src/workbench/agent_context_handoff.rs        |   34 +-
 src/workbench/agent_model_picker/mod.rs       |   14 +-
 .../agent_panel/ask_user_card/mod.rs          |    7 +-
 src/workbench/agent_panel/client_tools.rs     |    5 +-
 src/workbench/agent_panel/mod.rs              |    9 +-
 src/workbench/agent_panel/timeline.rs         |  125 +-
 .../agent_panel/turn_metrics_bar/mod.rs       |    5 +-
 src/workbench/agent_panel/voice_orb/mod.rs    |    9 +-
 src/workbench/agent_provider_pane/mod.rs      |    5 +-
 src/workbench/agent_timeline.rs               |   27 +-
 src/workbench/api_keys_pane/mod.rs            |   12 +-
 src/workbench/chat_markdown.rs                |   46 +-
 .../file_preview/code_context_menu.rs         |    4 +-
 src/workbench/file_preview/code_view.rs       |   83 +-
 src/workbench/file_preview/hljs_glue.rs       |   12 +-
 src/workbench/file_preview/markdown_view.rs   |    6 +-
 src/workbench/file_preview/mermaid_glue.rs    |   39 +-
 src/workbench/file_preview/util.rs            |   36 +-
 src/workbench/git_graph/mod.rs                |    4 +-
 src/workbench/harness_chords.rs               |   11 +-
 src/workbench/harness_image_pane/mod.rs       |    5 +-
 src/workbench/harness_ui.rs                   |    2 +-
 src/workbench/harness_voice_pane/mod.rs       |   17 +-
 src/workbench/memory_graph/mod.rs             |  213 ++-
 src/workbench/memory_panel.rs                 |  666 ++++++---
 src/workbench/mod.rs                          |   18 +-
 src/workbench/plans_panel/mod.rs              |    5 +-
 src/workbench/right_panel.rs                  |    2 +-
 src/workbench/sidebar_resizer/mod.rs          |   20 +-
 .../skills_rules_panel/install_dialog.rs      |    9 +-
 src/workbench/state.rs                        |   28 +-
 src/workbench/terminal_cell.rs                |    6 +-
 src/workbench/theme_service.rs                |    5 +-
 src/workbench/voice_app_controls/mod.rs       |    7 +-
 src/workbench/workspace_panel.rs              |    7 +-
 src/workbench/workspace_settings_pane/mod.rs  |   13 +-
 styles.css                                    |   48 +-
 104 files changed, 4040 insertions(+), 2264 deletions(-)
 create mode 100644 .agents/.cursor/plans/phase5-6-handoff-for-codex.md
 delete mode 100644 .agents/learnings/LEARNINGS.md
 create mode 100644 .agents/learnings/README.md
 create mode 100644 .agents/memory/README.md
 create mode 100644 .agents/memory/Test.md
 delete mode 100644 src-tauri/src/memory.rs
 create mode 100644 src-tauri/src/memory/frontmatter.rs
 create mode 100644 src-tauri/src/memory/graph.rs
 create mode 100644 src-tauri/src/memory/mod.rs
 create mode 100644 src-tauri/src/memory/paths.rs
 create mode 100644 src-tauri/src/memory/store.rs
 create mode 100644 src-tauri/src/memory/types.rs
 create mode 100644 src-tauri/src/memory/wikilinks.rs

diff --git a/.agents/.cursor/plans/phase5-6-handoff-for-codex.md b/.agents/.cursor/plans/phase5-6-handoff-for-codex.md
new file mode 100644
index 0000000..c1022c1
--- /dev/null
+++ b/.agents/.cursor/plans/phase5-6-handoff-for-codex.md
@@ -0,0 +1,327 @@
+# Handoff: Memory System — Phases 5 & 6
+
+## Context
+
+This is BLXCode (Tauri 2 + Leptos 0.8 CSR), a desktop IDE.  
+Phases 1–4 of the memory-parity plan are **complete and compiling**.  
+This document tells you exactly what is left for Phases 5 and 6 and where every relevant piece of code lives.
+
+---
+
+## What Was Done (Phases 1–4)
+
+### Backend (`src-tauri/src/memory/`)
+- `memory.rs` was replaced by a full module: `types.rs`, `paths.rs`, `frontmatter.rs`, `wikilinks.rs`, `graph.rs`, `store.rs`, `mod.rs`
+- `MemoryScope { Workspace, Global }` (serde: `"workspace"` / `"global"`) runs everywhere
+- Global roots: `~/.blxcode/memory/` and `~/.blxcode/learnings/` (via `dirs::home_dir()`)
+- New commands registered in `src-tauri/src/lib.rs`: `memory_status`, `memory_bootstrap`
+- All CRUD commands have `scope: MemoryScope` parameter
+- `memory_list` returns `MemoryListResponse { notes: Vec<NoteMeta>, memory_subcategories: MemorySubcategories { workspace, global } }`
+- `memory_backlinks` returns `Vec<BacklinkRef { scope, path }>`
+- Graph builder creates hub nodes (`id: "hub:{category}"`, `is_category_hub: true`) and cross-scope edges
+- Legacy migration (`migrate_legacy_memory`) removed from `agents_layout.rs`
+
+### Frontend (`src/`)
+- `src/tauri_bridge.rs`: all memory types updated, `MemoryScope` enum, `note_key(scope, path)`, `parse_note_key(key)`, `memory_bootstrap`, `memory_status`
+- `src/workbench/memory_panel.rs`: dual-scope sidebar implemented
+  - `MemoryState` has `active_scope`, `global_subcategories`, `global_bootstrapped`, `backlinks: Vec<BacklinkRef>`
+  - Files view has two sections: "Projekt" (workspace) and "Global"
+  - Global section shows "Create Global Memory" button when not bootstrapped
+  - All CRUD ops (create note/category, rename, delete, backlink click, context menu) use `note.scope`
+  - Workspace bootstrap called on workspace change
+- `src/workbench/memory_graph/mod.rs`: still uses **hardcoded `MemoryScope::Workspace`** in two places (intentional Phase 4 deferral)
+
+---
+
+## Current State of `memory_graph/mod.rs`
+
+File: `src/workbench/memory_graph/mod.rs`
+
+Two hardcoded workspace fallbacks that need to be fixed in Phase 5:
+
+**Line ~810** (in the "Open in Files" button click handler):
+```rust
+expand_files_group_for_path(state.clone(), &MemoryScope::Workspace, &path);
+load_note(state.clone(), ws, MemoryScope::Workspace, path);
+```
+
+**Line ~858** (inside `open_graph_preview`):
+```rust
+match tauri_bridge::memory_read(&ws, &MemoryScope::Workspace, &path).await {
+```
+
+The `GraphPreviewState.path` signal currently holds just the bare API path (`"decisions/note.md"`), without scope. The graph node ID is `"{scope}:{path}"` (see `GraphNode.id` in `tauri_bridge.rs`). The scope must be recovered from the node ID when a node is clicked, so it can be threaded through to `load_note`, `memory_read`, etc.
+
+---
+
+## Phase 5 — Graph-Tab: Scope-Aware Clicks + Hub-Node Styling
+
+### Goal
+1. Node clicks carry the correct scope (workspace or global)
+2. Hub nodes are visually distinct from regular note nodes
+3. Cross-scope edges are optionally styled differently
+
+### Key Types (already defined in `src/tauri_bridge.rs`)
+
+```rust
+pub struct GraphNode {
+    pub id: String,           // "workspace:decisions/note.md" or "hub:decisions"
+    pub scope: MemoryScope,
+    pub path: String,         // bare API path, e.g. "decisions/note.md"
+    pub label: String,
+    pub tags: Vec<String>,
+    pub orphan: bool,
+    pub category: String,
+    pub is_category_hub: Option<bool>,  // true for hub nodes
+    pub hub_scopes: Option<Vec<MemoryScope>>,
+    pub color: Option<String>,
+}
+
+pub struct GraphEdge {
+    pub source: String,
+    pub target: String,
+    pub cross_scope: bool,
+}
+```
+
+### Changes Required in `src/workbench/memory_graph/mod.rs`
+
+#### 1. `GraphPreviewState` — add scope field
+
+```rust
+struct GraphPreviewState {
+    open: RwSignal<bool>,
+    scope: RwSignal<MemoryScope>,      // ADD THIS
+    path: RwSignal<Option<String>>,
+    label: RwSignal<String>,
+    content: RwSignal<String>,
+    loading: RwSignal<bool>,
+}
+```
+
+Initialize `scope: RwSignal::new(MemoryScope::Workspace)` in `GraphPreviewState::new()`.
+
+#### 2. `open_graph_preview` — derive scope from node ID
+
+The function signature is `fn open_graph_preview(state: MemoryState, preview: GraphPreviewState, path: String)`.  
+The `path` argument is currently the bare API path. Change the call site to pass the node **ID** (which includes the scope prefix), then parse it:
+
+```rust
+fn open_graph_preview(state: MemoryState, preview: GraphPreviewState, node_id: String) {
+    // node_id is either "workspace:some/path.md" or "hub:category" or "global:some/path.md"
+    let (scope, path) = tauri_bridge::parse_note_key(&node_id)
+        .unwrap_or((MemoryScope::Workspace, node_id.clone()));
+
+    state.graph_selected_node.set(Some(node_id));
+    preview.open.set(true);
+    preview.scope.set(scope.clone());
+    preview.path.set(Some(path.clone()));
+    // ... rest unchanged, but use `scope` instead of MemoryScope::Workspace for memory_read
+    match tauri_bridge::memory_read(&ws, &scope, &path).await { ... }
+}
+```
+
+For hub nodes (`parse_note_key` returns `None` because the ID is `"hub:category"`, not `"scope:path"`): show a hub summary panel (list of notes in this category) instead of reading a file. Check: `if node_id.starts_with("hub:")`.
+
+#### 3. "Open in Files" button — pass scope correctly
+
+```rust
+expand_files_group_for_path(state.clone(), &preview.scope.get_untracked(), &path);
+load_note(state.clone(), ws, preview.scope.get_untracked(), path);
+```
+
+#### 4. `navigate_to_graph_node` in `src/workbench/memory_graph/mod.rs`
+
+This public function is called from `memory_panel.rs` when the user clicks "show in graph" for the active note. It currently takes a plain path. Update to also accept scope so it can set the correct selected node:
+
+Current signature (approx.):
+```rust
+pub(crate) fn navigate_to_graph_node(state: MemoryState, path: String)
+```
+
+Change to:
+```rust
+pub(crate) fn navigate_to_graph_node(state: MemoryState, scope: MemoryScope, path: String)
+```
+
+And form the node ID: `let node_id = tauri_bridge::note_key(&scope, &path);`  
+Then set `state.graph_selected_node.set(Some(node_id))`.
+
+Update all call sites in `memory_panel.rs` — search for `navigate_to_graph_node` to find them.
+
+#### 5. Hub Node Visual Styling
+
+In the graph renderer (JavaScript side in `public/` or wherever the 3D/2D graph is rendered), hub nodes can be detected by their ID prefix `"hub:"`.
+
+On the Leptos side, the node list passed to the JS graph should tag hub nodes. `GraphNode.is_category_hub` is already `Some(true)` for hubs. The existing graph bridge in `memory_graph/mod.rs` serializes the graph data to JS — check how nodes are passed and add a `hub` CSS class or color override.
+
+Look for the JS graph integration in `public/` (likely `public/memory_graph.js` or similar) and check if there is already a hub-specific rendering path. The `GraphNode.color` field can be set by the backend but may also be overridden in JS. Hub nodes should be rendered larger and with a folder/category icon.
+
+If the graph rendering is done entirely in WASM/Leptos without JS: add a `class:memory-graph-node--hub=move || node.is_category_hub.unwrap_or(false)` to the node element and style in `styles.css`.
+
+#### 6. Cross-scope Edge Styling
+
+`GraphEdge.cross_scope: bool` is already in the data. Style cross-scope edges with a dashed line or different color. Pass this through to the graph JS as an edge attribute.
+
+---
+
+## Phase 6 — Search-Tab: Scope-Aware Filter Chips
+
+### Current State
+
+File: `src/workbench/memory_panel.rs`, component `MemorySearchView` (around line 1830+).
+
+Current filter chips are hardcoded to `"memory"` and `"learnings"` strings, which only cover workspace. The filter functions `memory_hit_count`, `learnings_hit_count`, `search_hit_category`, `filter_search_hits` all use string-comparison against these two categories.
+
+`SearchHit` (in `src/tauri_bridge.rs`) already has:
+```rust
+pub struct SearchHit {
+    pub scope: MemoryScope,
+    pub path: String,
+    pub line: u32,
+    pub snippet: String,
+    pub category: String,  // e.g. "decisions", "learnings", "memory"
+}
+```
+
+### Changes Required
+
+#### 1. Replace hardcoded filter chips with dynamic scope+category chips
+
+Instead of a static "Memory" / "Learnings" split, build dynamic chips from the actual search results:
+
+```
+[All (N)]  [Workspace (N)]  [Global (N)]  [workspace:decisions (N)]  [global:memory (N)]  ...
+```
+
+The chip key format is:
+- `None` → All results
+- `Some("workspace")` → all workspace hits
+- `Some("global")` → all global hits
+- `Some("workspace:decisions")` → workspace hits in category "decisions"
+- `Some("global:learnings")` → global learnings
+
+Build chips dynamically from `SearchHit.scope` + `SearchHit.category`.
+
+#### 2. Update `filter_search_hits`
+
+```rust
+fn filter_search_hits(hits: Vec<SearchHit>, filter: Option<String>) -> Vec<SearchHit> {
+    match filter.as_deref() {
+        None => hits,
+        Some("workspace") => hits.into_iter().filter(|h| h.scope == MemoryScope::Workspace).collect(),
+        Some("global") => hits.into_iter().filter(|h| h.scope == MemoryScope::Global).collect(),
+        Some(key) => {
+            // "workspace:decisions" or "global:learnings"
+            if let Some((scope_str, cat)) = key.split_once(':') {
+                let target_scope = match scope_str {
+                    "workspace" => MemoryScope::Workspace,
+                    "global" => MemoryScope::Global,
+                    _ => return hits,
+                };
+                hits.into_iter()
+                    .filter(|h| h.scope == target_scope && h.category == cat)
+                    .collect()
+            } else {
+                hits
+            }
+        }
+    }
+}
+```
+
+#### 3. Update `load_note` call in search results
+
+The search hit click currently calls:
+```rust
+load_note(s.clone(), ws, sc.clone(), p.clone());
+```
+This is already correct (Phase 4 set `h.scope` into `sc`). Verify it's still wired up correctly.
+
+#### 4. Build dynamic filter chip list
+
+Add a helper:
+```rust
+fn search_scope_categories(hits: &[SearchHit]) -> Vec<(String, usize)> {
+    // Returns (chip_key, count) pairs for All + scope-level + scope:category level
+    // Only include chips where count > 0
+}
+```
+
+Render them in the `MemorySearchView` filter bar instead of the current hardcoded buttons.
+
+#### 5. i18n
+
+Add keys for "Workspace" and "Global" scope labels used in filter chips:
+- `MemSearchFilterWorkspace`
+- `MemSearchFilterGlobal`
+
+Add to `src/i18n/keys.rs` and all locale files in `src/i18n/locales/`. See how `MemGlobalCreate` was added in Phase 4 for the pattern.
+
+---
+
+## Reference: EB Implementation
+
+The BLXCode-eb reference lives at `c:\Users\quork\Entwicklung\BLXCode-eb\`.
+
+For Phase 5:
+- `src/views/app/layout/SidePanel/Memory/graph/MemoryGraphView.tsx` — hub node rendering, scope-aware click handlers
+- `src/shared/memory.ts` — `overviewPathForCategory`, `preferredScopeForHub`, `CATEGORY_HUB_PREFIX = "hub:"`
+
+For Phase 6:
+- `src/views/app/layout/SidePanel/Memory/search/MemorySearchView.tsx` — scope+category filter chips
+- `src/shared/memory.ts` — filter chip logic
+
+---
+
+## Compile Instructions
+
+```powershell
+# Check frontend only (fast)
+cargo check -p blxcode-ui --target wasm32-unknown-unknown
+
+# Check backend only
+cargo check -p blxcode
+
+# Run all tests
+cargo test --workspace
+
+# Full dev build
+cargo tauri dev
+```
+
+There are currently no compile errors. There are some `dead_code` / `unused_import` warnings in `src-tauri/src/memory/store.rs` and `tauri_bridge.rs` (`parse_note_key`) — these are harmless leftovers.
+
+---
+
+## Files to Touch
+
+| File | Why |
+|------|-----|
+| `src/workbench/memory_graph/mod.rs` | Phase 5: scope-aware node clicks, hub styling, `navigate_to_graph_node` signature |
+| `src/workbench/memory_panel.rs` | Phase 5: update `navigate_to_graph_node` call sites; Phase 6: `MemorySearchView` filter chips |
+| `src/i18n/keys.rs` | Phase 6: add `MemSearchFilterWorkspace`, `MemSearchFilterGlobal` |
+| `src/i18n/locales/*.rs` | Phase 6: add translations for all 13 locales |
+| `styles.css` | Phase 5: hub node CSS classes (if rendered in Leptos) |
+| `public/` (JS graph) | Phase 5: hub node visual distinction in graph renderer |
+
+Do **not** touch:
+- `src-tauri/src/memory/` — backend is complete
+- `src/tauri_bridge.rs` — bridge is complete (`parse_note_key` is already there)
+- `src-tauri/src/lib.rs` — all commands registered
+
+---
+
+## Acceptance Criteria
+
+**Phase 5 done when:**
+- Clicking a global graph node opens it in the editor with `MemoryScope::Global`
+- Clicking a hub node shows a summary (or a list of notes in that category) — not a 404
+- Hub nodes are visually distinct from note nodes (size, shape, or color)
+- The "Open in Files" button in the graph preview navigates to the correct scope section
+
+**Phase 6 done when:**
+- Search results from both workspace and global memory appear
+- Filter chips allow narrowing by scope (`workspace` / `global`) and by scope+category
+- Clicking a search result opens the note with the correct scope
+- `cargo check -p blxcode-ui --target wasm32-unknown-unknown` has no errors
diff --git a/.agents/learnings/LEARNINGS.md b/.agents/learnings/LEARNINGS.md
deleted file mode 100644
index e6cecf9..0000000
--- a/.agents/learnings/LEARNINGS.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Learnings
-
-This directory is the persistent knowledge base for AI coding agents working on
-this repository. Use it to capture facts, decisions, conventions, pitfalls, and
-resolved mistakes that are useful beyond a single task.
-
-Keep this file as the overview and index. Store individual learnings in separate
-Markdown files inside `.agents/learnings/`.
-
-## Index
-
-_(Add learnings here as `[[learnings/topic-filename|Short title]]` — one line per topic.)_
diff --git a/.agents/learnings/README.md b/.agents/learnings/README.md
new file mode 100644
index 0000000..238c001
--- /dev/null
+++ b/.agents/learnings/README.md
@@ -0,0 +1,28 @@
+---
+title: Learnings
+enabled: true
+tags: []
+---
+# Learnings
+
+This folder is a **growing knowledge base of resolved problems** - concrete things you discovered the hard way and want future agents (human or AI) to find.
+
+Each learning is a separate markdown file named `learning-<slug>.md`. Together they form a searchable log of "the thing we now know that we didn't know before."
+
+Keep this file as the overview and index. Store individual learnings in separate Markdown files inside `.agents/learnings/`.
+
+## When to record a learning
+
+- A bug you fixed that wasn't obvious from the symptom
+- A workaround for a quirk in a dependency, runtime, or environment
+- A migration step that required out-of-band knowledge
+
+## Tips for AI agents
+
+- Search here before debugging - someone may have hit this already.
+- When you fix a non-trivial bug, propose a new learning entry.
+- Keep one learning per file; cross-link related ones via `[[wikilinks]]`.
+
+## Index
+
+_(Add learnings here as `[[learnings/topic-filename|Short title]]` - one line per topic.)_
diff --git a/.agents/memory/README.md b/.agents/memory/README.md
new file mode 100644
index 0000000..813c477
--- /dev/null
+++ b/.agents/memory/README.md
@@ -0,0 +1,28 @@
+---
+title: Memory
+enabled: true
+tags: []
+---
+# Memory
+
+This folder stores **durable, project-wide notes** that should survive across coding sessions and be available to every AI agent or teammate working in this repo.
+
+## What belongs here
+
+- Architectural decisions and the reasoning behind them
+- Conventions, patterns and "house style" that aren't obvious from the code
+- Reference material: external systems, where to find logs / dashboards
+- Known-good workflows ("how we deploy", "how we cut a release")
+- User-specific preferences for collaboration
+
+## What does **not** belong here
+
+- Ephemeral todos for the current task (use a Plan or task list instead)
+- Things already documented in code, `CLAUDE.md`, or commit messages
+- Time-sensitive snapshots (`git log` is authoritative for history)
+
+## Tips for AI agents
+
+- Read existing notes before answering questions about this project.
+- When you learn something non-obvious, propose adding it here.
+- Prefer updating an existing note over creating a near-duplicate.
diff --git a/.agents/memory/Test.md b/.agents/memory/Test.md
new file mode 100644
index 0000000..88b97b5
--- /dev/null
+++ b/.agents/memory/Test.md
@@ -0,0 +1,2 @@
+# Test
+
diff --git a/frontend-js/graph3d_entry.mjs b/frontend-js/graph3d_entry.mjs
index 5afaaed..76ed55c 100644
--- a/frontend-js/graph3d_entry.mjs
+++ b/frontend-js/graph3d_entry.mjs
@@ -17,7 +17,11 @@ function readCssVar(name, fallback = "") {
 function applyGraph3dTheme(rec) {
   if (!rec?.graph) return;
   rec.graph.backgroundColor("rgba(0,0,0,0)");
-  rec.graph.linkColor(() => readCssVar("--overlay-4", "rgba(255,255,255,0.14)"));
+  rec.graph.linkColor((link) =>
+    link.crossScope
+      ? readCssVar("--accent-cool", "#7dd3fc")
+      : readCssVar("--overlay-4", "rgba(255,255,255,0.14)"),
+  );
   rec.graph.nodeThreeObject(makeNodeObject);
   rec.graph.refresh();
 }
@@ -74,6 +78,7 @@ function normalizeGraphData(graphData) {
     ? graphData.edges.map((edge) => ({
         source: edge.source,
         target: edge.target,
+        crossScope: Boolean(edge.crossScope),
       }))
     : [];
   return {
@@ -84,6 +89,7 @@ function normalizeGraphData(graphData) {
       orphan: Boolean(node.orphan),
       color: typeof node.color === "string" && node.color.trim() ? node.color : null,
       category: typeof node.category === "string" && node.category.trim() ? node.category : null,
+      isCategoryHub: Boolean(node.isCategoryHub || String(node.id).startsWith("hub:")),
     })),
     links,
   };
@@ -91,6 +97,7 @@ function normalizeGraphData(graphData) {
 
 function colorForNode(node) {
   if (node.color) return node.color;
+  if (node.isCategoryHub) return readCssVar("--accent-warm", "#f59e0b");
   if (node.orphan) return "#9aa3b8";
   const tag = node.tags?.[0] || "";
   let hash = 0;
@@ -104,23 +111,30 @@ function colorForNode(node) {
 function makeNodeObject(node) {
   const color = colorForNode(node);
   const group = new THREE.Group();
-  const geometry = new THREE.SphereGeometry(5.8, 24, 24);
+  const isHub = Boolean(node.isCategoryHub);
+  const geometry = isHub
+    ? new THREE.BoxGeometry(12.6, 8.8, 5.8)
+    : new THREE.SphereGeometry(5.8, 24, 24);
   const material = new THREE.MeshPhongMaterial({
     color,
     emissive: color,
-    emissiveIntensity: 0.22,
+    emissiveIntensity: isHub ? 0.34 : 0.22,
     shininess: 70,
   });
-  const sphere = new THREE.Mesh(geometry, material);
+  const body = new THREE.Mesh(geometry, material);
   const halo = new THREE.Mesh(
-    new THREE.SphereGeometry(8.5, 24, 24),
+    isHub ? new THREE.BoxGeometry(17.5, 12, 8) : new THREE.SphereGeometry(8.5, 24, 24),
     new THREE.MeshBasicMaterial({
       color,
       transparent: true,
-      opacity: 0.12,
+      opacity: isHub ? 0.18 : 0.12,
       depthWrite: false,
     }),
   );
+  if (isHub) {
+    halo.rotation.z = -0.08;
+    body.rotation.z = -0.08;
+  }
   const label = new SpriteText(wrapLabel(node.label || node.id));
   label.color = readCssVar("--text", "rgba(238,239,245,0.92)");
   label.backgroundColor = readCssVar("--scrim-bg", "rgba(8,10,16,0.58)");
@@ -128,14 +142,14 @@ function makeNodeObject(node) {
   label.borderWidth = 0.25;
   label.borderRadius = 2;
   label.padding = 2.6;
-  label.textHeight = 4.2;
+  label.textHeight = isHub ? 4.8 : 4.2;
   label.center.set(0, 0.5);
   label.position.set(12.5, 0, 0);
   label.material.depthWrite = false;
   label.material.depthTest = false;
   label.renderOrder = 10;
   group.add(halo);
-  group.add(sphere);
+  group.add(body);
   group.add(label);
   return group;
 }
@@ -368,9 +382,13 @@ window.__blxcodeGraph3d = {
       .nodeId("id")
       .nodeLabel("label")
       .nodeThreeObject(makeNodeObject)
-      .linkColor(() => readCssVar("--overlay-4", "rgba(255,255,255,0.14)"))
+      .linkColor((link) =>
+        link.crossScope
+          ? readCssVar("--accent-cool", "#7dd3fc")
+          : readCssVar("--overlay-4", "rgba(255,255,255,0.14)"),
+      )
       .linkOpacity(0.34)
-      .linkWidth(1)
+      .linkWidth((link) => (link.crossScope ? 1.45 : 1))
       .linkCurvature((link) => linkWobble(link))
       .linkCurveRotation((link) => linkRotation(link))
       .onLinkHover((link) => {
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 6488c21..d290542 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -39,3 +39,4 @@ uuid = { version = "1", features = ["v4"] }
 tauri-plugin-updater = "2"
 tauri-plugin-process = "2"
 notify = "6"
+dirs = "5"
diff --git a/src-tauri/src/agent/anthropic.rs b/src-tauri/src/agent/anthropic.rs
index 30810b4..2927401 100644
--- a/src-tauri/src/agent/anthropic.rs
+++ b/src-tauri/src/agent/anthropic.rs
@@ -10,11 +10,11 @@
 //! contracts as the OpenAI-compatible path.
 
 use super::system_prompt::system_prompt;
+use crate::agent::pricing;
 use crate::agent::protocol::{AgentEvent, AgentImageContextItem};
 use crate::agent::state::AgentEngineState;
 use crate::agent::tool_dispatch::{dispatch_tool, DispatchContext};
 use crate::agent::tools::{self, WorkspaceRootGuard};
-use crate::agent::pricing;
 use crate::agent_settings::{AgentProviderKind, AgentProviderSettings, ThinkingLevel};
 use crate::tasks;
 use serde::Deserialize;
@@ -192,8 +192,7 @@ pub async fn run_chat_turn(
                     return;
                 }
             };
-        let round_elapsed_ms =
-            round_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
+        let round_elapsed_ms = round_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
 
         // Anthropic's `/v1/messages` doesn't surface a cost field — always
         // fall back to local token×price math via the static id-mapping
@@ -273,18 +272,16 @@ pub async fn run_chat_turn(
             let args_val: Value =
                 serde_json::from_str(&call.arguments).unwrap_or_else(|_| json!({}));
             let tool_start = Instant::now();
-            let outcome =
-                dispatch_tool(
-                    &state,
-                    &call.id,
-                    &call.name,
-                    &args_val,
-                    root_guard.as_ref(),
-                    Some(&dispatch_ctx),
-                )
-                .await;
-            let tool_elapsed_ms =
-                tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
+            let outcome = dispatch_tool(
+                &state,
+                &call.id,
+                &call.name,
+                &args_val,
+                root_guard.as_ref(),
+                Some(&dispatch_ctx),
+            )
+            .await;
+            let tool_elapsed_ms = tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
 
             if outcome.ok && call.name.starts_with("task_") {
                 maybe_emit_task_snapshot(&state, root_guard.as_ref());
@@ -610,9 +607,9 @@ async fn run_one_round(
                     BlockDelta::TextDelta { text } => {
                         if !text.is_empty() {
                             if acc.ttft_ms.is_none() {
-                                acc.ttft_ms = Some(
-                                    request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                                );
+                                acc.ttft_ms =
+                                    Some(request_sent.elapsed().as_millis().min(u64::MAX as u128)
+                                        as u64);
                             }
                             if thinking_active && !thinking_closed {
                                 thinking_closed = true;
@@ -627,9 +624,9 @@ async fn run_one_round(
                     BlockDelta::ThinkingDelta { thinking } => {
                         if !thinking.is_empty() {
                             if acc.ttft_ms.is_none() {
-                                acc.ttft_ms = Some(
-                                    request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                                );
+                                acc.ttft_ms =
+                                    Some(request_sent.elapsed().as_millis().min(u64::MAX as u128)
+                                        as u64);
                             }
                             state.push(AgentEvent::ThinkingDelta {
                                 delta: thinking.clone(),
diff --git a/src-tauri/src/agent/git_agent.rs b/src-tauri/src/agent/git_agent.rs
index 9d8d865..9c0c5a2 100644
--- a/src-tauri/src/agent/git_agent.rs
+++ b/src-tauri/src/agent/git_agent.rs
@@ -43,10 +43,15 @@ fn require_env(root: &WorkspaceRootGuard) -> Result<(), ToolOutcome> {
 }
 
 fn optional_path<'a>(args: &'a Value, key: &str) -> Option<&'a str> {
-    args.get(key).and_then(|v| v.as_str()).filter(|s| !s.is_empty())
+    args.get(key)
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
 }
 
-fn resolve_cwd(root: &WorkspaceRootGuard, rel: Option<&str>) -> Result<std::path::PathBuf, ToolOutcome> {
+fn resolve_cwd(
+    root: &WorkspaceRootGuard,
+    rel: Option<&str>,
+) -> Result<std::path::PathBuf, ToolOutcome> {
     let base = root.as_str();
     let base_path = Path::new(&base);
     match rel {
@@ -118,7 +123,10 @@ pub fn tool_git_diff(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOut
     if args.get("staged").and_then(|v| v.as_bool()) == Some(true) {
         cmd_args.push("--staged");
     }
-    let output = Command::new("git").args(&cmd_args).current_dir(&cwd).output();
+    let output = Command::new("git")
+        .args(&cmd_args)
+        .current_dir(&cwd)
+        .output();
     match output {
         Ok(o) => ToolOutcome {
             ok: true,
diff --git a/src-tauri/src/agent/mod.rs b/src-tauri/src/agent/mod.rs
index 29f88bc..ea33fe7 100644
--- a/src-tauri/src/agent/mod.rs
+++ b/src-tauri/src/agent/mod.rs
@@ -13,12 +13,12 @@ mod shell_exec;
 mod subagent_prompts;
 mod subagent_runner;
 mod subagents;
-mod web_commands;
-pub(crate) mod web_settings;
 mod system_prompt;
 mod tool_dispatch;
 mod tool_groups;
 mod tools_extra;
+mod web_commands;
+pub(crate) mod web_settings;
 mod web_tools;
 mod workspace_agent;
 
diff --git a/src-tauri/src/agent/openrouter.rs b/src-tauri/src/agent/openrouter.rs
index 4d9d0c4..2e4214d 100644
--- a/src-tauri/src/agent/openrouter.rs
+++ b/src-tauri/src/agent/openrouter.rs
@@ -11,13 +11,13 @@
 //! Cancellation (`state.cancelled()`) is polled between SSE lines and
 //! between rounds; pending oneshots are dropped on cancel.
 
+use crate::agent::pricing;
 use crate::agent::protocol::{AgentEvent, AgentImageContextItem};
 use crate::agent::state::AgentEngineState;
 use crate::agent::system_prompt::system_prompt;
 use crate::agent::tool_dispatch::{dispatch_tool, DispatchContext};
 use crate::agent::tool_groups::openai_tool_name_to_internal;
 use crate::agent::tools::WorkspaceRootGuard;
-use crate::agent::pricing;
 use crate::agent_settings::{AgentProviderKind, AgentProviderSettings, ThinkingLevel};
 use crate::tasks;
 use serde::Deserialize;
@@ -298,8 +298,7 @@ pub async fn run_chat_turn(
                 return;
             }
         };
-        let round_elapsed_ms =
-            round_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
+        let round_elapsed_ms = round_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
 
         // Resolve USD cost: prefer OpenRouter's native number, fall back
         // to local token×price math via the cached pricing table.
@@ -379,8 +378,7 @@ pub async fn run_chat_turn(
                 Some(&dispatch_ctx),
             )
             .await;
-            let tool_elapsed_ms =
-                tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
+            let tool_elapsed_ms = tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
 
             if outcome.ok && internal_name.starts_with("task_") {
                 maybe_emit_task_snapshot(&state, root_guard.as_ref());
@@ -553,7 +551,8 @@ async fn run_one_round(
             if let Some(reasoning) = reasoning_chunk {
                 if !reasoning.is_empty() {
                     if acc.ttft_ms.is_none() {
-                        acc.ttft_ms = Some(request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64);
+                        acc.ttft_ms =
+                            Some(request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64);
                     }
                     thinking_active = true;
                     state.push(AgentEvent::ThinkingDelta { delta: reasoning });
@@ -562,7 +561,8 @@ async fn run_one_round(
             if let Some(text) = choice.delta.content {
                 if !text.is_empty() {
                     if acc.ttft_ms.is_none() {
-                        acc.ttft_ms = Some(request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64);
+                        acc.ttft_ms =
+                            Some(request_sent.elapsed().as_millis().min(u64::MAX as u128) as u64);
                     }
                     if thinking_active && !thinking_closed {
                         thinking_closed = true;
diff --git a/src-tauri/src/agent/pricing.rs b/src-tauri/src/agent/pricing.rs
index 1946b49..6d9aa9b 100644
--- a/src-tauri/src/agent/pricing.rs
+++ b/src-tauri/src/agent/pricing.rs
@@ -70,15 +70,14 @@ fn find_in_cache(
 /// OpenRouter id (whose pricing we reuse). Add entries as new direct
 /// models are exposed in the UI — the test below guards against typos.
 #[must_use]
-pub fn map_direct_to_openrouter(provider: AgentProviderKind, model_id: &str) -> Option<&'static str> {
+pub fn map_direct_to_openrouter(
+    provider: AgentProviderKind,
+    model_id: &str,
+) -> Option<&'static str> {
     match (provider, model_id) {
         // Anthropic Direct → OpenRouter
-        (AgentProviderKind::Anthropic, "claude-sonnet-4-5") => {
-            Some("anthropic/claude-sonnet-4.5")
-        }
-        (AgentProviderKind::Anthropic, "claude-sonnet-4-6") => {
-            Some("anthropic/claude-sonnet-4.6")
-        }
+        (AgentProviderKind::Anthropic, "claude-sonnet-4-5") => Some("anthropic/claude-sonnet-4.5"),
+        (AgentProviderKind::Anthropic, "claude-sonnet-4-6") => Some("anthropic/claude-sonnet-4.6"),
         (AgentProviderKind::Anthropic, "claude-opus-4-1") => Some("anthropic/claude-opus-4.1"),
         (AgentProviderKind::Anthropic, "claude-opus-4-7") => Some("anthropic/claude-opus-4.7"),
         (AgentProviderKind::Anthropic, "claude-haiku-4-5-20251001") => {
@@ -96,7 +95,9 @@ pub fn map_direct_to_openrouter(provider: AgentProviderKind, model_id: &str) ->
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::agent_settings::{AgentProviderKind, ModelPricing, ProviderModelEntry, ThinkingLevel};
+    use crate::agent_settings::{
+        AgentProviderKind, ModelPricing, ProviderModelEntry, ThinkingLevel,
+    };
 
     fn settings_with_openrouter(entries: Vec<ProviderModelEntry>) -> AgentProviderSettings {
         AgentProviderSettings {
@@ -120,8 +121,7 @@ mod tests {
 
     #[test]
     fn openrouter_hit_sums_prompt_and_completion() {
-        let settings =
-            settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
+        let settings = settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
         let cost = resolve_cost(
             &settings,
             AgentProviderKind::Openrouter,
@@ -185,8 +185,7 @@ mod tests {
 
     #[test]
     fn missing_tokens_still_prices_known_side() {
-        let settings =
-            settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
+        let settings = settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
         let cost = resolve_cost(
             &settings,
             AgentProviderKind::Openrouter,
@@ -200,8 +199,7 @@ mod tests {
 
     #[test]
     fn both_tokens_none_returns_none_even_with_pricing() {
-        let settings =
-            settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
+        let settings = settings_with_openrouter(vec![entry("openai/gpt-5", 0.000_002, 0.000_010)]);
         assert!(resolve_cost(
             &settings,
             AgentProviderKind::Openrouter,
diff --git a/src-tauri/src/agent/session_orchestrator.rs b/src-tauri/src/agent/session_orchestrator.rs
index a0f20ad..8541c9b 100644
--- a/src-tauri/src/agent/session_orchestrator.rs
+++ b/src-tauri/src/agent/session_orchestrator.rs
@@ -278,10 +278,8 @@ fn render_context_prompt(
                         .first()
                         .cloned()
                         .unwrap_or_else(|| item.source.clone());
-                    let mut line = format!(
-                        "- plan `{plan_path}`: {label}",
-                        label = item.label.trim()
-                    );
+                    let mut line =
+                        format!("- plan `{plan_path}`: {label}", label = item.label.trim());
                     if let Some(ws) = workspace_root {
                         if let Some(meta) = plans::plan_meta_for(ws, &plan_path) {
                             line.push_str(&format!(
diff --git a/src-tauri/src/agent/shell_exec.rs b/src-tauri/src/agent/shell_exec.rs
index 5231d5c..baf9016 100644
--- a/src-tauri/src/agent/shell_exec.rs
+++ b/src-tauri/src/agent/shell_exec.rs
@@ -41,8 +41,25 @@ pub fn kill_all_children() {
 fn read_only_allowlist(program: &str) -> bool {
     matches!(
         program,
-        "ls" | "pwd" | "cat" | "head" | "tail" | "wc" | "file" | "which" | "env" | "rg"
-            | "fd" | "find" | "tree" | "stat" | "du" | "df" | "node" | "npm" | "cargo" | "git"
+        "ls" | "pwd"
+            | "cat"
+            | "head"
+            | "tail"
+            | "wc"
+            | "file"
+            | "which"
+            | "env"
+            | "rg"
+            | "fd"
+            | "find"
+            | "tree"
+            | "stat"
+            | "du"
+            | "df"
+            | "node"
+            | "npm"
+            | "cargo"
+            | "git"
     )
 }
 
diff --git a/src-tauri/src/agent/subagent_prompts.rs b/src-tauri/src/agent/subagent_prompts.rs
index f32258b..060f093 100644
--- a/src-tauri/src/agent/subagent_prompts.rs
+++ b/src-tauri/src/agent/subagent_prompts.rs
@@ -74,38 +74,48 @@ fn render_tool_inventory(groups: &[ToolGroup]) -> String {
             .collect();
 
     let buckets: &[(&str, &[&str])] = &[
-        ("Workspace (read repo files)", &[
-            "list_workspace_files",
-            "read_workspace_file",
-            "workspace_search",
-        ]),
+        (
+            "Workspace (read repo files)",
+            &[
+                "list_workspace_files",
+                "read_workspace_file",
+                "workspace_search",
+            ],
+        ),
         ("Diffs", &["workspace_git_status", "workspace_diff"]),
-        ("Git", &[
-            "git_status",
-            "git_diff",
-            "git_log",
-            "git_show",
-            "git_branch_info",
-            "git_ls_files",
-        ]),
+        (
+            "Git",
+            &[
+                "git_status",
+                "git_diff",
+                "git_log",
+                "git_show",
+                "git_branch_info",
+                "git_ls_files",
+            ],
+        ),
         ("Environment / shell", &["environment_detect", "shell_exec"]),
-        ("Memory", &[
-            "memory_list",
-            "memory_read",
-            "memory_search",
-            "memory_graph",
-            "memory_backlinks",
-            "memory_category_list",
-            "memory_context_list",
-        ]),
-        ("Plans", &["plan_list", "plan_read", "plan_load", "plan_context_list"]),
+        (
+            "Memory",
+            &[
+                "memory_list",
+                "memory_read",
+                "memory_search",
+                "memory_graph",
+                "memory_backlinks",
+                "memory_category_list",
+                "memory_context_list",
+            ],
+        ),
+        (
+            "Plans",
+            &["plan_list", "plan_read", "plan_load", "plan_context_list"],
+        ),
         ("Tasks", &["task_list", "task_get"]),
-        ("Rules & Skills", &[
-            "rules_list",
-            "rules_read",
-            "skills_list",
-            "skills_read",
-        ]),
+        (
+            "Rules & Skills",
+            &["rules_list", "rules_read", "skills_list", "skills_read"],
+        ),
         ("Web", &["web_search", "web_fetch"]),
     ];
 
diff --git a/src-tauri/src/agent/subagent_runner.rs b/src-tauri/src/agent/subagent_runner.rs
index 3cd8833..f18bb61 100644
--- a/src-tauri/src/agent/subagent_runner.rs
+++ b/src-tauri/src/agent/subagent_runner.rs
@@ -4,10 +4,10 @@ use crate::agent::anthropic::{from_anthropic_name, to_anthropic_name};
 use crate::agent::openrouter::Endpoint;
 use crate::agent::protocol::AgentEvent;
 use crate::agent::state::AgentEngineState;
-use crate::agent::subagent_prompts::{self, SubagentRole, truncate_submit_result};
+use crate::agent::subagent_prompts::{self, truncate_submit_result, SubagentRole};
+use crate::agent::tool_dispatch::DispatchContext;
 use crate::agent::tool_groups::{openai_tool_name_to_internal, ToolGroup};
 use crate::agent::tools::{self, WorkspaceRootGuard};
-use crate::agent::tool_dispatch::DispatchContext;
 use crate::agent_settings::AgentProviderKind;
 use futures_util::TryStreamExt;
 use serde::Deserialize;
@@ -142,11 +142,10 @@ pub async fn run_one_subagent(
     // with as the first step. When models claim "tools not in schema", the
     // operator can immediately compare against this list and tell whether
     // the model is hallucinating or the provisioning really is empty.
-    let provisioned: Vec<&'static str> =
-        crate::agent::tool_groups::registry_filtered(groups, true)
-            .into_iter()
-            .map(|t| t.name)
-            .collect();
+    let provisioned: Vec<&'static str> = crate::agent::tool_groups::registry_filtered(groups, true)
+        .into_iter()
+        .map(|t| t.name)
+        .collect();
     state.push(AgentEvent::SubagentStep {
         agent_id: agent_id.to_owned(),
         step_id: "provisioned-tools".into(),
@@ -226,7 +225,12 @@ pub async fn run_one_subagent(
                 }
                 let round_start = Instant::now();
                 let round = match stream_openai_subagent_round(
-                    state, &client, endpoint, &ctx.api_key, &body, agent_id,
+                    state,
+                    &client,
+                    endpoint,
+                    &ctx.api_key,
+                    &body,
+                    agent_id,
                 )
                 .await
                 {
@@ -276,20 +280,24 @@ pub async fn run_one_subagent(
                 }
                 if !round.tool_calls.is_empty() {
                     assistant["tool_calls"] = Value::Array(
-                        round.tool_calls.iter().map(|tc| {
-                            json!({
-                                "id": tc.id,
-                                "type": "function",
-                                "function": {
-                                    "name": tc.name,
-                                    "arguments": if tc.arguments.is_empty() {
-                                        "{}".to_string()
-                                    } else {
-                                        tc.arguments.clone()
-                                    },
-                                }
+                        round
+                            .tool_calls
+                            .iter()
+                            .map(|tc| {
+                                json!({
+                                    "id": tc.id,
+                                    "type": "function",
+                                    "function": {
+                                        "name": tc.name,
+                                        "arguments": if tc.arguments.is_empty() {
+                                            "{}".to_string()
+                                        } else {
+                                            tc.arguments.clone()
+                                        },
+                                    }
+                                })
                             })
-                        }).collect(),
+                            .collect(),
                     );
                 }
                 messages.push(assistant);
@@ -340,11 +348,8 @@ pub async fn run_one_subagent(
                                 groups,
                                 root_guard.as_ref(),
                             );
-                            let tool_elapsed_ms = tool_start
-                                .elapsed()
-                                .as_millis()
-                                .min(u64::MAX as u128)
-                                as u64;
+                            let tool_elapsed_ms =
+                                tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
                             state.push(AgentEvent::TurnUsage {
                                 kind: crate::agent::protocol::TurnUsageKind::ToolExec,
                                 agent_id: Some(agent_id.to_owned()),
@@ -393,7 +398,11 @@ pub async fn run_one_subagent(
                 });
                 let round_start = Instant::now();
                 let round = match stream_anthropic_subagent_round(
-                    state, &client, &ctx.api_key, &body, agent_id,
+                    state,
+                    &client,
+                    &ctx.api_key,
+                    &body,
+                    agent_id,
                 )
                 .await
                 {
@@ -436,7 +445,8 @@ pub async fn run_one_subagent(
                     return result;
                 }
                 if !round.assistant_blocks.is_empty() {
-                    messages.push(json!({ "role": "assistant", "content": round.assistant_blocks }));
+                    messages
+                        .push(json!({ "role": "assistant", "content": round.assistant_blocks }));
                 }
                 if round.tool_uses.is_empty() {
                     break;
@@ -479,11 +489,8 @@ pub async fn run_one_subagent(
                             let tool_start = Instant::now();
                             let outcome =
                                 execute_subagent_tool(&name, &args, groups, root_guard.as_ref());
-                            let tool_elapsed_ms = tool_start
-                                .elapsed()
-                                .as_millis()
-                                .min(u64::MAX as u128)
-                                as u64;
+                            let tool_elapsed_ms =
+                                tool_start.elapsed().as_millis().min(u64::MAX as u128) as u64;
                             state.push(AgentEvent::TurnUsage {
                                 kind: crate::agent::protocol::TurnUsageKind::ToolExec,
                                 agent_id: Some(agent_id.to_owned()),
@@ -936,9 +943,9 @@ async fn stream_anthropic_subagent_round(
                                 });
                             }
                             if acc.ttft_ms.is_none() {
-                                acc.ttft_ms = Some(
-                                    req_start.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                                );
+                                acc.ttft_ms =
+                                    Some(req_start.elapsed().as_millis().min(u64::MAX as u128)
+                                        as u64);
                             }
                             state.push(AgentEvent::SubagentAssistantDelta {
                                 agent_id: agent_id.to_owned(),
@@ -951,9 +958,9 @@ async fn stream_anthropic_subagent_round(
                     AnthroBlockDelta::ThinkingDelta { thinking } => {
                         if !thinking.is_empty() {
                             if acc.ttft_ms.is_none() {
-                                acc.ttft_ms = Some(
-                                    req_start.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                                );
+                                acc.ttft_ms =
+                                    Some(req_start.elapsed().as_millis().min(u64::MAX as u128)
+                                        as u64);
                             }
                             state.push(AgentEvent::SubagentThinkingDelta {
                                 agent_id: agent_id.to_owned(),
@@ -1121,9 +1128,8 @@ async fn stream_openai_subagent_round(
                 if !reasoning.is_empty() {
                     thinking_active = true;
                     if acc.ttft_ms.is_none() {
-                        acc.ttft_ms = Some(
-                            req_start.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                        );
+                        acc.ttft_ms =
+                            Some(req_start.elapsed().as_millis().min(u64::MAX as u128) as u64);
                     }
                     state.push(AgentEvent::SubagentThinkingDelta {
                         agent_id: agent_id.to_owned(),
@@ -1140,9 +1146,8 @@ async fn stream_openai_subagent_round(
                         });
                     }
                     if acc.ttft_ms.is_none() {
-                        acc.ttft_ms = Some(
-                            req_start.elapsed().as_millis().min(u64::MAX as u128) as u64,
-                        );
+                        acc.ttft_ms =
+                            Some(req_start.elapsed().as_millis().min(u64::MAX as u128) as u64);
                     }
                     state.push(AgentEvent::SubagentAssistantDelta {
                         agent_id: agent_id.to_owned(),
@@ -1208,20 +1213,14 @@ mod tests {
         let args = json!({ "status": "blocked", "summary": "denied" });
         let mut called: HashSet<String> = HashSet::new();
         called.insert("list_workspace_files".into());
-        assert_eq!(
-            validate_submit(&args, &called, true),
-            SubmitVerdict::Accept
-        );
+        assert_eq!(validate_submit(&args, &called, true), SubmitVerdict::Accept);
     }
 
     #[test]
     fn validate_submit_accepts_completed_regardless() {
         let args = json!({ "status": "completed", "summary": "done" });
         let called: HashSet<String> = HashSet::new();
-        assert_eq!(
-            validate_submit(&args, &called, true),
-            SubmitVerdict::Accept
-        );
+        assert_eq!(validate_submit(&args, &called, true), SubmitVerdict::Accept);
     }
 
     #[test]
diff --git a/src-tauri/src/agent/subagents.rs b/src-tauri/src/agent/subagents.rs
index a449b90..46a0f5e 100644
--- a/src-tauri/src/agent/subagents.rs
+++ b/src-tauri/src/agent/subagents.rs
@@ -1,11 +1,11 @@
 //! Coordinated subagent runs via `subagents.run`.
 
+use crate::agent::protocol::AgentEvent;
+use crate::agent::state::AgentEngineState;
 use crate::agent::subagent_prompts::{self, SubagentRole};
 use crate::agent::subagent_runner::{run_one_subagent, SubagentProvider};
-use crate::agent::state::AgentEngineState;
 use crate::agent::tool_dispatch::DispatchContext;
 use crate::agent::tool_groups::{self, parse_allowed_groups_strict, ToolGroup};
-use crate::agent::protocol::AgentEvent;
 use crate::agent::tools::{ToolOutcome, WorkspaceRootGuard};
 use serde::Deserialize;
 use serde_json::{json, Value};
@@ -147,10 +147,8 @@ pub async fn run(
         groups.push(ToolGroup::SubagentSubmit);
         groups.retain(|g| !matches!(g, ToolGroup::SubagentsRun | ToolGroup::ShellWrite));
 
-        let tools_openai =
-            tool_groups::render_for_openai_filtered(&groups, web_enabled);
-        let mut tools_anthropic =
-            tool_groups::render_for_anthropic_filtered(&groups, web_enabled);
+        let tools_openai = tool_groups::render_for_openai_filtered(&groups, web_enabled);
+        let mut tools_anthropic = tool_groups::render_for_anthropic_filtered(&groups, web_enabled);
         if let Some(arr) = tools_anthropic.as_array_mut() {
             for entry in arr {
                 if let Some(name) = entry.get("name").and_then(|v| v.as_str()) {
diff --git a/src-tauri/src/agent/system_prompt.rs b/src-tauri/src/agent/system_prompt.rs
index 5a07eeb..688d4d5 100644
--- a/src-tauri/src/agent/system_prompt.rs
+++ b/src-tauri/src/agent/system_prompt.rs
@@ -252,7 +252,12 @@ mod tests {
         // Resume step covers EN+DE continuation directives
         assert!(p.contains("**Resume check.**"));
         for kw in [
-            "continue", "keep going", "resume", "weiter", "fortsetzen", "weitermachen",
+            "continue",
+            "keep going",
+            "resume",
+            "weiter",
+            "fortsetzen",
+            "weitermachen",
         ] {
             assert!(p.contains(kw), "missing resume keyword: {kw}");
         }
diff --git a/src-tauri/src/agent/tool_groups.rs b/src-tauri/src/agent/tool_groups.rs
index d28c8da..20cab99 100644
--- a/src-tauri/src/agent/tool_groups.rs
+++ b/src-tauri/src/agent/tool_groups.rs
@@ -98,12 +98,7 @@ impl ToolGroup {
                 "memory_context_attach",
                 "memory_context_detach",
             ],
-            Self::PlansRead => &[
-                "plan_list",
-                "plan_read",
-                "plan_load",
-                "plan_context_list",
-            ],
+            Self::PlansRead => &["plan_list", "plan_read", "plan_load", "plan_context_list"],
             Self::PlansWrite => &[
                 "plan_create",
                 "plan_write",
@@ -114,12 +109,7 @@ impl ToolGroup {
                 "plan_context_detach",
             ],
             Self::TasksRead => &["task_list", "task_get"],
-            Self::TasksWrite => &[
-                "task_create",
-                "task_update",
-                "task_delete",
-                "task_reorder",
-            ],
+            Self::TasksWrite => &["task_create", "task_update", "task_delete", "task_reorder"],
             Self::RulesSkillsRead => &["rules_list", "rules_read", "skills_list", "skills_read"],
             Self::RulesSkillsWrite => &[
                 "rules_write",
@@ -175,10 +165,7 @@ pub fn coordinator_groups(web_enabled: bool) -> Vec<ToolGroup> {
 }
 
 pub fn parse_allowed_groups(names: &[String]) -> Vec<ToolGroup> {
-    names
-        .iter()
-        .filter_map(|s| ToolGroup::parse(s))
-        .collect()
+    names.iter().filter_map(|s| ToolGroup::parse(s)).collect()
 }
 
 /// Like [`parse_allowed_groups`] but also returns the strings that failed to
@@ -303,9 +290,9 @@ mod tests {
     fn parse_allowed_groups_strict_separates_known_from_unknown() {
         let input = vec![
             "workspace_read".to_string(),
-            "file_access".to_string(),     // bogus
+            "file_access".to_string(), // bogus
             "git_read".to_string(),
-            "shell".to_string(),           // bogus (correct names are shell_read/shell_write)
+            "shell".to_string(), // bogus (correct names are shell_read/shell_write)
         ];
         let (ok, bad) = parse_allowed_groups_strict(&input);
         assert_eq!(ok, vec![ToolGroup::WorkspaceRead, ToolGroup::GitRead]);
@@ -349,7 +336,10 @@ mod tests {
         }
         // SubagentSubmit is force-pushed onto every subagent's group list.
         for tool in ToolGroup::SubagentSubmit.tool_names() {
-            assert!(!tool.contains('.'), "SubagentSubmit tool {tool:?} must be dotless");
+            assert!(
+                !tool.contains('.'),
+                "SubagentSubmit tool {tool:?} must be dotless"
+            );
         }
     }
 
diff --git a/src-tauri/src/agent/tools.rs b/src-tauri/src/agent/tools.rs
index 6d2601e..c20055d 100644
--- a/src-tauri/src/agent/tools.rs
+++ b/src-tauri/src/agent/tools.rs
@@ -1412,10 +1412,10 @@ fn tool_memory_list(root: Option<&WorkspaceRootGuard>) -> ToolOutcome {
         Err(out) => return out,
     };
     match memory::memory_list(ws) {
-        Ok(mut notes) => {
-            notes.truncate(200);
+        Ok(mut resp) => {
+            resp.notes.truncate(200);
             let body =
-                serde_json::to_string(&notes).unwrap_or_else(|e| format!("{{\"error\":\"{e}\"}}"));
+                serde_json::to_string(&resp).unwrap_or_else(|e| format!("{{\"error\":\"{e}\"}}"));
             ToolOutcome {
                 ok: true,
                 content: body,
@@ -1439,7 +1439,7 @@ fn tool_memory_read(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOutc
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_read(ws, path.to_owned()) {
+    match memory::memory_read(ws, memory::MemoryScope::Workspace, path.to_owned()) {
         Ok(note) => {
             let body = truncate_chars(&note.content, 4000);
             ToolOutcome {
@@ -1509,7 +1509,12 @@ fn tool_memory_create(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOu
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_create(ws, path.to_owned(), Some(content)) {
+    match memory::memory_create(
+        ws,
+        memory::MemoryScope::Workspace,
+        path.to_owned(),
+        Some(content),
+    ) {
         Ok(meta) => {
             let body =
                 serde_json::to_string(&meta).unwrap_or_else(|e| format!("{{\"error\":\"{e}\"}}"));
@@ -1551,7 +1556,12 @@ fn tool_memory_write(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOut
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_write(ws, path.to_owned(), content.to_owned()) {
+    match memory::memory_write(
+        ws,
+        memory::MemoryScope::Workspace,
+        path.to_owned(),
+        content.to_owned(),
+    ) {
         Ok(note) => ToolOutcome {
             ok: true,
             content: format!("wrote {} ({} bytes)", note.path, note.content.len()),
@@ -1574,7 +1584,7 @@ fn tool_memory_delete(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOu
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_delete(ws, path.to_owned()) {
+    match memory::memory_delete(ws, memory::MemoryScope::Workspace, path.to_owned()) {
         Ok(()) => ToolOutcome {
             ok: true,
             content: format!("deleted {path}"),
@@ -1607,7 +1617,13 @@ fn tool_memory_rename(args: &Value, root: Option<&WorkspaceRootGuard>) -> ToolOu
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_rename(ws, old_path.to_owned(), new_path.to_owned(), rewrite_links) {
+    match memory::memory_rename(
+        ws,
+        memory::MemoryScope::Workspace,
+        old_path.to_owned(),
+        new_path.to_owned(),
+        rewrite_links,
+    ) {
         Ok(report) => {
             let body =
                 serde_json::to_string(&report).unwrap_or_else(|e| format!("{{\"error\":\"{e}\"}}"));
@@ -1655,7 +1671,7 @@ fn tool_memory_backlinks(args: &Value, root: Option<&WorkspaceRootGuard>) -> Too
         Ok(s) => s,
         Err(out) => return out,
     };
-    match memory::memory_backlinks(ws, path.to_owned()) {
+    match memory::memory_backlinks(ws, memory::MemoryScope::Workspace, path.to_owned()) {
         Ok(links) => {
             let body =
                 serde_json::to_string(&links).unwrap_or_else(|e| format!("{{\"error\":\"{e}\"}}"));
diff --git a/src-tauri/src/agent/web_settings.rs b/src-tauri/src/agent/web_settings.rs
index 7b5ef90..8e8a787 100644
--- a/src-tauri/src/agent/web_settings.rs
+++ b/src-tauri/src/agent/web_settings.rs
@@ -77,10 +77,7 @@ pub fn refresh_runtime_from_app(app: &AppHandle) {
 }
 
 pub fn runtime_provider() -> WebProviderKind {
-    runtime()
-        .lock()
-        .map(|g| g.provider)
-        .unwrap_or_default()
+    runtime().lock().map(|g| g.provider).unwrap_or_default()
 }
 
 pub fn load(app: &AppHandle) -> Result<AgentWebSettings, String> {
@@ -136,7 +133,9 @@ fn key_masked(kind: WebKeyKind) -> Result<Option<String>, String> {
     let entry = keyring_entry(kind)?;
     match entry.get_password() {
         Ok(secret) => Ok(agent_settings::mask_secret_pub(&secret)),
-        Err(keyring_core::Error::NoEntry) => Ok(env_key(kind).and_then(|s| agent_settings::mask_secret_pub(&s))),
+        Err(keyring_core::Error::NoEntry) => {
+            Ok(env_key(kind).and_then(|s| agent_settings::mask_secret_pub(&s)))
+        }
         Err(_) if cfg!(target_os = "linux") => {
             Ok(env_key(kind).and_then(|s| agent_settings::mask_secret_pub(&s)))
         }
@@ -189,8 +188,12 @@ pub fn resolve_key(kind: WebKeyKind) -> Option<String> {
 
 pub fn resolve_active_key() -> Option<(WebProviderKind, String)> {
     match runtime_provider() {
-        WebProviderKind::Tavily => resolve_key(WebKeyKind::Tavily).map(|k| (WebProviderKind::Tavily, k)),
-        WebProviderKind::Brave => resolve_key(WebKeyKind::Brave).map(|k| (WebProviderKind::Brave, k)),
+        WebProviderKind::Tavily => {
+            resolve_key(WebKeyKind::Tavily).map(|k| (WebProviderKind::Tavily, k))
+        }
+        WebProviderKind::Brave => {
+            resolve_key(WebKeyKind::Brave).map(|k| (WebProviderKind::Brave, k))
+        }
         WebProviderKind::None => env_key(WebKeyKind::Tavily)
             .map(|k| (WebProviderKind::Tavily, k))
             .or_else(|| env_key(WebKeyKind::Brave).map(|k| (WebProviderKind::Brave, k))),
@@ -201,7 +204,11 @@ pub fn web_tools_enabled() -> bool {
     resolve_active_key().is_some()
 }
 
-pub fn set_key(app: &AppHandle, kind: WebKeyKind, api_key: String) -> Result<AgentWebSettingsView, String> {
+pub fn set_key(
+    app: &AppHandle,
+    kind: WebKeyKind,
+    api_key: String,
+) -> Result<AgentWebSettingsView, String> {
     let secret = api_key.trim();
     if secret.is_empty() {
         return Err("API key is empty".into());
diff --git a/src-tauri/src/agent/web_tools.rs b/src-tauri/src/agent/web_tools.rs
index f05af17..49aba5f 100644
--- a/src-tauri/src/agent/web_tools.rs
+++ b/src-tauri/src/agent/web_tools.rs
@@ -21,14 +21,16 @@ pub fn tool_web_search(args: &Value, _root: Option<&WorkspaceRootGuard>) -> Tool
     let Some((provider, key)) = web_settings::resolve_active_key() else {
         return ToolOutcome {
             ok: false,
-            content: "web tools disabled: configure API keys in Settings → Agent → Web Tools".into(),
+            content: "web tools disabled: configure API keys in Settings → Agent → Web Tools"
+                .into(),
         };
     };
     match provider {
         WebProviderKind::Tavily => tavily_search(query, &key),
         WebProviderKind::Brave => ToolOutcome {
             ok: false,
-            content: "Brave search not implemented in v1; select Tavily in Web Tools settings".into(),
+            content: "Brave search not implemented in v1; select Tavily in Web Tools settings"
+                .into(),
         },
         WebProviderKind::None => ToolOutcome {
             ok: false,
diff --git a/src-tauri/src/agent/workspace_agent.rs b/src-tauri/src/agent/workspace_agent.rs
index c6482bc..a0f1521 100644
--- a/src-tauri/src/agent/workspace_agent.rs
+++ b/src-tauri/src/agent/workspace_agent.rs
@@ -51,11 +51,9 @@ pub fn tool_workspace_search(args: &Value, root: Option<&WorkspaceRootGuard>) ->
                 },
             }
         }
-        Err(_) => {
-            ToolOutcome {
-                ok: false,
-                content: "rg not available; install ripgrep for workspace_search".into(),
-            }
-        }
+        Err(_) => ToolOutcome {
+            ok: false,
+            content: "rg not available; install ripgrep for workspace_search".into(),
+        },
     }
 }
diff --git a/src-tauri/src/agent_settings.rs b/src-tauri/src/agent_settings.rs
index 22e2af2..6e32924 100644
--- a/src-tauri/src/agent_settings.rs
+++ b/src-tauri/src/agent_settings.rs
@@ -215,9 +215,7 @@ pub(crate) fn provider_key_with_source(
 ) -> Result<(Option<String>, KeySource), String> {
     let entry = keyring_entry(provider)?;
     match entry.get_password() {
-        Ok(secret) if !secret.trim().is_empty() => {
-            Ok((mask_secret(&secret), KeySource::Keyring))
-        }
+        Ok(secret) if !secret.trim().is_empty() => Ok((mask_secret(&secret), KeySource::Keyring)),
         Ok(_) | Err(keyring_core::Error::NoEntry) => match read_fallback_secret(app, provider)? {
             Some(secret) => Ok((mask_secret(&secret), KeySource::File)),
             None => match provider_env_secret(provider) {
@@ -362,8 +360,8 @@ fn save_settings(app: &AppHandle, settings: &AgentProviderSettings) -> Result<()
     // Merge the agent settings into the existing envelope so sibling keys
     // (voice/image) are preserved.
     let mut envelope = read_envelope(app)?;
-    let value = serde_json::to_value(settings)
-        .map_err(|e| format!("serialize agent settings: {e}"))?;
+    let value =
+        serde_json::to_value(settings).map_err(|e| format!("serialize agent settings: {e}"))?;
     let merged = match value {
         serde_json::Value::Object(map) => map,
         _ => return Err("agent settings did not serialize to a JSON object".into()),
@@ -580,7 +578,6 @@ fn settings_view(
     })
 }
 
-
 #[derive(Deserialize)]
 struct OpenrouterModelsEnvelope {
     data: Vec<OpenrouterModel>,
diff --git a/src-tauri/src/agents_layout.rs b/src-tauri/src/agents_layout.rs
index 6f6385b..c05f1a0 100644
--- a/src-tauri/src/agents_layout.rs
+++ b/src-tauri/src/agents_layout.rs
@@ -1,4 +1,4 @@
-//! Workspace `.agents/` bootstrap, legacy memory migration, and learnings wikilink upgrades.
+//! Workspace `.agents/` bootstrap and learnings wikilink upgrades.
 
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -7,7 +7,6 @@ pub const AGENTS_REL: &str = ".agents";
 pub const MEMORY_REL: &str = ".agents/memory";
 pub const LEARNINGS_REL: &str = ".agents/learnings";
 pub const PLANS_REL: &str = ".agents/plans";
-pub const LEGACY_MEMORY_REL: &str = ".blxcode/memory";
 pub const LEARNINGS_API_PREFIX: &str = "learnings/";
 pub const PLANS_INDEX: &str = "PLANS.md";
 const TEMPLATES_DIRNAME: &str = "_templates";
@@ -67,7 +66,7 @@ pub fn validate_workspace_cwd(ws: &str) -> Result<PathBuf, String> {
     Ok(p)
 }
 
-/// Creates `.agents/memory`, `.agents/learnings`, migrates legacy memory, seeds index, upgrades wikilinks.
+/// Creates `.agents/memory`, `.agents/learnings`, seeds index, upgrades wikilinks.
 pub fn ensure_agents_layout(ws: &str) -> Result<WorkspaceRoots, String> {
     let ws_path = validate_workspace_cwd(ws)?;
     let agents = ws_path.join(AGENTS_REL);
@@ -82,7 +81,6 @@ pub fn ensure_agents_layout(ws: &str) -> Result<WorkspaceRoots, String> {
     fs::create_dir_all(&learnings).map_err(|e| format!("create {LEARNINGS_REL}: {e}"))?;
     fs::create_dir_all(&plans).map_err(|e| format!("create {PLANS_REL}: {e}"))?;
 
-    migrate_legacy_memory(&ws_path, &memory)?;
     seed_learnings_index_if_empty(&learnings)?;
     fix_learnings_index_typo(&learnings)?;
     upgrade_learnings_graph_links(&learnings)?;
@@ -126,38 +124,6 @@ fn dir_has_any_md(dir: &Path) -> bool {
     false
 }
 
-fn copy_dir_recursive(src: &Path, dest: &Path) -> Result<(), String> {
-    if !src.is_dir() {
-        return Ok(());
-    }
-    fs::create_dir_all(dest).map_err(|e| format!("mkdir {}: {e}", dest.display()))?;
-    for entry in fs::read_dir(src).map_err(|e| format!("read {}: {e}", src.display()))? {
-        let entry = entry.map_err(|e| e.to_string())?;
-        let from = entry.path();
-        let to = dest.join(entry.file_name());
-        if entry.file_type().map(|t| t.is_dir()).unwrap_or(false) {
-            copy_dir_recursive(&from, &to)?;
-        } else {
-            fs::copy(&from, &to).map_err(|e| format!("copy {}: {e}", from.display()))?;
-        }
-    }
-    Ok(())
-}
-
-fn migrate_legacy_memory(ws: &Path, memory: &Path) -> Result<(), String> {
-    let legacy = ws.join(LEGACY_MEMORY_REL);
-    if !legacy.is_dir() {
-        return Ok(());
-    }
-    if dir_has_any_md(memory) {
-        return Ok(());
-    }
-    if !dir_has_any_md(&legacy) {
-        return Ok(());
-    }
-    copy_dir_recursive(&legacy, memory)
-}
-
 fn seed_learnings_index_if_empty(learnings: &Path) -> Result<(), String> {
     if dir_has_any_md(learnings) {
         return Ok(());
@@ -246,9 +212,7 @@ fn md_link_target_to_wikilink(target: &str) -> Option<String> {
     if !path_part.to_ascii_lowercase().ends_with(".md") {
         return None;
     }
-    let stem = path_part
-        .trim_end_matches(".md")
-        .trim_end_matches(".MD");
+    let stem = path_part.trim_end_matches(".md").trim_end_matches(".MD");
     if stem.is_empty() || stem.contains("..") || stem.starts_with('/') {
         return None;
     }
@@ -378,29 +342,6 @@ mod tests {
         assert_eq!(out, line);
     }
 
-    #[test]
-    fn migrate_legacy_only_when_new_empty() {
-        let ws = std::env::temp_dir().join(format!(
-            "blxcode_agents_migrate_{}_{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        let _ = fs::remove_dir_all(&ws);
-        fs::create_dir_all(ws.join(LEGACY_MEMORY_REL)).unwrap();
-        fs::write(ws.join(LEGACY_MEMORY_REL).join("note.md"), "legacy").unwrap();
-
-        let roots = ensure_agents_layout(&ws.to_string_lossy()).unwrap();
-        assert_eq!(
-            fs::read_to_string(roots.memory.join("note.md")).unwrap(),
-            "legacy"
-        );
-
-        let _ = fs::remove_dir_all(&ws);
-    }
-
     #[test]
     fn wikilink_upgrade_creates_graph_edge_fixture() {
         let ws = std::env::temp_dir().join(format!(
diff --git a/src-tauri/src/api_keys.rs b/src-tauri/src/api_keys.rs
index 2bccc34..2bd7c4d 100644
--- a/src-tauri/src/api_keys.rs
+++ b/src-tauri/src/api_keys.rs
@@ -11,11 +11,11 @@ use serde::{Deserialize, Serialize};
 use tauri::AppHandle;
 
 use crate::agent::web_settings::{self, WebKeyKind};
-use crate::media_keys::{self, MediaKeyKind};
 use crate::agent_settings::{
     self, delete_provider_key_secret, provider_env_var, provider_key_with_source,
     set_provider_key_secret, AgentProviderKind, KeySource,
 };
+use crate::media_keys::{self, MediaKeyKind};
 
 #[derive(Clone, Copy, Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
@@ -98,7 +98,10 @@ fn media_kind_from_kind(kind: &str) -> Option<MediaKeyKind> {
 
 fn build_status(app: &AppHandle) -> Result<ApiKeysStatus, String> {
     let mut entries = Vec::with_capacity(
-        LLM_KINDS.len() + SEARCH_KINDS.len() + COMING_SOON_LLM.len() + media_keys::MEDIA_KEY_KINDS.len(),
+        LLM_KINDS.len()
+            + SEARCH_KINDS.len()
+            + COMING_SOON_LLM.len()
+            + media_keys::MEDIA_KEY_KINDS.len(),
     );
 
     for (provider, kind, label) in LLM_KINDS {
diff --git a/src-tauri/src/browser_host.rs b/src-tauri/src/browser_host.rs
index 6105a97..e134a33 100644
--- a/src-tauri/src/browser_host.rs
+++ b/src-tauri/src/browser_host.rs
@@ -9,7 +9,6 @@ use tauri::webview::WebviewBuilder;
 use tauri::{AppHandle, LogicalPosition, LogicalSize, Manager, WebviewUrl};
 use url::Url;
 
-
 /// Child-WebViews mit SPA-gestützten Bounds funktionieren zuverlässig nur dort,
 /// wo das Tauri-/wry-Backend eine echte Unter-WebView einpasst (Windows: HWND-Child,
 /// macOS: NSView addSubview). Auf Linux/GTK fügt `add_child` die Webview als
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
index 787091f..6b2f4e7 100644
--- a/src-tauri/src/commands.rs
+++ b/src-tauri/src/commands.rs
@@ -193,8 +193,7 @@ pub fn agent_export_context_images(
     }
     let base_dir = ws_root.join(AGENT_CONTEXT_REL_DIR);
     let images_dir = base_dir.join(AGENT_CONTEXT_IMAGES_DIRNAME);
-    std::fs::create_dir_all(&images_dir)
-        .map_err(|e| format!("create context image dir: {e}"))?;
+    std::fs::create_dir_all(&images_dir).map_err(|e| format!("create context image dir: {e}"))?;
 
     let mut exports: Vec<AgentContextImageExport> = Vec::with_capacity(items.len());
     for item in items {
@@ -357,8 +356,8 @@ mod tests {
             bytes_b64: b64,
             size_bytes: png.len() as u64,
         }];
-        let report = agent_export_context_images(ws.to_string_lossy().into(), items)
-            .expect("export ok");
+        let report =
+            agent_export_context_images(ws.to_string_lossy().into(), items).expect("export ok");
         let dir = std::path::PathBuf::from(&report.dir);
         assert!(dir.ends_with(AGENT_CONTEXT_REL_DIR));
         let manifest = std::path::PathBuf::from(&report.manifest_path);
@@ -366,7 +365,11 @@ mod tests {
         assert_eq!(report.images.len(), 1);
         let exported = std::path::PathBuf::from(&report.images[0].path);
         assert!(exported.is_file());
-        assert!(exported.file_name().unwrap().to_string_lossy().ends_with(".png"));
+        assert!(exported
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .ends_with(".png"));
         let manifest_body = std::fs::read_to_string(&manifest).unwrap();
         assert!(manifest_body.contains("\"images\""));
         assert!(manifest_body.contains("img:1"));
@@ -481,7 +484,8 @@ where
             let _ = tx.send(f(app));
         })
         .map_err(|e| e.to_string())?;
-    rx.await.map_err(|_| "main thread channel dropped".to_string())?
+    rx.await
+        .map_err(|_| "main thread channel dropped".to_string())?
 }
 
 #[tauri::command]
@@ -505,7 +509,8 @@ pub async fn browser_run_js(
     script: String,
 ) -> Result<(), String> {
     dispatch_on_main(app, move |app| {
-        app.state::<BrowserHost>().eval_embedded(&app, tab_id, script)
+        app.state::<BrowserHost>()
+            .eval_embedded(&app, tab_id, script)
     })
     .await
 }
@@ -523,10 +528,7 @@ pub async fn browser_navigate(
 }
 
 #[tauri::command]
-pub async fn browser_close_tab(
-    app: tauri::AppHandle,
-    tab_id: u64,
-) -> Result<(), String> {
+pub async fn browser_close_tab(app: tauri::AppHandle, tab_id: u64) -> Result<(), String> {
     dispatch_on_main(app, move |app| {
         app.state::<BrowserHost>().close_tab(&app, tab_id)
     })
diff --git a/src-tauri/src/fs_entries.rs b/src-tauri/src/fs_entries.rs
index a00c9a1..49f0534 100644
--- a/src-tauri/src/fs_entries.rs
+++ b/src-tauri/src/fs_entries.rs
@@ -103,17 +103,14 @@ fn stem_lower(path: &Path) -> String {
 /// variant (`LICENSE.md`) since the caller always passes the stem.
 fn classify_policy(stem: &str) -> Option<PolicyKind> {
     match stem {
-        "license" | "licence" | "copying" | "copyright" | "unlicense" => {
-            Some(PolicyKind::License)
-        }
+        "license" | "licence" | "copying" | "copyright" | "unlicense" => Some(PolicyKind::License),
         "contributing" | "contribution" | "contributions" => Some(PolicyKind::Contributing),
         "contributors" | "contributer" | "contributers" => Some(PolicyKind::Contributors),
         "code_of_conduct" | "code-of-conduct" | "codeofconduct" => Some(PolicyKind::CodeOfConduct),
         "security" | "security-policy" | "security_policy" => Some(PolicyKind::Security),
         "authors" | "maintainers" | "owners" | "codeowners" => Some(PolicyKind::Authors),
-        "changelog" | "changes" | "history" | "release_notes" | "release-notes" | "releasenotes" => {
-            Some(PolicyKind::Changelog)
-        }
+        "changelog" | "changes" | "history" | "release_notes" | "release-notes"
+        | "releasenotes" => Some(PolicyKind::Changelog),
         "readme" => Some(PolicyKind::Readme),
         _ => None,
     }
@@ -127,24 +124,20 @@ fn classify_kind(ext: &str) -> FileKind {
         "md" | "markdown" => FileKind::Markdown,
         "mmd" | "mermaid" => FileKind::Mermaid,
         // Source code with syntax highlighting.
-        "rs" | "ts" | "tsx" | "js" | "jsx" | "mjs" | "cjs"
-        | "py" | "pyw" | "pyi"
-        | "go" | "java" | "kt" | "kts" | "scala" | "groovy" | "gradle"
-        | "swift" | "m" | "mm" | "c" | "h" | "cpp" | "cc" | "cxx" | "hpp" | "hxx"
-        | "cs" | "fs" | "fsx" | "vb" | "rb" | "erb" | "php" | "phtml"
-        | "lua" | "pl" | "pm" | "dart" | "r" | "jl"
-        | "clj" | "cljs" | "cljc" | "edn" | "ex" | "exs" | "eex" | "erl" | "hrl"
-        | "hs" | "lhs" | "purs" | "elm" | "nim" | "zig" | "ml" | "mli" | "ocaml"
-        | "html" | "htm" | "xhtml" | "vue" | "svelte" | "css" | "scss" | "sass" | "less" | "styl"
-        | "json" | "json5" | "jsonc" | "toml" | "yaml" | "yml" | "xml" | "plist"
-        | "sh" | "bash" | "zsh" | "fish" | "ps1" | "bat" | "cmd"
-        | "sql" | "graphql" | "gql" | "proto" | "thrift" | "tf" | "tfvars" | "hcl" | "nix"
-        | "dockerfile" | "containerfile" | "makefile" | "mk" | "cmake"
-        | "diff" | "patch" => FileKind::Code,
+        "rs" | "ts" | "tsx" | "js" | "jsx" | "mjs" | "cjs" | "py" | "pyw" | "pyi" | "go"
+        | "java" | "kt" | "kts" | "scala" | "groovy" | "gradle" | "swift" | "m" | "mm" | "c"
+        | "h" | "cpp" | "cc" | "cxx" | "hpp" | "hxx" | "cs" | "fs" | "fsx" | "vb" | "rb"
+        | "erb" | "php" | "phtml" | "lua" | "pl" | "pm" | "dart" | "r" | "jl" | "clj" | "cljs"
+        | "cljc" | "edn" | "ex" | "exs" | "eex" | "erl" | "hrl" | "hs" | "lhs" | "purs" | "elm"
+        | "nim" | "zig" | "ml" | "mli" | "ocaml" | "html" | "htm" | "xhtml" | "vue" | "svelte"
+        | "css" | "scss" | "sass" | "less" | "styl" | "json" | "json5" | "jsonc" | "toml"
+        | "yaml" | "yml" | "xml" | "plist" | "sh" | "bash" | "zsh" | "fish" | "ps1" | "bat"
+        | "cmd" | "sql" | "graphql" | "gql" | "proto" | "thrift" | "tf" | "tfvars" | "hcl"
+        | "nix" | "dockerfile" | "containerfile" | "makefile" | "mk" | "cmake" | "diff"
+        | "patch" => FileKind::Code,
         // Plain text without highlighting (still gets line numbers in the preview).
-        "txt" | "log" | "ini" | "conf" | "cfg" | "env" | "properties"
-        | "lock" | "gitignore" | "gitattributes" | "editorconfig"
-        | "csv" | "tsv" => FileKind::Text,
+        "txt" | "log" | "ini" | "conf" | "cfg" | "env" | "properties" | "lock" | "gitignore"
+        | "gitattributes" | "editorconfig" | "csv" | "tsv" => FileKind::Text,
         _ => FileKind::Binary,
     }
 }
@@ -447,9 +440,18 @@ mod tests {
 
     #[test]
     fn classify_policy_matches_known_stems() {
-        assert!(matches!(classify_policy("license"), Some(PolicyKind::License)));
-        assert!(matches!(classify_policy("licence"), Some(PolicyKind::License)));
-        assert!(matches!(classify_policy("copying"), Some(PolicyKind::License)));
+        assert!(matches!(
+            classify_policy("license"),
+            Some(PolicyKind::License)
+        ));
+        assert!(matches!(
+            classify_policy("licence"),
+            Some(PolicyKind::License)
+        ));
+        assert!(matches!(
+            classify_policy("copying"),
+            Some(PolicyKind::License)
+        ));
         assert!(matches!(
             classify_policy("contributing"),
             Some(PolicyKind::Contributing)
@@ -474,7 +476,10 @@ mod tests {
             classify_policy("changelog"),
             Some(PolicyKind::Changelog)
         ));
-        assert!(matches!(classify_policy("readme"), Some(PolicyKind::Readme)));
+        assert!(matches!(
+            classify_policy("readme"),
+            Some(PolicyKind::Readme)
+        ));
         assert!(classify_policy("random").is_none());
     }
 
@@ -498,10 +503,7 @@ mod tests {
         let root = tmp.to_string_lossy().into_owned();
         let meta = stat_workspace_file(root, "CONTRIBUTING.md".into()).unwrap();
         assert!(matches!(meta.kind, FileKind::Markdown));
-        assert!(matches!(
-            meta.policy_kind,
-            Some(PolicyKind::Contributing)
-        ));
+        assert!(matches!(meta.policy_kind, Some(PolicyKind::Contributing)));
         let _ = fs::remove_dir_all(tmp);
     }
 
diff --git a/src-tauri/src/git_graph.rs b/src-tauri/src/git_graph.rs
index e8cc610..0b1e41a 100644
--- a/src-tauri/src/git_graph.rs
+++ b/src-tauri/src/git_graph.rs
@@ -77,9 +77,8 @@ pub fn git_commit_graph(cwd: String, limit: Option<u32>) -> Result<GitGraphLayou
 }
 
 fn fetch_graph_entries(work_tree: &Path, limit: u32) -> Result<GitGraphLayout, String> {
-    let pretty = format!(
-        "%x1e%H{FIELD_SEP}%P{FIELD_SEP}%s{FIELD_SEP}%an{FIELD_SEP}%ar{FIELD_SEP}%D%x02"
-    );
+    let pretty =
+        format!("%x1e%H{FIELD_SEP}%P{FIELD_SEP}%s{FIELD_SEP}%an{FIELD_SEP}%ar{FIELD_SEP}%D%x02");
     let out = Command::new("git")
         .arg("-C")
         .arg(work_tree)
@@ -235,7 +234,9 @@ mod tests {
 
     #[test]
     fn parse_commit_record_fields() {
-        let rec = format!("deadbeef{FIELD_SEP}{FIELD_SEP}subject{FIELD_SEP}author{FIELD_SEP}1 day ago{FIELD_SEP}");
+        let rec = format!(
+            "deadbeef{FIELD_SEP}{FIELD_SEP}subject{FIELD_SEP}author{FIELD_SEP}1 day ago{FIELD_SEP}"
+        );
         let c = parse_commit_record(&rec).expect("parse");
         assert_eq!(c.oid, "deadbeef");
         assert_eq!(c.subject, "subject");
diff --git a/src-tauri/src/gitignore.rs b/src-tauri/src/gitignore.rs
index f055535..1230f17 100644
--- a/src-tauri/src/gitignore.rs
+++ b/src-tauri/src/gitignore.rs
@@ -43,8 +43,8 @@ pub fn gitignore_append_blxcode(workspace_cwd: String) -> Result<GitignoreAppend
     let path_display = gitignore_path.to_string_lossy().into_owned();
 
     if gitignore_path.is_file() {
-        let body = fs::read_to_string(&gitignore_path)
-            .map_err(|e| format!("read .gitignore: {e}"))?;
+        let body =
+            fs::read_to_string(&gitignore_path).map_err(|e| format!("read .gitignore: {e}"))?;
         if entry_present(&body) {
             return Ok(GitignoreAppendResult {
                 path: path_display,
diff --git a/src-tauri/src/image/generate.rs b/src-tauri/src/image/generate.rs
index fc0d0e7..1a66a9e 100644
--- a/src-tauri/src/image/generate.rs
+++ b/src-tauri/src/image/generate.rs
@@ -115,9 +115,7 @@ pub async fn generate(
         return Err(GenerateError::Cancelled);
     }
     if prompt.trim().is_empty() {
-        return Err(GenerateError::Validation(
-            "prompt must not be empty".into(),
-        ));
+        return Err(GenerateError::Validation("prompt must not be empty".into()));
     }
     validate_refs(refs)?;
 
@@ -435,19 +433,14 @@ async fn parse_fal_envelope(
     client: &reqwest::Client,
     body: &str,
 ) -> Result<GeneratedImage, GenerateError> {
-    let env: FalImageEnvelope = serde_json::from_str(body)
-        .map_err(|e| GenerateError::Parse(format!("fal json: {e}")))?;
-    let item = env
-        .images
-        .into_iter()
-        .next()
-        .or(env.image)
-        .ok_or_else(|| {
-            GenerateError::Provider(
-                env.detail
-                    .unwrap_or_else(|| "fal returned no images".into()),
-            )
-        })?;
+    let env: FalImageEnvelope =
+        serde_json::from_str(body).map_err(|e| GenerateError::Parse(format!("fal json: {e}")))?;
+    let item = env.images.into_iter().next().or(env.image).ok_or_else(|| {
+        GenerateError::Provider(
+            env.detail
+                .unwrap_or_else(|| "fal returned no images".into()),
+        )
+    })?;
     let url = item
         .url
         .ok_or_else(|| GenerateError::Provider("fal image had no url".into()))?;
@@ -594,13 +587,19 @@ fn parse_openrouter_envelope(body: &str) -> Result<GeneratedImage, GenerateError
 fn openrouter_text_fallback(content: Option<&Value>) -> Option<String> {
     let value = content?;
     if let Some(s) = value.as_str() {
-        return Some(format!("openrouter returned no image: {}", truncate(s, 240)));
+        return Some(format!(
+            "openrouter returned no image: {}",
+            truncate(s, 240)
+        ));
     }
     if let Some(arr) = value.as_array() {
         for block in arr {
             if block.get("type").and_then(|t| t.as_str()) == Some("text") {
                 if let Some(t) = block.get("text").and_then(|t| t.as_str()) {
-                    return Some(format!("openrouter returned no image: {}", truncate(t, 240)));
+                    return Some(format!(
+                        "openrouter returned no image: {}",
+                        truncate(t, 240)
+                    ));
                 }
             }
         }
@@ -628,9 +627,7 @@ fn decode_data_url(url: &str) -> Result<(String, Vec<u8>), GenerateError> {
         }
     }
     if !is_b64 {
-        return Err(GenerateError::Parse(
-            "data URL not base64-encoded".into(),
-        ));
+        return Err(GenerateError::Parse("data URL not base64-encoded".into()));
     }
     let bytes = BASE64
         .decode(payload.as_bytes())
diff --git a/src-tauri/src/image/settings.rs b/src-tauri/src/image/settings.rs
index 4f78d0e..e0de2df 100644
--- a/src-tauri/src/image/settings.rs
+++ b/src-tauri/src/image/settings.rs
@@ -141,13 +141,14 @@ pub fn provider_key(app: &AppHandle, provider: ImageProviderKind) -> Result<Stri
         ImageProviderKind::Openrouter => {
             agent_settings::provider_key_pub(app, agent_settings::AgentProviderKind::Openrouter)
         }
-        ImageProviderKind::Fal => crate::media_keys::resolve_key(crate::media_keys::MediaKeyKind::Fal)
-            .ok_or_else(|| {
+        ImageProviderKind::Fal => {
+            crate::media_keys::resolve_key(crate::media_keys::MediaKeyKind::Fal).ok_or_else(|| {
                 format!(
                     "fal.ai API key missing — set it in Settings → API Keys (env: {})",
                     crate::media_keys::MediaKeyKind::Fal.env_var()
                 )
-            }),
+            })
+        }
     }
 }
 
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 1719e55..457a8ed 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -37,8 +37,8 @@ use updater::{
     BlxUpdaterState,
 };
 use voice::{
-    voice_cancel_recording, voice_settings_get, voice_settings_save,
-    voice_start_recording, voice_stop_and_transcribe, voice_tts_preview, VoiceRecorderState,
+    voice_cancel_recording, voice_settings_get, voice_settings_save, voice_start_recording,
+    voice_stop_and_transcribe, voice_tts_preview, VoiceRecorderState,
 };
 use workbench_state::{
     agent_latest_session_id, agent_session_exists, workbench_clear_terminal_notifications,
@@ -183,11 +183,12 @@ pub fn run() {
             gitignore::gitignore_append_blxcode,
             memory::workspace_ensure_agents,
             memory::memory_root,
+            memory::memory_status,
+            memory::memory_bootstrap,
             memory::memory_list,
             memory::memory_read,
             memory::memory_write,
             memory::memory_create,
-            memory::memory_list_categories,
             memory::memory_create_category,
             memory::memory_delete,
             memory::memory_rename,
diff --git a/src-tauri/src/memory.rs b/src-tauri/src/memory.rs
deleted file mode 100644
index 5c755a5..0000000
--- a/src-tauri/src/memory.rs
+++ /dev/null
@@ -1,1276 +0,0 @@
-//! Workspace-scoped Obsidian-style memory.
-//!
-//! Layout per workspace:
-//!
-//! ```text
-//! <workspace_cwd>/.agents/memory/      — user notes (+ _templates/)
-//! <workspace_cwd>/.agents/learnings/ — durable repo learnings (API: `learnings/…`)
-//! ```
-//!
-//! Legacy `.blxcode/memory/` is migrated once into `.agents/memory/` when empty.
-//! All Tauri commands take the workspace cwd; API paths are sandboxed.
-//!
-//! Link syntax (Obsidian-compatible subset):
-//!   `[[Note Name]]`            — link to `Note Name.md` (by basename, case-insensitive)
-//!   `[[folder/Note]]`          — explicit relative path
-//!   `[[Note Name|alias]]`      — display alias (ignored for graph)
-//!   `#tag`                     — tag (graph metadata)
-
-use crate::agents_layout::{
-    ensure_agents_layout, validate_workspace_cwd, WorkspaceRoots, LEARNINGS_API_PREFIX,
-    LEARNINGS_REL, MEMORY_REL,
-};
-use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, BTreeSet, HashMap};
-use std::fs;
-use std::io::Write;
-use std::path::{Component, Path, PathBuf};
-
-const TEMPLATES_DIRNAME: &str = "_templates";
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct NoteMeta {
-    /// Relative path within the memory root, forward slashes, includes `.md`.
-    pub path: String,
-    /// Basename without extension.
-    pub name: String,
-    /// File size in bytes.
-    pub size: u64,
-    /// Last-modified time as seconds since UNIX epoch.
-    pub modified: i64,
-    /// True if under the `_templates/` subdir.
-    pub is_template: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct NoteContent {
-    pub path: String,
-    pub content: String,
-    pub modified: i64,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct GraphNode {
-    pub id: String,
-    pub label: String,
-    pub tags: Vec<String>,
-    pub orphan: bool,
-    /// Category key derived from the API path (first segment under
-    /// `.agents/memory/`, or `learnings` for the learnings root, or
-    /// `memory` for top-level memory notes).
-    pub category: String,
-}
-
-fn graph_category_for(api_path: &str) -> String {
-    if api_path.starts_with(LEARNINGS_API_PREFIX) {
-        return "learnings".to_string();
-    }
-    if let Some((head, _)) = api_path.split_once('/') {
-        if !head.is_empty() {
-            return head.to_string();
-        }
-    }
-    "memory".to_string()
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct GraphEdge {
-    pub source: String,
-    pub target: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct GraphData {
-    pub nodes: Vec<GraphNode>,
-    pub edges: Vec<GraphEdge>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct SearchHit {
-    pub path: String,
-    pub line: u32,
-    pub snippet: String,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct PointerResult {
-    pub agent: String,
-    pub path: String,
-    pub installed: bool,
-    pub note: Option<String>,
-}
-
-fn err<T>(s: impl Into<String>) -> Result<T, String> {
-    Err(s.into())
-}
-
-fn ensure_workspace_memory(ws: &str) -> Result<WorkspaceRoots, String> {
-    ensure_agents_layout(ws)
-}
-
-fn resolve_api_path(api_path: &str) -> Result<(bool, String), String> {
-    let p = api_path.trim().replace('\\', "/");
-    if p.is_empty() {
-        return err("empty path");
-    }
-    if p.starts_with(LEARNINGS_API_PREFIX) {
-        let rel = p
-            .strip_prefix(LEARNINGS_API_PREFIX)
-            .unwrap_or_default()
-            .trim();
-        if rel.is_empty() || rel.contains("..") {
-            return err("invalid learnings path");
-        }
-        return Ok((true, rel.to_owned()));
-    }
-    if p.contains("..") {
-        return err("invalid path");
-    }
-    Ok((false, p))
-}
-
-fn note_root<'a>(roots: &'a WorkspaceRoots, is_learnings: bool) -> &'a Path {
-    if is_learnings {
-        roots.learnings.as_path()
-    } else {
-        roots.memory.as_path()
-    }
-}
-
-fn resolve_note_abs(roots: &WorkspaceRoots, api_path: &str) -> Result<PathBuf, String> {
-    let (is_learnings, rel) = resolve_api_path(api_path)?;
-    safe_join(note_root(roots, is_learnings), &rel, true)
-}
-
-fn api_path_for(roots: &WorkspaceRoots, file_root: &Path, rel: &str) -> String {
-    if file_root == roots.learnings.as_path() {
-        format!("{LEARNINGS_API_PREFIX}{rel}")
-    } else {
-        rel.to_owned()
-    }
-}
-
-fn collect_all_md(roots: &WorkspaceRoots, out: &mut Vec<(String, PathBuf, PathBuf)>) {
-    for root in [roots.memory.as_path(), roots.learnings.as_path()] {
-        let mut files = Vec::new();
-        walk_md(root, &mut files);
-        for abs in files {
-            let Some(rel) = rel_from_root(root, &abs) else {
-                continue;
-            };
-            let api = api_path_for(roots, root, &rel);
-            out.push((api, abs, root.to_path_buf()));
-        }
-    }
-}
-
-fn meta_from_abs(_roots: &WorkspaceRoots, api_path: &str, abs: &Path, file_root: &Path) -> NoteMeta {
-    let rel = rel_from_root(file_root, abs).unwrap_or_default();
-    let meta = fs::metadata(abs).ok();
-    let name = abs
-        .file_stem()
-        .and_then(|s| s.to_str())
-        .unwrap_or("")
-        .to_owned();
-    let is_template = !api_path.starts_with(LEARNINGS_API_PREFIX)
-        && rel.starts_with(&format!("{TEMPLATES_DIRNAME}/"));
-    NoteMeta {
-        path: api_path.to_owned(),
-        name,
-        size: meta.as_ref().map(|m| m.len()).unwrap_or(0),
-        modified: mtime_secs(abs),
-        is_template,
-    }
-}
-
-/// Validates `rel` is a clean relative path with no `..` or absolute
-/// segments, normalises slashes to forward, and returns the absolute
-/// path inside `root`. Also enforces `.md` extension when `enforce_md`.
-fn safe_join(root: &Path, rel: &str, enforce_md: bool) -> Result<PathBuf, String> {
-    let rel = rel.trim().trim_start_matches('/').trim_start_matches('\\');
-    if rel.is_empty() {
-        return err("empty relative path");
-    }
-    let normalized = rel.replace('\\', "/");
-    let candidate = PathBuf::from(&normalized);
-    for c in candidate.components() {
-        match c {
-            Component::Normal(_) => {}
-            _ => return err(format!("disallowed path component in {rel}")),
-        }
-    }
-    let abs = root.join(&candidate);
-    // Cheap defense-in-depth: re-check the joined path lies under root.
-    let canon_root = fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
-    let canon_abs = abs
-        .parent()
-        .and_then(|p| fs::canonicalize(p).ok())
-        .map(|p| p.join(abs.file_name().unwrap_or_default()))
-        .unwrap_or(abs.clone());
-    if !canon_abs.starts_with(&canon_root) {
-        return err("path escapes memory root");
-    }
-    if enforce_md {
-        let is_md = canon_abs
-            .extension()
-            .and_then(|e| e.to_str())
-            .map(|e| e.eq_ignore_ascii_case("md"))
-            .unwrap_or(false);
-        if !is_md {
-            return err("only .md files allowed");
-        }
-    }
-    Ok(abs)
-}
-
-fn rel_from_root(root: &Path, p: &Path) -> Option<String> {
-    p.strip_prefix(root)
-        .ok()
-        .map(|rel| rel.to_string_lossy().replace('\\', "/"))
-}
-
-fn mtime_secs(p: &Path) -> i64 {
-    fs::metadata(p)
-        .and_then(|m| m.modified())
-        .ok()
-        .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
-        .map(|d| d.as_secs() as i64)
-        .unwrap_or(0)
-}
-
-fn walk_md(root: &Path, out: &mut Vec<PathBuf>) {
-    let Ok(read) = fs::read_dir(root) else { return };
-    for entry in read.flatten() {
-        let path = entry.path();
-        let Ok(ft) = entry.file_type() else { continue };
-        if ft.is_dir() {
-            walk_md(&path, out);
-            continue;
-        }
-        if ft.is_file() {
-            let is_md = path
-                .extension()
-                .and_then(|e| e.to_str())
-                .map(|e| e.eq_ignore_ascii_case("md"))
-                .unwrap_or(false);
-            if is_md {
-                out.push(path);
-            }
-        }
-    }
-}
-
-#[tauri::command]
-pub fn workspace_ensure_agents(workspace_cwd: String) -> Result<(), String> {
-    ensure_agents_layout(&workspace_cwd)?;
-    Ok(())
-}
-
-#[tauri::command]
-pub fn memory_root(workspace_cwd: String) -> Result<String, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    Ok(roots.memory.to_string_lossy().into_owned())
-}
-
-#[tauri::command]
-pub fn memory_list(workspace_cwd: String) -> Result<Vec<NoteMeta>, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let mut collected = Vec::new();
-    collect_all_md(&roots, &mut collected);
-    let mut out: Vec<NoteMeta> = collected
-        .into_iter()
-        .map(|(api, abs, file_root)| meta_from_abs(&roots, &api, &abs, &file_root))
-        .collect();
-    out.sort_by(|a, b| a.path.to_lowercase().cmp(&b.path.to_lowercase()));
-    Ok(out)
-}
-
-#[tauri::command]
-pub fn memory_read(workspace_cwd: String, path: String) -> Result<NoteContent, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let abs = resolve_note_abs(&roots, &path)?;
-    let content = fs::read_to_string(&abs).map_err(|e| format!("read {path}: {e}"))?;
-    Ok(NoteContent {
-        path,
-        content,
-        modified: mtime_secs(&abs),
-    })
-}
-
-#[tauri::command]
-pub fn memory_write(
-    workspace_cwd: String,
-    path: String,
-    content: String,
-) -> Result<NoteContent, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let abs = resolve_note_abs(&roots, &path)?;
-    if let Some(parent) = abs.parent() {
-        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
-    }
-    let mut file = fs::File::create(&abs).map_err(|e| format!("create {path}: {e}"))?;
-    file.write_all(content.as_bytes())
-        .map_err(|e| format!("write {path}: {e}"))?;
-    Ok(NoteContent {
-        path,
-        content,
-        modified: mtime_secs(&abs),
-    })
-}
-
-#[tauri::command]
-pub fn memory_create(
-    workspace_cwd: String,
-    path: String,
-    content: Option<String>,
-) -> Result<NoteMeta, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let abs = resolve_note_abs(&roots, &path)?;
-    if abs.exists() {
-        return err(format!("already exists: {path}"));
-    }
-    if let Some(parent) = abs.parent() {
-        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
-    }
-    let body = content.unwrap_or_default();
-    fs::write(&abs, body.as_bytes()).map_err(|e| format!("write {path}: {e}"))?;
-    let (is_learnings, _) = resolve_api_path(&path)?;
-    let file_root = note_root(&roots, is_learnings);
-    Ok(meta_from_abs(&roots, &path, &abs, file_root))
-}
-
-/// Marker file dropped into a freshly created empty category so it survives
-/// `git`/cleanup without any notes. `memory_list` ignores it because it's not `.md`.
-const CATEGORY_PLACEHOLDER: &str = ".gitkeep";
-
-fn is_reserved_category(name: &str) -> bool {
-    name.eq_ignore_ascii_case(TEMPLATES_DIRNAME)
-        || name.eq_ignore_ascii_case("memory")
-        || name.eq_ignore_ascii_case("learnings")
-}
-
-fn validate_category_name(name: &str) -> Result<String, String> {
-    let trimmed = name.trim();
-    if trimmed.is_empty() {
-        return err("empty category name");
-    }
-    if trimmed.contains('/') || trimmed.contains('\\') || trimmed.contains("..") {
-        return err("invalid category name");
-    }
-    if is_reserved_category(trimmed) {
-        return err(format!("reserved category name: {trimmed}"));
-    }
-    Ok(trimmed.to_owned())
-}
-
-#[tauri::command]
-pub fn memory_list_categories(workspace_cwd: String) -> Result<Vec<String>, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let mut out: Vec<String> = Vec::new();
-    let Ok(read) = fs::read_dir(roots.memory.as_path()) else {
-        return Ok(out);
-    };
-    for entry in read.flatten() {
-        let Ok(ft) = entry.file_type() else { continue };
-        if !ft.is_dir() {
-            continue;
-        }
-        let Some(name) = entry.file_name().to_str().map(str::to_owned) else {
-            continue;
-        };
-        if name.starts_with('.') || name.eq_ignore_ascii_case(TEMPLATES_DIRNAME) {
-            continue;
-        }
-        out.push(name);
-    }
-    out.sort_unstable_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
-    Ok(out)
-}
-
-#[tauri::command]
-pub fn memory_create_category(workspace_cwd: String, name: String) -> Result<String, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let clean = validate_category_name(&name)?;
-    let dir = roots.memory.join(&clean);
-    if dir.exists() {
-        return err(format!("already exists: {clean}"));
-    }
-    fs::create_dir_all(&dir).map_err(|e| format!("mkdir: {e}"))?;
-    let placeholder = dir.join(CATEGORY_PLACEHOLDER);
-    let _ = fs::write(&placeholder, b"");
-    Ok(clean)
-}
-
-#[tauri::command]
-pub fn memory_delete(workspace_cwd: String, path: String) -> Result<(), String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let (is_learnings, _) = resolve_api_path(&path)?;
-    let root = note_root(&roots, is_learnings);
-    let abs = resolve_note_abs(&roots, &path)?;
-    if !abs.exists() {
-        return err(format!("not found: {path}"));
-    }
-    fs::remove_file(&abs).map_err(|e| format!("delete {path}: {e}"))?;
-    // best-effort: remove empty parent dirs up to root
-    if let Some(mut parent) = abs.parent() {
-        while parent != root {
-            if fs::read_dir(parent)
-                .map(|mut r| r.next().is_none())
-                .unwrap_or(false)
-            {
-                let _ = fs::remove_dir(parent);
-                if let Some(grand) = parent.parent() {
-                    parent = grand;
-                } else {
-                    break;
-                }
-            } else {
-                break;
-            }
-        }
-    }
-    Ok(())
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct RenameReport {
-    pub old_path: String,
-    pub new_path: String,
-    pub link_rewrites: u32,
-    pub files_changed: u32,
-}
-
-#[tauri::command]
-pub fn memory_rename(
-    workspace_cwd: String,
-    old_path: String,
-    new_path: String,
-    rewrite_links: bool,
-) -> Result<RenameReport, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let (old_learn, _) = resolve_api_path(&old_path)?;
-    let (new_learn, _) = resolve_api_path(&new_path)?;
-    if old_learn != new_learn {
-        return err("cannot rename across memory and learnings roots");
-    }
-    let abs_old = resolve_note_abs(&roots, &old_path)?;
-    let abs_new = resolve_note_abs(&roots, &new_path)?;
-    if !abs_old.exists() {
-        return err(format!("not found: {old_path}"));
-    }
-    if abs_new.exists() {
-        return err(format!("already exists: {new_path}"));
-    }
-    if let Some(parent) = abs_new.parent() {
-        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
-    }
-    fs::rename(&abs_old, &abs_new).map_err(|e| format!("rename: {e}"))?;
-
-    let old_basename = Path::new(&old_path)
-        .file_stem()
-        .and_then(|s| s.to_str())
-        .unwrap_or("")
-        .to_owned();
-    let new_basename = Path::new(&new_path)
-        .file_stem()
-        .and_then(|s| s.to_str())
-        .unwrap_or("")
-        .to_owned();
-
-    let mut total_rewrites = 0u32;
-    let mut files_changed = 0u32;
-
-    if rewrite_links && !old_basename.is_empty() && !new_basename.is_empty() {
-        let mut collected = Vec::new();
-        collect_all_md(&roots, &mut collected);
-        for (_, f, _) in collected {
-            let Ok(content) = fs::read_to_string(&f) else {
-                continue;
-            };
-            let (updated, n) =
-                rewrite_wikilinks(&content, &old_basename, &new_basename, &old_path, &new_path);
-            if n > 0 {
-                if fs::write(&f, updated.as_bytes()).is_ok() {
-                    total_rewrites += n;
-                    files_changed += 1;
-                }
-            }
-        }
-    }
-    Ok(RenameReport {
-        old_path,
-        new_path,
-        link_rewrites: total_rewrites,
-        files_changed,
-    })
-}
-
-/// Rewrites `[[old_basename|...]]` -> `[[new_basename|...]]` and
-/// `[[old_path_without_ext|...]]` -> `[[new_path_without_ext|...]]`.
-/// Returns (new_content, count).
-fn rewrite_wikilinks(
-    content: &str,
-    old_basename: &str,
-    new_basename: &str,
-    old_path: &str,
-    new_path: &str,
-) -> (String, u32) {
-    let old_pwx = strip_md_ext(old_path);
-    let new_pwx = strip_md_ext(new_path);
-    let mut out = String::with_capacity(content.len());
-    let mut i = 0usize;
-    let bytes = content.as_bytes();
-    let mut count = 0u32;
-    while i < bytes.len() {
-        if i + 1 < bytes.len() && bytes[i] == b'[' && bytes[i + 1] == b'[' {
-            if let Some(end) = find_close_link(&content[i + 2..]) {
-                let inner = &content[i + 2..i + 2 + end];
-                // split target|alias
-                let (target, alias) = match inner.find('|') {
-                    Some(j) => (&inner[..j], Some(&inner[j + 1..])),
-                    None => (inner, None),
-                };
-                let target_t = target.trim();
-                let new_target = if target_t.eq_ignore_ascii_case(old_basename)
-                    || target_t.eq_ignore_ascii_case(&old_pwx)
-                {
-                    if target_t.contains('/') {
-                        Some(new_pwx.clone())
-                    } else {
-                        Some(new_basename.to_owned())
-                    }
-                } else {
-                    None
-                };
-                if let Some(t) = new_target {
-                    out.push_str("[[");
-                    out.push_str(&t);
-                    if let Some(a) = alias {
-                        out.push('|');
-                        out.push_str(a);
-                    }
-                    out.push_str("]]");
-                    count += 1;
-                } else {
-                    out.push_str(&content[i..i + 2 + end + 2]);
-                }
-                i += 2 + end + 2;
-                continue;
-            }
-        }
-        out.push(content[i..].chars().next().unwrap());
-        i += content[i..].chars().next().unwrap().len_utf8();
-    }
-    (out, count)
-}
-
-fn strip_md_ext(p: &str) -> String {
-    if let Some(idx) = p.rfind('.') {
-        if p[idx + 1..].eq_ignore_ascii_case("md") {
-            return p[..idx].to_owned();
-        }
-    }
-    p.to_owned()
-}
-
-fn find_close_link(s: &str) -> Option<usize> {
-    let bytes = s.as_bytes();
-    let mut i = 0;
-    while i + 1 < bytes.len() {
-        if bytes[i] == b']' && bytes[i + 1] == b']' {
-            return Some(i);
-        }
-        if bytes[i] == b'\n' {
-            return None;
-        }
-        i += 1;
-    }
-    None
-}
-
-/// Extracts `[[link]]` targets (without alias) and `#tag`s from a body.
-fn parse_links_and_tags(body: &str) -> (Vec<String>, Vec<String>) {
-    let mut links: Vec<String> = Vec::new();
-    let mut tags: BTreeSet<String> = BTreeSet::new();
-    let mut i = 0;
-    let bytes = body.as_bytes();
-    while i < bytes.len() {
-        if i + 1 < bytes.len() && bytes[i] == b'[' && bytes[i + 1] == b'[' {
-            if let Some(end) = find_close_link(&body[i + 2..]) {
-                let inner = &body[i + 2..i + 2 + end];
-                let target = match inner.find('|') {
-                    Some(j) => &inner[..j],
-                    None => inner,
-                };
-                let t = target.trim();
-                if !t.is_empty() {
-                    links.push(t.to_owned());
-                }
-                i += 2 + end + 2;
-                continue;
-            }
-        }
-        if bytes[i] == b'#' {
-            let prev = if i == 0 { b'\n' } else { bytes[i - 1] };
-            // tag must follow whitespace or start of line; skip markdown headings
-            if prev == b'\n' || prev == b' ' || prev == b'\t' {
-                let mut j = i + 1;
-                while j < bytes.len() {
-                    let c = bytes[j];
-                    let ok = c.is_ascii_alphanumeric() || c == b'-' || c == b'_' || c == b'/';
-                    if !ok {
-                        break;
-                    }
-                    j += 1;
-                }
-                // Heading `# Foo` => j == i+1 with space after; require at least 1 char
-                // and that the char after '#' is not space (so headings are excluded).
-                if j > i + 1 {
-                    let after_hash = bytes[i + 1];
-                    if after_hash != b' ' {
-                        let tag = &body[i + 1..j];
-                        if !tag.is_empty() && !tag.chars().all(|c| c.is_ascii_digit()) {
-                            tags.insert(tag.to_owned());
-                        }
-                    }
-                }
-                i = j.max(i + 1);
-                continue;
-            }
-        }
-        i += 1;
-    }
-    (links, tags.into_iter().collect())
-}
-
-#[tauri::command]
-pub fn memory_graph(workspace_cwd: String) -> Result<GraphData, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let mut collected = Vec::new();
-    collect_all_md(&roots, &mut collected);
-    collected.retain(|(api, _, _)| !api.starts_with(&format!("{TEMPLATES_DIRNAME}/")));
-
-    let mut by_basename: HashMap<String, Vec<String>> = HashMap::new();
-    let mut by_pwx: HashMap<String, String> = HashMap::new();
-    let mut bodies: BTreeMap<String, String> = BTreeMap::new();
-
-    for (api, f, _) in &collected {
-        if let Some(stem) = Path::new(api)
-            .file_stem()
-            .and_then(|s| s.to_str())
-        {
-            by_basename
-                .entry(stem.to_ascii_lowercase())
-                .or_default()
-                .push(api.clone());
-        }
-        by_pwx.insert(strip_md_ext(api).to_ascii_lowercase(), api.clone());
-        if let Ok(body) = fs::read_to_string(f) {
-            bodies.insert(api.clone(), body);
-        }
-    }
-
-    let mut nodes: Vec<GraphNode> = Vec::new();
-    let mut edges: Vec<GraphEdge> = Vec::new();
-    let mut has_edge: BTreeSet<String> = BTreeSet::new();
-
-    for (rel, body) in &bodies {
-        let (links, tags) = parse_links_and_tags(body);
-        let mut node_tags = tags;
-        node_tags.sort();
-        node_tags.dedup();
-        let stem = Path::new(rel)
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .unwrap_or("")
-            .to_owned();
-        let category = graph_category_for(rel);
-        nodes.push(GraphNode {
-            id: rel.clone(),
-            label: stem,
-            tags: node_tags,
-            orphan: false,
-            category,
-        });
-        for raw in links {
-            let lower = raw.to_ascii_lowercase();
-            let target = if let Some(t) = by_pwx.get(&lower) {
-                Some(t.clone())
-            } else if let Some(list) = by_basename.get(&lower) {
-                list.first().cloned()
-            } else {
-                None
-            };
-            if let Some(t) = target {
-                if t != *rel {
-                    has_edge.insert(rel.clone());
-                    has_edge.insert(t.clone());
-                    edges.push(GraphEdge {
-                        source: rel.clone(),
-                        target: t,
-                    });
-                }
-            }
-        }
-    }
-
-    for n in nodes.iter_mut() {
-        n.orphan = !has_edge.contains(&n.id);
-    }
-
-    Ok(GraphData { nodes, edges })
-}
-
-#[tauri::command]
-pub fn memory_backlinks(workspace_cwd: String, path: String) -> Result<Vec<String>, String> {
-    let g = memory_graph(workspace_cwd)?;
-    let mut out: Vec<String> = g
-        .edges
-        .into_iter()
-        .filter_map(|e| {
-            if e.target == path {
-                Some(e.source)
-            } else {
-                None
-            }
-        })
-        .collect();
-    out.sort();
-    out.dedup();
-    Ok(out)
-}
-
-#[tauri::command]
-pub fn memory_search(workspace_cwd: String, query: String) -> Result<Vec<SearchHit>, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let needle = query.trim();
-    if needle.is_empty() {
-        return Ok(Vec::new());
-    }
-    let needle_l = needle.to_ascii_lowercase();
-    let mut collected = Vec::new();
-    collect_all_md(&roots, &mut collected);
-    let mut hits: Vec<SearchHit> = Vec::new();
-    for (api, f, _) in collected {
-        let Ok(body) = fs::read_to_string(&f) else {
-            continue;
-        };
-        for (idx, line) in body.lines().enumerate() {
-            if line.to_ascii_lowercase().contains(&needle_l) {
-                let snip = if line.len() > 200 { &line[..200] } else { line };
-                hits.push(SearchHit {
-                    path: api.clone(),
-                    line: (idx + 1) as u32,
-                    snippet: snip.to_owned(),
-                });
-                if hits.len() >= 500 {
-                    return Ok(hits);
-                }
-            }
-        }
-    }
-    Ok(hits)
-}
-
-#[tauri::command]
-pub fn memory_export(workspace_cwd: String, dest_dir: String) -> Result<u32, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let dest = PathBuf::from(dest_dir.trim());
-    if !dest.is_absolute() {
-        return err("dest_dir must be absolute");
-    }
-    fs::create_dir_all(&dest).map_err(|e| format!("mkdir dest: {e}"))?;
-    let mut n = 0u32;
-    for (root, sub) in [
-        (roots.memory.as_path(), "memory"),
-        (roots.learnings.as_path(), "learnings"),
-    ] {
-        let mut files = Vec::new();
-        walk_md(root, &mut files);
-        for f in files {
-            let Some(rel) = rel_from_root(root, &f) else {
-                continue;
-            };
-            let target = dest.join(sub).join(&rel);
-            if let Some(parent) = target.parent() {
-                fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
-            }
-            fs::copy(&f, &target).map_err(|e| format!("copy {rel}: {e}"))?;
-            n += 1;
-        }
-    }
-    Ok(n)
-}
-
-#[tauri::command]
-pub fn memory_import(workspace_cwd: String, src_dir: String) -> Result<u32, String> {
-    let roots = ensure_workspace_memory(&workspace_cwd)?;
-    let src = PathBuf::from(src_dir.trim());
-    if !src.is_absolute() {
-        return err("src_dir must be absolute");
-    }
-    if !src.exists() {
-        return err("src_dir does not exist");
-    }
-    let mut n = 0u32;
-    let learnings_src = src.join("learnings");
-    let memory_src = src.join("memory");
-    if learnings_src.is_dir() {
-        n += import_tree_into_root(&learnings_src, &roots.learnings)?;
-    }
-    if memory_src.is_dir() {
-        n += import_tree_into_root(&memory_src, &roots.memory)?;
-    } else if !learnings_src.is_dir() {
-        n += import_tree_into_root(&src, &roots.memory)?;
-    }
-    Ok(n)
-}
-
-fn import_tree_into_root(src: &Path, dest_root: &Path) -> Result<u32, String> {
-    let mut files = Vec::new();
-    walk_md(src, &mut files);
-    let mut n = 0u32;
-    for f in files {
-        let Ok(rel_pb) = f.strip_prefix(src) else {
-            continue;
-        };
-        let rel = rel_pb.to_string_lossy().replace('\\', "/");
-        let abs = match safe_join(dest_root, &rel, true) {
-            Ok(p) => p,
-            Err(_) => continue,
-        };
-        if abs.exists() {
-            continue;
-        }
-        if let Some(parent) = abs.parent() {
-            fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
-        }
-        fs::copy(&f, &abs).map_err(|e| format!("copy {rel}: {e}"))?;
-        n += 1;
-    }
-    Ok(n)
-}
-
-// ---------------------------------------------------------------------
-// Phase 4: agent pointer files.
-//
-// Each supported agent CLI has its own "memory" convention. blxcode can
-// manage a short pointer block inside those files, but must never create
-// them implicitly or modify unrelated user-owned content.
-//
-//   claude    -> CLAUDE.md
-//   codex     -> AGENTS.md
-//   gemini    -> GEMINI.md
-//   cursor    -> .cursorrules
-//   opencode  -> AGENTS.md   (shares with codex; we write once)
-//
-// The block is delimited by a marker so re-installs replace cleanly
-// instead of duplicating content. Anything outside the markers is
-// preserved.
-
-const POINTER_BEGIN: &str = "<!-- blxcode-memory:begin -->";
-const POINTER_END: &str = "<!-- blxcode-memory:end -->";
-const POINTER_BEGIN_CURSOR: &str = "# blxcode-memory:begin";
-const POINTER_END_CURSOR: &str = "# blxcode-memory:end";
-
-fn pointer_filename(agent: &str) -> Option<&'static str> {
-    match agent {
-        "claude" => Some("CLAUDE.md"),
-        "codex" => Some("AGENTS.md"),
-        "gemini" => Some("GEMINI.md"),
-        "cursor" => Some(".cursorrules"),
-        "opencode" => Some("AGENTS.md"),
-        _ => None,
-    }
-}
-
-fn pointer_body(workspace_cwd: &Path, notes: &[NoteMeta], cursor_style: bool) -> String {
-    let memory_dir = workspace_cwd.join(MEMORY_REL);
-    let learnings_dir = workspace_cwd.join(LEARNINGS_REL);
-    let mut s = String::new();
-    if cursor_style {
-        s.push_str("blxcode tracks per-workspace memory and learnings at the paths below.\n");
-    } else {
-        s.push_str("## blxcode workspace memory\n\n");
-        s.push_str(
-            "This workspace uses **blxcode** to maintain Markdown notes and learnings \
-shared across all agent sessions. Treat the directories below as authoritative \
-context: read notes that are relevant to the task, and propose new notes \
-or edits when you learn something the team should remember.\n\n",
-        );
-    }
-    s.push_str(&format!("Memory root: `{}`\n", memory_dir.display()));
-    s.push_str(&format!(
-        "Learnings root: `{}` (API paths: `learnings/…`)\n\n",
-        learnings_dir.display()
-    ));
-    if notes.is_empty() {
-        s.push_str("(no notes yet)\n");
-    } else {
-        s.push_str("Current notes:\n");
-        let mut shown = 0;
-        for n in notes {
-            if n.is_template {
-                continue;
-            }
-            s.push_str(&format!("- `{}`\n", n.path));
-            shown += 1;
-            if shown >= 80 {
-                s.push_str(&format!("- … and {} more\n", notes.len() - shown));
-                break;
-            }
-        }
-    }
-    s.push('\n');
-    s
-}
-
-fn splice_block(existing: &str, begin: &str, end: &str, new_body: &str) -> String {
-    let block = format!("{begin}\n{new_body}{end}\n");
-    if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
-        let ei_end = ei + end.len();
-        let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
-            ei_end + 1
-        } else {
-            ei_end
-        };
-        let head = &existing[..bi];
-        let tail = &existing[tail_start..];
-        let mut out = String::with_capacity(head.len() + block.len() + tail.len());
-        out.push_str(head);
-        out.push_str(&block);
-        out.push_str(tail);
-        return out;
-    }
-    let mut out = String::new();
-    out.push_str(existing);
-    if !existing.is_empty() && !existing.ends_with('\n') {
-        out.push('\n');
-    }
-    if !existing.is_empty() {
-        out.push('\n');
-    }
-    out.push_str(&block);
-    out
-}
-
-fn strip_block(existing: &str, begin: &str, end: &str) -> String {
-    if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
-        let ei_end = ei + end.len();
-        let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
-            ei_end + 1
-        } else {
-            ei_end
-        };
-        let mut out = String::new();
-        out.push_str(&existing[..bi]);
-        out.push_str(&existing[tail_start..]);
-        return out.trim_end_matches('\n').to_owned() + "\n";
-    }
-    existing.to_owned()
-}
-
-#[tauri::command]
-pub fn memory_install_pointers(
-    workspace_cwd: String,
-    agents: Vec<String>,
-) -> Result<Vec<PointerResult>, String> {
-    let ws = validate_workspace_cwd(&workspace_cwd)?;
-    let _ = ensure_workspace_memory(&workspace_cwd)?;
-    let notes = memory_list(workspace_cwd.clone()).unwrap_or_default();
-    let mut results: Vec<PointerResult> = Vec::new();
-    let mut written_files: BTreeSet<String> = BTreeSet::new();
-    for agent in agents {
-        let Some(fname) = pointer_filename(&agent) else {
-            results.push(PointerResult {
-                agent,
-                path: String::new(),
-                installed: false,
-                note: Some("unknown agent".into()),
-            });
-            continue;
-        };
-        let path = ws.join(fname);
-        if written_files.contains(fname) {
-            // codex+opencode share AGENTS.md; report second one as skipped
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some("shared file already handled".into()),
-            });
-            continue;
-        }
-        if !path.exists() {
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some(
-                    "skipped: file absent; blxcode does not auto-create root pointer files".into(),
-                ),
-            });
-            written_files.insert(fname.to_owned());
-            continue;
-        }
-        let cursor_style = agent == "cursor";
-        let body = pointer_body(&ws, &notes, cursor_style);
-        let (begin, end) = if cursor_style {
-            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
-        } else {
-            (POINTER_BEGIN, POINTER_END)
-        };
-        let existing = fs::read_to_string(&path).unwrap_or_default();
-        if !existing.contains(begin) {
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some(
-                    "skipped: existing file is user-owned and has no blxcode managed block".into(),
-                ),
-            });
-            written_files.insert(fname.to_owned());
-            continue;
-        }
-        let updated = splice_block(&existing, begin, end, &body);
-        match fs::write(&path, updated.as_bytes()) {
-            Ok(()) => {
-                written_files.insert(fname.to_owned());
-                results.push(PointerResult {
-                    agent,
-                    path: path.to_string_lossy().into_owned(),
-                    installed: true,
-                    note: None,
-                });
-            }
-            Err(e) => results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some(format!("write failed: {e}")),
-            }),
-        }
-    }
-    Ok(results)
-}
-
-#[tauri::command]
-pub fn memory_uninstall_pointers(
-    workspace_cwd: String,
-    agents: Vec<String>,
-) -> Result<Vec<PointerResult>, String> {
-    let ws = validate_workspace_cwd(&workspace_cwd)?;
-    let mut results = Vec::new();
-    let mut handled: BTreeSet<String> = BTreeSet::new();
-    for agent in agents {
-        let Some(fname) = pointer_filename(&agent) else {
-            results.push(PointerResult {
-                agent,
-                path: String::new(),
-                installed: false,
-                note: Some("unknown agent".into()),
-            });
-            continue;
-        };
-        if handled.contains(fname) {
-            results.push(PointerResult {
-                agent,
-                path: ws.join(fname).to_string_lossy().into_owned(),
-                installed: false,
-                note: Some("shared file already cleaned".into()),
-            });
-            continue;
-        }
-        let path = ws.join(fname);
-        let cursor_style = agent == "cursor";
-        let (begin, end) = if cursor_style {
-            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
-        } else {
-            (POINTER_BEGIN, POINTER_END)
-        };
-        let existing = fs::read_to_string(&path).unwrap_or_default();
-        if existing.is_empty() {
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some("no file".into()),
-            });
-            continue;
-        }
-        let stripped = strip_block(&existing, begin, end);
-        if stripped.trim().is_empty() {
-            let _ = fs::remove_file(&path);
-        } else if let Err(e) = fs::write(&path, stripped.as_bytes()) {
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some(format!("write failed: {e}")),
-            });
-            continue;
-        }
-        handled.insert(fname.to_owned());
-        results.push(PointerResult {
-            agent,
-            path: path.to_string_lossy().into_owned(),
-            installed: false,
-            note: Some("removed".into()),
-        });
-    }
-    Ok(results)
-}
-
-#[tauri::command]
-pub fn memory_pointer_status(workspace_cwd: String) -> Result<Vec<PointerResult>, String> {
-    let ws = validate_workspace_cwd(&workspace_cwd)?;
-    let agents = ["claude", "codex", "gemini", "cursor", "opencode"];
-    let mut out = Vec::new();
-    for a in agents {
-        let Some(fname) = pointer_filename(a) else {
-            continue;
-        };
-        let path = ws.join(fname);
-        let body = fs::read_to_string(&path).unwrap_or_default();
-        let cursor_style = a == "cursor";
-        let begin = if cursor_style {
-            POINTER_BEGIN_CURSOR
-        } else {
-            POINTER_BEGIN
-        };
-        let installed = body.contains(begin);
-        out.push(PointerResult {
-            agent: a.to_owned(),
-            path: path.to_string_lossy().into_owned(),
-            installed,
-            note: None,
-        });
-    }
-    Ok(out)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::agents_layout::{LEGACY_MEMORY_REL, LEARNINGS_REL};
-
-    #[test]
-    fn safe_join_rejects_traversal() {
-        let tmp = std::env::temp_dir().join("blxcode_memtest_safe");
-        let _ = fs::create_dir_all(&tmp);
-        assert!(safe_join(&tmp, "../etc/passwd", false).is_err());
-        // Leading slash is stripped and treated as relative — the safety
-        // invariant is "result stays under root", not "reject the input".
-        assert!(safe_join(&tmp, "/abs/note.md", true).is_ok());
-        assert!(safe_join(&tmp, "ok/file.md", true).is_ok());
-        assert!(safe_join(&tmp, "ok/file.txt", true).is_err());
-        assert!(safe_join(&tmp, "ok/../../../etc/passwd", true).is_err());
-    }
-
-    #[test]
-    fn rewrite_wikilinks_basic() {
-        let body = "see [[Old]] and [[Old|label]] but not [[Other]]";
-        let (out, n) = rewrite_wikilinks(body, "Old", "New", "Old.md", "New.md");
-        assert_eq!(n, 2);
-        assert!(out.contains("[[New]]"));
-        assert!(out.contains("[[New|label]]"));
-        assert!(out.contains("[[Other]]"));
-    }
-
-    #[test]
-    fn parse_tags_skips_headings() {
-        let (_, tags) = parse_links_and_tags("# Heading\n\nText with #foo and #bar-baz here");
-        assert!(tags.contains(&"foo".to_owned()));
-        assert!(tags.contains(&"bar-baz".to_owned()));
-        assert!(!tags.iter().any(|t| t == "Heading"));
-    }
-
-    #[test]
-    fn memory_list_includes_learnings_and_legacy_migrates() {
-        let ws = std::env::temp_dir().join(format!(
-            "blxcode_mem_multi_{}_{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        let _ = fs::remove_dir_all(&ws);
-        fs::create_dir_all(&ws).unwrap();
-        fs::create_dir_all(ws.join(LEARNINGS_REL)).unwrap();
-        fs::write(
-            ws.join(LEARNINGS_REL).join("LEARNINGS.md"),
-            "## Index\n\n- [Topic](topic.md)\n",
-        )
-        .unwrap();
-        fs::write(ws.join(LEARNINGS_REL).join("topic.md"), "# Topic").unwrap();
-        fs::create_dir_all(ws.join(LEGACY_MEMORY_REL)).unwrap();
-        fs::write(ws.join(LEGACY_MEMORY_REL).join("legacy.md"), "old").unwrap();
-
-        let cwd = ws.to_string_lossy().into_owned();
-        let list = memory_list(cwd.clone()).unwrap();
-        assert!(list.iter().any(|n| n.path == "learnings/topic.md"));
-        assert!(list.iter().any(|n| n.path == "legacy.md"));
-
-        let g = memory_graph(cwd).unwrap();
-        assert!(g.edges.iter().any(|e| e.source.contains("LEARNINGS") || e.target.contains("topic")));
-
-        let _ = fs::remove_dir_all(&ws);
-    }
-
-    #[test]
-    fn install_pointers_does_not_create_missing_root_files() {
-        let ws = std::env::temp_dir().join(format!(
-            "blxcode_memtest_no_create_{}_{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        fs::create_dir_all(&ws).unwrap();
-
-        let out = memory_install_pointers(
-            ws.to_string_lossy().into_owned(),
-            vec!["claude".into(), "codex".into()],
-        )
-        .unwrap();
-
-        assert!(!ws.join("CLAUDE.md").exists());
-        assert!(!ws.join("AGENTS.md").exists());
-        assert!(out.iter().all(|r| !r.installed));
-    }
-
-    #[test]
-    fn install_pointers_does_not_touch_unmanaged_existing_files() {
-        let ws = std::env::temp_dir().join(format!(
-            "blxcode_memtest_unmanaged_{}_{}",
-            std::process::id(),
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_nanos()
-        ));
-        fs::create_dir_all(&ws).unwrap();
-        let agents = ws.join("AGENTS.md");
-        fs::write(&agents, "# user content\n").unwrap();
-
-        let before = fs::read_to_string(&agents).unwrap();
-        let out = memory_install_pointers(ws.to_string_lossy().into_owned(), vec!["codex".into()])
-            .unwrap();
-        let after = fs::read_to_string(&agents).unwrap();
-
-        assert_eq!(before, after);
-        assert_eq!(out.len(), 1);
-        assert!(!out[0].installed);
-    }
-}
diff --git a/src-tauri/src/memory/frontmatter.rs b/src-tauri/src/memory/frontmatter.rs
new file mode 100644
index 0000000..a101406
--- /dev/null
+++ b/src-tauri/src/memory/frontmatter.rs
@@ -0,0 +1,87 @@
+/// Minimal YAML-frontmatter subset used in memory notes.
+///
+/// Only `title`, `enabled`, and `tags` are parsed; everything else is ignored.
+/// The delimiter is `---` on its own line.
+
+#[derive(Debug, Default, Clone)]
+pub struct MemoryFrontmatter {
+    pub title: Option<String>,
+    pub enabled: Option<bool>,
+    pub tags: Option<Vec<String>>,
+}
+
+pub fn parse_frontmatter(body: &str) -> (MemoryFrontmatter, String) {
+    if !body.starts_with("---") {
+        return (MemoryFrontmatter::default(), body.to_owned());
+    }
+    let rest = &body[3..];
+    let end = match rest.find("\n---") {
+        Some(i) => i,
+        None => return (MemoryFrontmatter::default(), body.to_owned()),
+    };
+    let raw = &rest[..end];
+    let body_rest = &rest[end + 4..];
+    let body_rest = body_rest.strip_prefix('\n').unwrap_or(body_rest);
+
+    let mut fm = MemoryFrontmatter::default();
+    for line in raw.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() || trimmed.starts_with('#') {
+            continue;
+        }
+        let Some(colon) = trimmed.find(':') else {
+            continue;
+        };
+        if colon == 0 {
+            continue;
+        }
+        let key = trimmed[..colon].trim();
+        let value = trimmed[colon + 1..].trim();
+        match key {
+            "title" => {
+                fm.title = Some(value.trim_matches(|c| c == '"' || c == '\'').to_owned());
+            }
+            "enabled" => {
+                fm.enabled = Some(value == "true");
+            }
+            "tags" => {
+                if value.starts_with('[') && value.ends_with(']') {
+                    let inner = &value[1..value.len() - 1];
+                    fm.tags = Some(
+                        inner
+                            .split(',')
+                            .map(|t| t.trim().trim_matches(|c| c == '"' || c == '\'').to_owned())
+                            .filter(|t| !t.is_empty())
+                            .collect(),
+                    );
+                }
+            }
+            _ => {}
+        }
+    }
+    (fm, body_rest.to_owned())
+}
+
+pub fn serialize_frontmatter(fm: &MemoryFrontmatter, body: &str) -> String {
+    let mut lines = vec!["---".to_owned()];
+    if let Some(t) = &fm.title {
+        lines.push(format!("title: {t}"));
+    }
+    if let Some(e) = fm.enabled {
+        lines.push(format!("enabled: {e}"));
+    }
+    if let Some(tags) = &fm.tags {
+        let rendered = tags
+            .iter()
+            .map(|t| format!("\"{t}\""))
+            .collect::<Vec<_>>()
+            .join(", ");
+        lines.push(format!("tags: [{rendered}]"));
+    }
+    lines.push("---".to_owned());
+    format!("{}\n{body}", lines.join("\n"))
+}
+
+pub fn strip_frontmatter(body: &str) -> String {
+    parse_frontmatter(body).1
+}
diff --git a/src-tauri/src/memory/graph.rs b/src-tauri/src/memory/graph.rs
new file mode 100644
index 0000000..7a7d194
--- /dev/null
+++ b/src-tauri/src/memory/graph.rs
@@ -0,0 +1,153 @@
+use std::collections::{BTreeSet, HashMap};
+
+use super::frontmatter::strip_frontmatter;
+use super::paths::{category_hub_node_id, category_hub_path, graph_category_for, node_id};
+use super::types::{GraphData, GraphEdge, GraphNode, MemoryScope};
+use super::wikilinks::{parse_links_and_tags, resolve_link_target};
+
+pub struct ScopeNote {
+    pub scope: MemoryScope,
+    pub path: String,
+    pub body: String,
+    pub label: String,
+}
+
+pub struct CategoryHubInput {
+    pub category: String,
+    pub label: String,
+    pub scopes: Vec<MemoryScope>,
+}
+
+pub fn build_graph(notes: Vec<ScopeNote>, category_hubs: Vec<CategoryHubInput>) -> GraphData {
+    let mut scope_paths: HashMap<MemoryScope, Vec<String>> = HashMap::new();
+    for n in &notes {
+        scope_paths
+            .entry(n.scope.clone())
+            .or_default()
+            .push(n.path.clone());
+    }
+
+    let mut nodes: Vec<GraphNode> = notes
+        .iter()
+        .map(|n| {
+            let body = strip_frontmatter(&n.body);
+            let pr = parse_links_and_tags(&body);
+            GraphNode {
+                id: node_id(&n.scope, &n.path),
+                scope: n.scope.clone(),
+                path: n.path.clone(),
+                label: n.label.clone(),
+                tags: pr.tags,
+                orphan: true,
+                category: graph_category_for(&n.path),
+                is_category_hub: None,
+                hub_scopes: None,
+            }
+        })
+        .collect();
+
+    let mut hub_ids: BTreeSet<String> = BTreeSet::new();
+    for hub in &category_hubs {
+        let id = category_hub_node_id(&hub.category);
+        if hub_ids.contains(&id) {
+            continue;
+        }
+        hub_ids.insert(id.clone());
+        let scope = if hub.scopes.contains(&MemoryScope::Workspace) {
+            MemoryScope::Workspace
+        } else {
+            hub.scopes
+                .first()
+                .cloned()
+                .unwrap_or(MemoryScope::Workspace)
+        };
+        nodes.push(GraphNode {
+            id,
+            scope,
+            path: category_hub_path(&hub.category),
+            label: hub.label.clone(),
+            tags: Vec::new(),
+            orphan: false,
+            category: hub.category.clone(),
+            is_category_hub: Some(true),
+            hub_scopes: Some(hub.scopes.clone()),
+        });
+    }
+
+    let node_set: BTreeSet<String> = nodes.iter().map(|n| n.id.clone()).collect();
+    let hub_id_set: BTreeSet<String> = nodes
+        .iter()
+        .filter(|n| n.is_category_hub.unwrap_or(false))
+        .map(|n| n.id.clone())
+        .collect();
+
+    let mut edges: Vec<GraphEdge> = Vec::new();
+    let mut edge_keys: BTreeSet<String> = BTreeSet::new();
+
+    for note in &notes {
+        let body = strip_frontmatter(&note.body);
+        let pr = parse_links_and_tags(&body);
+        let source_id = node_id(&note.scope, &note.path);
+        for link in &pr.links {
+            let Some((target_scope, target_path)) =
+                resolve_link_target(&note.scope, link, &scope_paths)
+            else {
+                continue;
+            };
+            let target_id = node_id(&target_scope, &target_path);
+            if !node_set.contains(&target_id) || hub_id_set.contains(&target_id) {
+                continue;
+            }
+            let key = format!("{source_id}->{target_id}");
+            if edge_keys.contains(&key) {
+                continue;
+            }
+            edge_keys.insert(key);
+            let cross_scope = note.scope != target_scope;
+            edges.push(GraphEdge {
+                source: source_id.clone(),
+                target: target_id,
+                cross_scope,
+            });
+        }
+    }
+
+    // Note → hub edges
+    for note in &notes {
+        let note_id = node_id(&note.scope, &note.path);
+        let cat = graph_category_for(&note.path);
+        if cat == "memory" {
+            continue;
+        }
+        let hub_id = category_hub_node_id(&cat);
+        if !hub_id_set.contains(&hub_id) {
+            continue;
+        }
+        let key = format!("{note_id}->{hub_id}");
+        if edge_keys.contains(&key) {
+            continue;
+        }
+        edge_keys.insert(key);
+        edges.push(GraphEdge {
+            source: note_id,
+            target: hub_id,
+            cross_scope: false,
+        });
+    }
+
+    // Mark orphan nodes
+    let mut connected: BTreeSet<String> = BTreeSet::new();
+    for e in &edges {
+        connected.insert(e.source.clone());
+        connected.insert(e.target.clone());
+    }
+    for n in nodes.iter_mut() {
+        if n.is_category_hub.unwrap_or(false) {
+            n.orphan = false;
+            continue;
+        }
+        n.orphan = !connected.contains(&n.id);
+    }
+
+    GraphData { nodes, edges }
+}
diff --git a/src-tauri/src/memory/mod.rs b/src-tauri/src/memory/mod.rs
new file mode 100644
index 0000000..7056324
--- /dev/null
+++ b/src-tauri/src/memory/mod.rs
@@ -0,0 +1,178 @@
+//! Obsidian-style memory system with workspace + global scope.
+//!
+//! Layout:
+//! ```text
+//! <workspace>/.agents/memory/      workspace notes
+//! <workspace>/.agents/learnings/   workspace learnings (API: `learnings/…`)
+//! ~/.blxcode/memory/               global notes
+//! ~/.blxcode/learnings/            global learnings
+//! ```
+//!
+//! Node IDs: `{scope}:{api_path}` (e.g. `workspace:decisions/note.md`)
+
+mod frontmatter;
+mod graph;
+pub mod paths;
+mod store;
+mod types;
+pub mod wikilinks;
+
+pub use types::*;
+
+use crate::agents_layout::ensure_agents_layout;
+use store::{
+    collect_notes, memory_backlinks_impl, memory_bootstrap_impl, memory_create_category_impl,
+    memory_create_impl, memory_delete_impl, memory_export_impl, memory_graph_impl,
+    memory_import_impl, memory_install_pointers_impl, memory_list_impl, memory_pointer_status_impl,
+    memory_read_impl, memory_rename_impl, memory_search_impl, memory_status_impl,
+    memory_uninstall_pointers_impl, memory_write_impl,
+};
+
+// ── Bootstrap / status ────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn workspace_ensure_agents(workspace_cwd: String) -> Result<(), String> {
+    ensure_agents_layout(&workspace_cwd)?;
+    Ok(())
+}
+
+#[tauri::command]
+pub fn memory_status(workspace_cwd: String) -> Result<MemoryStatusResponse, String> {
+    Ok(memory_status_impl(&workspace_cwd))
+}
+
+#[tauri::command]
+pub fn memory_bootstrap(workspace_cwd: String, target: String) -> Result<(), String> {
+    memory_bootstrap_impl(&target, &workspace_cwd)
+}
+
+// ── List ──────────────────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn memory_list(workspace_cwd: String) -> Result<MemoryListResponse, String> {
+    Ok(memory_list_impl(&workspace_cwd))
+}
+
+// ── CRUD ──────────────────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn memory_read(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    path: String,
+) -> Result<NoteContent, String> {
+    memory_read_impl(&scope, &workspace_cwd, &path)
+}
+
+#[tauri::command]
+pub fn memory_write(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    path: String,
+    content: String,
+) -> Result<NoteContent, String> {
+    memory_write_impl(&scope, &workspace_cwd, &path, &content)
+}
+
+#[tauri::command]
+pub fn memory_create(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    path: String,
+    content: Option<String>,
+) -> Result<NoteMeta, String> {
+    memory_create_impl(&scope, &workspace_cwd, &path, content)
+}
+
+#[tauri::command]
+pub fn memory_delete(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    path: String,
+) -> Result<(), String> {
+    memory_delete_impl(&scope, &workspace_cwd, &path)
+}
+
+#[tauri::command]
+pub fn memory_rename(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    old_path: String,
+    new_path: String,
+    rewrite_links: bool,
+) -> Result<RenameReport, String> {
+    memory_rename_impl(&scope, &workspace_cwd, &old_path, &new_path, rewrite_links)
+}
+
+#[tauri::command]
+pub fn memory_create_category(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    name: String,
+) -> Result<String, String> {
+    memory_create_category_impl(&scope, &workspace_cwd, &name)
+}
+
+// ── Graph, backlinks, search ──────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn memory_graph(workspace_cwd: String) -> Result<GraphData, String> {
+    memory_graph_impl(&workspace_cwd)
+}
+
+#[tauri::command]
+pub fn memory_backlinks(
+    workspace_cwd: String,
+    scope: MemoryScope,
+    path: String,
+) -> Result<Vec<BacklinkRef>, String> {
+    memory_backlinks_impl(&scope, &workspace_cwd, &path)
+}
+
+#[tauri::command]
+pub fn memory_search(workspace_cwd: String, query: String) -> Result<Vec<SearchHit>, String> {
+    memory_search_impl(&workspace_cwd, &query)
+}
+
+// ── Export / Import ───────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn memory_export(workspace_cwd: String, dest_dir: String) -> Result<u32, String> {
+    memory_export_impl(&workspace_cwd, &dest_dir)
+}
+
+#[tauri::command]
+pub fn memory_import(workspace_cwd: String, src_dir: String) -> Result<u32, String> {
+    memory_import_impl(&workspace_cwd, &src_dir)
+}
+
+// ── Pointer files ─────────────────────────────────────────────────────────────
+
+#[tauri::command]
+pub fn memory_install_pointers(
+    workspace_cwd: String,
+    agents: Vec<String>,
+) -> Result<Vec<PointerResult>, String> {
+    memory_install_pointers_impl(&workspace_cwd, agents)
+}
+
+#[tauri::command]
+pub fn memory_uninstall_pointers(
+    workspace_cwd: String,
+    agents: Vec<String>,
+) -> Result<Vec<PointerResult>, String> {
+    memory_uninstall_pointers_impl(&workspace_cwd, agents)
+}
+
+#[tauri::command]
+pub fn memory_pointer_status(workspace_cwd: String) -> Result<Vec<PointerResult>, String> {
+    memory_pointer_status_impl(&workspace_cwd)
+}
+
+// ── Legacy stub (kept for binary compatibility) ───────────────────────────────
+
+#[tauri::command]
+pub fn memory_root(workspace_cwd: String) -> Result<String, String> {
+    let roots = paths::get_workspace_roots(&workspace_cwd)?;
+    Ok(roots.memory.to_string_lossy().into_owned())
+}
diff --git a/src-tauri/src/memory/paths.rs b/src-tauri/src/memory/paths.rs
new file mode 100644
index 0000000..0b0d97f
--- /dev/null
+++ b/src-tauri/src/memory/paths.rs
@@ -0,0 +1,153 @@
+use crate::agents_layout::{
+    validate_workspace_cwd, LEARNINGS_API_PREFIX, LEARNINGS_REL, MEMORY_REL,
+};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use super::types::MemoryScope;
+
+pub const TEMPLATES_DIRNAME: &str = "_templates";
+pub const CATEGORY_PLACEHOLDER: &str = ".gitkeep";
+pub const CATEGORY_HUB_ID_PREFIX: &str = "hub:";
+pub const CATEGORY_HUB_PATH_PREFIX: &str = "@category/";
+
+#[derive(Debug, Clone)]
+pub struct MemoryRoots {
+    pub memory: PathBuf,
+    pub learnings: PathBuf,
+}
+
+pub fn home_dir() -> PathBuf {
+    dirs::home_dir().unwrap_or_else(|| PathBuf::from("/"))
+}
+
+pub fn get_global_roots() -> MemoryRoots {
+    let base = home_dir().join(".blxcode");
+    MemoryRoots {
+        memory: base.join("memory"),
+        learnings: base.join("learnings"),
+    }
+}
+
+pub fn get_workspace_roots(ws: &str) -> Result<MemoryRoots, String> {
+    let path = validate_workspace_cwd(ws)?;
+    Ok(MemoryRoots {
+        memory: path.join(MEMORY_REL),
+        learnings: path.join(LEARNINGS_REL),
+    })
+}
+
+pub fn get_roots_for_scope(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+) -> Result<MemoryRoots, String> {
+    match scope {
+        MemoryScope::Global => Ok(get_global_roots()),
+        MemoryScope::Workspace => get_workspace_roots(workspace_cwd),
+    }
+}
+
+pub fn folder_exists(dir: &Path) -> bool {
+    dir.is_dir()
+}
+
+pub fn node_id(scope: &MemoryScope, api_path: &str) -> String {
+    let s = scope_str(scope);
+    format!("{s}:{api_path}")
+}
+
+pub fn scope_str(scope: &MemoryScope) -> &'static str {
+    match scope {
+        MemoryScope::Workspace => "workspace",
+        MemoryScope::Global => "global",
+    }
+}
+
+pub fn parse_node_id(id: &str) -> Option<(MemoryScope, String)> {
+    let idx = id.find(':')?;
+    if idx == 0 {
+        return None;
+    }
+    let scope = match &id[..idx] {
+        "workspace" => MemoryScope::Workspace,
+        "global" => MemoryScope::Global,
+        _ => return None,
+    };
+    Some((scope, id[idx + 1..].to_owned()))
+}
+
+pub fn graph_category_for(api_path: &str) -> String {
+    if api_path.starts_with(LEARNINGS_API_PREFIX) {
+        return "learnings".to_string();
+    }
+    if let Some((head, _)) = api_path.split_once('/') {
+        if !head.is_empty() && !head.ends_with(".md") {
+            return head.to_string();
+        }
+    }
+    "memory".to_string()
+}
+
+pub fn list_memory_subcategories(memory_root: &Path) -> Vec<String> {
+    if !memory_root.is_dir() {
+        return Vec::new();
+    }
+    let mut out = Vec::new();
+    let Ok(read) = fs::read_dir(memory_root) else {
+        return out;
+    };
+    for entry in read.flatten() {
+        let Ok(ft) = entry.file_type() else { continue };
+        if !ft.is_dir() {
+            continue;
+        }
+        let Some(name) = entry.file_name().to_str().map(str::to_owned) else {
+            continue;
+        };
+        if name.starts_with('.') || name.eq_ignore_ascii_case(TEMPLATES_DIRNAME) {
+            continue;
+        }
+        out.push(name);
+    }
+    out.sort_unstable_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));
+    out
+}
+
+pub fn validate_category_name(name: &str) -> Result<String, String> {
+    let trimmed = name.trim();
+    if trimmed.is_empty() {
+        return Err("empty category name".into());
+    }
+    if trimmed.contains('/')
+        || trimmed.contains('\\')
+        || trimmed.contains("..")
+        || trimmed.starts_with('.')
+    {
+        return Err("invalid category name".into());
+    }
+    if is_reserved_category(trimmed) {
+        return Err(format!("reserved category name: {trimmed}"));
+    }
+    Ok(trimmed.to_owned())
+}
+
+fn is_reserved_category(name: &str) -> bool {
+    name.eq_ignore_ascii_case(TEMPLATES_DIRNAME)
+        || name.eq_ignore_ascii_case("memory")
+        || name.eq_ignore_ascii_case("learnings")
+}
+
+pub fn category_hub_node_id(category: &str) -> String {
+    format!("{CATEGORY_HUB_ID_PREFIX}{category}")
+}
+
+pub fn category_hub_path(category: &str) -> String {
+    format!("{CATEGORY_HUB_PATH_PREFIX}{category}")
+}
+
+pub fn overview_path_for_category(category: &str) -> String {
+    if category == "learnings" {
+        return format!("{LEARNINGS_API_PREFIX}README.md");
+    }
+    format!("{category}/README.md")
+}
diff --git a/src-tauri/src/memory/store.rs b/src-tauri/src/memory/store.rs
new file mode 100644
index 0000000..59caafe
--- /dev/null
+++ b/src-tauri/src/memory/store.rs
@@ -0,0 +1,1092 @@
+//! Core CRUD helpers — called from #[tauri::command] wrappers in mod.rs.
+
+use crate::agents_layout::{ensure_agents_layout, LEARNINGS_API_PREFIX, LEARNINGS_REL, MEMORY_REL};
+use std::collections::HashMap;
+use std::fs;
+use std::io::Write as IoWrite;
+use std::path::{Component, Path, PathBuf};
+
+use super::frontmatter::{
+    parse_frontmatter, serialize_frontmatter, strip_frontmatter, MemoryFrontmatter,
+};
+use super::graph::{build_graph, CategoryHubInput, ScopeNote};
+use super::paths::{
+    folder_exists, get_global_roots, get_roots_for_scope, graph_category_for,
+    list_memory_subcategories, node_id, parse_node_id, validate_category_name, MemoryRoots,
+    CATEGORY_PLACEHOLDER, TEMPLATES_DIRNAME,
+};
+use super::types::{
+    BacklinkRef, GraphData, MemoryFolderStatus, MemoryListResponse, MemoryScope,
+    MemoryStatusResponse, MemorySubcategories, NoteContent, NoteMeta, PointerResult, RenameReport,
+    SearchHit,
+};
+use super::wikilinks::{parse_links_and_tags, rewrite_wikilinks};
+
+// ── Bootstrap seed text ────────────────────────────────────────────────────────
+
+const MEMORY_OVERVIEW_BODY: &str = r#"# Memory
+
+This folder stores **durable, project-wide notes** that should survive across coding sessions and be available to every AI agent or teammate working in this repo.
+
+## What belongs here
+
+- Architectural decisions and the reasoning behind them
+- Conventions, patterns and "house style" that aren't obvious from the code
+- Reference material: external systems, where to find logs / dashboards
+- Known-good workflows ("how we deploy", "how we cut a release")
+- User-specific preferences for collaboration
+
+## What does **not** belong here
+
+- Ephemeral todos for the current task (use a Plan or task list instead)
+- Things already documented in code, `CLAUDE.md`, or commit messages
+- Time-sensitive snapshots (`git log` is authoritative for history)
+
+## Tips for AI agents
+
+- Read existing notes before answering questions about this project.
+- When you learn something non-obvious, propose adding it here.
+- Prefer updating an existing note over creating a near-duplicate.
+"#;
+
+const LEARNINGS_OVERVIEW_BODY: &str = r#"# Learnings
+
+This folder is a **growing knowledge base of resolved problems** — concrete things you discovered the hard way and want future agents (human or AI) to find.
+
+Each learning is a separate markdown file named `learning-<slug>.md`. Together they form a searchable log of "the thing we now know that we didn't know before."
+
+## When to record a learning
+
+- A bug you fixed that wasn't obvious from the symptom
+- A workaround for a quirk in a dependency, runtime, or environment
+- A migration step that required out-of-band knowledge
+
+## Tips for AI agents
+
+- Search here before debugging — someone may have hit this already.
+- When you fix a non-trivial bug, propose a new learning entry.
+- Keep one learning per file; cross-link related ones via `[[wikilinks]]`.
+"#;
+
+// ── Path helpers ───────────────────────────────────────────────────────────────
+
+fn err<T>(s: impl Into<String>) -> Result<T, String> {
+    Err(s.into())
+}
+
+fn mtime_secs(p: &Path) -> i64 {
+    fs::metadata(p)
+        .and_then(|m| m.modified())
+        .ok()
+        .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
+        .map(|d| d.as_secs() as i64)
+        .unwrap_or(0)
+}
+
+fn walk_md(root: &Path, out: &mut Vec<PathBuf>) {
+    let Ok(read) = fs::read_dir(root) else { return };
+    for entry in read.flatten() {
+        let path = entry.path();
+        let Ok(ft) = entry.file_type() else { continue };
+        if ft.is_dir() {
+            walk_md(&path, out);
+            continue;
+        }
+        if ft.is_file() {
+            let is_md = path
+                .extension()
+                .and_then(|e| e.to_str())
+                .map(|e| e.eq_ignore_ascii_case("md"))
+                .unwrap_or(false);
+            if is_md {
+                out.push(path);
+            }
+        }
+    }
+}
+
+fn rel_from_root(root: &Path, p: &Path) -> Option<String> {
+    p.strip_prefix(root)
+        .ok()
+        .map(|rel| rel.to_string_lossy().replace('\\', "/"))
+}
+
+/// Returns (is_learnings, rel_within_root).
+fn resolve_api_path(api_path: &str) -> Result<(bool, String), String> {
+    let p = api_path.trim().replace('\\', "/");
+    if p.is_empty() {
+        return err("empty path");
+    }
+    if p.starts_with(LEARNINGS_API_PREFIX) {
+        let rel = p
+            .strip_prefix(LEARNINGS_API_PREFIX)
+            .unwrap_or_default()
+            .trim();
+        if rel.is_empty() || rel.contains("..") {
+            return err("invalid learnings path");
+        }
+        return Ok((true, rel.to_owned()));
+    }
+    if p.contains("..") {
+        return err("invalid path");
+    }
+    Ok((false, p))
+}
+
+fn note_abs(roots: &MemoryRoots, api_path: &str) -> Result<PathBuf, String> {
+    let (is_learnings, rel) = resolve_api_path(api_path)?;
+    let root = if is_learnings {
+        roots.learnings.as_path()
+    } else {
+        roots.memory.as_path()
+    };
+    safe_join(root, &rel, true)
+}
+
+fn safe_join(root: &Path, rel: &str, enforce_md: bool) -> Result<PathBuf, String> {
+    let rel = rel.trim().trim_start_matches('/').trim_start_matches('\\');
+    if rel.is_empty() {
+        return err("empty relative path");
+    }
+    let normalized = rel.replace('\\', "/");
+    let candidate = PathBuf::from(&normalized);
+    for c in candidate.components() {
+        match c {
+            Component::Normal(_) => {}
+            _ => return err(format!("disallowed path component in {rel}")),
+        }
+    }
+    let abs = root.join(&candidate);
+    let canon_root = fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
+    let canon_abs = abs
+        .parent()
+        .and_then(|p| fs::canonicalize(p).ok())
+        .map(|p| p.join(abs.file_name().unwrap_or_default()))
+        .unwrap_or(abs.clone());
+    if !canon_abs.starts_with(&canon_root) {
+        return err("path escapes memory root");
+    }
+    if enforce_md {
+        let is_md = canon_abs
+            .extension()
+            .and_then(|e| e.to_str())
+            .map(|e| e.eq_ignore_ascii_case("md"))
+            .unwrap_or(false);
+        if !is_md {
+            return err("only .md files allowed");
+        }
+    }
+    Ok(abs)
+}
+
+// ── Note metadata collection ───────────────────────────────────────────────────
+
+fn meta_from_file(scope: &MemoryScope, api_path: &str, abs: &Path) -> Option<NoteMeta> {
+    let content = fs::read_to_string(abs).ok()?;
+    let (fm, body_rest) = parse_frontmatter(&content);
+    let (is_learnings, _) = resolve_api_path(api_path).ok()?;
+    let file_name = Path::new(api_path)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_owned();
+    let basename = Path::new(api_path)
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_owned();
+    let is_overview = basename.eq_ignore_ascii_case("README.md");
+    let is_template = !is_learnings && api_path.starts_with(&format!("{TEMPLATES_DIRNAME}/"));
+    let title = fm
+        .title
+        .clone()
+        .unwrap_or_else(|| extract_h1_title(&body_rest).unwrap_or_else(|| file_name.clone()));
+    let meta = fs::metadata(abs).ok();
+    Some(NoteMeta {
+        scope: scope.clone(),
+        path: api_path.to_owned(),
+        name: file_name,
+        title,
+        enabled: fm.enabled.unwrap_or(true),
+        tags: fm.tags.unwrap_or_default(),
+        size: meta.as_ref().map(|m| m.len()).unwrap_or(0),
+        modified: mtime_secs(abs),
+        is_template,
+        is_learning: is_learnings,
+        is_overview,
+        category: graph_category_for(api_path),
+    })
+}
+
+fn extract_h1_title(body: &str) -> Option<String> {
+    for line in body.lines() {
+        let trimmed = line.trim();
+        if let Some(rest) = trimmed.strip_prefix("# ") {
+            let t = rest.trim();
+            if !t.is_empty() {
+                return Some(t.to_owned());
+            }
+        }
+    }
+    None
+}
+
+pub fn collect_notes(scope: &MemoryScope, workspace_cwd: &str) -> Vec<NoteMeta> {
+    let Ok(roots) = get_roots_for_scope(scope, workspace_cwd) else {
+        return Vec::new();
+    };
+    let mut out = Vec::new();
+    for (is_learnings, root) in [
+        (false, roots.memory.as_path()),
+        (true, roots.learnings.as_path()),
+    ] {
+        let mut files = Vec::new();
+        walk_md(root, &mut files);
+        for abs in files {
+            let Some(rel) = rel_from_root(root, &abs) else {
+                continue;
+            };
+            let api = if is_learnings {
+                format!("{LEARNINGS_API_PREFIX}{rel}")
+            } else {
+                rel
+            };
+            if let Some(meta) = meta_from_file(scope, &api, &abs) {
+                out.push(meta);
+            }
+        }
+    }
+    out.sort_by(|a, b| a.path.to_lowercase().cmp(&b.path.to_lowercase()));
+    out
+}
+
+// ── Status & Bootstrap ────────────────────────────────────────────────────────
+
+pub fn memory_status_impl(workspace_cwd: &str) -> MemoryStatusResponse {
+    let global = get_global_roots();
+    let ws = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd).ok();
+    MemoryStatusResponse {
+        workspace: MemoryFolderStatus {
+            memory: ws
+                .as_ref()
+                .map(|r| folder_exists(&r.memory))
+                .unwrap_or(false),
+            learnings: ws
+                .as_ref()
+                .map(|r| folder_exists(&r.learnings))
+                .unwrap_or(false),
+        },
+        global: MemoryFolderStatus {
+            memory: folder_exists(&global.memory),
+            learnings: folder_exists(&global.learnings),
+        },
+    }
+}
+
+fn seed_memory(memory_dir: &Path) -> Result<(), String> {
+    fs::create_dir_all(memory_dir).map_err(|e| format!("mkdir: {e}"))?;
+    let readme = memory_dir.join("README.md");
+    if !readme.exists() {
+        let fm = MemoryFrontmatter {
+            title: Some("Memory".into()),
+            enabled: Some(true),
+            tags: Some(Vec::new()),
+        };
+        let content = serialize_frontmatter(&fm, MEMORY_OVERVIEW_BODY);
+        fs::write(&readme, content.as_bytes()).map_err(|e| format!("write README: {e}"))?;
+    }
+    Ok(())
+}
+
+fn seed_learnings(learnings_dir: &Path) -> Result<(), String> {
+    fs::create_dir_all(learnings_dir).map_err(|e| format!("mkdir: {e}"))?;
+    let readme = learnings_dir.join("README.md");
+    if !readme.exists() {
+        let fm = MemoryFrontmatter {
+            title: Some("Learnings".into()),
+            enabled: Some(true),
+            tags: Some(Vec::new()),
+        };
+        let content = serialize_frontmatter(&fm, LEARNINGS_OVERVIEW_BODY);
+        fs::write(&readme, content.as_bytes()).map_err(|e| format!("write README: {e}"))?;
+    }
+    Ok(())
+}
+
+pub fn memory_bootstrap_impl(target: &str, workspace_cwd: &str) -> Result<(), String> {
+    match target {
+        "workspace" | "all" => {
+            let roots = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd)?;
+            seed_memory(&roots.memory)?;
+            seed_learnings(&roots.learnings)?;
+            if target == "workspace" {
+                return Ok(());
+            }
+            // fall through for "all"
+            let global = get_global_roots();
+            if let Some(parent) = global.memory.parent() {
+                fs::create_dir_all(parent).map_err(|e| format!("mkdir global base: {e}"))?;
+            }
+            seed_memory(&global.memory)?;
+            seed_learnings(&global.learnings)?;
+        }
+        "global" => {
+            let global = get_global_roots();
+            if let Some(parent) = global.memory.parent() {
+                fs::create_dir_all(parent).map_err(|e| format!("mkdir global base: {e}"))?;
+            }
+            seed_memory(&global.memory)?;
+            seed_learnings(&global.learnings)?;
+        }
+        _ => return err(format!("unknown target: {target}")),
+    }
+    Ok(())
+}
+
+// ── memory_list ────────────────────────────────────────────────────────────────
+
+pub fn memory_list_impl(workspace_cwd: &str) -> MemoryListResponse {
+    // Workspace scope
+    let ws_notes = collect_notes(&MemoryScope::Workspace, workspace_cwd);
+    let ws_cats = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd)
+        .map(|r| list_memory_subcategories(&r.memory))
+        .unwrap_or_default();
+
+    // Global scope
+    let global_roots = get_global_roots();
+    let global_notes =
+        if folder_exists(&global_roots.memory) || folder_exists(&global_roots.learnings) {
+            // collect_notes for global doesn't need workspace_cwd but the function signature takes it;
+            // for global we can pass an empty string and use get_global_roots directly
+            collect_notes_global()
+        } else {
+            Vec::new()
+        };
+    let global_cats = list_memory_subcategories(&global_roots.memory);
+
+    let mut all_notes = ws_notes;
+    all_notes.extend(global_notes);
+
+    MemoryListResponse {
+        notes: all_notes,
+        memory_subcategories: MemorySubcategories {
+            workspace: ws_cats,
+            global: global_cats,
+        },
+    }
+}
+
+fn collect_notes_global() -> Vec<NoteMeta> {
+    let roots = get_global_roots();
+    let mut out = Vec::new();
+    for (is_learnings, root) in [
+        (false, roots.memory.as_path()),
+        (true, roots.learnings.as_path()),
+    ] {
+        let mut files = Vec::new();
+        walk_md(root, &mut files);
+        for abs in files {
+            let Some(rel) = rel_from_root(root, &abs) else {
+                continue;
+            };
+            let api = if is_learnings {
+                format!("{LEARNINGS_API_PREFIX}{rel}")
+            } else {
+                rel
+            };
+            if let Some(meta) = meta_from_file(&MemoryScope::Global, &api, &abs) {
+                out.push(meta);
+            }
+        }
+    }
+    out.sort_by(|a, b| a.path.to_lowercase().cmp(&b.path.to_lowercase()));
+    out
+}
+
+// ── CRUD ──────────────────────────────────────────────────────────────────────
+
+pub fn memory_read_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    path: &str,
+) -> Result<NoteContent, String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let abs = note_abs(&roots, path)?;
+    let content = fs::read_to_string(&abs).map_err(|e| format!("read {path}: {e}"))?;
+    Ok(NoteContent {
+        scope: scope.clone(),
+        path: path.to_owned(),
+        content,
+        modified: mtime_secs(&abs),
+    })
+}
+
+pub fn memory_write_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    path: &str,
+    content: &str,
+) -> Result<NoteContent, String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let abs = note_abs(&roots, path)?;
+    if let Some(parent) = abs.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
+    }
+    let mut file = fs::File::create(&abs).map_err(|e| format!("create {path}: {e}"))?;
+    file.write_all(content.as_bytes())
+        .map_err(|e| format!("write {path}: {e}"))?;
+    Ok(NoteContent {
+        scope: scope.clone(),
+        path: path.to_owned(),
+        content: content.to_owned(),
+        modified: mtime_secs(&abs),
+    })
+}
+
+pub fn memory_create_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    path: &str,
+    content: Option<String>,
+) -> Result<NoteMeta, String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let abs = note_abs(&roots, path)?;
+    if abs.exists() {
+        return err(format!("already exists: {path}"));
+    }
+    if let Some(parent) = abs.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
+    }
+    let body = content.unwrap_or_default();
+    fs::write(&abs, body.as_bytes()).map_err(|e| format!("write {path}: {e}"))?;
+    meta_from_file(scope, path, &abs).ok_or_else(|| format!("failed to read meta for {path}"))
+}
+
+pub fn memory_delete_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    path: &str,
+) -> Result<(), String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let (is_learnings, _) = resolve_api_path(path)?;
+    let root = if is_learnings {
+        &roots.learnings
+    } else {
+        &roots.memory
+    };
+    let abs = note_abs(&roots, path)?;
+    if !abs.exists() {
+        return err(format!("not found: {path}"));
+    }
+    fs::remove_file(&abs).map_err(|e| format!("delete {path}: {e}"))?;
+    // Remove empty parent dirs up to root
+    if let Some(mut parent) = abs.parent() {
+        while parent != root.as_path() {
+            if fs::read_dir(parent)
+                .map(|mut r| r.next().is_none())
+                .unwrap_or(false)
+            {
+                let _ = fs::remove_dir(parent);
+                if let Some(grand) = parent.parent() {
+                    parent = grand;
+                } else {
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub fn memory_rename_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    old_path: &str,
+    new_path: &str,
+    rewrite_links: bool,
+) -> Result<RenameReport, String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let (old_learn, _) = resolve_api_path(old_path)?;
+    let (new_learn, _) = resolve_api_path(new_path)?;
+    if old_learn != new_learn {
+        return err("cannot rename across memory and learnings roots");
+    }
+    let abs_old = note_abs(&roots, old_path)?;
+    let abs_new = note_abs(&roots, new_path)?;
+    if !abs_old.exists() {
+        return err(format!("not found: {old_path}"));
+    }
+    if abs_new.exists() {
+        return err(format!("already exists: {new_path}"));
+    }
+    if let Some(parent) = abs_new.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
+    }
+    fs::rename(&abs_old, &abs_new).map_err(|e| format!("rename: {e}"))?;
+
+    let old_basename = Path::new(old_path)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_owned();
+    let new_basename = Path::new(new_path)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("")
+        .to_owned();
+
+    let mut total_rewrites = 0u32;
+    let mut files_changed = 0u32;
+
+    if rewrite_links && !old_basename.is_empty() && !new_basename.is_empty() {
+        let mut all_files = Vec::new();
+        walk_md(&roots.memory, &mut all_files);
+        walk_md(&roots.learnings, &mut all_files);
+        for f in all_files {
+            let Ok(content) = fs::read_to_string(&f) else {
+                continue;
+            };
+            let (updated, n) =
+                rewrite_wikilinks(&content, &old_basename, &new_basename, old_path, new_path);
+            if n > 0 {
+                if fs::write(&f, updated.as_bytes()).is_ok() {
+                    total_rewrites += n;
+                    files_changed += 1;
+                }
+            }
+        }
+    }
+    Ok(RenameReport {
+        old_path: old_path.to_owned(),
+        new_path: new_path.to_owned(),
+        link_rewrites: total_rewrites,
+        files_changed,
+    })
+}
+
+pub fn memory_create_category_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    name: &str,
+) -> Result<String, String> {
+    let roots = get_roots_for_scope(scope, workspace_cwd)?;
+    let clean = validate_category_name(name)?;
+    let dir = roots.memory.join(&clean);
+    if dir.exists() {
+        return err(format!("already exists: {clean}"));
+    }
+    fs::create_dir_all(&dir).map_err(|e| format!("mkdir: {e}"))?;
+    let _ = fs::write(dir.join(CATEGORY_PLACEHOLDER), b"");
+    Ok(clean)
+}
+
+// ── Graph ─────────────────────────────────────────────────────────────────────
+
+pub fn memory_graph_impl(workspace_cwd: &str) -> Result<GraphData, String> {
+    let ws_roots = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd).ok();
+    let global_roots = get_global_roots();
+
+    let ws_notes = collect_notes(&MemoryScope::Workspace, workspace_cwd);
+    let global_notes = collect_notes_global();
+
+    let mut scope_notes: Vec<ScopeNote> = Vec::new();
+
+    for meta in &ws_notes {
+        if meta.is_template || meta.is_overview {
+            continue;
+        }
+        let body = ws_roots
+            .as_ref()
+            .and_then(|roots| note_abs(roots, &meta.path).ok())
+            .and_then(|abs| fs::read_to_string(&abs).ok())
+            .unwrap_or_default();
+        scope_notes.push(ScopeNote {
+            scope: MemoryScope::Workspace,
+            path: meta.path.clone(),
+            body,
+            label: meta.name.clone(),
+        });
+    }
+
+    for meta in &global_notes {
+        if meta.is_template || meta.is_overview {
+            continue;
+        }
+        let body = note_abs(&global_roots, &meta.path)
+            .ok()
+            .and_then(|abs| fs::read_to_string(&abs).ok())
+            .unwrap_or_default();
+        scope_notes.push(ScopeNote {
+            scope: MemoryScope::Global,
+            path: meta.path.clone(),
+            body,
+            label: meta.name.clone(),
+        });
+    }
+
+    // Build category hubs from unique categories across both scopes
+    let mut cat_scopes: HashMap<String, Vec<MemoryScope>> = HashMap::new();
+    for sn in &scope_notes {
+        let cat = graph_category_for(&sn.path);
+        if cat != "memory" {
+            let entry = cat_scopes.entry(cat).or_default();
+            if !entry.contains(&sn.scope) {
+                entry.push(sn.scope.clone());
+            }
+        }
+    }
+    let category_hubs: Vec<CategoryHubInput> = cat_scopes
+        .into_iter()
+        .map(|(cat, scopes)| CategoryHubInput {
+            label: capitalize_first(&cat),
+            category: cat,
+            scopes,
+        })
+        .collect();
+
+    Ok(build_graph(scope_notes, category_hubs))
+}
+
+fn capitalize_first(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        None => String::new(),
+        Some(c) => c.to_uppercase().collect::<String>() + chars.as_str(),
+    }
+}
+
+// ── Backlinks & Search ────────────────────────────────────────────────────────
+
+pub fn memory_backlinks_impl(
+    scope: &MemoryScope,
+    workspace_cwd: &str,
+    path: &str,
+) -> Result<Vec<BacklinkRef>, String> {
+    let graph = memory_graph_impl(workspace_cwd)?;
+    let target_id = node_id(scope, path);
+    let mut out: Vec<BacklinkRef> = graph
+        .edges
+        .into_iter()
+        .filter_map(|e| {
+            if e.target == target_id {
+                super::paths::parse_node_id(&e.source)
+                    .map(|(s, p)| BacklinkRef { scope: s, path: p })
+            } else {
+                None
+            }
+        })
+        .collect();
+    out.sort_by(|a, b| a.path.cmp(&b.path));
+    out.dedup_by(|a, b| a.path == b.path && a.scope == b.scope);
+    Ok(out)
+}
+
+pub fn memory_search_impl(workspace_cwd: &str, query: &str) -> Result<Vec<SearchHit>, String> {
+    let needle = query.trim();
+    if needle.is_empty() {
+        return Ok(Vec::new());
+    }
+    let needle_l = needle.to_ascii_lowercase();
+    let mut hits: Vec<SearchHit> = Vec::new();
+
+    for scope in [MemoryScope::Workspace, MemoryScope::Global] {
+        let roots = match get_roots_for_scope(&scope, workspace_cwd) {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+        for (is_learnings, root) in [
+            (false, roots.memory.as_path()),
+            (true, roots.learnings.as_path()),
+        ] {
+            let mut files = Vec::new();
+            walk_md(root, &mut files);
+            for abs in files {
+                let Some(rel) = rel_from_root(root, &abs) else {
+                    continue;
+                };
+                let api = if is_learnings {
+                    format!("{LEARNINGS_API_PREFIX}{rel}")
+                } else {
+                    rel
+                };
+                let Ok(body) = fs::read_to_string(&abs) else {
+                    continue;
+                };
+                for (idx, line) in body.lines().enumerate() {
+                    if line.to_ascii_lowercase().contains(&needle_l) {
+                        let snip = if line.len() > 200 { &line[..200] } else { line };
+                        hits.push(SearchHit {
+                            scope: scope.clone(),
+                            path: api.clone(),
+                            line: (idx + 1) as u32,
+                            snippet: snip.to_owned(),
+                            category: graph_category_for(&api),
+                        });
+                        if hits.len() >= 500 {
+                            return Ok(hits);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(hits)
+}
+
+// ── Export / Import ───────────────────────────────────────────────────────────
+
+pub fn memory_export_impl(workspace_cwd: &str, dest_dir: &str) -> Result<u32, String> {
+    let roots = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd)?;
+    let dest = PathBuf::from(dest_dir.trim());
+    if !dest.is_absolute() {
+        return err("dest_dir must be absolute");
+    }
+    fs::create_dir_all(&dest).map_err(|e| format!("mkdir dest: {e}"))?;
+    let mut n = 0u32;
+    for (root, sub) in [
+        (roots.memory.as_path(), "memory"),
+        (roots.learnings.as_path(), "learnings"),
+    ] {
+        let mut files = Vec::new();
+        walk_md(root, &mut files);
+        for f in files {
+            let Some(rel) = rel_from_root(root, &f) else {
+                continue;
+            };
+            let target = dest.join(sub).join(&rel);
+            if let Some(parent) = target.parent() {
+                fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
+            }
+            fs::copy(&f, &target).map_err(|e| format!("copy {rel}: {e}"))?;
+            n += 1;
+        }
+    }
+    Ok(n)
+}
+
+pub fn memory_import_impl(workspace_cwd: &str, src_dir: &str) -> Result<u32, String> {
+    let roots = get_roots_for_scope(&MemoryScope::Workspace, workspace_cwd)?;
+    let src = PathBuf::from(src_dir.trim());
+    if !src.is_absolute() {
+        return err("src_dir must be absolute");
+    }
+    if !src.exists() {
+        return err("src_dir does not exist");
+    }
+    let mut n = 0u32;
+    let learnings_src = src.join("learnings");
+    let memory_src = src.join("memory");
+    if learnings_src.is_dir() {
+        n += import_tree(&learnings_src, &roots.learnings)?;
+    }
+    if memory_src.is_dir() {
+        n += import_tree(&memory_src, &roots.memory)?;
+    } else if !learnings_src.is_dir() {
+        n += import_tree(&src, &roots.memory)?;
+    }
+    Ok(n)
+}
+
+fn import_tree(src: &Path, dest_root: &Path) -> Result<u32, String> {
+    let mut files = Vec::new();
+    walk_md(src, &mut files);
+    let mut n = 0u32;
+    for f in files {
+        let Ok(rel_pb) = f.strip_prefix(src) else {
+            continue;
+        };
+        let rel = rel_pb.to_string_lossy().replace('\\', "/");
+        let abs = match safe_join(dest_root, &rel, true) {
+            Ok(p) => p,
+            Err(_) => continue,
+        };
+        if abs.exists() {
+            continue;
+        }
+        if let Some(parent) = abs.parent() {
+            fs::create_dir_all(parent).map_err(|e| format!("mkdir: {e}"))?;
+        }
+        fs::copy(&f, &abs).map_err(|e| format!("copy {rel}: {e}"))?;
+        n += 1;
+    }
+    Ok(n)
+}
+
+// ── Pointer files ─────────────────────────────────────────────────────────────
+
+const POINTER_BEGIN: &str = "<!-- blxcode-memory:begin -->";
+const POINTER_END: &str = "<!-- blxcode-memory:end -->";
+const POINTER_BEGIN_CURSOR: &str = "# blxcode-memory:begin";
+const POINTER_END_CURSOR: &str = "# blxcode-memory:end";
+
+fn pointer_filename(agent: &str) -> Option<&'static str> {
+    match agent {
+        "claude" => Some("CLAUDE.md"),
+        "codex" => Some("AGENTS.md"),
+        "gemini" => Some("GEMINI.md"),
+        "cursor" => Some(".cursorrules"),
+        "opencode" => Some("AGENTS.md"),
+        _ => None,
+    }
+}
+
+fn pointer_body(workspace_cwd: &Path, notes: &[NoteMeta], cursor_style: bool) -> String {
+    let memory_dir = workspace_cwd.join(MEMORY_REL);
+    let learnings_dir = workspace_cwd.join(LEARNINGS_REL);
+    let mut s = String::new();
+    if cursor_style {
+        s.push_str("blxcode tracks per-workspace memory and learnings at the paths below.\n");
+    } else {
+        s.push_str("## blxcode workspace memory\n\n");
+        s.push_str(
+            "This workspace uses **blxcode** to maintain Markdown notes and learnings \
+shared across all agent sessions. Treat the directories below as authoritative \
+context: read notes that are relevant to the task, and propose new notes \
+or edits when you learn something the team should remember.\n\n",
+        );
+    }
+    s.push_str(&format!("Memory root: `{}`\n", memory_dir.display()));
+    s.push_str(&format!(
+        "Learnings root: `{}` (API paths: `learnings/…`)\n\n",
+        learnings_dir.display()
+    ));
+    let non_template: Vec<_> = notes.iter().filter(|n| !n.is_template).collect();
+    if non_template.is_empty() {
+        s.push_str("(no notes yet)\n");
+    } else {
+        s.push_str("Current notes:\n");
+        let mut shown = 0;
+        for n in &non_template {
+            s.push_str(&format!("- `{}`\n", n.path));
+            shown += 1;
+            if shown >= 80 {
+                s.push_str(&format!("- … and {} more\n", non_template.len() - shown));
+                break;
+            }
+        }
+    }
+    s.push('\n');
+    s
+}
+
+fn splice_block(existing: &str, begin: &str, end: &str, new_body: &str) -> String {
+    let block = format!("{begin}\n{new_body}{end}\n");
+    if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
+        let ei_end = ei + end.len();
+        let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
+            ei_end + 1
+        } else {
+            ei_end
+        };
+        let mut out = String::with_capacity(bi + block.len() + existing.len() - tail_start);
+        out.push_str(&existing[..bi]);
+        out.push_str(&block);
+        out.push_str(&existing[tail_start..]);
+        return out;
+    }
+    let mut out = String::new();
+    out.push_str(existing);
+    if !existing.is_empty() && !existing.ends_with('\n') {
+        out.push('\n');
+    }
+    if !existing.is_empty() {
+        out.push('\n');
+    }
+    out.push_str(&block);
+    out
+}
+
+fn strip_block(existing: &str, begin: &str, end: &str) -> String {
+    if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
+        let ei_end = ei + end.len();
+        let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
+            ei_end + 1
+        } else {
+            ei_end
+        };
+        let mut out = String::new();
+        out.push_str(&existing[..bi]);
+        out.push_str(&existing[tail_start..]);
+        return out.trim_end_matches('\n').to_owned() + "\n";
+    }
+    existing.to_owned()
+}
+
+pub fn memory_install_pointers_impl(
+    workspace_cwd: &str,
+    agents: Vec<String>,
+) -> Result<Vec<PointerResult>, String> {
+    use crate::agents_layout::validate_workspace_cwd;
+    let ws = validate_workspace_cwd(workspace_cwd)?;
+    let notes = collect_notes(&MemoryScope::Workspace, workspace_cwd);
+    let mut results: Vec<PointerResult> = Vec::new();
+    let mut written: std::collections::BTreeSet<String> = Default::default();
+    for agent in agents {
+        let Some(fname) = pointer_filename(&agent) else {
+            results.push(PointerResult {
+                agent,
+                path: String::new(),
+                installed: false,
+                note: Some("unknown agent".into()),
+            });
+            continue;
+        };
+        let path = ws.join(fname);
+        if written.contains(fname) {
+            results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some("shared file already handled".into()),
+            });
+            continue;
+        }
+        if !path.exists() {
+            results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some(
+                    "skipped: file absent; blxcode does not auto-create root pointer files".into(),
+                ),
+            });
+            written.insert(fname.to_owned());
+            continue;
+        }
+        let cursor_style = agent == "cursor";
+        let body = pointer_body(&ws, &notes, cursor_style);
+        let (begin, end) = if cursor_style {
+            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
+        } else {
+            (POINTER_BEGIN, POINTER_END)
+        };
+        let existing = fs::read_to_string(&path).unwrap_or_default();
+        if !existing.contains(begin) {
+            results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some(
+                    "skipped: existing file is user-owned and has no blxcode managed block".into(),
+                ),
+            });
+            written.insert(fname.to_owned());
+            continue;
+        }
+        let updated = splice_block(&existing, begin, end, &body);
+        match fs::write(&path, updated.as_bytes()) {
+            Ok(()) => {
+                written.insert(fname.to_owned());
+                results.push(PointerResult {
+                    agent,
+                    path: path.to_string_lossy().into_owned(),
+                    installed: true,
+                    note: None,
+                });
+            }
+            Err(e) => results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some(format!("write failed: {e}")),
+            }),
+        }
+    }
+    Ok(results)
+}
+
+pub fn memory_uninstall_pointers_impl(
+    workspace_cwd: &str,
+    agents: Vec<String>,
+) -> Result<Vec<PointerResult>, String> {
+    use crate::agents_layout::validate_workspace_cwd;
+    let ws = validate_workspace_cwd(workspace_cwd)?;
+    let mut results = Vec::new();
+    let mut handled: std::collections::BTreeSet<String> = Default::default();
+    for agent in agents {
+        let Some(fname) = pointer_filename(&agent) else {
+            results.push(PointerResult {
+                agent,
+                path: String::new(),
+                installed: false,
+                note: Some("unknown agent".into()),
+            });
+            continue;
+        };
+        if handled.contains(fname) {
+            results.push(PointerResult {
+                agent,
+                path: ws.join(fname).to_string_lossy().into_owned(),
+                installed: false,
+                note: Some("shared file already cleaned".into()),
+            });
+            continue;
+        }
+        let path = ws.join(fname);
+        let cursor_style = agent == "cursor";
+        let (begin, end) = if cursor_style {
+            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
+        } else {
+            (POINTER_BEGIN, POINTER_END)
+        };
+        let existing = fs::read_to_string(&path).unwrap_or_default();
+        if existing.is_empty() {
+            results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some("no file".into()),
+            });
+            continue;
+        }
+        let stripped = strip_block(&existing, begin, end);
+        if stripped.trim().is_empty() {
+            let _ = fs::remove_file(&path);
+        } else if let Err(e) = fs::write(&path, stripped.as_bytes()) {
+            results.push(PointerResult {
+                agent,
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some(format!("write failed: {e}")),
+            });
+            continue;
+        }
+        handled.insert(fname.to_owned());
+        results.push(PointerResult {
+            agent,
+            path: path.to_string_lossy().into_owned(),
+            installed: false,
+            note: Some("removed".into()),
+        });
+    }
+    Ok(results)
+}
+
+pub fn memory_pointer_status_impl(workspace_cwd: &str) -> Result<Vec<PointerResult>, String> {
+    use crate::agents_layout::validate_workspace_cwd;
+    let ws = validate_workspace_cwd(workspace_cwd)?;
+    let agents = ["claude", "codex", "gemini", "cursor", "opencode"];
+    let mut out = Vec::new();
+    for a in agents {
+        let Some(fname) = pointer_filename(a) else {
+            continue;
+        };
+        let path = ws.join(fname);
+        let body = fs::read_to_string(&path).unwrap_or_default();
+        let cursor_style = a == "cursor";
+        let begin = if cursor_style {
+            POINTER_BEGIN_CURSOR
+        } else {
+            POINTER_BEGIN
+        };
+        out.push(PointerResult {
+            agent: a.to_owned(),
+            path: path.to_string_lossy().into_owned(),
+            installed: body.contains(begin),
+            note: None,
+        });
+    }
+    Ok(out)
+}
diff --git a/src-tauri/src/memory/types.rs b/src-tauri/src/memory/types.rs
new file mode 100644
index 0000000..699547f
--- /dev/null
+++ b/src-tauri/src/memory/types.rs
@@ -0,0 +1,128 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[serde(rename_all = "lowercase")]
+pub enum MemoryScope {
+    Workspace,
+    Global,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct NoteMeta {
+    pub scope: MemoryScope,
+    pub path: String,
+    pub name: String,
+    pub title: String,
+    pub enabled: bool,
+    pub tags: Vec<String>,
+    pub size: u64,
+    pub modified: i64,
+    pub is_template: bool,
+    pub is_learning: bool,
+    pub is_overview: bool,
+    pub category: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct NoteContent {
+    pub scope: MemoryScope,
+    pub path: String,
+    pub content: String,
+    pub modified: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphNode {
+    pub id: String,
+    pub scope: MemoryScope,
+    pub path: String,
+    pub label: String,
+    pub tags: Vec<String>,
+    pub orphan: bool,
+    pub category: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub is_category_hub: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hub_scopes: Option<Vec<MemoryScope>>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphEdge {
+    pub source: String,
+    pub target: String,
+    pub cross_scope: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct GraphData {
+    pub nodes: Vec<GraphNode>,
+    pub edges: Vec<GraphEdge>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchHit {
+    pub scope: MemoryScope,
+    pub path: String,
+    pub line: u32,
+    pub snippet: String,
+    pub category: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct BacklinkRef {
+    pub scope: MemoryScope,
+    pub path: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryFolderStatus {
+    pub memory: bool,
+    pub learnings: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryStatusResponse {
+    pub workspace: MemoryFolderStatus,
+    pub global: MemoryFolderStatus,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MemorySubcategories {
+    pub workspace: Vec<String>,
+    pub global: Vec<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryListResponse {
+    pub notes: Vec<NoteMeta>,
+    pub memory_subcategories: MemorySubcategories,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct PointerResult {
+    pub agent: String,
+    pub path: String,
+    pub installed: bool,
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct RenameReport {
+    pub old_path: String,
+    pub new_path: String,
+    pub link_rewrites: u32,
+    pub files_changed: u32,
+}
diff --git a/src-tauri/src/memory/wikilinks.rs b/src-tauri/src/memory/wikilinks.rs
new file mode 100644
index 0000000..a3187d3
--- /dev/null
+++ b/src-tauri/src/memory/wikilinks.rs
@@ -0,0 +1,253 @@
+use std::collections::{BTreeSet, HashMap};
+
+use super::types::MemoryScope;
+
+#[derive(Debug, Clone)]
+pub struct ParsedWikilink {
+    pub target: String,
+    pub alias: Option<String>,
+    pub scope: Option<MemoryScope>,
+}
+
+pub fn parse_wikilink_inner(inner: &str) -> Option<ParsedWikilink> {
+    let (target_part, alias) = match inner.find('|') {
+        Some(i) => (&inner[..i], Some(inner[i + 1..].trim().to_owned())),
+        None => (inner, None),
+    };
+    let target_part = target_part.trim();
+    if target_part.is_empty() {
+        return None;
+    }
+    let (scope, target) = if let Some(colon) = target_part.find(':') {
+        if colon > 0 {
+            let prefix = &target_part[..colon];
+            match prefix {
+                "global" => (
+                    Some(MemoryScope::Global),
+                    target_part[colon + 1..].trim().to_owned(),
+                ),
+                "workspace" => (
+                    Some(MemoryScope::Workspace),
+                    target_part[colon + 1..].trim().to_owned(),
+                ),
+                _ => (None, target_part.to_owned()),
+            }
+        } else {
+            (None, target_part.to_owned())
+        }
+    } else {
+        (None, target_part.to_owned())
+    };
+    if target.is_empty() {
+        return None;
+    }
+    Some(ParsedWikilink {
+        target,
+        alias,
+        scope,
+    })
+}
+
+pub struct ParseResult {
+    pub links: Vec<ParsedWikilink>,
+    pub tags: Vec<String>,
+}
+
+pub fn parse_links_and_tags(body: &str) -> ParseResult {
+    let mut links: Vec<ParsedWikilink> = Vec::new();
+    let mut tags: BTreeSet<String> = BTreeSet::new();
+    let bytes = body.as_bytes();
+    let mut i = 0usize;
+
+    while i < bytes.len() {
+        if i + 1 < bytes.len() && bytes[i] == b'[' && bytes[i + 1] == b'[' {
+            let start = i + 2;
+            let mut j = start;
+            let mut found = false;
+            while j + 1 < bytes.len() {
+                if bytes[j] == b']' && bytes[j + 1] == b']' {
+                    let inner = &body[start..j];
+                    if let Some(link) = parse_wikilink_inner(inner) {
+                        links.push(link);
+                    }
+                    i = j + 2;
+                    found = true;
+                    break;
+                }
+                j += 1;
+            }
+            if !found {
+                i += 1;
+            }
+            continue;
+        }
+        if bytes[i] == b'#' {
+            let prev = if i == 0 { b'\n' } else { bytes[i - 1] };
+            if prev == b'\n' || prev == b' ' || prev == b'\t' {
+                let mut j = i + 1;
+                while j < bytes.len() {
+                    let c = bytes[j];
+                    let ok = c.is_ascii_alphanumeric() || c == b'-' || c == b'_' || c == b'/';
+                    if !ok {
+                        break;
+                    }
+                    j += 1;
+                }
+                if j > i + 1 && bytes[i + 1] != b' ' {
+                    let tag = &body[i + 1..j];
+                    if !tag.is_empty() && !tag.chars().all(|c| c.is_ascii_digit()) {
+                        tags.insert(tag.to_owned());
+                    }
+                }
+                i = j.max(i + 1);
+                continue;
+            }
+        }
+        i += 1;
+    }
+
+    ParseResult {
+        links,
+        tags: tags.into_iter().collect(),
+    }
+}
+
+pub struct NoteLookup {
+    pub by_path: HashMap<String, String>,
+    pub by_basename: HashMap<String, Vec<String>>,
+}
+
+pub fn build_note_lookup(api_paths: &[String]) -> NoteLookup {
+    let mut by_path: HashMap<String, String> = HashMap::new();
+    let mut by_basename: HashMap<String, Vec<String>> = HashMap::new();
+    for api in api_paths {
+        by_path.insert(api.to_lowercase(), api.clone());
+        let no_ext = strip_md_ext(api).to_ascii_lowercase();
+        by_path.insert(no_ext, api.clone());
+        if let Some(base) = api.split('/').last() {
+            let stem = strip_md_ext(base).to_ascii_lowercase();
+            by_basename.entry(stem).or_default().push(api.clone());
+        }
+    }
+    NoteLookup {
+        by_path,
+        by_basename,
+    }
+}
+
+pub fn resolve_link_target(
+    source_scope: &MemoryScope,
+    link: &ParsedWikilink,
+    scope_paths: &HashMap<MemoryScope, Vec<String>>,
+) -> Option<(MemoryScope, String)> {
+    let target_scope = link.scope.as_ref().unwrap_or(source_scope);
+    let empty = Vec::new();
+    let paths = scope_paths.get(target_scope).unwrap_or(&empty);
+    let lookup = build_note_lookup(paths);
+    let raw = link.target.replace('\\', "/");
+    if raw.is_empty() {
+        return None;
+    }
+    let candidate = if raw.ends_with(".md") {
+        raw.clone()
+    } else {
+        format!("{raw}.md")
+    };
+    if let Some(p) = lookup.by_path.get(&candidate.to_ascii_lowercase()) {
+        return Some((target_scope.clone(), p.clone()));
+    }
+    let no_ext = strip_md_ext(&raw).to_ascii_lowercase();
+    if let Some(p) = lookup.by_path.get(&no_ext) {
+        return Some((target_scope.clone(), p.clone()));
+    }
+    if let Some(base) = raw.split('/').last() {
+        let stem = strip_md_ext(base).to_ascii_lowercase();
+        if let Some(matches) = lookup.by_basename.get(&stem) {
+            if matches.len() == 1 {
+                return Some((target_scope.clone(), matches[0].clone()));
+            }
+        }
+    }
+    None
+}
+
+pub fn rewrite_wikilinks(
+    content: &str,
+    old_basename: &str,
+    new_basename: &str,
+    old_path: &str,
+    new_path: &str,
+) -> (String, u32) {
+    let old_pwx = strip_md_ext(old_path);
+    let new_pwx = strip_md_ext(new_path);
+    let mut out = String::with_capacity(content.len());
+    let bytes = content.as_bytes();
+    let mut i = 0usize;
+    let mut count = 0u32;
+
+    while i < bytes.len() {
+        if i + 1 < bytes.len() && bytes[i] == b'[' && bytes[i + 1] == b'[' {
+            if let Some(end) = find_close_link(&content[i + 2..]) {
+                let inner = &content[i + 2..i + 2 + end];
+                let (target, alias) = match inner.find('|') {
+                    Some(j) => (&inner[..j], Some(&inner[j + 1..])),
+                    None => (inner, None),
+                };
+                let target_t = target.trim();
+                let new_target = if target_t.eq_ignore_ascii_case(old_basename)
+                    || target_t.eq_ignore_ascii_case(&old_pwx)
+                {
+                    if target_t.contains('/') {
+                        Some(new_pwx.clone())
+                    } else {
+                        Some(new_basename.to_owned())
+                    }
+                } else {
+                    None
+                };
+                if let Some(t) = new_target {
+                    out.push_str("[[");
+                    out.push_str(&t);
+                    if let Some(a) = alias {
+                        out.push('|');
+                        out.push_str(a);
+                    }
+                    out.push_str("]]");
+                    count += 1;
+                } else {
+                    out.push_str(&content[i..i + 2 + end + 2]);
+                }
+                i += 2 + end + 2;
+                continue;
+            }
+        }
+        let ch = content[i..].chars().next().unwrap();
+        out.push(ch);
+        i += ch.len_utf8();
+    }
+    (out, count)
+}
+
+pub fn strip_md_ext(p: &str) -> String {
+    if let Some(idx) = p.rfind('.') {
+        if p[idx + 1..].eq_ignore_ascii_case("md") {
+            return p[..idx].to_owned();
+        }
+    }
+    p.to_owned()
+}
+
+fn find_close_link(s: &str) -> Option<usize> {
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i + 1 < bytes.len() {
+        if bytes[i] == b']' && bytes[i + 1] == b']' {
+            return Some(i);
+        }
+        if bytes[i] == b'\n' {
+            return None;
+        }
+        i += 1;
+    }
+    None
+}
diff --git a/src-tauri/src/plans.rs b/src-tauri/src/plans.rs
index 4452929..92471ed 100644
--- a/src-tauri/src/plans.rs
+++ b/src-tauri/src/plans.rs
@@ -439,10 +439,7 @@ pub fn plan_create_inner(
     }
     let body = content.unwrap_or("").to_owned();
     let body = if body.is_empty() {
-        let stem = abs
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .unwrap_or("Plan");
+        let stem = abs.file_stem().and_then(|s| s.to_str()).unwrap_or("Plan");
         format!("# {stem}\n\n## Tasks\n\n")
     } else {
         body
@@ -528,8 +525,11 @@ pub fn plan_rename_inner(
     }
     fs::rename(&abs_old, &abs_new).map_err(|e| format!("rename: {e}"))?;
     // Plan task records that referenced the old path get rewritten too.
-    tasks::tasks_rewrite_plan_path(workspace_cwd, &rel_from_root(&root, &abs_old).unwrap_or_default(),
-        &rel_from_root(&root, &abs_new).unwrap_or_default())?;
+    tasks::tasks_rewrite_plan_path(
+        workspace_cwd,
+        &rel_from_root(&root, &abs_old).unwrap_or_default(),
+        &rel_from_root(&root, &abs_new).unwrap_or_default(),
+    )?;
     meta_from_abs(&root, &abs_new).ok_or_else(|| "failed to read back renamed plan".to_owned())
 }
 
@@ -675,10 +675,7 @@ pub fn plan_load(workspace_cwd: String, path: String) -> Result<PlanLoadReport,
 }
 
 #[tauri::command]
-pub fn plan_sync_from_tasks(
-    workspace_cwd: String,
-    path: String,
-) -> Result<PlanSyncReport, String> {
+pub fn plan_sync_from_tasks(workspace_cwd: String, path: String) -> Result<PlanSyncReport, String> {
     plan_sync_from_tasks_inner(&workspace_cwd, &path)
 }
 
@@ -796,9 +793,7 @@ mod tests {
 
     #[test]
     fn load_replaces_only_plan_tasks_and_keeps_free_tasks() {
-        use crate::tasks::{
-            tasks_create_inner, tasks_snapshot, TaskCreateInput, TaskStatus,
-        };
+        use crate::tasks::{tasks_create_inner, tasks_snapshot, TaskCreateInput, TaskStatus};
         let ws = temp_ws("load_keep_free");
         let cwd = ws.to_string_lossy().into_owned();
 
diff --git a/src-tauri/src/skills_rules/commands.rs b/src-tauri/src/skills_rules/commands.rs
index e6d2806..f34954b 100644
--- a/src-tauri/src/skills_rules/commands.rs
+++ b/src-tauri/src/skills_rules/commands.rs
@@ -22,9 +22,7 @@
 
 use crate::skills_rules::install;
 use crate::skills_rules::store;
-use crate::skills_rules::types::{
-    RuleEntry, SkillEntry, SkillSourceInput,
-};
+use crate::skills_rules::types::{RuleEntry, SkillEntry, SkillSourceInput};
 
 /// Idempotently create `.agents/{rules,skills}/` plus their `index.json`
 /// manifests. Safe to call on every workspace open.
diff --git a/src-tauri/src/skills_rules/install.rs b/src-tauri/src/skills_rules/install.rs
index 2a7dbd5..b592016 100644
--- a/src-tauri/src/skills_rules/install.rs
+++ b/src-tauri/src/skills_rules/install.rs
@@ -42,9 +42,7 @@ pub fn install_skill(ws: &str, name: &str, source: SkillSourceInput) -> Result<S
             SkillSourceKind::AgentCreated => {
                 Err("agent-created skills must use skills_write, not skills_install".into())
             }
-            SkillSourceKind::Core => {
-                Err("core skills are built-in and cannot be installed".into())
-            }
+            SkillSourceKind::Core => Err("core skills are built-in and cannot be installed".into()),
         }
     })();
 
@@ -241,8 +239,9 @@ fn is_safe_npm_version(v: &str) -> bool {
     let v = v.trim();
     !v.is_empty()
         && !v.starts_with('-')
-        && v.chars()
-            .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '/' | '-' | '+' | '~' | '^'))
+        && v.chars().all(|c| {
+            c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '/' | '-' | '+' | '~' | '^')
+        })
 }
 
 /// Extracts a `*.tgz` produced by `npm pack` into `dest` by delegating to the
diff --git a/src-tauri/src/skills_rules/store.rs b/src-tauri/src/skills_rules/store.rs
index 2645011..c60231d 100644
--- a/src-tauri/src/skills_rules/store.rs
+++ b/src-tauri/src/skills_rules/store.rs
@@ -26,17 +26,32 @@ pub const SKILLS_REL: &str = ".agents/skills";
 /// Built-in harness skills embedded in the binary.
 /// Each entry is `(name, markdown_content)`.
 pub const CORE_SKILLS: &[(&str, &str)] = &[
-    ("file-access", include_str!("../agent/harness_skills/file-access.md")),
+    (
+        "file-access",
+        include_str!("../agent/harness_skills/file-access.md"),
+    ),
     ("memory", include_str!("../agent/harness_skills/memory.md")),
     ("plans", include_str!("../agent/harness_skills/plans.md")),
     ("tasks", include_str!("../agent/harness_skills/tasks.md")),
-    ("rules-skills", include_str!("../agent/harness_skills/rules-skills.md")),
-    ("harness", include_str!("../agent/harness_skills/harness.md")),
-    ("environment", include_str!("../agent/harness_skills/environment.md")),
+    (
+        "rules-skills",
+        include_str!("../agent/harness_skills/rules-skills.md"),
+    ),
+    (
+        "harness",
+        include_str!("../agent/harness_skills/harness.md"),
+    ),
+    (
+        "environment",
+        include_str!("../agent/harness_skills/environment.md"),
+    ),
     ("shell", include_str!("../agent/harness_skills/shell.md")),
     ("git", include_str!("../agent/harness_skills/git.md")),
     ("web", include_str!("../agent/harness_skills/web.md")),
-    ("subagents", include_str!("../agent/harness_skills/subagents.md")),
+    (
+        "subagents",
+        include_str!("../agent/harness_skills/subagents.md"),
+    ),
 ];
 
 const CORE_INSTALLED_AT: &str = "2026-01-01T00:00:00Z";
@@ -250,9 +265,7 @@ fn atomic_write_json<T: serde::Serialize>(path: &Path, value: &T) -> Result<(),
     fs::create_dir_all(parent).map_err(|e| format!("mkdir parent: {e}"))?;
     let tmp = parent.join(format!(
         ".{}.{}.tmp",
-        path.file_name()
-            .and_then(|s| s.to_str())
-            .unwrap_or("index"),
+        path.file_name().and_then(|s| s.to_str()).unwrap_or("index"),
         std::process::id()
     ));
     {
@@ -367,8 +380,7 @@ pub fn list_rules(ws: &str) -> Result<Vec<RuleEntry>, String> {
         let path = roots.rules.join(&name);
         let body = fs::read_to_string(&path).unwrap_or_default();
         let meta = fs::metadata(&path).ok();
-        let (title, summary) =
-            extract_title_and_summary(&body, name.trim_end_matches(".md"));
+        let (title, summary) = extract_title_and_summary(&body, name.trim_end_matches(".md"));
         let enabled = idx.rules.get(&name).map(|e| e.enabled).unwrap_or(true);
         entries.push(RuleEntry {
             name,
@@ -519,11 +531,7 @@ pub fn list_skills(ws: &str) -> Result<Vec<SkillEntry>, String> {
         .iter()
         .map(|(name, content)| {
             let (title, summary) = extract_title_and_summary(content, name);
-            let enabled = idx
-                .skills
-                .get(*name)
-                .map(|e| e.enabled)
-                .unwrap_or(true);
+            let enabled = idx.skills.get(*name).map(|e| e.enabled).unwrap_or(true);
             SkillEntry {
                 name: name.to_string(),
                 title,
@@ -940,7 +948,10 @@ mod tests {
         set_rule_enabled(&ws_str(&ws), "rule-beta.md", false).unwrap();
         let _ = ensure_skills_rules_roots(&ws_str(&ws)).unwrap();
         let rules_after = list_rules(&ws_str(&ws)).unwrap();
-        let beta = rules_after.iter().find(|r| r.name == "rule-beta.md").unwrap();
+        let beta = rules_after
+            .iter()
+            .find(|r| r.name == "rule-beta.md")
+            .unwrap();
         assert!(!beta.enabled, "bootstrap must be a no-op when index exists");
         let _ = fs::remove_dir_all(&ws);
     }
diff --git a/src-tauri/src/skills_rules/types.rs b/src-tauri/src/skills_rules/types.rs
index 5747fb3..8ec1c98 100644
--- a/src-tauri/src/skills_rules/types.rs
+++ b/src-tauri/src/skills_rules/types.rs
@@ -138,13 +138,19 @@ pub struct SkillIndexEntry {
 
 impl Default for RulesIndex {
     fn default() -> Self {
-        Self { version: INDEX_VERSION, rules: BTreeMap::new() }
+        Self {
+            version: INDEX_VERSION,
+            rules: BTreeMap::new(),
+        }
     }
 }
 
 impl Default for SkillsIndex {
     fn default() -> Self {
-        Self { version: INDEX_VERSION, skills: BTreeMap::new() }
+        Self {
+            version: INDEX_VERSION,
+            skills: BTreeMap::new(),
+        }
     }
 }
 
diff --git a/src-tauri/src/voice/settings.rs b/src-tauri/src/voice/settings.rs
index 8030232..9613c7e 100644
--- a/src-tauri/src/voice/settings.rs
+++ b/src-tauri/src/voice/settings.rs
@@ -160,10 +160,11 @@ pub fn save(app: &AppHandle, settings: &VoiceSettings) -> Result<VoiceSettings,
 /// existing agent provider keyring entries.
 pub fn provider_key(app: &AppHandle, provider: VoiceProviderKind) -> Result<String, String> {
     match provider {
-        VoiceProviderKind::Aws => crate::media_keys::resolve_key(crate::media_keys::MediaKeyKind::AwsPolly)
-            .ok_or_else(|| {
-                "AWS API key missing. Add it under Settings → API Keys (Amazon Polly).".into()
-            }),
+        VoiceProviderKind::Aws => {
+            crate::media_keys::resolve_key(crate::media_keys::MediaKeyKind::AwsPolly).ok_or_else(
+                || "AWS API key missing. Add it under Settings → API Keys (Amazon Polly).".into(),
+            )
+        }
         VoiceProviderKind::Openai => {
             agent_settings::provider_key_pub(app, agent_settings::AgentProviderKind::Openai)
         }
diff --git a/src-tauri/src/voice/stt.rs b/src-tauri/src/voice/stt.rs
index 6430532..607dbe8 100644
--- a/src-tauri/src/voice/stt.rs
+++ b/src-tauri/src/voice/stt.rs
@@ -35,7 +35,8 @@ pub async fn transcribe_wav(
     if provider == VoiceProviderKind::Aws {
         let _ = (model, api_key, wav_path, language);
         return Err(
-            "AWS Transcribe STT ist in den Einstellungen wählbar; die Laufzeit-Anbindung folgt.".into(),
+            "AWS Transcribe STT ist in den Einstellungen wählbar; die Laufzeit-Anbindung folgt."
+                .into(),
         );
     }
     let bytes = tokio::fs::read(wav_path)
diff --git a/src/i18n/keys.rs b/src/i18n/keys.rs
index e31cbcc..b7c8f97 100644
--- a/src/i18n/keys.rs
+++ b/src/i18n/keys.rs
@@ -243,12 +243,15 @@ pub enum I18nKey {
     MemGraph3dLoadFailed,
     MemSearchPh,
     MemSearchFilterAll,
+    MemSearchFilterWorkspace,
+    MemSearchFilterGlobal,
     MemFilesExpand,
     MemFilesCollapse,
     MemFilesGroupMemory,
     MemFilesGroupLearnings,
     MemFilesGroupExpand,
     MemFilesGroupCollapse,
+    MemGlobalCreate,
 
     AgAriaPane,
     AgSandbox,
diff --git a/src/i18n/locales/de_de.rs b/src/i18n/locales/de_de.rs
index 2487a03..1feec6c 100644
--- a/src/i18n/locales/de_de.rs
+++ b/src/i18n/locales/de_de.rs
@@ -241,12 +241,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "3D-Grafik konnte nicht geladen werden. 2D-Grafik wird angezeigt.",
         I18nKey::MemSearchPh => "Notizen durchsuchen…",
         I18nKey::MemSearchFilterAll => "Alle",
+        I18nKey::MemSearchFilterWorkspace => "Arbeitsbereich",
+        I18nKey::MemSearchFilterGlobal => "Global",
         I18nKey::MemFilesExpand => "Dateiliste erweitern",
         I18nKey::MemFilesCollapse => "Dateiliste einklappen",
         I18nKey::MemFilesGroupMemory => "Erinnerung",
         I18nKey::MemFilesGroupLearnings => "Erkenntnisse",
         I18nKey::MemFilesGroupExpand => "Gruppe aufklappen",
         I18nKey::MemFilesGroupCollapse => "Gruppe einklappen",
+        I18nKey::MemGlobalCreate => "Globalen Speicher anlegen",
         I18nKey::AgAriaPane => "Agent Harness",
         I18nKey::AgSandbox => "Tool-Sandbox ",
         I18nKey::AgNoPath => "(kein Pfad)",
diff --git a/src/i18n/locales/en_us.rs b/src/i18n/locales/en_us.rs
index d9472ee..8cd5b74 100644
--- a/src/i18n/locales/en_us.rs
+++ b/src/i18n/locales/en_us.rs
@@ -266,12 +266,15 @@ Classic: Ctrl+O quick open, Ctrl+` new terminal, Ctrl+Shift+P palette."
         I18nKey::MemGraph3dLoadFailed => "3D graph could not load. Showing 2D graph.",
         I18nKey::MemSearchPh => "Search notes…",
         I18nKey::MemSearchFilterAll => "All",
+        I18nKey::MemSearchFilterWorkspace => "Workspace",
+        I18nKey::MemSearchFilterGlobal => "Global",
         I18nKey::MemFilesExpand => "Expand file list",
         I18nKey::MemFilesCollapse => "Collapse file list",
         I18nKey::MemFilesGroupMemory => "Memory",
         I18nKey::MemFilesGroupLearnings => "Learnings",
         I18nKey::MemFilesGroupExpand => "Expand group",
         I18nKey::MemFilesGroupCollapse => "Collapse group",
+        I18nKey::MemGlobalCreate => "Create Global Memory",
 
         I18nKey::AgAriaPane => "Agent harness",
         I18nKey::AgSandbox => "Tool sandbox ",
diff --git a/src/i18n/locales/es_es.rs b/src/i18n/locales/es_es.rs
index 364716d..84c7e2b 100644
--- a/src/i18n/locales/es_es.rs
+++ b/src/i18n/locales/es_es.rs
@@ -241,12 +241,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "No se pudo cargar el gráfico 3D. Mostrando gráfico 2D.",
         I18nKey::MemSearchPh => "Notas de búsqueda...",
         I18nKey::MemSearchFilterAll => "Todo",
+        I18nKey::MemSearchFilterWorkspace => "Espacio de trabajo",
+        I18nKey::MemSearchFilterGlobal => "Global",
         I18nKey::MemFilesExpand => "Expandir lista de archivos",
         I18nKey::MemFilesCollapse => "Contraer lista de archivos",
         I18nKey::MemFilesGroupMemory => "Memoria",
         I18nKey::MemFilesGroupLearnings => "Aprendizajes",
         I18nKey::MemFilesGroupExpand => "Expandir grupo",
         I18nKey::MemFilesGroupCollapse => "Colapsar grupo",
+        I18nKey::MemGlobalCreate => "Crear memoria global",
         I18nKey::AgAriaPane => "Arnés de agente",
         I18nKey::AgSandbox => "Caja de arena para herramientas",
         I18nKey::AgNoPath => "(sin camino)",
diff --git a/src/i18n/locales/fr_fr.rs b/src/i18n/locales/fr_fr.rs
index 3cc3400..e0069fb 100644
--- a/src/i18n/locales/fr_fr.rs
+++ b/src/i18n/locales/fr_fr.rs
@@ -243,12 +243,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "Le graphique 3D n'a pas pu se charger. Affichage d'un graphique 2D.",
         I18nKey::MemSearchPh => "Notes de recherche…",
         I18nKey::MemSearchFilterAll => "Tous",
+        I18nKey::MemSearchFilterWorkspace => "Espace de travail",
+        I18nKey::MemSearchFilterGlobal => "Global",
         I18nKey::MemFilesExpand => "Développer la liste des fichiers",
         I18nKey::MemFilesCollapse => "Réduire la liste des fichiers",
         I18nKey::MemFilesGroupMemory => "Mémoire",
         I18nKey::MemFilesGroupLearnings => "Apprentissages",
         I18nKey::MemFilesGroupExpand => "Agrandir le groupe",
         I18nKey::MemFilesGroupCollapse => "Réduire le groupe",
+        I18nKey::MemGlobalCreate => "Créer la mémoire globale",
         I18nKey::AgAriaPane => "Harnais d'agent",
         I18nKey::AgSandbox => "Bac à sable à outils",
         I18nKey::AgNoPath => "(pas de chemin)",
diff --git a/src/i18n/locales/hu_hu.rs b/src/i18n/locales/hu_hu.rs
index fe9c523..bddd285 100644
--- a/src/i18n/locales/hu_hu.rs
+++ b/src/i18n/locales/hu_hu.rs
@@ -241,12 +241,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "A 3D-s grafikont nem sikerült betölteni. 2D grafikon megjelenítése.",
         I18nKey::MemSearchPh => "Jegyzetek keresése…",
         I18nKey::MemSearchFilterAll => "Minden",
+        I18nKey::MemSearchFilterWorkspace => "Munkaterület",
+        I18nKey::MemSearchFilterGlobal => "Globális",
         I18nKey::MemFilesExpand => "A fájllista kibontása",
         I18nKey::MemFilesCollapse => "Fájllista összecsukása",
         I18nKey::MemFilesGroupMemory => "Memória",
         I18nKey::MemFilesGroupLearnings => "Tanulmányok",
         I18nKey::MemFilesGroupExpand => "Csoport bővítése",
         I18nKey::MemFilesGroupCollapse => "Csoport összecsukása",
+        I18nKey::MemGlobalCreate => "Globális memória létrehozása",
         I18nKey::AgAriaPane => "Ügynök hám",
         I18nKey::AgSandbox => "Szerszám homokozó",
         I18nKey::AgNoPath => "(nincs út)",
diff --git a/src/i18n/locales/it_it.rs b/src/i18n/locales/it_it.rs
index d01545f..164ca78 100644
--- a/src/i18n/locales/it_it.rs
+++ b/src/i18n/locales/it_it.rs
@@ -241,12 +241,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "Impossibile caricare il grafico 3D. Mostra il grafico 2D.",
         I18nKey::MemSearchPh => "Cerca note...",
         I18nKey::MemSearchFilterAll => "Tutto",
+        I18nKey::MemSearchFilterWorkspace => "Area di lavoro",
+        I18nKey::MemSearchFilterGlobal => "Globale",
         I18nKey::MemFilesExpand => "Espandi l'elenco dei file",
         I18nKey::MemFilesCollapse => "Comprimi l'elenco dei file",
         I18nKey::MemFilesGroupMemory => "Memoria",
         I18nKey::MemFilesGroupLearnings => "Apprendimenti",
         I18nKey::MemFilesGroupExpand => "Espandi gruppo",
         I18nKey::MemFilesGroupCollapse => "Comprimi gruppo",
+        I18nKey::MemGlobalCreate => "Crea memoria globale",
         I18nKey::AgAriaPane => "Imbracatura dell'agente",
         I18nKey::AgSandbox => "Sabbiera per strumenti",
         I18nKey::AgNoPath => "(nessun percorso)",
diff --git a/src/i18n/locales/ja_jp.rs b/src/i18n/locales/ja_jp.rs
index 2e49293..432a880 100644
--- a/src/i18n/locales/ja_jp.rs
+++ b/src/i18n/locales/ja_jp.rs
@@ -235,12 +235,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "3D グラフを読み込めませんでした。 2D グラフを表示します。",
         I18nKey::MemSearchPh => "メモを検索…",
         I18nKey::MemSearchFilterAll => "全て",
+        I18nKey::MemSearchFilterWorkspace => "ワークスペース",
+        I18nKey::MemSearchFilterGlobal => "グローバル",
         I18nKey::MemFilesExpand => "ファイルリストを展開する",
         I18nKey::MemFilesCollapse => "ファイルリストを折りたたむ",
         I18nKey::MemFilesGroupMemory => "メモリ",
         I18nKey::MemFilesGroupLearnings => "学び",
         I18nKey::MemFilesGroupExpand => "グループを展開する",
         I18nKey::MemFilesGroupCollapse => "グループを折りたたむ",
+        I18nKey::MemGlobalCreate => "グローバルメモリを作成",
         I18nKey::AgAriaPane => "エージェントハーネス",
         I18nKey::AgSandbox => "ツールサンドボックス",
         I18nKey::AgNoPath => "(パスがありません)",
diff --git a/src/i18n/locales/ko_kr.rs b/src/i18n/locales/ko_kr.rs
index 0ec9908..77574b6 100644
--- a/src/i18n/locales/ko_kr.rs
+++ b/src/i18n/locales/ko_kr.rs
@@ -235,12 +235,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "3D 그래프를 로드할 수 없습니다. 2D 그래프를 표시합니다.",
         I18nKey::MemSearchPh => "메모 검색…",
         I18nKey::MemSearchFilterAll => "모두",
+        I18nKey::MemSearchFilterWorkspace => "작업 영역",
+        I18nKey::MemSearchFilterGlobal => "전역",
         I18nKey::MemFilesExpand => "파일 목록 펼치기",
         I18nKey::MemFilesCollapse => "파일 목록 축소",
         I18nKey::MemFilesGroupMemory => "메모리",
         I18nKey::MemFilesGroupLearnings => "학습",
         I18nKey::MemFilesGroupExpand => "그룹 펼치기",
         I18nKey::MemFilesGroupCollapse => "그룹 축소",
+        I18nKey::MemGlobalCreate => "전역 메모리 만들기",
         I18nKey::AgAriaPane => "에이전트 하네스",
         I18nKey::AgSandbox => "도구 샌드박스",
         I18nKey::AgNoPath => "(경로 없음)",
diff --git a/src/i18n/locales/pl_pl.rs b/src/i18n/locales/pl_pl.rs
index 593983d..6600247 100644
--- a/src/i18n/locales/pl_pl.rs
+++ b/src/i18n/locales/pl_pl.rs
@@ -239,12 +239,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "Nie można wczytać wykresu 3D. Wyświetlanie wykresu 2D.",
         I18nKey::MemSearchPh => "Wyszukaj notatki…",
         I18nKey::MemSearchFilterAll => "Wszystko",
+        I18nKey::MemSearchFilterWorkspace => "Obszar roboczy",
+        I18nKey::MemSearchFilterGlobal => "Globalne",
         I18nKey::MemFilesExpand => "Rozwiń listę plików",
         I18nKey::MemFilesCollapse => "Zwiń listę plików",
         I18nKey::MemFilesGroupMemory => "Pamięć",
         I18nKey::MemFilesGroupLearnings => "Nauka",
         I18nKey::MemFilesGroupExpand => "Rozwiń grupę",
         I18nKey::MemFilesGroupCollapse => "Zwiń grupę",
+        I18nKey::MemGlobalCreate => "Utwórz pamięć globalną",
         I18nKey::AgAriaPane => "Uprząż agenta",
         I18nKey::AgSandbox => "Piaskownica narzędziowa",
         I18nKey::AgNoPath => "(bez ścieżki)",
diff --git a/src/i18n/locales/pt_br.rs b/src/i18n/locales/pt_br.rs
index 20c3356..91c1023 100644
--- a/src/i18n/locales/pt_br.rs
+++ b/src/i18n/locales/pt_br.rs
@@ -241,12 +241,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "O gráfico 3D não pôde ser carregado. Mostrando gráfico 2D.",
         I18nKey::MemSearchPh => "Notas de pesquisa…",
         I18nKey::MemSearchFilterAll => "Todos",
+        I18nKey::MemSearchFilterWorkspace => "Workspace",
+        I18nKey::MemSearchFilterGlobal => "Global",
         I18nKey::MemFilesExpand => "Expandir lista de arquivos",
         I18nKey::MemFilesCollapse => "Recolher lista de arquivos",
         I18nKey::MemFilesGroupMemory => "Memória",
         I18nKey::MemFilesGroupLearnings => "Aprendizados",
         I18nKey::MemFilesGroupExpand => "Expandir grupo",
         I18nKey::MemFilesGroupCollapse => "Recolher grupo",
+        I18nKey::MemGlobalCreate => "Criar memória global",
         I18nKey::AgAriaPane => "Arnês do agente",
         I18nKey::AgSandbox => "Caixa de areia de ferramentas",
         I18nKey::AgNoPath => "(sem caminho)",
diff --git a/src/i18n/locales/ru_ru.rs b/src/i18n/locales/ru_ru.rs
index d140b01..1264a69 100644
--- a/src/i18n/locales/ru_ru.rs
+++ b/src/i18n/locales/ru_ru.rs
@@ -239,12 +239,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "Не удалось загрузить 3D-график. Показан 2D-график.",
         I18nKey::MemSearchPh => "Поиск заметок…",
         I18nKey::MemSearchFilterAll => "Все",
+        I18nKey::MemSearchFilterWorkspace => "Рабочая область",
+        I18nKey::MemSearchFilterGlobal => "Глобально",
         I18nKey::MemFilesExpand => "Развернуть список файлов",
         I18nKey::MemFilesCollapse => "Свернуть список файлов",
         I18nKey::MemFilesGroupMemory => "Память",
         I18nKey::MemFilesGroupLearnings => "Обучение",
         I18nKey::MemFilesGroupExpand => "Развернуть группу",
         I18nKey::MemFilesGroupCollapse => "Свернуть группу",
+        I18nKey::MemGlobalCreate => "Создать глобальную память",
         I18nKey::AgAriaPane => "Агентская обвязка",
         I18nKey::AgSandbox => "Песочница для инструментов",
         I18nKey::AgNoPath => "(нет пути)",
diff --git a/src/i18n/locales/zh_cn.rs b/src/i18n/locales/zh_cn.rs
index 5f9a65d..b1ba3fc 100644
--- a/src/i18n/locales/zh_cn.rs
+++ b/src/i18n/locales/zh_cn.rs
@@ -235,12 +235,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "3D 图表无法加载。显示 2D 图表。",
         I18nKey::MemSearchPh => "搜索笔记...",
         I18nKey::MemSearchFilterAll => "全部",
+        I18nKey::MemSearchFilterWorkspace => "工作区",
+        I18nKey::MemSearchFilterGlobal => "全局",
         I18nKey::MemFilesExpand => "展开文件列表",
         I18nKey::MemFilesCollapse => "折叠文件列表",
         I18nKey::MemFilesGroupMemory => "记忆",
         I18nKey::MemFilesGroupLearnings => "学习内容",
         I18nKey::MemFilesGroupExpand => "展开组",
         I18nKey::MemFilesGroupCollapse => "折叠组",
+        I18nKey::MemGlobalCreate => "创建全局记忆",
         I18nKey::AgAriaPane => "代理线束",
         I18nKey::AgSandbox => "工具沙箱",
         I18nKey::AgNoPath => "（没有路径）",
diff --git a/src/i18n/locales/zh_tw.rs b/src/i18n/locales/zh_tw.rs
index 11217f8..9dff9a3 100644
--- a/src/i18n/locales/zh_tw.rs
+++ b/src/i18n/locales/zh_tw.rs
@@ -235,12 +235,15 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::MemGraph3dLoadFailed => "3D 圖表無法載入。顯示 2D 圖表。",
         I18nKey::MemSearchPh => "搜尋筆記...",
         I18nKey::MemSearchFilterAll => "全部",
+        I18nKey::MemSearchFilterWorkspace => "工作區",
+        I18nKey::MemSearchFilterGlobal => "全域",
         I18nKey::MemFilesExpand => "展開文件列表",
         I18nKey::MemFilesCollapse => "折疊文件列表",
         I18nKey::MemFilesGroupMemory => "記憶",
         I18nKey::MemFilesGroupLearnings => "學習內容",
         I18nKey::MemFilesGroupExpand => "展開組",
         I18nKey::MemFilesGroupCollapse => "折疊組",
+        I18nKey::MemGlobalCreate => "建立全域記憶",
         I18nKey::AgAriaPane => "代理線束",
         I18nKey::AgSandbox => "工具沙箱",
         I18nKey::AgNoPath => "（沒有路徑）",
diff --git a/src/main.rs b/src/main.rs
index 918957e..e572462 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,9 +7,9 @@ mod memory_paths;
 mod open_http;
 mod quit;
 mod service;
-mod theme;
 mod skills_rules_wire;
 mod tauri_bridge;
+mod theme;
 mod workbench;
 
 use app::*;
diff --git a/src/tauri_bridge.rs b/src/tauri_bridge.rs
index 549c373..0703805 100644
--- a/src/tauri_bridge.rs
+++ b/src/tauri_bridge.rs
@@ -553,7 +553,6 @@ pub async fn agent_web_settings_save(
     .await
 }
 
-
 pub async fn agent_environment_invalidate() -> Result<(), String> {
     invoke_unit_js("agent_environment_invalidate", JsValue::NULL).await
 }
@@ -717,10 +716,7 @@ pub struct BinaryFilePreview {
     pub truncated: bool,
 }
 
-pub async fn stat_workspace_file(
-    workspace_root: String,
-    path: String,
-) -> Result<FileMeta, String> {
+pub async fn stat_workspace_file(workspace_root: String, path: String) -> Result<FileMeta, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A {
@@ -1146,27 +1142,68 @@ pub async fn agent_latest_session_id(agent: String, cwd: String) -> Result<Optio
 }
 
 // ---------------------------------------------------------------------
-// Memory (workspace-scoped Markdown notes, Obsidian-style)
+// Memory (workspace + global Markdown notes, Obsidian-style)
 
 pub async fn workspace_ensure_agents(ws: &str) -> Result<(), String> {
     invoke_typed("workspace_ensure_agents", WsArg { workspace_cwd: ws }).await
 }
 
+// ── Scope ──────────────────────────────────────────────────────────────────────
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum MemoryScope {
+    Workspace,
+    Global,
+}
+
+/// Composite key used as node ID and for addressing notes across scopes.
+pub fn note_key(scope: &MemoryScope, path: &str) -> String {
+    let s = match scope {
+        MemoryScope::Workspace => "workspace",
+        MemoryScope::Global => "global",
+    };
+    format!("{s}:{path}")
+}
+
+pub fn parse_note_key(key: &str) -> Option<(MemoryScope, String)> {
+    let idx = key.find(':')?;
+    if idx == 0 {
+        return None;
+    }
+    let scope = match &key[..idx] {
+        "workspace" => MemoryScope::Workspace,
+        "global" => MemoryScope::Global,
+        _ => return None,
+    };
+    Some((scope, key[idx + 1..].to_owned()))
+}
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
 #[allow(dead_code)]
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NoteMeta {
+    pub scope: MemoryScope,
     pub path: String,
     pub name: String,
+    pub title: String,
+    pub enabled: bool,
+    pub tags: Vec<String>,
     pub size: u64,
     pub modified: i64,
     pub is_template: bool,
+    pub is_learning: bool,
+    pub is_overview: bool,
+    pub category: String,
 }
 
 #[allow(dead_code)]
 #[derive(Clone, Debug, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct NoteContent {
+    pub scope: MemoryScope,
     pub path: String,
     pub content: String,
     pub modified: i64,
@@ -1177,15 +1214,18 @@ pub struct NoteContent {
 #[serde(rename_all = "camelCase")]
 pub struct GraphNode {
     pub id: String,
+    pub scope: MemoryScope,
+    pub path: String,
     pub label: String,
     pub tags: Vec<String>,
     pub orphan: bool,
+    pub category: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub color: Option<String>,
-    /// Category key (derived from path prefix). Filled in by the frontend
-    /// after fetching, used by the renderer to cluster nodes per category.
+    pub is_category_hub: Option<bool>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub category: Option<String>,
+    pub hub_scopes: Option<Vec<MemoryScope>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub color: Option<String>,
 }
 
 #[allow(dead_code)]
@@ -1194,6 +1234,7 @@ pub struct GraphNode {
 pub struct GraphEdge {
     pub source: String,
     pub target: String,
+    pub cross_scope: bool,
 }
 
 #[allow(dead_code)]
@@ -1208,9 +1249,51 @@ pub struct GraphData {
 #[derive(Clone, Debug, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchHit {
+    pub scope: MemoryScope,
     pub path: String,
     pub line: u32,
     pub snippet: String,
+    pub category: String,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BacklinkRef {
+    pub scope: MemoryScope,
+    pub path: String,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryFolderStatus {
+    pub memory: bool,
+    pub learnings: bool,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryStatusResponse {
+    pub workspace: MemoryFolderStatus,
+    pub global: MemoryFolderStatus,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemorySubcategories {
+    pub workspace: Vec<String>,
+    pub global: Vec<String>,
+}
+
+#[allow(dead_code)]
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MemoryListResponse {
+    pub notes: Vec<NoteMeta>,
+    pub memory_subcategories: MemorySubcategories,
 }
 
 #[allow(dead_code)]
@@ -1239,32 +1322,63 @@ struct WsArg<'a> {
     workspace_cwd: &'a str,
 }
 
-pub async fn memory_list(ws: &str) -> Result<Vec<NoteMeta>, String> {
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+pub async fn memory_status(ws: &str) -> Result<MemoryStatusResponse, String> {
+    invoke_typed("memory_status", WsArg { workspace_cwd: ws }).await
+}
+
+pub async fn memory_bootstrap(ws: &str, target: &str) -> Result<(), String> {
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct A<'a> {
+        workspace_cwd: &'a str,
+        target: &'a str,
+    }
+    invoke_unit_js(
+        "memory_bootstrap",
+        args_value(A {
+            workspace_cwd: ws,
+            target,
+        })?,
+    )
+    .await
+}
+
+pub async fn memory_list(ws: &str) -> Result<MemoryListResponse, String> {
     invoke_typed("memory_list", WsArg { workspace_cwd: ws }).await
 }
 
-pub async fn memory_read(ws: &str, path: &str) -> Result<NoteContent, String> {
+pub async fn memory_read(ws: &str, scope: &MemoryScope, path: &str) -> Result<NoteContent, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         path: &'a str,
     }
     invoke_typed(
         "memory_read",
         A {
             workspace_cwd: ws,
+            scope,
             path,
         },
     )
     .await
 }
 
-pub async fn memory_write(ws: &str, path: &str, content: &str) -> Result<NoteContent, String> {
+pub async fn memory_write(
+    ws: &str,
+    scope: &MemoryScope,
+    path: &str,
+    content: &str,
+) -> Result<NoteContent, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         path: &'a str,
         content: &'a str,
     }
@@ -1272,6 +1386,7 @@ pub async fn memory_write(ws: &str, path: &str, content: &str) -> Result<NoteCon
         "memory_write",
         A {
             workspace_cwd: ws,
+            scope,
             path,
             content,
         },
@@ -1281,6 +1396,7 @@ pub async fn memory_write(ws: &str, path: &str, content: &str) -> Result<NoteCon
 
 pub async fn memory_create(
     ws: &str,
+    scope: &MemoryScope,
     path: &str,
     content: Option<&str>,
 ) -> Result<NoteMeta, String> {
@@ -1288,6 +1404,7 @@ pub async fn memory_create(
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         path: &'a str,
         #[serde(skip_serializing_if = "Option::is_none")]
         content: Option<&'a str>,
@@ -1296,6 +1413,7 @@ pub async fn memory_create(
         "memory_create",
         A {
             workspace_cwd: ws,
+            scope,
             path,
             content,
         },
@@ -1303,38 +1421,42 @@ pub async fn memory_create(
     .await
 }
 
-pub async fn memory_list_categories(ws: &str) -> Result<Vec<String>, String> {
-    invoke_typed("memory_list_categories", WsArg { workspace_cwd: ws }).await
-}
-
-pub async fn memory_create_category(ws: &str, name: &str) -> Result<String, String> {
+pub async fn memory_create_category(
+    ws: &str,
+    scope: &MemoryScope,
+    name: &str,
+) -> Result<String, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         name: &'a str,
     }
     invoke_typed(
         "memory_create_category",
         A {
             workspace_cwd: ws,
+            scope,
             name,
         },
     )
     .await
 }
 
-pub async fn memory_delete(ws: &str, path: &str) -> Result<(), String> {
+pub async fn memory_delete(ws: &str, scope: &MemoryScope, path: &str) -> Result<(), String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         path: &'a str,
     }
     invoke_unit_js(
         "memory_delete",
         args_value(A {
             workspace_cwd: ws,
+            scope,
             path,
         })?,
     )
@@ -1343,6 +1465,7 @@ pub async fn memory_delete(ws: &str, path: &str) -> Result<(), String> {
 
 pub async fn memory_rename(
     ws: &str,
+    scope: &MemoryScope,
     old_path: &str,
     new_path: &str,
     rewrite_links: bool,
@@ -1351,6 +1474,7 @@ pub async fn memory_rename(
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         old_path: &'a str,
         new_path: &'a str,
         rewrite_links: bool,
@@ -1359,6 +1483,7 @@ pub async fn memory_rename(
         "memory_rename",
         A {
             workspace_cwd: ws,
+            scope,
             old_path,
             new_path,
             rewrite_links,
@@ -1371,17 +1496,23 @@ pub async fn memory_graph(ws: &str) -> Result<GraphData, String> {
     invoke_typed("memory_graph", WsArg { workspace_cwd: ws }).await
 }
 
-pub async fn memory_backlinks(ws: &str, path: &str) -> Result<Vec<String>, String> {
+pub async fn memory_backlinks(
+    ws: &str,
+    scope: &MemoryScope,
+    path: &str,
+) -> Result<Vec<BacklinkRef>, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct A<'a> {
         workspace_cwd: &'a str,
+        scope: &'a MemoryScope,
         path: &'a str,
     }
     invoke_typed(
         "memory_backlinks",
         A {
             workspace_cwd: ws,
+            scope,
             path,
         },
     )
@@ -1824,11 +1955,7 @@ pub async fn git_status_changes(cwd: String) -> Result<Vec<ChangedFile>, String>
     invoke_typed("git_status_changes", Args { cwd }).await
 }
 
-pub async fn git_file_diff(
-    cwd: String,
-    rel_path: String,
-    staged: bool,
-) -> Result<String, String> {
+pub async fn git_file_diff(cwd: String, rel_path: String, staged: bool) -> Result<String, String> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     struct Args {
@@ -1905,7 +2032,8 @@ pub fn listen_git_status_dirty(
 #[wasm_bindgen]
 extern "C" {
     #[wasm_bindgen(catch, js_namespace = ["window", "__TAURI__", "event"], js_name = listen)]
-    async fn tauri_listen_raw(event: &str, callback: &js_sys::Function) -> Result<JsValue, JsValue>;
+    async fn tauri_listen_raw(event: &str, callback: &js_sys::Function)
+        -> Result<JsValue, JsValue>;
 }
 
 /// RAII handle returned by [`listen_tauri_event`]. Drop calls the
diff --git a/src/theme/catalog.rs b/src/theme/catalog.rs
index c0502a0..4c67d4c 100644
--- a/src/theme/catalog.rs
+++ b/src/theme/catalog.rs
@@ -240,10 +240,6 @@ pub fn is_valid_theme_id(id: &str) -> bool {
 pub fn themes_for_mode(mode: Option<ThemeMode>) -> Vec<AppTheme> {
     match mode {
         None => THEMES.iter().copied().collect(),
-        Some(m) => THEMES
-            .iter()
-            .copied()
-            .filter(|t| t.mode == m)
-            .collect(),
+        Some(m) => THEMES.iter().copied().filter(|t| t.mode == m).collect(),
     }
 }
diff --git a/src/theme/mod.rs b/src/theme/mod.rs
index 106ebec..620958d 100644
--- a/src/theme/mod.rs
+++ b/src/theme/mod.rs
@@ -1,7 +1,5 @@
 mod catalog;
 mod i18n;
 
-pub use catalog::{
-    is_valid_theme_id, theme_by_id, AppTheme, ThemeMode, DEFAULT_THEME_ID, THEMES,
-};
+pub use catalog::{is_valid_theme_id, theme_by_id, AppTheme, ThemeMode, DEFAULT_THEME_ID, THEMES};
 pub use i18n::{theme_desc_key, theme_name_key};
diff --git a/src/workbench/agent_context_handoff.rs b/src/workbench/agent_context_handoff.rs
index 6b0e673..1583a43 100644
--- a/src/workbench/agent_context_handoff.rs
+++ b/src/workbench/agent_context_handoff.rs
@@ -133,7 +133,10 @@ pub fn render_agent_context_block(input: &RenderInputs) -> String {
                         out.push_str(&format!("  - `{p}`\n"));
                     }
                 } else if item.paths.len() > 12 {
-                    out.push_str(&format!("  - ({} paths — see manifest)\n", item.paths.len()));
+                    out.push_str(&format!(
+                        "  - ({} paths — see manifest)\n",
+                        item.paths.len()
+                    ));
                 }
             }
         }
@@ -599,8 +602,8 @@ pub async fn perform_handoff(
 
     // Pull workspace-attached context once. We keep plan items separate from
     // memory-style items so the kind filters can be respected.
-    let attached = context_items
-        .unwrap_or_else(|| wb.agent_context_for_workspace_untracked(workspace_id));
+    let attached =
+        context_items.unwrap_or_else(|| wb.agent_context_for_workspace_untracked(workspace_id));
     let mut effective_items: Vec<AgentContextItem> = Vec::new();
     for item in attached {
         let is_plan = matches!(
@@ -1008,7 +1011,10 @@ fn build_plan_task_snapshot(
     for task in &snapshot.tasks {
         if let Some(path) = task.plan_path.as_deref() {
             if attached_plans.is_empty() || attached_plans.contains(path) {
-                buckets.entry(path.to_owned()).or_default().push(task.clone());
+                buckets
+                    .entry(path.to_owned())
+                    .or_default()
+                    .push(task.clone());
             }
         }
     }
@@ -1120,10 +1126,7 @@ pub fn file_snippet_context_item(
         Some(ws) if !ws.is_empty() => format!("file-snippet:{ws}:{rel_path}:{start}-{end}"),
         _ => format!("file-snippet:{rel_path}:{start}-{end}"),
     };
-    let source = format!(
-        "{} · lines {start}-{end}",
-        language.unwrap_or("text")
-    );
+    let source = format!("{} · lines {start}-{end}", language.unwrap_or("text"));
     AgentContextItem {
         id,
         kind: AgentContextKind::FileSnippet,
@@ -1204,10 +1207,7 @@ mod tests {
             workspace_root: Some("/repo".into()),
             include_memory: true,
             include_images: true,
-            context_items: vec![note_context_item(
-                "learnings/index.md",
-                "Learnings",
-            )],
+            context_items: vec![note_context_item("learnings/index.md", "Learnings")],
             images: vec![RenderImageMeta {
                 id: "img".into(),
                 label: "Shot".into(),
@@ -1352,15 +1352,7 @@ mod tests {
 
     #[test]
     fn file_snippet_item_id_includes_workspace_when_provided() {
-        let item = file_snippet_context_item(
-            "src/foo.rs",
-            1,
-            1,
-            None,
-            "S",
-            "x",
-            Some("Demo"),
-        );
+        let item = file_snippet_context_item("src/foo.rs", 1, 1, None, "S", "x", Some("Demo"));
         assert_eq!(item.id, "file-snippet:Demo:src/foo.rs:1-1");
     }
 
diff --git a/src/workbench/agent_model_picker/mod.rs b/src/workbench/agent_model_picker/mod.rs
index 159dbc1..e6f518b 100644
--- a/src/workbench/agent_model_picker/mod.rs
+++ b/src/workbench/agent_model_picker/mod.rs
@@ -78,13 +78,7 @@ fn focus_by_id(id: &str) {
 fn model_option_dom_id(prefix: &str, model_id: &str) -> String {
     let slug: String = model_id
         .chars()
-        .map(|c| {
-            if c.is_ascii_alphanumeric() {
-                c
-            } else {
-                '-'
-            }
-        })
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
         .collect();
     format!("{prefix}-option-{slug}")
 }
@@ -94,10 +88,8 @@ pub fn AgentModelPicker(
     model_id: RwSignal<String>,
     model_entries: RwSignal<Vec<ProviderModelEntry>>,
     loading_models: RwSignal<bool>,
-    #[prop(default = "agent-model")]
-    option_id_prefix: &'static str,
-    #[prop(default = true)]
-    show_custom_field: bool,
+    #[prop(default = "agent-model")] option_id_prefix: &'static str,
+    #[prop(default = true)] show_custom_field: bool,
     #[prop(optional)] on_change: Option<Callback<String>>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
diff --git a/src/workbench/agent_panel/ask_user_card/mod.rs b/src/workbench/agent_panel/ask_user_card/mod.rs
index 52bf0bc..b13ed60 100644
--- a/src/workbench/agent_panel/ask_user_card/mod.rs
+++ b/src/workbench/agent_panel/ask_user_card/mod.rs
@@ -300,12 +300,7 @@ fn mark_cancelled(timeline: RwSignal<Vec<TimelineItem>>, call_id: &str) {
     });
 }
 
-fn submit_async(
-    call_id: String,
-    ok: bool,
-    message: String,
-    data: Option<serde_json::Value>,
-) {
+fn submit_async(call_id: String, ok: bool, message: String, data: Option<serde_json::Value>) {
     leptos::task::spawn_local(async move {
         let _ = agent_submit_tool_result(call_id, ok, Some(message), data).await;
     });
diff --git a/src/workbench/agent_panel/client_tools.rs b/src/workbench/agent_panel/client_tools.rs
index 15b082f..2fb8942 100644
--- a/src/workbench/agent_panel/client_tools.rs
+++ b/src/workbench/agent_panel/client_tools.rs
@@ -273,8 +273,9 @@ fn handle_memory_context_attach(
         };
         leptos::task::spawn_local(async move {
             match memory_list(&cwd).await {
-                Ok(notes) => {
-                    let paths: Vec<String> = notes
+                Ok(resp) => {
+                    let paths: Vec<String> = resp
+                        .notes
                         .into_iter()
                         .filter(|n| {
                             if category == "learnings" {
diff --git a/src/workbench/agent_panel/mod.rs b/src/workbench/agent_panel/mod.rs
index fa12a05..f563a7d 100644
--- a/src/workbench/agent_panel/mod.rs
+++ b/src/workbench/agent_panel/mod.rs
@@ -22,14 +22,13 @@ use crate::workbench::agent_panel::image_context::{
     clear_drop_state, handle_dom_drag_event, handle_dom_drop, install_agent_image_intake,
     DropZoneState,
 };
-use crate::workbench::agent_panel::task_list::TaskSection;
 use crate::workbench::agent_panel::subagent_debounce::{
     is_subagent_timeline_event, SubagentEventDebounce,
 };
+use crate::workbench::agent_panel::task_list::TaskSection;
 use crate::workbench::agent_panel::timeline::{
     apply_agent_event, compact_timeline, ChatLineIndexColumn, TimelineItem, TimelineRow,
 };
-use std::rc::Rc;
 use crate::workbench::agent_panel::voice_orb::{
     handle_voice_event, install_ptt_hotkey, VoiceOrb, VoiceOrbHandle,
 };
@@ -38,6 +37,7 @@ use leptos::html;
 use leptos::prelude::*;
 use leptos_icons::Icon as LxIcon;
 use std::collections::HashMap;
+use std::rc::Rc;
 use wasm_bindgen::JsCast;
 
 #[component]
@@ -146,10 +146,7 @@ pub fn AgentPanelDock() -> impl IntoView {
             // Prime the handoff renderer cache so terminal handoffs after
             // a workspace reload see the restored plan-task state.
             if let Some(ws_id) = active {
-                crate::workbench::agent_context_handoff::store_task_snapshot(
-                    ws_id,
-                    next.clone(),
-                );
+                crate::workbench::agent_context_handoff::store_task_snapshot(ws_id, next.clone());
             }
             task_snapshot_sig.set(next);
         });
diff --git a/src/workbench/agent_panel/timeline.rs b/src/workbench/agent_panel/timeline.rs
index 83e77ea..64a56b1 100644
--- a/src/workbench/agent_panel/timeline.rs
+++ b/src/workbench/agent_panel/timeline.rs
@@ -2,6 +2,8 @@ use crate::agent_wire::{AgentEvent, TaskSnapshot, TurnMetrics, TurnUsageKind};
 use crate::i18n::{lookup, I18nKey, Locale};
 use crate::service::I18nService;
 use crate::tauri_bridge::{is_tauri_shell, voice_settings_get};
+use crate::workbench::agent_panel::ask_user_card::AskUserCard;
+use crate::workbench::agent_panel::turn_metrics_bar::{BarContext, TurnMetricsBar};
 use crate::workbench::agent_panel::voice_orb::{
     play_line_tts, tts_line_playback_available, VoiceOrbHandle,
 };
@@ -10,8 +12,6 @@ use crate::workbench::agent_timeline::{
     subagent_role_label, subagent_status_label, ActivityStatus, AskUserOption, AskUserState,
     SubagentCard, SubagentGroup, SubagentStepRow, ToolActivity,
 };
-use crate::workbench::agent_panel::ask_user_card::AskUserCard;
-use crate::workbench::agent_panel::turn_metrics_bar::{BarContext, TurnMetricsBar};
 use crate::workbench::chat_markdown::render_markdown_to_html;
 use crate::workbench::WorkbenchService;
 use leptos::prelude::*;
@@ -20,7 +20,9 @@ use std::collections::HashMap;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum DisplayTimelineItem {
-    User { text: String },
+    User {
+        text: String,
+    },
     Assistant {
         text: String,
         /// Latest user-message text preceding this assistant block — used as
@@ -37,7 +39,10 @@ pub enum DisplayTimelineItem {
         tools: Vec<ToolActivity>,
     },
     SubagentGroup(SubagentGroup),
-    Thinking { text: String, done: bool },
+    Thinking {
+        text: String,
+        done: bool,
+    },
     GeneratedImage {
         prompt: String,
         mime: String,
@@ -75,7 +80,10 @@ fn persist_agent_timeline(
             .filter(|item| {
                 !matches!(
                     item,
-                    TimelineItem::AskUser { state: AskUserState::Open, .. }
+                    TimelineItem::AskUser {
+                        state: AskUserState::Open,
+                        ..
+                    }
                 )
             })
             .map(|item| match item {
@@ -86,13 +94,15 @@ fn persist_agent_timeline(
                     saved_path,
                     filename,
                 } => {
-                    let drop_preview = saved_path
-                        .as_deref()
-                        .is_some_and(|p| !p.trim().is_empty());
+                    let drop_preview = saved_path.as_deref().is_some_and(|p| !p.trim().is_empty());
                     TimelineItem::GeneratedImage {
                         prompt,
                         mime,
-                        preview_src: if drop_preview { String::new() } else { preview_src },
+                        preview_src: if drop_preview {
+                            String::new()
+                        } else {
+                            preview_src
+                        },
                         saved_path,
                         filename,
                     }
@@ -163,10 +173,9 @@ fn find_subagent_card_mut<'a>(
     agent_id: &str,
 ) -> Option<&'a mut SubagentCard> {
     rows.iter_mut().rev().find_map(|entry| match entry {
-        TimelineItem::SubagentGroup(group) => group
-            .agents
-            .iter_mut()
-            .find(|c| c.agent_id == agent_id),
+        TimelineItem::SubagentGroup(group) => {
+            group.agents.iter_mut().find(|c| c.agent_id == agent_id)
+        }
         _ => None,
     })
 }
@@ -282,7 +291,11 @@ pub fn apply_agent_event(
             });
             persist_agent_timeline(persist, timeline);
         }
-        AgentEvent::ToolCall { tool, args, call_id } => {
+        AgentEvent::ToolCall {
+            tool,
+            args,
+            call_id,
+        } => {
             if tool == "harness.ask_user" {
                 if let Some((call_id, ask)) = call_id
                     .clone()
@@ -306,8 +319,7 @@ pub fn apply_agent_event(
                 // user at least sees something landed. The client_tools.rs
                 // dispatcher will short-circuit the result with ok=false.
             }
-            let entry =
-                ToolActivity::from_call_with_id(tool, args.as_ref(), loc, call_id.clone());
+            let entry = ToolActivity::from_call_with_id(tool, args.as_ref(), loc, call_id.clone());
             timeline.update(|rows| rows.push(TimelineItem::Tool(entry)));
             persist_agent_timeline(persist, timeline);
         }
@@ -393,11 +405,7 @@ pub fn apply_agent_event(
         } => {
             timeline.update(|rows| {
                 if let Some(card) = find_subagent_card_mut(rows, agent_id) {
-                    if let Some(step) = card
-                        .steps
-                        .iter_mut()
-                        .find(|s| s.id == *step_id)
-                    {
+                    if let Some(step) = card.steps.iter_mut().find(|s| s.id == *step_id) {
                         step.title = title.clone();
                         step.status = status.clone();
                         step.note = note.clone();
@@ -413,7 +421,12 @@ pub fn apply_agent_event(
             });
             persist_agent_timeline(persist, timeline);
         }
-        AgentEvent::SubagentToolCall { agent_id, tool, args, .. } => {
+        AgentEvent::SubagentToolCall {
+            agent_id,
+            tool,
+            args,
+            ..
+        } => {
             let entry = ToolActivity::from_call(tool, args.as_ref(), loc);
             timeline.update(|rows| {
                 if let Some(card) = find_subagent_card_mut(rows, agent_id) {
@@ -462,25 +475,27 @@ pub fn apply_agent_event(
             };
 
             // 2) Per-row routing — the 4 cases from the plan.
-            timeline.update(|rows| match (*kind, agent_id.as_deref(), call_id.as_deref()) {
-                (TurnUsageKind::ToolExec, None, Some(call_id)) => {
-                    attach_main_tool_exec(rows, call_id, metrics);
-                }
-                (TurnUsageKind::ToolExec, Some(agent_id), Some(call_id)) => {
-                    attach_subagent_tool_exec(rows, agent_id, call_id, metrics);
-                }
-                (TurnUsageKind::ModelRound, None, _) => {
-                    attach_main_model_round(rows, metrics);
-                }
-                (TurnUsageKind::ModelRound, Some(agent_id), _) => {
-                    if let Some(card) = find_subagent_card_mut(rows, agent_id) {
-                        card.metrics.merge(&metrics);
+            timeline.update(
+                |rows| match (*kind, agent_id.as_deref(), call_id.as_deref()) {
+                    (TurnUsageKind::ToolExec, None, Some(call_id)) => {
+                        attach_main_tool_exec(rows, call_id, metrics);
                     }
-                }
-                // ToolExec without a call_id is malformed — nothing to
-                // route to, the session aggregate above still counted it.
-                (TurnUsageKind::ToolExec, _, None) => {}
-            });
+                    (TurnUsageKind::ToolExec, Some(agent_id), Some(call_id)) => {
+                        attach_subagent_tool_exec(rows, agent_id, call_id, metrics);
+                    }
+                    (TurnUsageKind::ModelRound, None, _) => {
+                        attach_main_model_round(rows, metrics);
+                    }
+                    (TurnUsageKind::ModelRound, Some(agent_id), _) => {
+                        if let Some(card) = find_subagent_card_mut(rows, agent_id) {
+                            card.metrics.merge(&metrics);
+                        }
+                    }
+                    // ToolExec without a call_id is malformed — nothing to
+                    // route to, the session aggregate above still counted it.
+                    (TurnUsageKind::ToolExec, _, None) => {}
+                },
+            );
             persist_agent_timeline(persist, timeline);
         }
         AgentEvent::SubagentAssistantDelta { agent_id, delta } => {
@@ -607,9 +622,9 @@ fn synthesize_completion_message(rows: &[TimelineItem]) -> Option<String> {
         .iter()
         .rposition(|entry| matches!(entry, TimelineItem::User { .. }))?;
 
-    let has_assistant_after_user = rows[last_user_idx + 1..]
-        .iter()
-        .any(|entry| matches!(entry, TimelineItem::Assistant { text, .. } if !text.trim().is_empty()));
+    let has_assistant_after_user = rows[last_user_idx + 1..].iter().any(
+        |entry| matches!(entry, TimelineItem::Assistant { text, .. } if !text.trim().is_empty()),
+    );
     if has_assistant_after_user {
         return None;
     }
@@ -661,11 +676,7 @@ fn synthesize_completion_message(rows: &[TimelineItem]) -> Option<String> {
 fn merge_consecutive_model_rounds(items: Vec<DisplayTimelineItem>) -> Vec<DisplayTimelineItem> {
     let mut out: Vec<DisplayTimelineItem> = Vec::new();
     for item in items {
-        if let DisplayTimelineItem::ModelRound {
-            metrics,
-            mut tools,
-        } = item
-        {
+        if let DisplayTimelineItem::ModelRound { metrics, mut tools } = item {
             // Only collapse single-tool rounds with the same tool name as the
             // previous round.
             if tools.len() == 1 {
@@ -675,9 +686,7 @@ fn merge_consecutive_model_rounds(items: Vec<DisplayTimelineItem>) -> Vec<Displa
                     tools: prev_tools,
                 }) = out.last_mut()
                 {
-                    if prev_tools.len() == 1
-                        && prev_tools[0].tool == incoming_tool.tool
-                    {
+                    if prev_tools.len() == 1 && prev_tools[0].tool == incoming_tool.tool {
                         let prev = &mut prev_tools[0];
                         prev.paths.extend(incoming_tool.paths);
                         prev.metrics.merge(&incoming_tool.metrics);
@@ -716,9 +725,7 @@ fn group_consecutive_tools(tools: Vec<ToolActivity>) -> Vec<ToolActivity> {
                 last.merged_count += t.merged_count;
                 if t.status == ActivityStatus::Fail {
                     last.status = ActivityStatus::Fail;
-                } else if last.status == ActivityStatus::Ok
-                    && t.status == ActivityStatus::Pending
-                {
+                } else if last.status == ActivityStatus::Ok && t.status == ActivityStatus::Pending {
                     last.status = ActivityStatus::Pending;
                 }
                 continue;
@@ -751,7 +758,10 @@ pub fn compact_timeline(items: Vec<TimelineItem>) -> Vec<DisplayTimelineItem> {
                 // Collect the tool calls that follow this model round into a
                 // single grouped block instead of emitting separate Tool rows.
                 let mut tools = Vec::new();
-                while iter.peek().is_some_and(|x| matches!(x, TimelineItem::Tool(_))) {
+                while iter
+                    .peek()
+                    .is_some_and(|x| matches!(x, TimelineItem::Tool(_)))
+                {
                     if let Some(TimelineItem::Tool(t)) = iter.next() {
                         tools.push(t);
                     }
@@ -1255,9 +1265,7 @@ fn GeneratedImageRow(
             return;
         }
         leptos::task::spawn_local(async move {
-            if let Ok(resp) =
-                crate::tauri_bridge::generated_image_preview(path).await
-            {
+            if let Ok(resp) = crate::tauri_bridge::generated_image_preview(path).await {
                 preview.set(format!("data:{};base64,{}", resp.mime, resp.bytes_b64));
             }
         });
@@ -1446,4 +1454,3 @@ fn ToolActivityRow(
         </li>
     }
 }
-
diff --git a/src/workbench/agent_panel/turn_metrics_bar/mod.rs b/src/workbench/agent_panel/turn_metrics_bar/mod.rs
index 58b7e7a..65d26fe 100644
--- a/src/workbench/agent_panel/turn_metrics_bar/mod.rs
+++ b/src/workbench/agent_panel/turn_metrics_bar/mod.rs
@@ -47,7 +47,10 @@ pub fn TurnMetricsBar(metrics: TurnMetrics, context: BarContext) -> impl IntoVie
         _ => dash.clone(),
     };
     let ttft = metrics.ttft_ms.map(fmt_ms).unwrap_or_else(|| dash.clone());
-    let cost = metrics.cost_usd.map(fmt_cost).unwrap_or_else(|| dash.clone());
+    let cost = metrics
+        .cost_usd
+        .map(fmt_cost)
+        .unwrap_or_else(|| dash.clone());
 
     let label_in = lookup(loc, I18nKey::AgMetricsIn);
     let label_out = lookup(loc, I18nKey::AgMetricsOut);
diff --git a/src/workbench/agent_panel/voice_orb/mod.rs b/src/workbench/agent_panel/voice_orb/mod.rs
index 15d22d4..424e2b9 100644
--- a/src/workbench/agent_panel/voice_orb/mod.rs
+++ b/src/workbench/agent_panel/voice_orb/mod.rs
@@ -248,16 +248,11 @@ pub fn handle_voice_event(audio_ref: NodeRef<html::Audio>, ev: &AgentEvent) {
 /// True when App voice settings have a non-empty TTS model (provider is always set).
 #[must_use]
 pub fn tts_line_playback_available(settings: Option<&VoiceSettings>) -> bool {
-    settings
-        .is_some_and(|s| !s.tts.model_id.trim().is_empty())
+    settings.is_some_and(|s| !s.tts.model_id.trim().is_empty())
 }
 
 /// Synthesize and play one chat line via configured TTS (same API as voice settings preview).
-pub fn play_line_tts(
-    audio_ref: NodeRef<html::Audio>,
-    settings: VoiceSettings,
-    text: String,
-) {
+pub fn play_line_tts(audio_ref: NodeRef<html::Audio>, settings: VoiceSettings, text: String) {
     let text = text.trim().to_owned();
     if text.is_empty() {
         return;
diff --git a/src/workbench/agent_provider_pane/mod.rs b/src/workbench/agent_provider_pane/mod.rs
index c4da278..09bfd6a 100644
--- a/src/workbench/agent_provider_pane/mod.rs
+++ b/src/workbench/agent_provider_pane/mod.rs
@@ -97,7 +97,10 @@ fn provider_key_status_text(
     }
 }
 
-fn provider_cache(view: &AgentProviderSettingsView, provider: AgentProviderKind) -> Vec<ProviderModelEntry> {
+fn provider_cache(
+    view: &AgentProviderSettingsView,
+    provider: AgentProviderKind,
+) -> Vec<ProviderModelEntry> {
     match provider {
         AgentProviderKind::Openrouter => view.model_cache_openrouter.clone(),
         AgentProviderKind::Anthropic => view.model_cache_anthropic.clone(),
diff --git a/src/workbench/agent_timeline.rs b/src/workbench/agent_timeline.rs
index 8ee742a..9edeeff 100644
--- a/src/workbench/agent_timeline.rs
+++ b/src/workbench/agent_timeline.rs
@@ -228,7 +228,9 @@ pub enum AskUserState {
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum TimelineItem {
-    User { text: String },
+    User {
+        text: String,
+    },
     Assistant {
         text: String,
         /// Per-row metrics aggregated from `ModelRound` events whose visible
@@ -238,7 +240,10 @@ pub enum TimelineItem {
         metrics: TurnMetrics,
     },
     Tool(ToolActivity),
-    Thinking { text: String, done: bool },
+    Thinking {
+        text: String,
+        done: bool,
+    },
     SubagentGroup(SubagentGroup),
     /// Synthetic row inserted for tool-only model rounds (no assistant
     /// text was emitted). Carries the round's metrics so cost / tokens
@@ -287,7 +292,12 @@ fn summarize_args(tool: &str, args: Option<&Value>) -> String {
     let pick = match tool {
         "harness.create_workspace" => Some("title"),
         "list_workspace_files" => Some("path"),
-        "read_workspace_file" | "memory_read" | "memory_create" | "memory_write" | "memory_delete" | "memory_backlinks" => Some("path"),
+        "read_workspace_file"
+        | "memory_read"
+        | "memory_create"
+        | "memory_write"
+        | "memory_delete"
+        | "memory_backlinks" => Some("path"),
         "memory_rename" => Some("newPath"),
         "memory_search" => Some("query"),
         "memory_category_update" => Some("category"),
@@ -332,10 +342,13 @@ fn file_arg_path(tool: &str, args: Option<&Value>) -> Option<String> {
             let name = args.get("name")?.as_str()?;
             Some(format!(".agents/skills/{name}/SKILL.md"))
         }
-        "read_workspace_file" | "memory_read" | "memory_create" | "memory_write"
-        | "memory_delete" | "memory_backlinks" | "list_workspace_files" => {
-            args.get("path")?.as_str().map(|s| s.to_owned())
-        }
+        "read_workspace_file"
+        | "memory_read"
+        | "memory_create"
+        | "memory_write"
+        | "memory_delete"
+        | "memory_backlinks"
+        | "list_workspace_files" => args.get("path")?.as_str().map(|s| s.to_owned()),
         "memory_rename" => args.get("newPath")?.as_str().map(|s| s.to_owned()),
         _ => None,
     }
diff --git a/src/workbench/api_keys_pane/mod.rs b/src/workbench/api_keys_pane/mod.rs
index 0b2ea80..bc91566 100644
--- a/src/workbench/api_keys_pane/mod.rs
+++ b/src/workbench/api_keys_pane/mod.rs
@@ -294,13 +294,17 @@ fn ApiKeyRow(entry: ApiKeyEntry, drafts: RwSignal<DraftMap>) -> impl IntoView {
 
     let kind_for_delete_check = kind.clone();
     let marked_delete = Signal::derive(move || {
-        drafts.with(|m| matches!(m.get(kind_for_delete_check.as_ref()), Some(DraftAction::Delete)))
+        drafts.with(|m| {
+            matches!(
+                m.get(kind_for_delete_check.as_ref()),
+                Some(DraftAction::Delete)
+            )
+        })
     });
 
     let kind_for_dirty = kind.clone();
-    let row_dirty = Signal::derive(move || {
-        drafts.with(|m| m.contains_key(kind_for_dirty.as_ref()))
-    });
+    let row_dirty =
+        Signal::derive(move || drafts.with(|m| m.contains_key(kind_for_dirty.as_ref())));
 
     let kind_for_input = kind.clone();
     let on_input = move |ev: web_sys::Event| {
diff --git a/src/workbench/chat_markdown.rs b/src/workbench/chat_markdown.rs
index 5df9e12..e799556 100644
--- a/src/workbench/chat_markdown.rs
+++ b/src/workbench/chat_markdown.rs
@@ -29,11 +29,8 @@ fn strip_known_prefixes(path: &str) -> Cow<'_, str> {
     Cow::Borrowed(t)
 }
 
-const MEMORY_PATH_PREFIXES: &[&str] = &[
-    ".agents/learnings/",
-    ".agents/memory/",
-    ".blxcode/memory/",
-];
+const MEMORY_PATH_PREFIXES: &[&str] =
+    &[".agents/learnings/", ".agents/memory/", ".blxcode/memory/"];
 
 fn memory_rel_from_display_path(display_path: &str) -> Option<String> {
     let t = display_path.trim();
@@ -174,6 +171,22 @@ pub fn preprocess_agent_chat_markdown(src: &str) -> String {
     out
 }
 
+fn strip_yaml_frontmatter(src: &str) -> &str {
+    let rest = src
+        .strip_prefix("---\r\n")
+        .or_else(|| src.strip_prefix("---\n"));
+    let Some(rest) = rest else {
+        return src;
+    };
+
+    for marker in ["\n---\r\n", "\n---\n", "\n...\r\n", "\n...\n"] {
+        if let Some(pos) = rest.find(marker) {
+            return &rest[pos + marker.len()..];
+        }
+    }
+    src
+}
+
 /// Strips `blx-open` from fenced-block info lines (first token only) and records whether each
 /// fence should start expanded.
 fn normalize_blx_open_fenced_markers(md: &str) -> (String, Vec<bool>) {
@@ -487,9 +500,7 @@ fn postprocess_html_inline_code_memory_paths(html: &mut String) {
         rest = &rest[en + 7..];
         let trimmed = inner.trim();
         if !inner.contains('\n')
-            && MEMORY_PATH_PREFIXES
-                .iter()
-                .any(|p| trimmed.starts_with(p))
+            && MEMORY_PATH_PREFIXES.iter().any(|p| trimmed.starts_with(p))
             && trimmed.to_ascii_lowercase().ends_with(".md")
         {
             if let Some(rel) = memory_rel_from_display_path(trimmed) {
@@ -510,7 +521,7 @@ fn postprocess_html_inline_code_memory_paths(html: &mut String) {
 
 #[must_use]
 pub fn render_markdown_to_html(src: &str) -> String {
-    let prepped = preprocess_agent_chat_markdown(src);
+    let prepped = preprocess_agent_chat_markdown(strip_yaml_frontmatter(src));
     let (md_for_cmark, fence_expand) = normalize_blx_open_fenced_markers(&prepped);
     let mut opts = Options::empty();
     opts.insert(Options::ENABLE_TABLES);
@@ -583,6 +594,23 @@ fn main() {}
         assert!(!html.contains("```"));
     }
 
+    #[test]
+    fn render_strips_yaml_frontmatter() {
+        let md = "---\ntitle: Learnings\nenabled: true\n---\n# Learnings\n";
+        let html = render_markdown_to_html(md);
+        assert!(!html.contains("title:"));
+        assert!(!html.contains("enabled:"));
+        assert!(html.contains("<h1>Learnings</h1>"));
+    }
+
+    #[test]
+    fn render_keeps_horizontal_rule_without_frontmatter_close() {
+        let md = "---\n# Title\n";
+        let html = render_markdown_to_html(md);
+        assert!(html.contains("<hr"));
+        assert!(html.contains("<h1>Title</h1>"));
+    }
+
     #[test]
     fn vague_markdown_fence_shows_inferred_rust_in_summary() {
         let html = r#"<pre><code class="language-markdown">fn main() {
diff --git a/src/workbench/file_preview/code_context_menu.rs b/src/workbench/file_preview/code_context_menu.rs
index 6725fee..f7fe34a 100644
--- a/src/workbench/file_preview/code_context_menu.rs
+++ b/src/workbench/file_preview/code_context_menu.rs
@@ -13,9 +13,7 @@
 
 use crate::i18n::I18nKey;
 use crate::service::I18nService;
-use crate::workbench::agent_context_handoff::{
-    WorkspaceTerminalGroup, WorkspaceTerminalTarget,
-};
+use crate::workbench::agent_context_handoff::{WorkspaceTerminalGroup, WorkspaceTerminalTarget};
 use leptos::prelude::*;
 
 /// Action emitted from a menu item. The parent component holds the
diff --git a/src/workbench/file_preview/code_view.rs b/src/workbench/file_preview/code_view.rs
index f4e6f42..4bac378 100644
--- a/src/workbench/file_preview/code_view.rs
+++ b/src/workbench/file_preview/code_view.rs
@@ -9,8 +9,7 @@ use crate::i18n::I18nKey;
 use crate::service::I18nService;
 use crate::tauri_bridge::{is_tauri_shell, pty_write, read_workspace_text_file};
 use crate::workbench::agent_context_handoff::{
-    file_snippet_context_item, list_terminal_targets_all_workspaces,
-    render_file_snippet_envelope,
+    file_snippet_context_item, list_terminal_targets_all_workspaces, render_file_snippet_envelope,
 };
 use crate::workbench::file_preview::code_context_menu::{
     CodeContextMenu, CodeContextMenuState, CodeMenuAction,
@@ -169,42 +168,36 @@ pub fn CodeView(
 
     // Window-level mouseup ends any in-progress drag, even if the pointer
     // left the code area. We register once and clean up with on_cleanup.
-    let mouseup_handle = leptos::leptos_dom::helpers::window_event_listener_untyped(
-        "mouseup",
-        move |_| {
+    let mouseup_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped("mouseup", move |_| {
             if drag_anchor.get_untracked().is_some() {
                 drag_anchor.set(None);
                 drag_moved.set(false);
             }
-        },
-    );
+        });
     on_cleanup(move || drop(mouseup_handle));
 
     // Click anywhere closes the menu. We listen at window level instead of
     // installing per-element listeners so the menu closes consistently for
     // every dismissal path (clicking another row, the page background, etc.).
-    let click_close_handle = leptos::leptos_dom::helpers::window_event_listener_untyped(
-        "mousedown",
-        move |_| {
+    let click_close_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped("mousedown", move |_| {
             if menu_state.get_untracked().is_some() {
                 menu_state.set(None);
             }
-        },
-    );
+        });
     on_cleanup(move || drop(click_close_handle));
 
     // Escape key also closes the menu.
-    let escape_handle = leptos::leptos_dom::helpers::window_event_listener_untyped(
-        "keydown",
-        move |ev| {
+    let escape_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped("keydown", move |ev| {
             let Some(kev) = ev.dyn_ref::<web_sys::KeyboardEvent>() else {
                 return;
             };
             if kev.key() == "Escape" && menu_state.get_untracked().is_some() {
                 menu_state.set(None);
             }
-        },
-    );
+        });
     on_cleanup(move || drop(escape_handle));
 
     let rel_path_for_actions = rel_path.clone();
@@ -442,7 +435,11 @@ fn handle_menu_action(
                 language,
                 &plain_lines,
                 range,
-                if cross { Some(&preview_workspace_label) } else { None },
+                if cross {
+                    Some(&preview_workspace_label)
+                } else {
+                    None
+                },
             );
             let payload = if snippet.ends_with('\n') {
                 snippet
@@ -458,15 +455,13 @@ fn handle_menu_action(
                 let b64 = base64::engine::general_purpose::STANDARD.encode(payload.as_bytes());
                 match pty_write(session_id, b64).await {
                     Ok(()) => {
-                        let msg = i18n_for_msg
-                            .tr(I18nKey::CodeViewToastSnippetInsertedTerminal)()
+                        let msg = i18n_for_msg.tr(I18nKey::CodeViewToastSnippetInsertedTerminal)()
                             .replace("{terminal}", &target_label)
                             .replace("{workspace}", &ws_label);
                         toast.success(msg);
                     }
                     Err(e) => {
-                        let msg = i18n_for_msg
-                            .tr(I18nKey::CodeViewToastInsertFailed)()
+                        let msg = i18n_for_msg.tr(I18nKey::CodeViewToastInsertFailed)()
                             .replace("{error}", &e);
                         toast.error(msg);
                     }
@@ -484,7 +479,11 @@ fn handle_menu_action(
                 language,
                 &plain_lines,
                 range,
-                if cross { Some(&preview_workspace_label) } else { None },
+                if cross {
+                    Some(&preview_workspace_label)
+                } else {
+                    None
+                },
             );
             let target_workspace_root = wb.workspaces().with_untracked(|all| {
                 all.iter()
@@ -505,7 +504,11 @@ fn handle_menu_action(
                 range,
                 language,
                 &snippet,
-                if cross { Some(&preview_workspace_label) } else { None },
+                if cross {
+                    Some(&preview_workspace_label)
+                } else {
+                    None
+                },
             );
             let toast = toast;
             let i18n_for_msg = i18n;
@@ -516,15 +519,13 @@ fn handle_menu_action(
                 let b64 = base64::engine::general_purpose::STANDARD.encode(envelope.as_bytes());
                 match pty_write(session_id, b64).await {
                     Ok(()) => {
-                        let msg = i18n_for_msg
-                            .tr(I18nKey::CodeViewToastEnvelopeInsertedTerminal)()
+                        let msg = i18n_for_msg.tr(I18nKey::CodeViewToastEnvelopeInsertedTerminal)()
                             .replace("{terminal}", &target_label)
                             .replace("{workspace}", &ws_label);
                         toast.success(msg);
                     }
                     Err(e) => {
-                        let msg = i18n_for_msg
-                            .tr(I18nKey::CodeViewToastInsertFailed)()
+                        let msg = i18n_for_msg.tr(I18nKey::CodeViewToastInsertFailed)()
                             .replace("{error}", &e);
                         toast.error(msg);
                     }
@@ -541,7 +542,11 @@ fn handle_menu_action(
                 language,
                 &plain_lines,
                 range,
-                if cross { Some(&preview_workspace_label) } else { None },
+                if cross {
+                    Some(&preview_workspace_label)
+                } else {
+                    None
+                },
             );
             let item_label = if range.0 == range.1 {
                 format!("Snippet · {}:{}", rel_path, range.0)
@@ -555,24 +560,21 @@ fn handle_menu_action(
                 language,
                 &item_label,
                 &snippet,
-                if cross { Some(&preview_workspace_label) } else { None },
+                if cross {
+                    Some(&preview_workspace_label)
+                } else {
+                    None
+                },
             );
             wb.upsert_workspace_agent_context(workspace_id, item);
-            let msg = i18n
-                .tr(I18nKey::CodeViewToastAgentAttached)()
+            let msg = i18n.tr(I18nKey::CodeViewToastAgentAttached)()
                 .replace("{workspace}", &workspace_label);
             toast.success(msg);
         }
         CodeMenuAction::CopySnippet => {
             let cross_label_unused = (); // always preview workspace for clipboard
             let _ = cross_label_unused;
-            let snippet = build_file_snippet_block(
-                rel_path,
-                language,
-                &plain_lines,
-                range,
-                None,
-            );
+            let snippet = build_file_snippet_block(rel_path, language, &plain_lines, range, None);
             copy_to_clipboard(snippet, i18n, toast, I18nKey::CodeViewToastCopiedSnippet);
         }
         CodeMenuAction::CopyRange => {
@@ -612,8 +614,7 @@ fn copy_to_clipboard(text: String, i18n: I18nService, toast: ToastService, succe
                             .and_then(|v| v.as_string())
                     })
                     .unwrap_or_else(|| "unknown".to_string());
-                let msg = i18n_for_msg
-                    .tr(I18nKey::CodeViewToastClipboardFailed)()
+                let msg = i18n_for_msg.tr(I18nKey::CodeViewToastClipboardFailed)()
                     .replace("{error}", &err);
                 toast.error(msg);
             }
diff --git a/src/workbench/file_preview/hljs_glue.rs b/src/workbench/file_preview/hljs_glue.rs
index 4068830..6377762 100644
--- a/src/workbench/file_preview/hljs_glue.rs
+++ b/src/workbench/file_preview/hljs_glue.rs
@@ -62,8 +62,8 @@ pub async fn ensure_hljs_loaded() -> Result<(), String> {
 pub async fn highlight(code: &str, language: &str) -> Result<String, String> {
     ensure_hljs_loaded().await?;
     let hljs = hljs_global().ok_or("hljs not available")?;
-    let highlight_fn = Reflect::get(&hljs, &JsValue::from_str("highlight"))
-        .map_err(|_| "no hljs.highlight")?;
+    let highlight_fn =
+        Reflect::get(&hljs, &JsValue::from_str("highlight")).map_err(|_| "no hljs.highlight")?;
     let highlight_fn: Function = highlight_fn
         .dyn_into()
         .map_err(|_| "hljs.highlight not callable")?;
@@ -75,12 +75,8 @@ pub async fn highlight(code: &str, language: &str) -> Result<String, String> {
         &JsValue::from_str(language),
     )
     .map_err(|_| "set language")?;
-    Reflect::set(
-        &opts,
-        &JsValue::from_str("ignoreIllegals"),
-        &JsValue::TRUE,
-    )
-    .map_err(|_| "set ignoreIllegals")?;
+    Reflect::set(&opts, &JsValue::from_str("ignoreIllegals"), &JsValue::TRUE)
+        .map_err(|_| "set ignoreIllegals")?;
 
     let result = highlight_fn
         .call2(&hljs, &JsValue::from_str(code), &opts)
diff --git a/src/workbench/file_preview/markdown_view.rs b/src/workbench/file_preview/markdown_view.rs
index c361547..92f68f4 100644
--- a/src/workbench/file_preview/markdown_view.rs
+++ b/src/workbench/file_preview/markdown_view.rs
@@ -43,10 +43,8 @@ fn render_markdown(src: &str) -> String {
             Event::End(TagEnd::CodeBlock) if in_mermaid => {
                 let escaped = html_escape(&mermaid_buf);
                 buffered.push(Event::Html(
-                    format!(
-                        r#"<pre class="mermaid file-preview__mermaid-inline">{escaped}</pre>"#
-                    )
-                    .into(),
+                    format!(r#"<pre class="mermaid file-preview__mermaid-inline">{escaped}</pre>"#)
+                        .into(),
                 ));
                 in_mermaid = false;
                 mermaid_buf.clear();
diff --git a/src/workbench/file_preview/mermaid_glue.rs b/src/workbench/file_preview/mermaid_glue.rs
index 6dc1d6d..b3fd4df 100644
--- a/src/workbench/file_preview/mermaid_glue.rs
+++ b/src/workbench/file_preview/mermaid_glue.rs
@@ -13,13 +13,15 @@ const MERMAID_SRC: &str = "/public/vendor/mermaid/mermaid.min.js";
 
 fn mermaid_global() -> Option<JsValue> {
     let w = web_sys::window()?;
-    Reflect::get(&w, &JsValue::from_str("mermaid")).ok().and_then(|v| {
-        if v.is_undefined() || v.is_null() {
-            None
-        } else {
-            Some(v)
-        }
-    })
+    Reflect::get(&w, &JsValue::from_str("mermaid"))
+        .ok()
+        .and_then(|v| {
+            if v.is_undefined() || v.is_null() {
+                None
+            } else {
+                Some(v)
+            }
+        })
 }
 
 /// Returns `Ok(())` once `globalThis.mermaid` exists. Inserts a `<script>`
@@ -58,17 +60,26 @@ pub async fn ensure_mermaid_loaded() -> Result<(), String> {
 
 fn initialize_mermaid() -> Result<(), String> {
     let mermaid = mermaid_global().ok_or("mermaid not available")?;
-    let init = Reflect::get(&mermaid, &JsValue::from_str("initialize"))
-        .map_err(|_| "no initialize")?;
+    let init =
+        Reflect::get(&mermaid, &JsValue::from_str("initialize")).map_err(|_| "no initialize")?;
     let init: Function = init.dyn_into().map_err(|_| "initialize not callable")?;
     let opts = Object::new();
     Reflect::set(&opts, &JsValue::from_str("startOnLoad"), &JsValue::FALSE)
         .map_err(|_| "set startOnLoad")?;
-    Reflect::set(&opts, &JsValue::from_str("securityLevel"), &JsValue::from_str("strict"))
-        .map_err(|_| "set securityLevel")?;
-    Reflect::set(&opts, &JsValue::from_str("theme"), &JsValue::from_str("dark"))
-        .map_err(|_| "set theme")?;
-    init.call1(&mermaid, &opts).map_err(|e| format!("mermaid.initialize: {e:?}"))?;
+    Reflect::set(
+        &opts,
+        &JsValue::from_str("securityLevel"),
+        &JsValue::from_str("strict"),
+    )
+    .map_err(|_| "set securityLevel")?;
+    Reflect::set(
+        &opts,
+        &JsValue::from_str("theme"),
+        &JsValue::from_str("dark"),
+    )
+    .map_err(|_| "set theme")?;
+    init.call1(&mermaid, &opts)
+        .map_err(|e| format!("mermaid.initialize: {e:?}"))?;
     Ok(())
 }
 
diff --git a/src/workbench/file_preview/util.rs b/src/workbench/file_preview/util.rs
index 40cc9b7..fb5cf82 100644
--- a/src/workbench/file_preview/util.rs
+++ b/src/workbench/file_preview/util.rs
@@ -338,7 +338,10 @@ fn strip_tag_blocks(input: &str, tag: &str) -> String {
         let open_start = cursor + rel;
         let after_name = open_start + open_tok.len();
         let after_name_ch = lower.as_bytes().get(after_name).copied();
-        if !matches!(after_name_ch, Some(b' ' | b'\t' | b'\n' | b'\r' | b'>' | b'/')) {
+        if !matches!(
+            after_name_ch,
+            Some(b' ' | b'\t' | b'\n' | b'\r' | b'>' | b'/')
+        ) {
             out.push_str(&input[cursor..=open_start]);
             cursor = open_start + 1;
             continue;
@@ -657,30 +660,16 @@ z</span>w</span>"#;
 
     #[test]
     fn build_file_snippet_block_without_language_leaves_fence_tag_empty() {
-        let out = build_file_snippet_block(
-            "notes/log.txt",
-            None,
-            &sample_plain_lines(),
-            (1, 1),
-            None,
-        );
+        let out =
+            build_file_snippet_block("notes/log.txt", None, &sample_plain_lines(), (1, 1), None);
         // Fence opens with bare three backticks (no lang tag).
         assert!(out.contains("```\nlet a = 1;\n```"));
     }
 
     #[test]
     fn build_file_snippet_block_preserves_utf8() {
-        let lines: Vec<String> = vec![
-            "Grüße aus München".into(),
-            "你好世界 ✓".into(),
-        ];
-        let out = build_file_snippet_block(
-            "i18n.md",
-            None,
-            &lines,
-            (1, 2),
-            None,
-        );
+        let lines: Vec<String> = vec!["Grüße aus München".into(), "你好世界 ✓".into()];
+        let out = build_file_snippet_block("i18n.md", None, &lines, (1, 2), None);
         assert!(out.contains("Grüße aus München"));
         assert!(out.contains("你好世界 ✓"));
         // Header sanity-checks UTF-8 path safety too.
@@ -690,13 +679,8 @@ z</span>w</span>"#;
     #[test]
     fn build_file_snippet_block_clamps_out_of_range() {
         // start above total -> clamp to last line; end below start -> raised to start.
-        let out = build_file_snippet_block(
-            "x.rs",
-            Some("rust"),
-            &sample_plain_lines(),
-            (99, 1),
-            None,
-        );
+        let out =
+            build_file_snippet_block("x.rs", Some("rust"), &sample_plain_lines(), (99, 1), None);
         assert!(out.contains("**`x.rs:4`**"));
         assert!(out.contains("let d = 4;"));
     }
diff --git a/src/workbench/git_graph/mod.rs b/src/workbench/git_graph/mod.rs
index fb68ba4..9a73089 100644
--- a/src/workbench/git_graph/mod.rs
+++ b/src/workbench/git_graph/mod.rs
@@ -131,9 +131,7 @@ pub fn GitGraphSection(git_repo_available: ReadSignal<Option<bool>>) -> impl Int
         listener_for_cleanup.borrow_mut().take();
     });
 
-    let show = move || {
-        !collapsed.get() && git_repo_available.get() == Some(true)
-    };
+    let show = move || !collapsed.get() && git_repo_available.get() == Some(true);
 
     view! {
         <Show when=show>
diff --git a/src/workbench/harness_chords.rs b/src/workbench/harness_chords.rs
index 09584e6..0540a8b 100644
--- a/src/workbench/harness_chords.rs
+++ b/src/workbench/harness_chords.rs
@@ -2,7 +2,9 @@
 
 use super::app_prefs::{AppPrefsService, ShortcutMode};
 use super::browser_tab::sync_embedded_browser_layer;
-use super::state::{BrowserEmbedSurface, HarnessUiService, RightPanelTab, SlotPaneState, WorkbenchService};
+use super::state::{
+    BrowserEmbedSurface, HarnessUiService, RightPanelTab, SlotPaneState, WorkbenchService,
+};
 use gloo_timers::future::TimeoutFuture;
 use leptos::prelude::*;
 use wasm_bindgen::JsCast;
@@ -249,7 +251,12 @@ fn handle_legacy_keydown(
         match key.as_str() {
             "p" | "P" => {
                 ke.prevent_default();
-                dispatch_shortcut_action(HarnessShortcutAction::ToggleCommandPalette, ui, wb, embed);
+                dispatch_shortcut_action(
+                    HarnessShortcutAction::ToggleCommandPalette,
+                    ui,
+                    wb,
+                    embed,
+                );
                 return true;
             }
             "a" | "A" => {
diff --git a/src/workbench/harness_image_pane/mod.rs b/src/workbench/harness_image_pane/mod.rs
index 5907bfb..4b532a3 100644
--- a/src/workbench/harness_image_pane/mod.rs
+++ b/src/workbench/harness_image_pane/mod.rs
@@ -180,10 +180,7 @@ fn looks_like_image_model(id: &str) -> bool {
         || l.contains("imagen")
 }
 
-async fn fetch_image_models(
-    provider: ImageProviderKind,
-    out: RwSignal<Vec<ProviderModelEntry>>,
-) {
+async fn fetch_image_models(provider: ImageProviderKind, out: RwSignal<Vec<ProviderModelEntry>>) {
     if provider == ImageProviderKind::Fal {
         if let Ok(resp) = image_curated_models(provider).await {
             let entries = resp
diff --git a/src/workbench/harness_ui.rs b/src/workbench/harness_ui.rs
index f49302e..40ad9c2 100644
--- a/src/workbench/harness_ui.rs
+++ b/src/workbench/harness_ui.rs
@@ -3,7 +3,6 @@
 //! Tastenkürzel (tmux-Standard: `Ctrl+b` + zweite Taste; Legacy in App-Einstellungen)
 //! sind im Haupt-Webview gebunden ([`HarnessHost`] → [`super::harness_chords`]).
 use super::app_prefs::{AppPrefsService, ShortcutMode};
-use super::voice_app_controls::{VoicePttControls, VoiceSttLanguageControls};
 use super::browser_tab::sync_embedded_browser_layer;
 use super::harness_chords::handle_harness_keydown;
 use super::state::{
@@ -11,6 +10,7 @@ use super::state::{
     RecentWorkspaceItem, RightPanelTab, WorkbenchService,
 };
 use super::update_service::{UpdateService, UpdateUiStatus};
+use super::voice_app_controls::{VoicePttControls, VoiceSttLanguageControls};
 use crate::i18n::{lookup, I18nKey, Locale, APP_LOCALES};
 use crate::service::I18nService;
 use crate::tauri_bridge::{
diff --git a/src/workbench/harness_voice_pane/mod.rs b/src/workbench/harness_voice_pane/mod.rs
index 6218e95..6ccc52b 100644
--- a/src/workbench/harness_voice_pane/mod.rs
+++ b/src/workbench/harness_voice_pane/mod.rs
@@ -4,11 +4,10 @@
 use crate::i18n::I18nKey;
 use crate::service::I18nService;
 use crate::tauri_bridge::{
-    agent_provider_models, agent_settings_get, api_keys_status, is_tauri_shell,
-    voice_settings_get, voice_settings_save, voice_tts_preview,
-    AgentProviderKind, AgentProviderSettingsView, ApiKeyEntry, ApiKeysStatus, PostSttFlow,
-    ProviderModelEntry, SttSettings, TtsSettings, VoiceEntry, VoiceGender, VoiceProviderKind,
-    VoiceSettings,
+    agent_provider_models, agent_settings_get, api_keys_status, is_tauri_shell, voice_settings_get,
+    voice_settings_save, voice_tts_preview, AgentProviderKind, AgentProviderSettingsView,
+    ApiKeyEntry, ApiKeysStatus, PostSttFlow, ProviderModelEntry, SttSettings, TtsSettings,
+    VoiceEntry, VoiceGender, VoiceProviderKind, VoiceSettings,
 };
 use crate::workbench::agent_model_picker::AgentModelPicker;
 use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
@@ -254,10 +253,7 @@ fn voice_catalog_for(provider: VoiceProviderKind) -> Vec<VoiceEntry> {
 }
 
 fn voices_pick_enabled(provider: VoiceProviderKind) -> bool {
-    matches!(
-        provider,
-        VoiceProviderKind::Openai | VoiceProviderKind::Aws
-    )
+    matches!(provider, VoiceProviderKind::Openai | VoiceProviderKind::Aws)
 }
 
 fn is_openai_voice_id(id: &str) -> bool {
@@ -911,8 +907,7 @@ fn VoicePicksGrid(
     on_pick: Callback<String>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
-    let picks_enabled =
-        Memo::new(move |_| voices_pick_enabled(voice_provider.get()));
+    let picks_enabled = Memo::new(move |_| voices_pick_enabled(voice_provider.get()));
     view! {
         <div class="voice-pane__voice-picks">
             <div class="voice-pane__gender-row">
diff --git a/src/workbench/memory_graph/mod.rs b/src/workbench/memory_graph/mod.rs
index 2d9dfe6..9c6edfc 100644
--- a/src/workbench/memory_graph/mod.rs
+++ b/src/workbench/memory_graph/mod.rs
@@ -3,18 +3,18 @@ mod graph_glue;
 use crate::i18n::I18nKey;
 use crate::open_http::{dom_click_nav_href, DomNavHref};
 use crate::service::I18nService;
-use crate::tauri_bridge::{self, GraphData, NoteContent};
+use crate::tauri_bridge::{self, GraphData, MemoryScope, NoteContent};
+use crate::workbench::agent_context_handoff::HandoffMenu;
 use crate::workbench::chat_markdown::render_markdown_to_html;
 use crate::workbench::memory_graph::graph_glue::{
     ensure_graph3d_script, graph3d_create, graph3d_dispose, graph3d_fly_to_node,
     graph3d_reset_view, graph3d_resize, graph3d_set_data, graph3d_zoom,
 };
-use crate::workbench::agent_context_handoff::HandoffMenu;
 use crate::workbench::memory_panel::{
     expand_files_group_for_path, load_note, refresh_graph, MemoryState, MemoryView,
 };
-use crate::workbench::WorkbenchService;
 use crate::workbench::ThemeService;
+use crate::workbench::WorkbenchService;
 use gloo_timers::future::TimeoutFuture;
 use leptos::html;
 use leptos::leptos_dom::helpers::window_event_listener_untyped;
@@ -68,6 +68,7 @@ impl GraphMode {
 #[derive(Clone, Copy)]
 struct GraphPreviewState {
     open: RwSignal<bool>,
+    scope: RwSignal<MemoryScope>,
     path: RwSignal<Option<String>>,
     label: RwSignal<String>,
     content: RwSignal<String>,
@@ -78,6 +79,7 @@ impl GraphPreviewState {
     fn new() -> Self {
         Self {
             open: RwSignal::new(false),
+            scope: RwSignal::new(MemoryScope::Workspace),
             path: RwSignal::new(None),
             label: RwSignal::new(String::new()),
             content: RwSignal::new(String::new()),
@@ -394,26 +396,26 @@ fn Graph3dView(
     let click_handle = {
         let state = state.clone();
         window_event_listener_untyped("blxcode-graph3d-node-click", move |ev| {
-        let Some(custom) = ev.dyn_ref::<web_sys::CustomEvent>() else {
-            return;
-        };
-        let detail = custom.detail();
-        let event_graph_id =
-            js_sys::Reflect::get(&detail, &wasm_bindgen::JsValue::from_str("graphId"))
-                .ok()
-                .and_then(|v| v.as_f64());
-        if event_graph_id != graph_id.get_untracked() {
-            return;
-        }
-        let Some(node_id) =
-            js_sys::Reflect::get(&detail, &wasm_bindgen::JsValue::from_str("nodeId"))
-                .ok()
-                .and_then(|v| v.as_string())
-        else {
-            return;
-        };
-        state.graph_selected_node.set(Some(node_id.clone()));
-        open_preview.run(node_id);
+            let Some(custom) = ev.dyn_ref::<web_sys::CustomEvent>() else {
+                return;
+            };
+            let detail = custom.detail();
+            let event_graph_id =
+                js_sys::Reflect::get(&detail, &wasm_bindgen::JsValue::from_str("graphId"))
+                    .ok()
+                    .and_then(|v| v.as_f64());
+            if event_graph_id != graph_id.get_untracked() {
+                return;
+            }
+            let Some(node_id) =
+                js_sys::Reflect::get(&detail, &wasm_bindgen::JsValue::from_str("nodeId"))
+                    .ok()
+                    .and_then(|v| v.as_string())
+            else {
+                return;
+            };
+            state.graph_selected_node.set(Some(node_id.clone()));
+            open_preview.run(node_id);
         })
     };
 
@@ -633,12 +635,18 @@ fn Graph2dView(
                                     None => true,
                                 };
                                 let (stroke, width) = if hov.is_none() {
-                                    (edge_default.clone(), "1".to_string())
+                                    let stroke = if e.cross_scope {
+                                        edge_active.clone()
+                                    } else {
+                                        edge_default.clone()
+                                    };
+                                    (stroke, "1".to_string())
                                 } else if incident {
                                     (edge_active.clone(), "1.6".to_string())
                                 } else {
                                     (edge_dim.clone(), "1".to_string())
                                 };
+                                let dasharray = if e.cross_scope { "5 4" } else { "" };
                                 Some(view! {
                                     <line
                                         x1=sx.to_string()
@@ -648,6 +656,7 @@ fn Graph2dView(
                                         stroke=stroke
                                         stroke-width=width
                                         stroke-linecap="round"
+                                        stroke-dasharray=dasharray
                                     />
                                 })
                             }).collect::<Vec<_>>()
@@ -679,7 +688,12 @@ fn Graph2dView(
                             nodes.into_iter().filter_map(|n| {
                                 let (x, y) = *pos.get(&n.id)?;
                                 let deg = degrees.get(&n.id).copied().unwrap_or(0);
-                                let radius = 4.0_f32 + (deg as f32).sqrt() * 2.5;
+                                let is_hub = n.is_category_hub.unwrap_or(false);
+                                let radius = if is_hub {
+                                    8.0_f32 + (deg as f32).sqrt() * 2.2
+                                } else {
+                                    4.0_f32 + (deg as f32).sqrt() * 2.5
+                                };
                                 let is_selected = selected.as_deref() == Some(n.id.as_str());
                                 let (focus_state, is_hovered) = match hov.as_deref() {
                                     Some(h) if h == n.id => (NodeFocus::Hovered, true),
@@ -689,7 +703,18 @@ fn Graph2dView(
                                     }
                                     None => (NodeFocus::Normal, false),
                                 };
-                                let base_fill = n.color.clone().unwrap_or_else(|| cluster_color(&n.tags, n.orphan));
+                                let base_fill = n.color.clone().unwrap_or_else(|| {
+                                    if is_hub {
+                                        let warm = read_css_var("--accent-warm");
+                                        if warm.is_empty() {
+                                            "#f59e0b".to_string()
+                                        } else {
+                                            warm
+                                        }
+                                    } else {
+                                        cluster_color(&n.tags, n.orphan)
+                                    }
+                                });
                                 let fill = match focus_state {
                                     NodeFocus::Dim => fade_color(&base_fill, 0.18),
                                     _ => base_fill,
@@ -715,8 +740,13 @@ fn Graph2dView(
                                 let id_for_click = n.id.clone();
                                 let id_for_enter = n.id.clone();
                                 let label = clean_display_label(&n.label);
+                                let node_class = if is_hub {
+                                    "workbench-memory-graph__node workbench-memory-graph__node--hub"
+                                } else {
+                                    "workbench-memory-graph__node"
+                                };
                                 Some(view! {
-                                    <g class="workbench-memory-graph__node"
+                                    <g class=node_class
                                         on:click=move |_| {
                                             state.graph_selected_node.set(Some(id_for_click.clone()));
                                             open_preview.run(id_for_click.clone());
@@ -724,14 +754,31 @@ fn Graph2dView(
                                         on:mouseenter=move |_| hovered.set(Some(id_for_enter.clone()))
                                         on:mouseleave=move |_| hovered.set(None)
                                     >
-                                        <circle
-                                            cx=x.to_string()
-                                            cy=y.to_string()
-                                            r=radius.to_string()
-                                            fill=fill
-                                            stroke=stroke
-                                            stroke-width=stroke_width
-                                        />
+                                        {if is_hub {
+                                            view! {
+                                                <rect
+                                                    x=(x - radius).to_string()
+                                                    y=(y - radius * 0.72).to_string()
+                                                    width=(radius * 2.05).to_string()
+                                                    height=(radius * 1.55).to_string()
+                                                    rx="2.5"
+                                                    fill=fill
+                                                    stroke=stroke
+                                                    stroke-width=stroke_width
+                                                />
+                                            }.into_any()
+                                        } else {
+                                            view! {
+                                                <circle
+                                                    cx=x.to_string()
+                                                    cy=y.to_string()
+                                                    r=radius.to_string()
+                                                    fill=fill
+                                                    stroke=stroke
+                                                    stroke-width=stroke_width
+                                                />
+                                            }.into_any()
+                                        }}
                                         {(label_opacity > 0.0 || label_force_visible).then(|| view! {
                                             <text
                                                 x=(x + radius + 3.0).to_string()
@@ -767,8 +814,9 @@ fn GraphPreviewPopover(
             if let Some(DomNavHref::Memory(path)) = dom_click_nav_href(&ev) {
                 ev.prevent_default();
                 ev.stop_propagation();
-                state.graph_selected_node.set(Some(path.clone()));
-                open_preview.run(path);
+                let node_id = tauri_bridge::note_key(&preview.scope.get_untracked(), &path);
+                state.graph_selected_node.set(Some(node_id.clone()));
+                open_preview.run(node_id);
             }
         }
     };
@@ -807,9 +855,10 @@ fn GraphPreviewPopover(
                             on:click=move |_| {
                                 let Some(ws) = state.workspace_cwd.get_untracked() else { return };
                                 let Some(path) = preview.path.get_untracked() else { return };
-                                expand_files_group_for_path(state.clone(), &path);
+                                let scope = preview.scope.get_untracked();
+                                expand_files_group_for_path(state.clone(), &scope, &path);
                                 preview.open.set(false);
-                                load_note(state.clone(), ws, path);
+                                load_note(state.clone(), ws, scope, path);
                                 state.view.set(MemoryView::Files);
                             }
                         >
@@ -842,23 +891,36 @@ fn GraphPreviewPopover(
     }
 }
 
-fn open_graph_preview(state: MemoryState, preview: GraphPreviewState, path: String) {
-    state.graph_selected_node.set(Some(path.clone()));
+fn open_graph_preview(state: MemoryState, preview: GraphPreviewState, node_id: String) {
+    state.graph_selected_node.set(Some(node_id.clone()));
     preview.open.set(true);
-    preview.path.set(Some(path.clone()));
-    preview.label.set(label_for_path(&state, &path));
     preview.content.set(String::new());
     preview.loading.set(true);
+
+    if let Some(category) = node_id.strip_prefix("hub:") {
+        preview.scope.set(MemoryScope::Workspace);
+        preview.path.set(None);
+        preview.label.set(clean_display_label(category));
+        preview.content.set(hub_summary_markdown(&state, category));
+        preview.loading.set(false);
+        return;
+    }
+
+    let (scope, path) =
+        tauri_bridge::parse_note_key(&node_id).unwrap_or((MemoryScope::Workspace, node_id.clone()));
+    preview.scope.set(scope.clone());
+    preview.path.set(Some(path.clone()));
+    preview.label.set(label_for_node_id(&state, &node_id));
     let Some(ws) = state.workspace_cwd.get_untracked() else {
         preview.loading.set(false);
         return;
     };
     spawn_local(async move {
         TimeoutFuture::new(40).await;
-        match tauri_bridge::memory_read(&ws, &path).await {
+        match tauri_bridge::memory_read(&ws, &scope, &path).await {
             Ok(NoteContent { content, .. }) => {
                 preview.content.set(content);
-                preview.label.set(label_for_path(&state, &path));
+                preview.label.set(label_for_node_id(&state, &node_id));
                 preview.path.set(Some(path));
             }
             Err(e) => {
@@ -869,17 +931,48 @@ fn open_graph_preview(state: MemoryState, preview: GraphPreviewState, path: Stri
     });
 }
 
-fn label_for_path(state: &MemoryState, path: &str) -> String {
+fn hub_summary_markdown(state: &MemoryState, category: &str) -> String {
+    let Some(graph) = state.graph.get_untracked() else {
+        return String::new();
+    };
+    let mut notes: Vec<_> = graph
+        .nodes
+        .iter()
+        .filter(|node| node.category == category && !node.is_category_hub.unwrap_or(false))
+        .map(|node| {
+            let scope = match node.scope {
+                MemoryScope::Workspace => "workspace",
+                MemoryScope::Global => "global",
+            };
+            format!("- `{scope}` {}", clean_display_label(&node.label))
+        })
+        .collect();
+    notes.sort();
+    if notes.is_empty() {
+        format!(
+            "## {}\n\nNo notes in this category.",
+            clean_display_label(category)
+        )
+    } else {
+        format!(
+            "## {}\n\n{}",
+            clean_display_label(category),
+            notes.join("\n")
+        )
+    }
+}
+
+fn label_for_node_id(state: &MemoryState, node_id: &str) -> String {
     state
         .graph
         .get_untracked()
         .and_then(|g| {
             g.nodes
                 .iter()
-                .find(|node| node.id == path)
+                .find(|node| node.id == node_id)
                 .map(|node| clean_display_label(&node.label))
         })
-        .unwrap_or_else(|| clean_display_label(path))
+        .unwrap_or_else(|| clean_display_label(node_id))
 }
 
 fn clean_display_label(raw: &str) -> String {
@@ -978,7 +1071,7 @@ fn configured_graph(wb: WorkbenchService, graph: Option<GraphData>) -> Option<Gr
             return false;
         }
         node.color = Some(settings.color);
-        node.category = Some(category);
+        node.category = category;
         true
     });
     let visible: HashSet<String> = graph.nodes.iter().map(|node| node.id.clone()).collect();
@@ -1082,21 +1175,15 @@ fn force_layout(g: &GraphData, w: f32, h: f32, iters: u32) -> HashMap<String, (f
         .collect();
     let k = (w * h / (n as f32 + 1.0)).sqrt().max(20.0);
     let mut t = w.min(h) * 0.1;
-    let categories: Vec<String> = g
-        .nodes
-        .iter()
-        .map(|node| {
-            node.category
-                .clone()
-                .unwrap_or_else(|| graph_category_for_path(&node.id))
-        })
-        .collect();
+    let categories: Vec<String> = g.nodes.iter().map(|node| node.category.clone()).collect();
     let cluster_strength = 0.04_f32;
     for _ in 0..iters {
         // Per-category centroid (attracts same-category nodes toward each other).
         let mut centroids: HashMap<&str, (f32, f32, u32)> = HashMap::new();
         for i in 0..n {
-            let entry = centroids.entry(categories[i].as_str()).or_insert((0.0, 0.0, 0));
+            let entry = centroids
+                .entry(categories[i].as_str())
+                .or_insert((0.0, 0.0, 0));
             entry.0 += pos[i].0;
             entry.1 += pos[i].1;
             entry.2 += 1;
@@ -1156,9 +1243,11 @@ fn force_layout(g: &GraphData, w: f32, h: f32, iters: u32) -> HashMap<String, (f
         .collect()
 }
 
-/// Switch to Graph (3D), select `path`, and fly to that node when the graph is ready.
-pub fn navigate_to_graph_node(state: MemoryState, path: String) {
-    state.graph_selected_node.set(Some(path));
+/// Switch to Graph (3D), select a scoped note, and fly to that node when the graph is ready.
+pub fn navigate_to_graph_node(state: MemoryState, scope: MemoryScope, path: String) {
+    state
+        .graph_selected_node
+        .set(Some(tauri_bridge::note_key(&scope, &path)));
     state.graph_focus_generation.update(|n| *n += 1);
     state.graph_prefer_3d.set(true);
     state.view.set(MemoryView::Graph);
diff --git a/src/workbench/memory_panel.rs b/src/workbench/memory_panel.rs
index 149c7f2..6aad5a8 100644
--- a/src/workbench/memory_panel.rs
+++ b/src/workbench/memory_panel.rs
@@ -5,7 +5,9 @@ use crate::agent_wire::{AgentContextItem, AgentContextKind};
 use crate::i18n::I18nKey;
 use crate::memory_paths::slug_to_filename;
 use crate::service::I18nService;
-use crate::tauri_bridge::{self, GraphData, NoteContent, NoteMeta, SearchHit};
+use crate::tauri_bridge::{
+    self, note_key, BacklinkRef, GraphData, MemoryScope, NoteContent, NoteMeta, SearchHit,
+};
 use crate::workbench::chat_markdown::render_markdown_to_html;
 use crate::workbench::memory_graph::{navigate_to_graph_node, MemoryGraphView};
 use crate::workbench::state::{normalize_hex_color, MemoryCategorySettings};
@@ -21,8 +23,7 @@ use web_sys::HtmlInputElement;
 
 const SAVE_DEBOUNCE_MS: u32 = 600;
 const LEARNINGS_API_PREFIX: &str = "learnings/";
-const LEARNINGS_INDEX_PATHS: &[&str] = &["learnings/LEARNINGS.md", "learnings/LEARNIGS.md"];
-const MEMORY_INDEX_PATHS: &[&str] = &["README.md", "MEMORY.md"];
+const LEARNINGS_INDEX_PATHS: &[&str] = &["learnings/README.md"];
 /// Built-in pseudo categories — top-level memory files and the learnings root.
 const CATEGORY_MEMORY: &str = "memory";
 const CATEGORY_LEARNINGS: &str = "learnings";
@@ -52,20 +53,25 @@ pub(crate) struct MemoryState {
     pub(crate) workspace_cwd: RwSignal<Option<String>>,
     pub(crate) notes: RwSignal<Vec<NoteMeta>>,
     pub(crate) active_path: RwSignal<Option<String>>,
+    pub(crate) active_scope: RwSignal<MemoryScope>,
     pub(crate) editor_content: RwSignal<String>,
     pub(crate) editor_dirty: RwSignal<bool>,
     pub(crate) show_preview: RwSignal<bool>,
-    pub(crate) backlinks: RwSignal<Vec<String>>,
+    pub(crate) backlinks: RwSignal<Vec<BacklinkRef>>,
     pub(crate) view: RwSignal<MemoryView>,
     pub(crate) error: RwSignal<Option<String>>,
     pub(crate) save_token: RwSignal<u32>,
     pub(crate) graph: RwSignal<Option<GraphData>>,
     pub(crate) search_query: RwSignal<String>,
     pub(crate) search_results: RwSignal<Vec<SearchHit>>,
-    /// Expanded category groups in the Files sidebar (dynamic keys).
+    /// Expanded category groups in the Files sidebar (keys: plain for workspace, "global:cat" for global).
     pub(crate) groups_open: RwSignal<HashSet<String>>,
-    /// User-created categories that have no notes yet (subdirs under memory root).
+    /// User-created workspace categories that have no notes yet.
     pub(crate) empty_categories: RwSignal<Vec<String>>,
+    /// User-created global categories that have no notes yet.
+    pub(crate) global_subcategories: RwSignal<Vec<String>>,
+    /// True once global memory folders are known to exist.
+    pub(crate) global_bootstrapped: RwSignal<bool>,
     /// Selected graph node (API path); shared across Graph / Search / Files.
     pub(crate) graph_selected_node: RwSignal<Option<String>>,
     /// Bumped to re-run fly-to animation for the current selection.
@@ -80,6 +86,7 @@ impl MemoryState {
             workspace_cwd: RwSignal::new(None),
             notes: RwSignal::new(Vec::new()),
             active_path: RwSignal::new(None),
+            active_scope: RwSignal::new(MemoryScope::Workspace),
             editor_content: RwSignal::new(String::new()),
             editor_dirty: RwSignal::new(false),
             show_preview: RwSignal::new(false),
@@ -92,6 +99,8 @@ impl MemoryState {
             search_results: RwSignal::new(Vec::new()),
             groups_open: RwSignal::new(HashSet::new()),
             empty_categories: RwSignal::new(Vec::new()),
+            global_subcategories: RwSignal::new(Vec::new()),
+            global_bootstrapped: RwSignal::new(false),
             graph_selected_node: RwSignal::new(None),
             graph_focus_generation: RwSignal::new(0),
             graph_prefer_3d: RwSignal::new(false),
@@ -100,8 +109,12 @@ impl MemoryState {
 }
 
 /// Ensure the Files sidebar group containing `path` is expanded.
-pub(crate) fn expand_files_group_for_path(state: MemoryState, path: &str) {
-    let key = category_for_path(path);
+pub(crate) fn expand_files_group_for_path(state: MemoryState, scope: &MemoryScope, path: &str) {
+    let cat = category_for_path(path);
+    let key = match scope {
+        MemoryScope::Global => format!("global:{cat}"),
+        MemoryScope::Workspace => cat,
+    };
     state.groups_open.update(|open| {
         open.insert(key);
     });
@@ -118,37 +131,42 @@ fn current_workspace_cwd(wb: WorkbenchService) -> Option<String> {
 }
 
 fn load_notes(state: MemoryState, ws: String) {
-    let ws_cat = ws.clone();
     spawn_local(async move {
         match tauri_bridge::memory_list(&ws).await {
-            Ok(list) => {
-                state.notes.set(list);
+            Ok(resp) => {
+                state
+                    .empty_categories
+                    .set(resp.memory_subcategories.workspace);
+                state
+                    .global_subcategories
+                    .set(resp.memory_subcategories.global);
+                state.notes.set(resp.notes);
                 state.error.set(None);
             }
             Err(e) => state.error.set(Some(e)),
         }
-    });
-    spawn_local(async move {
-        if let Ok(list) = tauri_bridge::memory_list_categories(&ws_cat).await {
-            state.empty_categories.set(list);
+        if let Ok(status) = tauri_bridge::memory_status(&ws).await {
+            state
+                .global_bootstrapped
+                .set(status.global.memory || status.global.learnings);
         }
     });
 }
 
-pub(crate) fn load_note(state: MemoryState, ws: String, path: String) {
+pub(crate) fn load_note(state: MemoryState, ws: String, scope: MemoryScope, path: String) {
     spawn_local(async move {
-        match tauri_bridge::memory_read(&ws, &path).await {
+        match tauri_bridge::memory_read(&ws, &scope, &path).await {
             Ok(NoteContent { content, .. }) => {
                 state.editor_content.set(content);
                 state.editor_dirty.set(false);
                 state.show_preview.set(true);
                 state.active_path.set(Some(path.clone()));
+                state.active_scope.set(scope.clone());
                 state.error.set(None);
-                // backlinks for this note
                 let ws2 = ws.clone();
                 let p2 = path.clone();
                 spawn_local(async move {
-                    match tauri_bridge::memory_backlinks(&ws2, &p2).await {
+                    match tauri_bridge::memory_backlinks(&ws2, &scope, &p2).await {
                         Ok(v) => state.backlinks.set(v),
                         Err(_) => state.backlinks.set(Vec::new()),
                     }
@@ -165,16 +183,16 @@ fn schedule_save(state: MemoryState, ws: String) {
     let save_token = state.save_token;
     let path = state.active_path.get_untracked();
     let Some(path) = path else { return };
+    let scope = state.active_scope.get_untracked();
     let content = state.editor_content.get_untracked();
     spawn_local(async move {
         TimeoutFuture::new(SAVE_DEBOUNCE_MS).await;
         if save_token.get_untracked() != token {
             return;
         }
-        match tauri_bridge::memory_write(&ws, &path, &content).await {
+        match tauri_bridge::memory_write(&ws, &scope, &path, &content).await {
             Ok(_) => {
                 state.editor_dirty.set(false);
-                // refresh list (mtime/size update); cheap.
                 load_notes(state.clone(), ws.clone());
             }
             Err(e) => state.error.set(Some(e)),
@@ -203,7 +221,7 @@ pub fn MemoryPanel() -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let state = MemoryState::new();
 
-    // Track active workspace cwd; reload notes when it changes.
+    // Track active workspace cwd; bootstrap workspace memory and reload notes when it changes.
     let eff_state = state.clone();
     Effect::new(move |_| {
         let cwd = current_workspace_cwd(wb);
@@ -211,13 +229,20 @@ pub fn MemoryPanel() -> impl IntoView {
         if cwd != prev {
             eff_state.workspace_cwd.set(cwd.clone());
             eff_state.active_path.set(None);
+            eff_state.active_scope.set(MemoryScope::Workspace);
             eff_state.editor_content.set(String::new());
             eff_state.editor_dirty.set(false);
             eff_state.backlinks.set(Vec::new());
             eff_state.graph.set(None);
             eff_state.notes.set(Vec::new());
+            eff_state.global_bootstrapped.set(false);
             if let Some(ws) = cwd {
-                load_notes(eff_state.clone(), ws);
+                let st = eff_state.clone();
+                let ws2 = ws.clone();
+                spawn_local(async move {
+                    let _ = tauri_bridge::memory_bootstrap(&ws2, "workspace").await;
+                    load_notes(st, ws2);
+                });
             }
         }
     });
@@ -236,7 +261,7 @@ pub fn MemoryPanel() -> impl IntoView {
             };
             wb.pending_memory_note().set(None);
             st.view.set(MemoryView::Files);
-            load_note(st.clone(), ws, rel);
+            load_note(st.clone(), ws, MemoryScope::Workspace, rel);
         }
     });
 
@@ -346,8 +371,99 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
     let groups_open = state.groups_open;
     let context_menu = RwSignal::new(None::<MemoryContextMenu>);
     let editing_category = RwSignal::new(None::<String>);
-    let new_category_open = RwSignal::new(false);
-    let new_note_category = RwSignal::new(None::<String>);
+    // Some(scope) = dialog open for that scope; None = closed.
+    let new_category_scope: RwSignal<Option<MemoryScope>> = RwSignal::new(None);
+    let new_note_category: RwSignal<Option<(MemoryScope, String)>> = RwSignal::new(None);
+
+    let make_groups = {
+        let s = state.clone();
+        move |scope: MemoryScope| {
+            let _ = wb.workspaces().get();
+            let empty = match scope {
+                MemoryScope::Workspace => s.empty_categories.get(),
+                MemoryScope::Global => s.global_subcategories.get(),
+            };
+            memory_note_groups_for_scope(s.notes.get(), empty, scope)
+        }
+    };
+
+    let section = {
+        let state = state.clone();
+        move |scope: MemoryScope| {
+            let s = state.clone();
+            let make = make_groups.clone();
+            let scope2 = scope.clone();
+            let scope_for_roots = scope.clone();
+            view! {
+                <ul class="workbench-memory-files__list">
+                    <For
+                        each={
+                            let s = s.clone();
+                            move || root_memory_notes_for_scope(&s.notes.get(), &scope_for_roots)
+                        }
+                        key=|n| note_key(&n.scope, &n.path)
+                        children={
+                            let state = s.clone();
+                            move |n: NoteMeta| {
+                                let path = n.path.clone();
+                                let expanded_note = n.clone();
+                                let collapsed_note = n.clone();
+                                let s_active = state.clone();
+                                let note_scope = n.scope.clone();
+                                let path_for_active = path.clone();
+                                view! {
+                                    <li
+                                        class="workbench-memory-files__item"
+                                        class:workbench-memory-files__item--collapsed=move || files_collapsed.get()
+                                        class:workbench-memory-files__item--active=move || {
+                                            s_active.active_scope.get() == note_scope
+                                                && s_active.active_path.get().as_deref() == Some(path_for_active.as_str())
+                                        }
+                                    >
+                                        <Show
+                                            when=move || files_collapsed.get()
+                                            fallback=move || view! {
+                                                <MemoryFileExpandedRow
+                                                    state=state
+                                                    note=expanded_note.clone()
+                                                    renaming=renaming
+                                                    rename_input=rename_input
+                                                    context_menu=context_menu
+                                                />
+                                            }
+                                        >
+                                            <MemoryFileCollapsedRow state=state note=collapsed_note.clone() context_menu=context_menu />
+                                        </Show>
+                                    </li>
+                                }
+                            }
+                        }
+                    />
+                    <For
+                        each=move || make(scope2.clone())
+                        key=|g| g.key.clone()
+                        children={
+                            let state = s.clone();
+                            move |group: MemoryNoteGroup| {
+                                view! {
+                                    <MemoryFileGroupSection
+                                        state=state.clone()
+                                        group=group
+                                        groups_open=groups_open
+                                        files_collapsed=files_collapsed
+                                        renaming=renaming
+                                        rename_input=rename_input
+                                        context_menu=context_menu
+                                        new_note_category=new_note_category
+                                    />
+                                }
+                            }
+                        }
+                    />
+                </ul>
+            }
+        }
+    };
 
     view! {
         <div
@@ -368,7 +484,7 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         class="workbench-memory-files__new-btn"
                         title=move || i18n.tr(I18nKey::MemNewCategory)()
                         aria-label=move || i18n.tr(I18nKey::MemNewCategory)()
-                        on:click=move |_| new_category_open.set(true)
+                        on:click=move |_| new_category_scope.set(Some(MemoryScope::Workspace))
                     >
                         <LxIcon icon=icondata::LuFolderPlus width="0.82rem" height="0.82rem" />
                     </button>
@@ -404,35 +520,65 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         </Show>
                     </button>
                 </div>
-                <ul class="workbench-memory-files__list">
-                    <For
-                        each={
-                            let s = state.clone();
+
+                // ── Workspace (Projekt) section ──────────────────────────────
+                <div class="workbench-memory-files__scope-section">
+                    <div class="workbench-memory-files__scope-head">
+                        <span>"Projekt"</span>
+                    </div>
+                    {section(MemoryScope::Workspace)}
+                </div>
+
+                // ── Global section ───────────────────────────────────────────
+                <div class="workbench-memory-files__scope-section">
+                    <div class="workbench-memory-files__scope-head">
+                        <span>"Global"</span>
+                        <Show when=move || state.global_bootstrapped.get()>
+                            <button
+                                type="button"
+                                class="workbench-memory-files__new-btn"
+                                title=move || i18n.tr(I18nKey::MemNewCategory)()
+                                aria-label=move || i18n.tr(I18nKey::MemNewCategory)()
+                                on:click=move |_| new_category_scope.set(Some(MemoryScope::Global))
+                            >
+                                <LxIcon icon=icondata::LuFolderPlus width="0.82rem" height="0.82rem" />
+                            </button>
+                        </Show>
+                    </div>
+                    <Show
+                        when=move || state.global_bootstrapped.get()
+                        fallback={
+                            let st = state.clone();
+                            let i = i18n.clone();
                             move || {
-                                let _ = wb.workspaces().get();
-                                memory_note_groups(s.notes.get(), s.empty_categories.get())
-                            }
-                        }
-                        key=|g| g.key.clone()
-                        children={
-                            let state = state.clone();
-                            move |group: MemoryNoteGroup| {
+                                let st2 = st.clone();
                                 view! {
-                                    <MemoryFileGroupSection
-                                        state=state.clone()
-                                        group=group
-                                        groups_open=groups_open
-                                        files_collapsed=files_collapsed
-                                        renaming=renaming
-                                        rename_input=rename_input
-                                        context_menu=context_menu
-                                        new_note_category=new_note_category
-                                    />
+                                    <div class="workbench-memory-files__global-init">
+                                        <button
+                                            type="button"
+                                            class="workbench-memory-files__global-init-btn"
+                                            on:click=move |_| {
+                                                let Some(ws) = st2.workspace_cwd.get_untracked() else { return };
+                                                let st3 = st2.clone();
+                                                spawn_local(async move {
+                                                    if tauri_bridge::memory_bootstrap(&ws, "global").await.is_ok() {
+                                                        load_notes(st3, ws);
+                                                    }
+                                                });
+                                            }
+                                        >
+                                            <LxIcon icon=icondata::LuGlobe width="0.82rem" height="0.82rem" />
+                                            " "
+                                            {move || i.tr(I18nKey::MemGlobalCreate)()}
+                                        </button>
+                                    </div>
                                 }
                             }
                         }
-                    />
-                </ul>
+                    >
+                        {section(MemoryScope::Global)}
+                    </Show>
+                </div>
             </aside>
             <section class="workbench-memory-editor">
                 <Show
@@ -466,7 +612,11 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                                 let s = state.clone();
                                 move |_| {
                                     if let Some(path) = s.active_path.get_untracked() {
-                                        navigate_to_graph_node(s.clone(), path);
+                                        navigate_to_graph_node(
+                                            s.clone(),
+                                            s.active_scope.get_untracked(),
+                                            path,
+                                        );
                                     }
                                 }
                             }
@@ -552,12 +702,14 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                                         let s = state.clone();
                                         move || s.backlinks.get()
                                     }
-                                    key=|p| p.clone()
+                                    key=|b| note_key(&b.scope, &b.path)
                                     children={
                                         let s = state.clone();
-                                        move |p: String| {
+                                        move |b: BacklinkRef| {
                                             let s = s.clone();
-                                            let p2 = p.clone();
+                                            let scope = b.scope.clone();
+                                            let path = b.path.clone();
+                                            let label = path.clone();
                                             view! {
                                                 <li>
                                                     <button
@@ -565,9 +717,9 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                                                         class="workbench-memory-editor__backlink"
                                                         on:click=move |_| {
                                                             let Some(ws) = s.workspace_cwd.get_untracked() else { return };
-                                                            load_note(s.clone(), ws, p2.clone());
+                                                            load_note(s.clone(), ws, scope.clone(), path.clone());
                                                         }
-                                                    >{p}</button>
+                                                    >{label}</button>
                                                 </li>
                                             }
                                         }
@@ -595,19 +747,28 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         })
                 }}
             </Show>
-            <Show when=move || new_category_open.get()>
-                <NewCategoryDialog
-                    state=state.clone()
-                    on_close=Callback::new(move |_| new_category_open.set(false))
-                />
+            <Show when=move || new_category_scope.get().is_some()>
+                {
+                    let state_for_cat = state.clone();
+                    move || {
+                        new_category_scope.get().map(|scope| view! {
+                            <NewCategoryDialog
+                                state=state_for_cat.clone()
+                                scope=scope
+                                on_close=Callback::new(move |_| new_category_scope.set(None))
+                            />
+                        })
+                    }
+                }
             </Show>
             <Show when=move || new_note_category.get().is_some()>
                 {
                     let state_for_dialog = state.clone();
                     move || {
-                        new_note_category.get().map(|category| view! {
+                        new_note_category.get().map(|(scope, category)| view! {
                             <NewNoteDialog
                                 state=state_for_dialog.clone()
+                                scope=scope
                                 category=category
                                 on_close=Callback::new(move |_| new_note_category.set(None))
                             />
@@ -620,7 +781,11 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
 }
 
 #[component]
-fn NewCategoryDialog(state: MemoryState, on_close: Callback<()>) -> impl IntoView {
+fn NewCategoryDialog(
+    state: MemoryState,
+    scope: MemoryScope,
+    on_close: Callback<()>,
+) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let name = RwSignal::new(String::new());
     let error = RwSignal::new(None::<String>);
@@ -635,12 +800,17 @@ fn NewCategoryDialog(state: MemoryState, on_close: Callback<()>) -> impl IntoVie
             return;
         };
         let cat = trimmed.to_string();
+        let sc = scope.clone();
         let state2 = state.clone();
         spawn_local(async move {
-            match tauri_bridge::memory_create_category(&ws, &cat).await {
+            match tauri_bridge::memory_create_category(&ws, &sc, &cat).await {
                 Ok(created) => {
+                    let key = match sc {
+                        MemoryScope::Global => format!("global:{created}"),
+                        MemoryScope::Workspace => created,
+                    };
                     state2.groups_open.update(|s| {
-                        s.insert(created.clone());
+                        s.insert(key);
                     });
                     load_notes(state2.clone(), ws);
                     on_close.run(());
@@ -711,7 +881,12 @@ fn NewCategoryDialog(state: MemoryState, on_close: Callback<()>) -> impl IntoVie
 }
 
 #[component]
-fn NewNoteDialog(state: MemoryState, category: String, on_close: Callback<()>) -> impl IntoView {
+fn NewNoteDialog(
+    state: MemoryState,
+    scope: MemoryScope,
+    category: String,
+    on_close: Callback<()>,
+) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let title = RwSignal::new(String::new());
     let error = RwSignal::new(None::<String>);
@@ -738,15 +913,21 @@ fn NewNoteDialog(state: MemoryState, category: String, on_close: Callback<()>) -
         };
         let body = format!("# {}\n\n", strip_ext(&fname));
         let state2 = state.clone();
+        let sc = scope.clone();
         let cat = category_for_submit.clone();
+        // Group key uses scope prefix for global notes.
+        let group_key = match sc {
+            MemoryScope::Global => format!("global:{cat}"),
+            MemoryScope::Workspace => cat.clone(),
+        };
         spawn_local(async move {
-            match tauri_bridge::memory_create(&ws, &api_path, Some(&body)).await {
+            match tauri_bridge::memory_create(&ws, &sc, &api_path, Some(&body)).await {
                 Ok(meta) => {
                     state2.groups_open.update(|s| {
-                        s.insert(cat.clone());
+                        s.insert(group_key.clone());
                     });
                     load_notes(state2.clone(), ws.clone());
-                    load_note(state2.clone(), ws, meta.path);
+                    load_note(state2.clone(), ws, meta.scope, meta.path);
                     on_close.run(());
                 }
                 Err(e) => error.set(Some(e)),
@@ -828,26 +1009,36 @@ fn MemoryFileGroupHead(
     state: MemoryState,
     wb: WorkbenchService,
     group_key: String,
+    group_scope: MemoryScope,
     groups_open: RwSignal<HashSet<String>>,
     files_collapsed: RwSignal<bool>,
     header_title: String,
     index_path: Option<String>,
     group_paths: Vec<String>,
     context_menu: RwSignal<Option<MemoryContextMenu>>,
-    new_note_category: RwSignal<Option<String>>,
+    new_note_category: RwSignal<Option<(MemoryScope, String)>>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let index_active = index_path.clone();
     let index_open = index_path;
     let context_label = header_title.clone();
-    let key_for_settings = group_key.clone();
-    let key_for_color = group_key.clone();
+    let plain_key = group_key
+        .strip_prefix("global:")
+        .unwrap_or(&group_key)
+        .to_string();
+    let key_for_settings = plain_key.clone();
+    let key_for_color = plain_key.clone();
     let key_for_ctx = group_key.clone();
     let key_for_chev_class = group_key.clone();
     let key_for_aria_state = group_key.clone();
     let key_for_aria_label = group_key.clone();
     let key_for_click = group_key.clone();
-    let key_for_new = group_key.clone();
+    // Strip "global:" prefix so NewNoteDialog receives a plain category name.
+    let cat_for_new = group_key
+        .strip_prefix("global:")
+        .unwrap_or(&group_key)
+        .to_string();
+    let scope_for_new = group_scope.clone();
     view! {
         <li
             class="workbench-memory-files__group-head"
@@ -902,6 +1093,7 @@ fn MemoryFileGroupHead(
             </button>
             <MemoryFileGroupIndexButton
                 state=state
+                scope=group_scope.clone()
                 label=header_title
                 index_path=index_open
             />
@@ -912,7 +1104,7 @@ fn MemoryFileGroupHead(
                 aria-label=move || i18n.tr(I18nKey::MemNewNoteInGroup)()
                 on:click=move |ev: web_sys::MouseEvent| {
                     ev.stop_propagation();
-                    new_note_category.set(Some(key_for_new.clone()));
+                    new_note_category.set(Some((scope_for_new.clone(), cat_for_new.clone())));
                 }
             >
                 <LxIcon icon=icondata::LuPlus width="0.75rem" height="0.75rem" />
@@ -924,6 +1116,7 @@ fn MemoryFileGroupHead(
 #[component]
 fn MemoryFileGroupIndexButton(
     state: MemoryState,
+    scope: MemoryScope,
     label: String,
     index_path: Option<String>,
 ) -> impl IntoView {
@@ -933,7 +1126,7 @@ fn MemoryFileGroupIndexButton(
             type="button"
             class="workbench-memory-files__group-index"
             title=title
-            on:click=move |_| memory_open_group_index(state, index_path.clone())
+            on:click=move |_| memory_open_group_index(state, scope.clone(), index_path.clone())
         >
             {label}
         </button>
@@ -949,22 +1142,26 @@ fn MemoryFileGroupSection(
     renaming: RwSignal<Option<String>>,
     rename_input: RwSignal<String>,
     context_menu: RwSignal<Option<MemoryContextMenu>>,
-    new_note_category: RwSignal<Option<String>>,
+    new_note_category: RwSignal<Option<(MemoryScope, String)>>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let wb = expect_context::<WorkbenchService>();
     let group_key = group.key.clone();
+    let group_scope = group.scope.clone();
     let header_title = memory_group_header_label(&group, &i18n, wb);
     let index_path = group.index.as_ref().map(|n| n.path.clone());
     let index = group.index;
     let group_notes = group.notes;
-    let key_for_show = group_key.clone();
+    let plain_key_for_show = group_key
+        .strip_prefix("global:")
+        .unwrap_or(&group_key)
+        .to_string();
     let key_for_open_check = group_key.clone();
     let show_sidebar = move || {
         wb.active_id()
             .get()
             .map(|id| {
-                wb.memory_category_settings_for_workspace(id, &key_for_show)
+                wb.memory_category_settings_for_workspace(id, &plain_key_for_show)
                     .show_in_sidebar
             })
             .unwrap_or(true)
@@ -975,6 +1172,7 @@ fn MemoryFileGroupSection(
             state=state
             wb=wb
             group_key=group_key.clone()
+            group_scope=group_scope
             groups_open=groups_open
             files_collapsed=files_collapsed
             header_title=header_title
@@ -1042,7 +1240,9 @@ fn MemoryFileCollapsedRow(
 ) -> impl IntoView {
     let label = clean_memory_label(&note.name);
     let badge = note_badge_text(&label);
+    let scope = note.scope.clone();
     let path = note.path.clone();
+    let context_scope = scope.clone();
     let context_path = path.clone();
     let context_label = label.clone();
 
@@ -1059,6 +1259,7 @@ fn MemoryFileCollapsedRow(
                     x: ev.client_x(),
                     y: ev.client_y(),
                     target: MemoryContextTarget::Note {
+                        scope: context_scope.clone(),
                         path: context_path.clone(),
                         label: context_label.clone(),
                     },
@@ -1068,7 +1269,7 @@ fn MemoryFileCollapsedRow(
                 let Some(ws) = state.workspace_cwd.get_untracked() else {
                     return;
                 };
-                load_note(state, ws, path.clone());
+                load_note(state, ws, scope.clone(), path.clone());
             }
         >
             {badge}
@@ -1087,6 +1288,7 @@ fn MemoryFileExpandedRow(
     let i18n = expect_context::<I18nService>();
     let label = clean_memory_label(&note.name);
     let folder = memory_display_folder(&note.path);
+    let note_scope = note.scope.clone();
     let note_path = note.path.clone();
     let path_for_select = note_path.clone();
     let path_for_del = note_path.clone();
@@ -1104,6 +1306,7 @@ fn MemoryFileExpandedRow(
             let label_for_ren = label_for_ren.clone();
             if renaming.get().as_deref() == Some(note_path.as_str()) {
                 let old_path = note_path.clone();
+                let scope_for_rename = note_scope.clone();
                 view! {
                     <form
                         class="workbench-memory-files__rename"
@@ -1121,8 +1324,9 @@ fn MemoryFileExpandedRow(
                             };
                             let op = old_path.clone();
                             let np = new_path.clone();
+                            let sc = scope_for_rename.clone();
                             spawn_local(async move {
-                                match tauri_bridge::memory_rename(&ws, &op, &np, true).await {
+                                match tauri_bridge::memory_rename(&ws, &sc, &op, &np, true).await {
                                     Ok(_) => {
                                         renaming.set(None);
                                         if state.active_path.get_untracked().as_deref() == Some(op.as_str()) {
@@ -1156,6 +1360,9 @@ fn MemoryFileExpandedRow(
                 }
                 .into_any()
             } else {
+                let scope_for_ctx = note_scope.clone();
+                let scope_for_open = note_scope.clone();
+                let scope_for_del = note_scope.clone();
                 view! {
                     <button
                         type="button"
@@ -1170,6 +1377,7 @@ fn MemoryFileExpandedRow(
                                     x: ev.client_x(),
                                     y: ev.client_y(),
                                     target: MemoryContextTarget::Note {
+                                        scope: scope_for_ctx.clone(),
                                         path: p.clone(),
                                         label: l.clone(),
                                     },
@@ -1180,7 +1388,7 @@ fn MemoryFileExpandedRow(
                             let Some(ws) = state.workspace_cwd.get_untracked() else {
                                 return;
                             };
-                            load_note(state, ws, path_for_select.clone());
+                            load_note(state, ws, scope_for_open.clone(), path_for_select.clone());
                         }
                     >
                         <span class="workbench-memory-files__name-text">{label.clone()}</span>
@@ -1204,8 +1412,9 @@ fn MemoryFileExpandedRow(
                                 return;
                             };
                             let p = path_for_del.clone();
+                            let sc = scope_for_del.clone();
                             spawn_local(async move {
-                                match tauri_bridge::memory_delete(&ws, &p).await {
+                                match tauri_bridge::memory_delete(&ws, &sc, &p).await {
                                     Ok(()) => {
                                         if state.active_path.get_untracked().as_deref() == Some(p.as_str()) {
                                             state.active_path.set(None);
@@ -1267,7 +1476,8 @@ fn MemoryContextMenuView(
                         }
                         .into_any()
                     }
-                    MemoryContextTarget::Note { path, label } => {
+                    MemoryContextTarget::Note { scope, path, label } => {
+                        let open_scope = scope.clone();
                         let open_path = path.clone();
                         let send_path = path.clone();
                         let send_label = label.clone();
@@ -1279,7 +1489,7 @@ fn MemoryContextMenuView(
                                     on:click=move |_| {
                                         menu.set(None);
                                         if let Some(ws) = current_workspace_cwd(wb) {
-                                            load_note(state, ws, open_path.clone());
+                                            load_note(state, ws, open_scope.clone(), open_path.clone());
                                         }
                                     }
                                 >"Open"</button>
@@ -1456,7 +1666,8 @@ fn add_category_agent_context(
     let Some(ws_id) = wb.active_id().get_untracked() else {
         return;
     };
-    let kind = if category == CATEGORY_LEARNINGS {
+    let plain = category.strip_prefix("global:").unwrap_or(category);
+    let kind = if plain == CATEGORY_LEARNINGS {
         AgentContextKind::LearningCategory
     } else {
         AgentContextKind::MemoryCategory
@@ -1501,7 +1712,9 @@ fn add_note_agent_context(wb: WorkbenchService, path: String, label: String) {
 
 #[derive(Clone)]
 struct MemoryNoteGroup {
+    /// Group key; global groups are prefixed `"global:"`.
     key: String,
+    scope: MemoryScope,
     index: Option<NoteMeta>,
     notes: Vec<NoteMeta>,
 }
@@ -1514,6 +1727,7 @@ enum MemoryContextTarget {
         paths: Vec<String>,
     },
     Note {
+        scope: MemoryScope,
         path: String,
         label: String,
     },
@@ -1526,12 +1740,23 @@ struct MemoryContextMenu {
     target: MemoryContextTarget,
 }
 
-fn memory_note_groups(notes: Vec<NoteMeta>, empty_categories: Vec<String>) -> Vec<MemoryNoteGroup> {
+fn memory_note_groups_for_scope(
+    notes: Vec<NoteMeta>,
+    empty_categories: Vec<String>,
+    scope: MemoryScope,
+) -> Vec<MemoryNoteGroup> {
     use std::collections::BTreeMap;
     let mut buckets: BTreeMap<String, Vec<NoteMeta>> = BTreeMap::new();
-    for n in notes {
-        let key = category_for_path(&n.path);
-        buckets.entry(key).or_default().push(n);
+    buckets.entry(CATEGORY_LEARNINGS.to_string()).or_default();
+    for n in notes
+        .into_iter()
+        .filter(|n| n.scope == scope && n.enabled && !n.is_template)
+    {
+        let cat = category_for_path(&n.path);
+        if cat == CATEGORY_MEMORY {
+            continue;
+        }
+        buckets.entry(cat).or_default().push(n);
     }
     for cat in empty_categories {
         if cat == CATEGORY_MEMORY || cat == CATEGORY_LEARNINGS {
@@ -1540,25 +1765,31 @@ fn memory_note_groups(notes: Vec<NoteMeta>, empty_categories: Vec<String>) -> Ve
         buckets.entry(cat).or_default();
     }
 
-    // Preserve a stable ordering: memory first, learnings second, then alpha.
     let mut keys: Vec<String> = buckets.keys().cloned().collect();
     keys.sort_by(|a, b| match (a.as_str(), b.as_str()) {
-        (CATEGORY_MEMORY, _) => std::cmp::Ordering::Less,
-        (_, CATEGORY_MEMORY) => std::cmp::Ordering::Greater,
         (CATEGORY_LEARNINGS, _) => std::cmp::Ordering::Less,
         (_, CATEGORY_LEARNINGS) => std::cmp::Ordering::Greater,
         _ => a.to_lowercase().cmp(&b.to_lowercase()),
     });
 
     let mut groups = Vec::new();
-    for key in keys {
-        let bucket = buckets.remove(&key).unwrap_or_default();
-        let (index, notes) = match key.as_str() {
-            CATEGORY_MEMORY => split_group_index(bucket, is_memory_index_note),
+    for cat in keys {
+        let bucket = buckets.remove(&cat).unwrap_or_default();
+        let (index, notes) = match cat.as_str() {
             CATEGORY_LEARNINGS => split_group_index(bucket, is_learnings_index_note),
-            _ => (None, bucket),
+            _ => split_group_index(bucket, is_category_index_note),
+        };
+        // Global groups use a "global:" prefix on the key so they don't clash with workspace keys.
+        let key = match scope {
+            MemoryScope::Global => format!("global:{cat}"),
+            MemoryScope::Workspace => cat,
         };
-        groups.push(MemoryNoteGroup { key, index, notes });
+        groups.push(MemoryNoteGroup {
+            key,
+            scope: scope.clone(),
+            index,
+            notes,
+        });
     }
     groups
 }
@@ -1585,20 +1816,37 @@ fn is_learnings_index_note(note: &NoteMeta) -> bool {
         .any(|p| note.path.eq_ignore_ascii_case(p))
 }
 
-fn is_memory_index_note(note: &NoteMeta) -> bool {
-    MEMORY_INDEX_PATHS
+fn is_category_index_note(note: &NoteMeta) -> bool {
+    std::path::Path::new(&note.path)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| name.eq_ignore_ascii_case("README.md"))
+}
+
+fn root_memory_notes_for_scope(notes: &[NoteMeta], scope: &MemoryScope) -> Vec<NoteMeta> {
+    let mut out: Vec<NoteMeta> = notes
         .iter()
-        .any(|p| note.path.eq_ignore_ascii_case(p))
+        .filter(|n| {
+            &n.scope == scope
+                && n.enabled
+                && !n.is_template
+                && !n.is_overview
+                && n.category == CATEGORY_MEMORY
+        })
+        .cloned()
+        .collect();
+    out.sort_by(|a, b| a.title.to_lowercase().cmp(&b.title.to_lowercase()));
+    out
 }
 
-fn memory_open_group_index(state: MemoryState, index_path: Option<String>) {
+fn memory_open_group_index(state: MemoryState, scope: MemoryScope, index_path: Option<String>) {
     let Some(path) = index_path else {
         return;
     };
     let Some(ws) = state.workspace_cwd.get_untracked() else {
         return;
     };
-    load_note(state, ws, path);
+    load_note(state, ws, scope, path);
 }
 
 fn memory_group_index_active(state: &MemoryState, index_path: &Option<String>) -> bool {
@@ -1612,16 +1860,23 @@ fn memory_group_header_label(
     i18n: &I18nService,
     wb: WorkbenchService,
 ) -> String {
+    // Use plain category (strip "global:" prefix) for settings + i18n keys.
+    let plain_key = group.key.strip_prefix("global:").unwrap_or(&group.key);
     if let Some(ws_id) = wb.active_id().get_untracked() {
-        let settings = wb.memory_category_settings_for_workspace_untracked(ws_id, &group.key);
+        let settings = wb.memory_category_settings_for_workspace_untracked(ws_id, plain_key);
         if !settings.label.trim().is_empty() {
             return clean_memory_label(&settings.label);
         }
     }
+    match plain_key {
+        CATEGORY_LEARNINGS => return i18n.tr(I18nKey::MemFilesGroupLearnings)().to_string(),
+        CATEGORY_MEMORY => return i18n.tr(I18nKey::MemFilesGroupMemory)().to_string(),
+        _ => {}
+    }
     if let Some(idx) = &group.index {
         return clean_memory_label(&idx.name);
     }
-    match group.key.as_str() {
+    match plain_key {
         CATEGORY_LEARNINGS => i18n.tr(I18nKey::MemFilesGroupLearnings)().to_string(),
         CATEGORY_MEMORY => i18n.tr(I18nKey::MemFilesGroupMemory)().to_string(),
         other => clean_memory_label(other),
@@ -1712,33 +1967,96 @@ fn note_badge_text(name: &str) -> String {
     }
 }
 
-fn search_hit_category(path: &str) -> &'static str {
-    if path.starts_with(LEARNINGS_API_PREFIX) {
-        "learnings"
-    } else {
-        "memory"
+fn filter_search_hits(hits: Vec<SearchHit>, filter: Option<String>) -> Vec<SearchHit> {
+    match filter.as_deref() {
+        None => hits,
+        Some("workspace") => hits
+            .into_iter()
+            .filter(|h| h.scope == MemoryScope::Workspace)
+            .collect(),
+        Some("global") => hits
+            .into_iter()
+            .filter(|h| h.scope == MemoryScope::Global)
+            .collect(),
+        Some(key) => {
+            if let Some((scope_str, category)) = key.split_once(':') {
+                let target_scope = match scope_str {
+                    "workspace" => MemoryScope::Workspace,
+                    "global" => MemoryScope::Global,
+                    _ => return hits,
+                };
+                hits.into_iter()
+                    .filter(|h| h.scope == target_scope && h.category == category)
+                    .collect()
+            } else {
+                hits
+            }
+        }
     }
 }
 
-fn memory_hit_count(hits: &[SearchHit]) -> usize {
-    hits.iter()
-        .filter(|h| search_hit_category(&h.path) == "memory")
-        .count()
-}
+fn search_scope_categories(hits: &[SearchHit]) -> Vec<(Option<String>, usize)> {
+    let mut workspace_count = 0_usize;
+    let mut global_count = 0_usize;
+    let mut category_counts: Vec<(String, usize)> = Vec::new();
 
-fn learnings_hit_count(hits: &[SearchHit]) -> usize {
-    hits.iter()
-        .filter(|h| search_hit_category(&h.path) == "learnings")
-        .count()
-}
+    for hit in hits {
+        let scope_key = match hit.scope {
+            MemoryScope::Workspace => {
+                workspace_count += 1;
+                "workspace"
+            }
+            MemoryScope::Global => {
+                global_count += 1;
+                "global"
+            }
+        };
+        let key = format!("{scope_key}:{}", hit.category);
+        if let Some((_, count)) = category_counts
+            .iter_mut()
+            .find(|(existing, _)| existing == &key)
+        {
+            *count += 1;
+        } else {
+            category_counts.push((key, 1));
+        }
+    }
 
-fn filter_search_hits(hits: Vec<SearchHit>, filter: Option<String>) -> Vec<SearchHit> {
-    match filter {
-        None => hits,
-        Some(cat) => hits
+    category_counts.sort_by(|(a, _), (b, _)| a.cmp(b));
+    let mut chips = Vec::with_capacity(category_counts.len() + 3);
+    chips.push((None, hits.len()));
+    if workspace_count > 0 {
+        chips.push((Some("workspace".to_string()), workspace_count));
+    }
+    if global_count > 0 {
+        chips.push((Some("global".to_string()), global_count));
+    }
+    chips.extend(
+        category_counts
             .into_iter()
-            .filter(|h| search_hit_category(&h.path) == cat.as_str())
-            .collect(),
+            .filter(|(_, count)| *count > 0)
+            .map(|(key, count)| (Some(key), count)),
+    );
+    chips
+}
+
+fn search_filter_label(i18n: &I18nService, key: Option<&str>) -> String {
+    match key {
+        None => i18n.tr(I18nKey::MemSearchFilterAll)().to_string(),
+        Some("workspace") => i18n.tr(I18nKey::MemSearchFilterWorkspace)().to_string(),
+        Some("global") => i18n.tr(I18nKey::MemSearchFilterGlobal)().to_string(),
+        Some(key) => {
+            if let Some((scope, category)) = key.split_once(':') {
+                let scope_label = match scope {
+                    "workspace" => i18n.tr(I18nKey::MemSearchFilterWorkspace)().to_string(),
+                    "global" => i18n.tr(I18nKey::MemSearchFilterGlobal)().to_string(),
+                    _ => scope.to_string(),
+                };
+                format!("{scope_label}:{}", clean_memory_label(category))
+            } else {
+                clean_memory_label(key)
+            }
+        }
     }
 }
 
@@ -1796,56 +2114,36 @@ fn MemorySearchView(state: MemoryState) -> impl IntoView {
                 }
             >
                 <div class="workbench-memory-search__filters" role="group">
-                    <button
-                        type="button"
-                        class="workbench-memory-search__filter"
-                        class:workbench-memory-search__filter--active=move || search_filter.get().is_none()
-                        on:click=move |_| search_filter.set(None)
-                    >
-                        {move || {
+                    <For
+                        each={
                             let s = state.clone();
-                            let n = s.search_results.get().len();
-                            format!("{} ({n})", i18n.tr(I18nKey::MemSearchFilterAll)())
-                        }}
-                    </button>
-                    <Show when={
-                        let s = state.clone();
-                        move || memory_hit_count(&s.search_results.get()) > 0
-                    }>
-                        <button
-                            type="button"
-                            class="workbench-memory-search__filter"
-                            class:workbench-memory-search__filter--active=move || {
-                                search_filter.get().as_deref() == Some("memory")
-                            }
-                            on:click=move |_| search_filter.set(Some("memory".to_string()))
-                        >
-                            {move || {
-                                let s = state.clone();
-                                let n = memory_hit_count(&s.search_results.get());
-                                format!("{} ({n})", i18n.tr(I18nKey::MemFilesGroupMemory)())
-                            }}
-                        </button>
-                    </Show>
-                    <Show when={
-                        let s = state.clone();
-                        move || learnings_hit_count(&s.search_results.get()) > 0
-                    }>
-                        <button
-                            type="button"
-                            class="workbench-memory-search__filter"
-                            class:workbench-memory-search__filter--active=move || {
-                                search_filter.get().as_deref() == Some("learnings")
+                            move || search_scope_categories(&s.search_results.get())
+                        }
+                        key=|(key, _)| key.clone().unwrap_or_else(|| "__all".to_string())
+                        children={
+                            let i18n = i18n.clone();
+                            move |(key, count): (Option<String>, usize)| {
+                                let key_for_active = key.clone();
+                                let key_for_click = key.clone();
+                                let key_for_label = key.clone();
+                                view! {
+                                    <button
+                                        type="button"
+                                        class="workbench-memory-search__filter"
+                                        class:workbench-memory-search__filter--active=move || {
+                                            search_filter.get() == key_for_active
+                                        }
+                                        on:click=move |_| search_filter.set(key_for_click.clone())
+                                    >
+                                        {format!(
+                                            "{} ({count})",
+                                            search_filter_label(&i18n, key_for_label.as_deref())
+                                        )}
+                                    </button>
+                                }
                             }
-                            on:click=move |_| search_filter.set(Some("learnings".to_string()))
-                        >
-                            {move || {
-                                let s = state.clone();
-                                let n = learnings_hit_count(&s.search_results.get());
-                                format!("{} ({n})", i18n.tr(I18nKey::MemFilesGroupLearnings)())
-                            }}
-                        </button>
-                    </Show>
+                        }
+                    />
                 </div>
             </Show>
             <ul class="workbench-memory-search__results">
@@ -1857,13 +2155,15 @@ fn MemorySearchView(state: MemoryState) -> impl IntoView {
                             filter_search_hits(hits, search_filter.get())
                         }
                     }
-                    key=|h| format!("{}:{}", h.path, h.line)
+                    key=|h| format!("{:?}:{}:{}", h.scope, h.path, h.line)
                     children={
                         let state = state.clone();
                         move |h: SearchHit| {
                             let s = state.clone();
+                            let scope = h.scope.clone();
                             let p = h.path.clone();
                             let p_graph = p.clone();
+                            let scope_graph = scope.clone();
                             view! {
                                 <li class="workbench-memory-search__hit">
                                     <button
@@ -1871,10 +2171,11 @@ fn MemorySearchView(state: MemoryState) -> impl IntoView {
                                         class="workbench-memory-search__hit-btn"
                                         on:click={
                                             let p = p.clone();
+                                            let sc = scope.clone();
                                             move |_| {
                                                 let Some(ws) = s.workspace_cwd.get_untracked() else { return };
-                                                expand_files_group_for_path(s.clone(), &p);
-                                                load_note(s.clone(), ws, p.clone());
+                                                expand_files_group_for_path(s.clone(), &sc, &p);
+                                                load_note(s.clone(), ws, sc.clone(), p.clone());
                                                 s.view.set(MemoryView::Files);
                                             }
                                         }
@@ -1889,7 +2190,14 @@ fn MemorySearchView(state: MemoryState) -> impl IntoView {
                                         aria-label=move || i18n.tr(I18nKey::MemShowInGraph)()
                                         on:click={
                                             let p_graph = p_graph.clone();
-                                            move |_| navigate_to_graph_node(s.clone(), p_graph.clone())
+                                            let scope_graph = scope_graph.clone();
+                                            move |_| {
+                                                navigate_to_graph_node(
+                                                    s.clone(),
+                                                    scope_graph.clone(),
+                                                    p_graph.clone(),
+                                                )
+                                            }
                                         }
                                     >
                                         <LxIcon icon=icondata::LuNetwork width="0.82rem" height="0.82rem" />
diff --git a/src/workbench/mod.rs b/src/workbench/mod.rs
index f38ac01..9e05885 100644
--- a/src/workbench/mod.rs
+++ b/src/workbench/mod.rs
@@ -1,14 +1,13 @@
 //! Three-pane editor shell: collapsible sidebar, workspace, resizable right column.
 mod agent_accent;
 mod agent_context_handoff;
-mod agent_panel;
-mod agent_timeline;
 mod agent_model_picker;
+mod agent_panel;
 mod agent_provider_pane;
+mod agent_timeline;
 mod api_keys_pane;
-mod workspace_settings_pane;
-mod appearance_settings_pane;
 mod app_prefs;
+mod appearance_settings_pane;
 mod browser_tab;
 mod chat_markdown;
 mod close_terminals_tab_dialog;
@@ -33,7 +32,6 @@ mod sidebar_resizer;
 mod sidebar_view_section;
 pub mod skills_rules_panel;
 pub mod state;
-mod voice_app_controls;
 mod terminal_cell;
 mod terminal_glue;
 mod terminal_slot_dnd;
@@ -41,14 +39,14 @@ mod theme_service;
 mod toast;
 mod update_dialog;
 mod update_service;
+mod voice_app_controls;
 mod workspace_panel;
+mod workspace_settings_pane;
 
 pub use agent_panel::AgentPanelDock;
-pub use appearance_settings_pane::AppearanceSettingsPane;
-pub use theme_service::ThemeService;
 pub use agent_provider_pane::AgentProviderPane;
 pub use api_keys_pane::ApiKeysPane;
-pub use workspace_settings_pane::WorkspaceSettingsPane;
+pub use appearance_settings_pane::AppearanceSettingsPane;
 pub use browser_tab::{BrowserTabDock, EmbeddedBrowserGlue};
 pub use memory_panel::MemoryPanel;
 pub use plans_panel::PlansPanel;
@@ -60,7 +58,9 @@ pub use state::{
     LegacyStorageMigration, RightPanelTab, WorkbenchService, WorkbenchSnapshot,
     WorkspaceAgentImage,
 };
+pub use theme_service::ThemeService;
 pub use workspace_panel::WorkspacePanel;
+pub use workspace_settings_pane::WorkspaceSettingsPane;
 
 use crate::boot_loading::{BootLoadingScreen, BootPhase};
 use crate::config::{SIDEBAR_WIDTH_PX_KEY, SIDEBAR_WIDTH_PX_MIN};
@@ -73,6 +73,7 @@ use crate::tauri_bridge::{
     workbench_prune_notifications, workbench_prune_sessions, workbench_save_state,
 };
 use app_prefs::AppPrefsService;
+use close_terminals_tab_dialog::CloseTerminalsTabDialog;
 use gloo_timers::future::TimeoutFuture;
 use harness_ui::HarnessHost;
 use js_sys;
@@ -82,7 +83,6 @@ use send_wrapper::SendWrapper;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
 use toast::{ToastHost, ToastService};
-use close_terminals_tab_dialog::CloseTerminalsTabDialog;
 use update_dialog::{UpdateBanner, UpdateDialog};
 use update_service::UpdateService;
 use wasm_bindgen::closure::Closure;
diff --git a/src/workbench/plans_panel/mod.rs b/src/workbench/plans_panel/mod.rs
index 9ccd8ec..5f9298a 100644
--- a/src/workbench/plans_panel/mod.rs
+++ b/src/workbench/plans_panel/mod.rs
@@ -233,10 +233,7 @@ fn grouped_plans(plans: &[PlanMeta]) -> Vec<PlanGroup> {
         .collect()
 }
 
-fn open_plan_composer(
-    composer_open: RwSignal<bool>,
-    draft_error: RwSignal<Option<String>>,
-) {
+fn open_plan_composer(composer_open: RwSignal<bool>, draft_error: RwSignal<Option<String>>) {
     composer_open.set(true);
     draft_error.set(None);
     spawn_local(async move {
diff --git a/src/workbench/right_panel.rs b/src/workbench/right_panel.rs
index 09e7dd6..5a69ea3 100644
--- a/src/workbench/right_panel.rs
+++ b/src/workbench/right_panel.rs
@@ -417,7 +417,7 @@ pub fn RightPanel() -> impl IntoView {
                                 </span>
                                 <span class="workbench-right-tab__label">{move || i18n.tr(I18nKey::TabSkills)()}</span>
                             </button>
-                            
+
                         </div>
                         <RightPanelSettingsButton />
                     </div>
diff --git a/src/workbench/sidebar_resizer/mod.rs b/src/workbench/sidebar_resizer/mod.rs
index 84e07bd..952e5a9 100644
--- a/src/workbench/sidebar_resizer/mod.rs
+++ b/src/workbench/sidebar_resizer/mod.rs
@@ -5,8 +5,7 @@
 
 use crate::config::{
     SIDEBAR_DIFF_HEIGHT_PCT_MAX, SIDEBAR_DIFF_HEIGHT_PCT_MIN, SIDEBAR_EXPLORER_HEIGHT_PCT_MAX,
-    SIDEBAR_EXPLORER_HEIGHT_PCT_MIN, SIDEBAR_PANELS_HEIGHT_PCT_MAX,
-    SIDEBAR_PANELS_HEIGHT_PCT_MIN,
+    SIDEBAR_EXPLORER_HEIGHT_PCT_MIN, SIDEBAR_PANELS_HEIGHT_PCT_MAX, SIDEBAR_PANELS_HEIGHT_PCT_MIN,
 };
 use crate::i18n::I18nKey;
 use crate::service::I18nService;
@@ -26,13 +25,12 @@ pub enum SidebarResizerClamp {
 impl SidebarResizerClamp {
     fn min_max(self) -> (f64, f64) {
         match self {
-            Self::ExplorerInPanels => {
-                (SIDEBAR_EXPLORER_HEIGHT_PCT_MIN, SIDEBAR_EXPLORER_HEIGHT_PCT_MAX)
-            }
+            Self::ExplorerInPanels => (
+                SIDEBAR_EXPLORER_HEIGHT_PCT_MIN,
+                SIDEBAR_EXPLORER_HEIGHT_PCT_MAX,
+            ),
             Self::DiffInPanels => (SIDEBAR_DIFF_HEIGHT_PCT_MIN, SIDEBAR_DIFF_HEIGHT_PCT_MAX),
-            Self::PanelsInSidebar => {
-                (SIDEBAR_PANELS_HEIGHT_PCT_MIN, SIDEBAR_PANELS_HEIGHT_PCT_MAX)
-            }
+            Self::PanelsInSidebar => (SIDEBAR_PANELS_HEIGHT_PCT_MIN, SIDEBAR_PANELS_HEIGHT_PCT_MAX),
         }
     }
 }
@@ -46,11 +44,9 @@ pub fn SidebarResizer(
     /// When true, `height_pct` is the portion from the pointer down to the container bottom.
     #[prop(default = false)]
     measure_from_bottom: bool,
-    #[prop(default = SidebarResizerClamp::ExplorerInPanels)]
-    clamp: SidebarResizerClamp,
+    #[prop(default = SidebarResizerClamp::ExplorerInPanels)] clamp: SidebarResizerClamp,
     aria_key: I18nKey,
-    #[prop(default = "")]
-    extra_class: &'static str,
+    #[prop(default = "")] extra_class: &'static str,
     /// Subtract this percentage from the raw Y-from-top value before storing.
     /// Used when the resizer sits below another fixed-size slot (e.g. diff resizer
     /// must subtract explorer_pct so `height_pct` stores the section height, not
diff --git a/src/workbench/skills_rules_panel/install_dialog.rs b/src/workbench/skills_rules_panel/install_dialog.rs
index ad59766..6eb0390 100644
--- a/src/workbench/skills_rules_panel/install_dialog.rs
+++ b/src/workbench/skills_rules_panel/install_dialog.rs
@@ -93,7 +93,8 @@ pub fn SkillInstallDialog(open: RwSignal<bool>) -> impl IntoView {
                     on:input=move |ev| git_ref.set(read_input(&ev))
                 />
             </div>
-        }.into_any(),
+        }
+        .into_any(),
         SkillSourceKind::Npm => view! {
             <div class="blx-sr-dialog__row">
                 <label>{i18n.tr(I18nKey::SrNpmPackageLabel)}</label>
@@ -113,7 +114,8 @@ pub fn SkillInstallDialog(open: RwSignal<bool>) -> impl IntoView {
                     on:input=move |ev| npm_version.set(read_input(&ev))
                 />
             </div>
-        }.into_any(),
+        }
+        .into_any(),
         SkillSourceKind::Local => view! {
             <div class="blx-sr-dialog__row">
                 <label>{i18n.tr(I18nKey::SrLocalPathLabel)}</label>
@@ -124,7 +126,8 @@ pub fn SkillInstallDialog(open: RwSignal<bool>) -> impl IntoView {
                     on:input=move |ev| local_path.set(read_input(&ev))
                 />
             </div>
-        }.into_any(),
+        }
+        .into_any(),
         SkillSourceKind::AgentCreated | SkillSourceKind::Core => view! { <></> }.into_any(),
     };
 
diff --git a/src/workbench/state.rs b/src/workbench/state.rs
index 44cd974..9d8dfca 100644
--- a/src/workbench/state.rs
+++ b/src/workbench/state.rs
@@ -155,10 +155,15 @@ impl CenterTab {
 pub enum CenterTabKind {
     Terminals,
     Settings,
-    FilePreview { rel_path: String },
+    FilePreview {
+        rel_path: String,
+    },
     /// Side-by-side or inline diff view for one changed file.
     /// `staged` selects between `git diff [--cached]`.
-    FileDiff { rel_path: String, staged: bool },
+    FileDiff {
+        rel_path: String,
+        staged: bool,
+    },
 }
 
 /// Aggregated token / cost stats for a workspace's agent chat. Each
@@ -734,11 +739,12 @@ impl HarnessUiService {
         const COUNTDOWN_SECS: u8 = 3;
         let gen = self.close_terminals_gen.get_untracked().wrapping_add(1);
         self.close_terminals_gen.set(gen);
-        self.close_terminals_confirm.set(Some(CloseTerminalsConfirm {
-            workspace_id,
-            seconds_left: COUNTDOWN_SECS,
-            generation: gen,
-        }));
+        self.close_terminals_confirm
+            .set(Some(CloseTerminalsConfirm {
+                workspace_id,
+                seconds_left: COUNTDOWN_SECS,
+                generation: gen,
+            }));
         let me = *self;
         spawn_local(async move {
             let mut remaining = COUNTDOWN_SECS;
@@ -761,8 +767,7 @@ impl HarnessUiService {
     }
 
     pub fn dismiss_close_terminals_confirm(&self) {
-        self.close_terminals_gen
-            .update(|g| *g = g.wrapping_add(1));
+        self.close_terminals_gen.update(|g| *g = g.wrapping_add(1));
         self.close_terminals_confirm.set(None);
     }
 
@@ -3487,10 +3492,7 @@ mod center_tab_tests {
 
     #[test]
     fn repair_fixes_dangling_active_id() {
-        let mut ws = mk_workspace(
-            1,
-            vec![CenterTab::terminals()],
-        );
+        let mut ws = mk_workspace(1, vec![CenterTab::terminals()]);
         ws.center_active_tab_id = 999;
         repair_center_tab_state(&mut ws);
         assert_eq!(ws.center_active_tab_id, CENTER_TERMINALS_TAB_ID);
diff --git a/src/workbench/terminal_cell.rs b/src/workbench/terminal_cell.rs
index 6538445..6157e04 100644
--- a/src/workbench/terminal_cell.rs
+++ b/src/workbench/terminal_cell.rs
@@ -7,14 +7,14 @@ use crate::tauri_bridge::{
 };
 use crate::workbench::agent_accent::agent_accent_class;
 use crate::workbench::agent_context_handoff::TerminalSlotHandoffButton;
-use crate::workbench::terminal_slot_dnd::{
-    set_drag_payload, TerminalDragMeta, TerminalSlotDragPayload, TerminalSlotDragService,
-};
 use crate::workbench::terminal_glue::{
     terminal_create, terminal_dispose, terminal_fit, terminal_request_fit,
     terminal_set_stdin_enabled, terminal_show_fallback, terminal_size_from_js,
     terminal_wait_api_ready, terminal_write_b64, TerminalSize,
 };
+use crate::workbench::terminal_slot_dnd::{
+    set_drag_payload, TerminalDragMeta, TerminalSlotDragPayload, TerminalSlotDragService,
+};
 use gloo_timers::future::TimeoutFuture;
 use leptos::callback::{Callable, Callback};
 use leptos::html;
diff --git a/src/workbench/theme_service.rs b/src/workbench/theme_service.rs
index 8b15d36..b732b71 100644
--- a/src/workbench/theme_service.rs
+++ b/src/workbench/theme_service.rs
@@ -33,9 +33,8 @@ impl ThemeService {
     pub fn active_theme(&self) -> impl Fn() -> &'static crate::theme::AppTheme + Copy {
         let sig = self.active_theme_id;
         move || {
-            theme_by_id(&sig.get()).unwrap_or_else(|| {
-                theme_by_id(DEFAULT_THEME_ID).expect("default theme exists")
-            })
+            theme_by_id(&sig.get())
+                .unwrap_or_else(|| theme_by_id(DEFAULT_THEME_ID).expect("default theme exists"))
         }
     }
 
diff --git a/src/workbench/voice_app_controls/mod.rs b/src/workbench/voice_app_controls/mod.rs
index 739c12c..1328b25 100644
--- a/src/workbench/voice_app_controls/mod.rs
+++ b/src/workbench/voice_app_controls/mod.rs
@@ -1,7 +1,7 @@
 //! Voice STT language + push-to-talk controls styled for Settings → App.
 
-use crate::i18n::{Locale, APP_LOCALES};
 use crate::i18n::I18nKey;
+use crate::i18n::{Locale, APP_LOCALES};
 use crate::service::I18nService;
 use crate::tauri_bridge::{PttHotkey, SttLanguageMode, VoiceSettings};
 use gloo_timers::future::TimeoutFuture;
@@ -217,7 +217,10 @@ where
 
 /// STT input language (nested under App → Language).
 #[component]
-pub fn VoiceSttLanguageControls<F>(settings: RwSignal<Option<VoiceSettings>>, save: F) -> impl IntoView
+pub fn VoiceSttLanguageControls<F>(
+    settings: RwSignal<Option<VoiceSettings>>,
+    save: F,
+) -> impl IntoView
 where
     F: Fn(VoiceSettings) + Send + Sync + 'static + Copy,
 {
diff --git a/src/workbench/workspace_panel.rs b/src/workbench/workspace_panel.rs
index 94af2cf..53f9b15 100644
--- a/src/workbench/workspace_panel.rs
+++ b/src/workbench/workspace_panel.rs
@@ -206,9 +206,7 @@ fn WorkspaceSurface(workspace_id: u64) -> impl IntoView {
     provide_context(slot_dnd);
 
     let slot_drag_enabled = Memo::new(move |_| {
-        !is_configuring.get()
-            && !wb.sidebar_collapsed().get()
-            && full_size_terminal.get().is_none()
+        !is_configuring.get() && !wb.sidebar_collapsed().get() && full_size_terminal.get().is_none()
     });
     let term_grid_ref = NodeRef::<html::Div>::new();
 
@@ -248,8 +246,7 @@ fn WorkspaceSurface(workspace_id: u64) -> impl IntoView {
     // "No open terminals in any workspace". xterm.js inside the cells is
     // paused via `is_workspace_active` while hidden and refits on tab
     // re-activation, so a hidden 0x0 layout is harmless.
-    let grid_mounted =
-        Memo::new(move |_| !is_configuring.get());
+    let grid_mounted = Memo::new(move |_| !is_configuring.get());
 
     view! {
         <div
diff --git a/src/workbench/workspace_settings_pane/mod.rs b/src/workbench/workspace_settings_pane/mod.rs
index a48034e..3d02e24 100644
--- a/src/workbench/workspace_settings_pane/mod.rs
+++ b/src/workbench/workspace_settings_pane/mod.rs
@@ -4,10 +4,10 @@ mod category_colors;
 
 use super::browser_tab::sync_embedded_browser_layer;
 use super::state::{BrowserEmbedSurface, WorkbenchService};
-use category_colors::WorkspaceCategoryColorsSection;
 use crate::config::HARNESS_BROWSER_DEFAULT_URL;
 use crate::i18n::I18nKey;
 use crate::service::I18nService;
+use category_colors::WorkspaceCategoryColorsSection;
 use gloo_timers::future::TimeoutFuture;
 use leptos::prelude::*;
 use leptos_icons::Icon as LxIcon;
@@ -50,10 +50,7 @@ fn apply_browser_url(wb: WorkbenchService, embed: BrowserEmbedSurface, url: Stri
 }
 
 #[component]
-pub fn WorkspaceSettingsPane(
-    wb: WorkbenchService,
-    embed: BrowserEmbedSurface,
-) -> impl IntoView {
+pub fn WorkspaceSettingsPane(wb: WorkbenchService, embed: BrowserEmbedSurface) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let baseline = RwSignal::new(snapshot_baseline(&wb));
     let status_msg = RwSignal::new(None::<String>);
@@ -74,7 +71,11 @@ pub fn WorkspaceSettingsPane(
         status_msg.set(None);
         let b = baseline.get_untracked();
         let project = wb.default_project_dir().get_untracked().trim().to_owned();
-        let sandbox = wb.harness_workspace_root().get_untracked().trim().to_owned();
+        let sandbox = wb
+            .harness_workspace_root()
+            .get_untracked()
+            .trim()
+            .to_owned();
         let browser = wb.browser_url().get_untracked();
 
         if project != b.project_dir {
diff --git a/styles.css b/styles.css
index e154e65..d46e252 100644
--- a/styles.css
+++ b/styles.css
@@ -7594,11 +7594,52 @@ button {
 }
 
 .workbench-memory-files__list {
-  flex: 1;
   margin: 0;
   padding: 0.25rem 0;
   list-style: none;
-  overflow-y: auto;
+}
+/* Dual-scope sidebar sections */
+.workbench-memory-files__scope-section {
+  display: flex;
+  flex-direction: column;
+}
+.workbench-memory-files__scope-head {
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  padding: 0.3rem 0.5rem 0.15rem;
+  font-size: 0.68rem;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--color-text-muted);
+  user-select: none;
+}
+.workbench-memory-files__scope-head span {
+  flex: 1;
+}
+/* "Create Global Memory" placeholder */
+.workbench-memory-files__global-init {
+  padding: 0.4rem 0.5rem;
+}
+.workbench-memory-files__global-init-btn {
+  display: flex;
+  align-items: center;
+  gap: 0.3rem;
+  width: 100%;
+  padding: 0.35rem 0.5rem;
+  background: none;
+  border: 1px dashed var(--color-border);
+  border-radius: 4px;
+  color: var(--color-text-muted);
+  cursor: pointer;
+  font-size: 0.75rem;
+  text-align: left;
+  transition: color 0.15s, border-color 0.15s;
+}
+.workbench-memory-files__global-init-btn:hover {
+  color: var(--color-text);
+  border-color: var(--color-text-muted);
 }
 .workbench-memory-files__group-head {
   display: flex;
@@ -8450,6 +8491,9 @@ button {
 .workbench-memory-graph__nodes,
 .workbench-memory-graph__edges { pointer-events: auto; }
 .workbench-memory-graph__node { cursor: pointer; }
+.workbench-memory-graph__node--hub {
+  filter: drop-shadow(0 0 7px color-mix(in srgb, var(--accent-warm) 36%, transparent));
+}
 
 /* ============================================================ */
 /* Voice subsystem                                              */

From 61c5ba4554faf178cdec11056573626e9fee09a7 Mon Sep 17 00:00:00 2001
From: Maik Roland Damm <maik.damm@bluewave-tech.de>
Date: Wed, 27 May 2026 02:10:14 +0200
Subject: [PATCH 3/8] feat(memory-panel): enhance memory pointers management
 and bootstrap functionality

- Introduced PointerAgent struct to manage external agent pointers.
- Added memory status and pointer status signals to MemoryState.
- Implemented loading of pointer status and global README preview.
- Created MemoryBootstrapView and MemoryBootstrapCard components for workspace and global memory setup.
- Added MemoryPointersDialog and MemoryPointersNotice components for managing agent pointers.
- Enhanced CSS styles for new components and improved UI interactions.
- Refactored MemoryPanel to handle pointer actions and bootstrap prompts.
---
 .agents/memory/Test.md                        |   2 -
 .blxcode/tasks/index.json                     |  51 +-
 .cargo/config.toml                            |   3 +
 Cargo.toml                                    |   1 +
 public/brand-icons/opencode.svg               |   5 +
 src-tauri/src/agent/state.rs                  |   2 +
 src-tauri/src/agents_layout.rs                |   8 +-
 src-tauri/src/fs_entries.rs                   |  32 +
 src-tauri/src/git_status.rs                   |  51 +-
 src-tauri/src/memory/graph.rs                 |   2 +
 src-tauri/src/memory/mod.rs                   |   2 +-
 src-tauri/src/memory/paths.rs                 |   7 -
 src-tauri/src/memory/store.rs                 | 281 ++++++---
 src-tauri/src/memory/types.rs                 |   3 +
 src/i18n/keys.rs                              |  21 +
 src/i18n/locales/de_de.rs                     |  21 +
 src/i18n/locales/en_us.rs                     |  21 +
 src/i18n/locales/es_es.rs                     |  21 +
 src/i18n/locales/fr_fr.rs                     |  21 +
 src/i18n/locales/hu_hu.rs                     |  21 +
 src/i18n/locales/it_it.rs                     |  21 +
 src/i18n/locales/ja_jp.rs                     |  21 +
 src/i18n/locales/ko_kr.rs                     |  21 +
 src/i18n/locales/pl_pl.rs                     |  21 +
 src/i18n/locales/pt_br.rs                     |  21 +
 src/i18n/locales/ru_ru.rs                     |  21 +
 src/i18n/locales/zh_cn.rs                     |  21 +
 src/i18n/locales/zh_tw.rs                     |  21 +
 src/tauri_bridge.rs                           |  41 +-
 src/workbench/agent_panel/mod.rs              |  69 ++-
 src/workbench/agent_panel/timeline.rs         | 103 +++-
 .../file_diff_section/file-diff-section.css   |  51 ++
 src/workbench/file_diff_section/mod.rs        | 446 +++++++++-----
 src/workbench/file_preview/markdown_view.rs   |  30 +
 src/workbench/memory_panel.rs                 | 564 +++++++++++++++++-
 styles.css                                    | 376 +++++++++++-
 36 files changed, 2071 insertions(+), 353 deletions(-)
 delete mode 100644 .agents/memory/Test.md
 create mode 100644 public/brand-icons/opencode.svg

diff --git a/.agents/memory/Test.md b/.agents/memory/Test.md
deleted file mode 100644
index 88b97b5..0000000
--- a/.agents/memory/Test.md
+++ /dev/null
@@ -1,2 +0,0 @@
-# Test
-
diff --git a/.blxcode/tasks/index.json b/.blxcode/tasks/index.json
index f73b1d6..315da6a 100644
--- a/.blxcode/tasks/index.json
+++ b/.blxcode/tasks/index.json
@@ -1,5 +1,54 @@
 {
   "version": 1,
-  "tasks": [],
+  "tasks": [
+    {
+      "id": "task-1779838493-1",
+      "title": "Example: Demo task list",
+      "description": "Sample tasks to demonstrate BLXCode task tracking. Safe to edit or delete.",
+      "status": "pending",
+      "position": 0,
+      "createdAt": 1779838493,
+      "updatedAt": 1779838493,
+      "completedAt": null,
+      "parentId": null,
+      "notes": "These are example items only; feel free to rename, re-parent, or remove them."
+    },
+    {
+      "id": "task-1779838495-2",
+      "title": "Example: Change status flow",
+      "description": "Try marking this task as in_progress, then completed, to see how status updates look.",
+      "status": "pending",
+      "position": 1,
+      "createdAt": 1779838495,
+      "updatedAt": 1779838495,
+      "completedAt": null,
+      "parentId": "task-1779838493-1",
+      "notes": "Tip: You can drag tasks to reorder them."
+    },
+    {
+      "id": "task-1779838497-3",
+      "title": "Example: Personalize this task",
+      "description": "Edit the title/description and add your own subtasks.",
+      "status": "pending",
+      "position": 2,
+      "createdAt": 1779838497,
+      "updatedAt": 1779838497,
+      "completedAt": null,
+      "parentId": "task-1779838493-1",
+      "notes": "You can nest tasks multiple levels deep."
+    },
+    {
+      "id": "task-1779838499-4",
+      "title": "Example: Link tasks to a plan",
+      "description": "Use plan files under .agents/plans/ to capture multi-step work. Then load the plan to sync tasks.",
+      "status": "pending",
+      "position": 3,
+      "createdAt": 1779838499,
+      "updatedAt": 1779838499,
+      "completedAt": null,
+      "parentId": "task-1779838493-1",
+      "notes": "Create one plan via plan_create, then call plan_load to sync tasks."
+    }
+  ],
   "activePlanPath": null
 }
\ No newline at end of file
diff --git a/.cargo/config.toml b/.cargo/config.toml
index 5d5a432..9927dcc 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,3 +1,6 @@
+[build]
+rustc-wrapper = "sccache"
+
 # Cross-linkers for Linux release builds (see scripts/release/build.sh).
 [target.aarch64-unknown-linux-gnu]
 linker = "aarch64-linux-gnu-gcc"
diff --git a/Cargo.toml b/Cargo.toml
index 2f29d4d..663ff53 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -71,3 +71,4 @@ members = ["src-tauri"]
 [profile.dev]
 debug = 1
 incremental = true
+codegen-units = 256
diff --git a/public/brand-icons/opencode.svg b/public/brand-icons/opencode.svg
new file mode 100644
index 0000000..676f74d
--- /dev/null
+++ b/public/brand-icons/opencode.svg
@@ -0,0 +1,5 @@
+<svg role="img" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<title>OpenCode</title>
+	<path d="M320 224V352H192V224H320Z" fill="#5A5858"/>
+	<path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="#211E1E"/>
+</svg>
diff --git a/src-tauri/src/agent/state.rs b/src-tauri/src/agent/state.rs
index 3d86b1c..e5d9024 100644
--- a/src-tauri/src/agent/state.rs
+++ b/src-tauri/src/agent/state.rs
@@ -168,6 +168,7 @@ impl AgentEngineState {
 /// Optional env-based provider config (no network in stub).
 #[derive(Clone, Debug)]
 pub struct ProviderEnv {
+    #[allow(dead_code)]
     pub anthropic_api_key: Option<String>,
 }
 
@@ -181,6 +182,7 @@ impl ProviderEnv {
     }
 
     /// Returns JSON for settings UI (secrets redacted).
+    #[allow(dead_code)]
     pub fn status_json(&self) -> Value {
         let provider = if self.anthropic_api_key.is_some() {
             "anthropic_env_configured_stub"
diff --git a/src-tauri/src/agents_layout.rs b/src-tauri/src/agents_layout.rs
index c05f1a0..f16de63 100644
--- a/src-tauri/src/agents_layout.rs
+++ b/src-tauri/src/agents_layout.rs
@@ -46,8 +46,6 @@ _(Add learnings here as `[[learnings/topic-filename|Short title]]` — one line
 
 #[derive(Debug, Clone)]
 pub struct WorkspaceRoots {
-    pub memory: PathBuf,
-    pub learnings: PathBuf,
     pub plans: PathBuf,
 }
 
@@ -86,11 +84,7 @@ pub fn ensure_agents_layout(ws: &str) -> Result<WorkspaceRoots, String> {
     upgrade_learnings_graph_links(&learnings)?;
     seed_plans_index_if_missing(&plans)?;
 
-    Ok(WorkspaceRoots {
-        memory,
-        learnings,
-        plans,
-    })
+    Ok(WorkspaceRoots { plans })
 }
 
 fn seed_plans_index_if_missing(plans: &Path) -> Result<(), String> {
diff --git a/src-tauri/src/fs_entries.rs b/src-tauri/src/fs_entries.rs
index 49f0534..7104984 100644
--- a/src-tauri/src/fs_entries.rs
+++ b/src-tauri/src/fs_entries.rs
@@ -53,6 +53,11 @@ pub enum PolicyKind {
     Authors,
     Changelog,
     Readme,
+    Support,
+    Agents,
+    Claude,
+    Codex,
+    Gemini,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
@@ -112,6 +117,13 @@ fn classify_policy(stem: &str) -> Option<PolicyKind> {
         "changelog" | "changes" | "history" | "release_notes" | "release-notes"
         | "releasenotes" => Some(PolicyKind::Changelog),
         "readme" => Some(PolicyKind::Readme),
+        "support" => Some(PolicyKind::Support),
+        "agents" | "agent" => Some(PolicyKind::Agents),
+        "claude" => Some(PolicyKind::Claude),
+        "codex" => Some(PolicyKind::Codex),
+        "gemini" => Some(PolicyKind::Gemini),
+        "copilot" | "windsurf" | "aider" | "cursor" | "cody" | "devin" | "junie"
+        | "continue" => Some(PolicyKind::Agents),
         _ => None,
     }
 }
@@ -480,6 +492,26 @@ mod tests {
             classify_policy("readme"),
             Some(PolicyKind::Readme)
         ));
+        assert_eq!(
+            classify_policy("support"),
+            Some(PolicyKind::Support)
+        );
+        assert_eq!(
+            classify_policy("agents"),
+            Some(PolicyKind::Agents)
+        );
+        assert_eq!(
+            classify_policy("claude"),
+            Some(PolicyKind::Claude)
+        );
+        assert_eq!(
+            classify_policy("codex"),
+            Some(PolicyKind::Codex)
+        );
+        assert_eq!(
+            classify_policy("copilot"),
+            Some(PolicyKind::Agents)
+        );
         assert!(classify_policy("random").is_none());
     }
 
diff --git a/src-tauri/src/git_status.rs b/src-tauri/src/git_status.rs
index aec93c2..53e0424 100644
--- a/src-tauri/src/git_status.rs
+++ b/src-tauri/src/git_status.rs
@@ -16,6 +16,13 @@ use tauri::{AppHandle, Emitter, Manager};
 
 pub const GIT_MISSING_CODE: &str = "git_missing";
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LineStats {
+    pub added: u32,
+    pub removed: u32,
+}
+
 /// Minimal change record exposed to the frontend. One row per `rel_path`.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -25,8 +32,8 @@ pub struct ChangedFile {
     pub status: String,
     pub staged: bool,
     pub unstaged: bool,
-    pub added_lines: u32,
-    pub removed_lines: u32,
+    pub staged_stats: Option<LineStats>,
+    pub unstaged_stats: Option<LineStats>,
 }
 
 /// Payload of the `git_status_dirty` window event. Frontend listeners
@@ -63,21 +70,22 @@ pub fn git_status_changes(cwd: String) -> Result<Vec<ChangedFile>, String> {
 
     for entry in &mut entries {
         let path = entry.rel_path.clone();
-        let mut added = 0u32;
-        let mut removed = 0u32;
-        if let Some((a, r)) = unstaged_counts.get(&path) {
-            added = added.saturating_add(*a);
-            removed = removed.saturating_add(*r);
-        }
-        if let Some((a, r)) = staged_counts.get(&path) {
-            added = added.saturating_add(*a);
-            removed = removed.saturating_add(*r);
-        }
-        if entry.status == "untracked" && (added == 0 && removed == 0) {
-            added = count_file_lines(&work_tree.join(&path)).unwrap_or(0);
+        let mut unstaged_stats = unstaged_counts
+            .get(&path)
+            .copied()
+            .and_then(normalize_stats);
+        let mut staged_stats = staged_counts.get(&path).copied().and_then(normalize_stats);
+        if entry.status == "untracked" {
+            let lines = count_file_lines(&work_tree.join(&path)).unwrap_or(0);
+            unstaged_stats = normalize_stats((lines, 0));
+            staged_stats = None;
         }
-        entry.added_lines = added;
-        entry.removed_lines = removed;
+        entry.staged_stats = if entry.staged { staged_stats } else { None };
+        entry.unstaged_stats = if entry.unstaged {
+            unstaged_stats
+        } else {
+            None
+        };
     }
 
     entries.sort_by(|a, b| a.rel_path.cmp(&b.rel_path));
@@ -218,8 +226,8 @@ fn parse_porcelain(text: &str) -> Vec<ChangedFile> {
             status: status.to_string(),
             staged,
             unstaged: unstaged || (x == '?' && y == '?'),
-            added_lines: 0,
-            removed_lines: 0,
+            staged_stats: None,
+            unstaged_stats: None,
         });
         i = j + 1;
     }
@@ -229,6 +237,13 @@ fn parse_porcelain(text: &str) -> Vec<ChangedFile> {
 /// Parse `git diff --numstat -z` output. Format per record:
 /// `added\tdeleted\t<NUL>oldname<NUL>newname<NUL>` for renames, otherwise
 /// `added\tdeleted\tpath<NUL>`. Binary files use `-` for the counts.
+fn normalize_stats((added, removed): (u32, u32)) -> Option<LineStats> {
+    if added == 0 && removed == 0 {
+        return None;
+    }
+    Some(LineStats { added, removed })
+}
+
 fn parse_numstat(text: &str) -> HashMap<String, (u32, u32)> {
     let mut out = HashMap::new();
     let bytes = text.as_bytes();
diff --git a/src-tauri/src/memory/graph.rs b/src-tauri/src/memory/graph.rs
index 7a7d194..602788a 100644
--- a/src-tauri/src/memory/graph.rs
+++ b/src-tauri/src/memory/graph.rs
@@ -108,6 +108,7 @@ pub fn build_graph(notes: Vec<ScopeNote>, category_hubs: Vec<CategoryHubInput>)
                 source: source_id.clone(),
                 target: target_id,
                 cross_scope,
+                label: link.alias.clone(),
             });
         }
     }
@@ -132,6 +133,7 @@ pub fn build_graph(notes: Vec<ScopeNote>, category_hubs: Vec<CategoryHubInput>)
             source: note_id,
             target: hub_id,
             cross_scope: false,
+            label: None,
         });
     }
 
diff --git a/src-tauri/src/memory/mod.rs b/src-tauri/src/memory/mod.rs
index 7056324..c5e475a 100644
--- a/src-tauri/src/memory/mod.rs
+++ b/src-tauri/src/memory/mod.rs
@@ -21,7 +21,7 @@ pub use types::*;
 
 use crate::agents_layout::ensure_agents_layout;
 use store::{
-    collect_notes, memory_backlinks_impl, memory_bootstrap_impl, memory_create_category_impl,
+    memory_backlinks_impl, memory_bootstrap_impl, memory_create_category_impl,
     memory_create_impl, memory_delete_impl, memory_export_impl, memory_graph_impl,
     memory_import_impl, memory_install_pointers_impl, memory_list_impl, memory_pointer_status_impl,
     memory_read_impl, memory_rename_impl, memory_search_impl, memory_status_impl,
diff --git a/src-tauri/src/memory/paths.rs b/src-tauri/src/memory/paths.rs
index 0b0d97f..20077e2 100644
--- a/src-tauri/src/memory/paths.rs
+++ b/src-tauri/src/memory/paths.rs
@@ -144,10 +144,3 @@ pub fn category_hub_node_id(category: &str) -> String {
 pub fn category_hub_path(category: &str) -> String {
     format!("{CATEGORY_HUB_PATH_PREFIX}{category}")
 }
-
-pub fn overview_path_for_category(category: &str) -> String {
-    if category == "learnings" {
-        return format!("{LEARNINGS_API_PREFIX}README.md");
-    }
-    format!("{category}/README.md")
-}
diff --git a/src-tauri/src/memory/store.rs b/src-tauri/src/memory/store.rs
index 59caafe..f9f3717 100644
--- a/src-tauri/src/memory/store.rs
+++ b/src-tauri/src/memory/store.rs
@@ -1,18 +1,18 @@
 //! Core CRUD helpers — called from #[tauri::command] wrappers in mod.rs.
 
-use crate::agents_layout::{ensure_agents_layout, LEARNINGS_API_PREFIX, LEARNINGS_REL, MEMORY_REL};
-use std::collections::HashMap;
+use crate::agents_layout::{LEARNINGS_API_PREFIX, LEARNINGS_REL, MEMORY_REL};
+use std::collections::{BTreeSet, HashMap};
 use std::fs;
 use std::io::Write as IoWrite;
 use std::path::{Component, Path, PathBuf};
 
 use super::frontmatter::{
-    parse_frontmatter, serialize_frontmatter, strip_frontmatter, MemoryFrontmatter,
+    parse_frontmatter, serialize_frontmatter, MemoryFrontmatter,
 };
 use super::graph::{build_graph, CategoryHubInput, ScopeNote};
 use super::paths::{
     folder_exists, get_global_roots, get_roots_for_scope, graph_category_for,
-    list_memory_subcategories, node_id, parse_node_id, validate_category_name, MemoryRoots,
+    list_memory_subcategories, node_id, validate_category_name, MemoryRoots,
     CATEGORY_PLACEHOLDER, TEMPLATES_DIRNAME,
 };
 use super::types::{
@@ -20,7 +20,7 @@ use super::types::{
     MemoryStatusResponse, MemorySubcategories, NoteContent, NoteMeta, PointerResult, RenameReport,
     SearchHit,
 };
-use super::wikilinks::{parse_links_and_tags, rewrite_wikilinks};
+use super::wikilinks::rewrite_wikilinks;
 
 // ── Bootstrap seed text ────────────────────────────────────────────────────────
 
@@ -313,6 +313,16 @@ fn seed_learnings(learnings_dir: &Path) -> Result<(), String> {
     Ok(())
 }
 
+pub fn ensure_global_memory_seeded_impl() -> Result<(), String> {
+    let global = get_global_roots();
+    if let Some(parent) = global.memory.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("mkdir global base: {e}"))?;
+    }
+    seed_memory(&global.memory)?;
+    seed_learnings(&global.learnings)?;
+    Ok(())
+}
+
 pub fn memory_bootstrap_impl(target: &str, workspace_cwd: &str) -> Result<(), String> {
     match target {
         "workspace" | "all" => {
@@ -323,20 +333,10 @@ pub fn memory_bootstrap_impl(target: &str, workspace_cwd: &str) -> Result<(), St
                 return Ok(());
             }
             // fall through for "all"
-            let global = get_global_roots();
-            if let Some(parent) = global.memory.parent() {
-                fs::create_dir_all(parent).map_err(|e| format!("mkdir global base: {e}"))?;
-            }
-            seed_memory(&global.memory)?;
-            seed_learnings(&global.learnings)?;
+            ensure_global_memory_seeded_impl()?;
         }
         "global" => {
-            let global = get_global_roots();
-            if let Some(parent) = global.memory.parent() {
-                fs::create_dir_all(parent).map_err(|e| format!("mkdir global base: {e}"))?;
-            }
-            seed_memory(&global.memory)?;
-            seed_learnings(&global.learnings)?;
+            ensure_global_memory_seeded_impl()?;
         }
         _ => return err(format!("unknown target: {target}")),
     }
@@ -832,12 +832,17 @@ fn pointer_filename(agent: &str) -> Option<&'static str> {
     }
 }
 
+fn pointer_cursor_style(agent: &str) -> bool {
+    agent == "cursor"
+}
+
 fn pointer_body(workspace_cwd: &Path, notes: &[NoteMeta], cursor_style: bool) -> String {
     let memory_dir = workspace_cwd.join(MEMORY_REL);
     let learnings_dir = workspace_cwd.join(LEARNINGS_REL);
+    let global_roots = get_global_roots();
     let mut s = String::new();
     if cursor_style {
-        s.push_str("blxcode tracks per-workspace memory and learnings at the paths below.\n");
+        s.push_str("blxcode tracks per-workspace and global memory at the paths below.\n");
     } else {
         s.push_str("## blxcode workspace memory\n\n");
         s.push_str(
@@ -847,22 +852,37 @@ context: read notes that are relevant to the task, and propose new notes \
 or edits when you learn something the team should remember.\n\n",
         );
     }
-    s.push_str(&format!("Memory root: `{}`\n", memory_dir.display()));
+    s.push_str(&format!("Workspace memory: `{}`\n", memory_dir.display()));
     s.push_str(&format!(
-        "Learnings root: `{}` (API paths: `learnings/…`)\n\n",
+        "Workspace learnings: `{}` (API paths: `learnings/...`)\n",
         learnings_dir.display()
     ));
-    let non_template: Vec<_> = notes.iter().filter(|n| !n.is_template).collect();
-    if non_template.is_empty() {
+    s.push_str(&format!(
+        "Global memory: `{}`\n",
+        global_roots.memory.display()
+    ));
+    s.push_str(&format!(
+        "Global learnings: `{}`\n",
+        global_roots.learnings.display()
+    ));
+    s.push_str("Cross-scope links: `[[global:...]]` / `[[workspace:...]]`\n\n");
+    let workspace_notes: Vec<_> = notes
+        .iter()
+        .filter(|n| n.scope == MemoryScope::Workspace && !n.is_template)
+        .collect();
+    if workspace_notes.is_empty() {
         s.push_str("(no notes yet)\n");
     } else {
-        s.push_str("Current notes:\n");
+        s.push_str("Current workspace notes:\n");
         let mut shown = 0;
-        for n in &non_template {
+        for n in &workspace_notes {
             s.push_str(&format!("- `{}`\n", n.path));
             shown += 1;
             if shown >= 80 {
-                s.push_str(&format!("- … and {} more\n", non_template.len() - shown));
+                s.push_str(&format!(
+                    "- ... and {} more\n",
+                    workspace_notes.len().saturating_sub(shown)
+                ));
                 break;
             }
         }
@@ -874,32 +894,32 @@ or edits when you learn something the team should remember.\n\n",
 fn splice_block(existing: &str, begin: &str, end: &str, new_body: &str) -> String {
     let block = format!("{begin}\n{new_body}{end}\n");
     if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
-        let ei_end = ei + end.len();
-        let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
-            ei_end + 1
-        } else {
-            ei_end
-        };
-        let mut out = String::with_capacity(bi + block.len() + existing.len() - tail_start);
-        out.push_str(&existing[..bi]);
-        out.push_str(&block);
-        out.push_str(&existing[tail_start..]);
-        return out;
-    }
-    let mut out = String::new();
-    out.push_str(existing);
-    if !existing.is_empty() && !existing.ends_with('\n') {
-        out.push('\n');
+        if ei > bi {
+            let ei_end = ei + end.len();
+            let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
+                ei_end + 1
+            } else {
+                ei_end
+            };
+            let mut out = String::with_capacity(bi + block.len() + existing.len() - tail_start);
+            out.push_str(&existing[..bi]);
+            out.push_str(&block);
+            out.push_str(&existing[tail_start..]);
+            return out;
+        }
     }
-    if !existing.is_empty() {
-        out.push('\n');
+    if existing.trim().is_empty() {
+        block
+    } else {
+        format!("{}\n\n{block}", existing.trim_end())
     }
-    out.push_str(&block);
-    out
 }
 
 fn strip_block(existing: &str, begin: &str, end: &str) -> String {
     if let (Some(bi), Some(ei)) = (existing.find(begin), existing.find(end)) {
+        if ei <= bi {
+            return existing.to_owned();
+        }
         let ei_end = ei + end.len();
         let tail_start = if ei_end < existing.len() && existing.as_bytes()[ei_end] == b'\n' {
             ei_end + 1
@@ -909,11 +929,15 @@ fn strip_block(existing: &str, begin: &str, end: &str) -> String {
         let mut out = String::new();
         out.push_str(&existing[..bi]);
         out.push_str(&existing[tail_start..]);
-        return out.trim_end_matches('\n').to_owned() + "\n";
+        return out.trim_end().to_owned();
     }
     existing.to_owned()
 }
 
+fn block_installed(content: &str, begin: &str, end: &str) -> bool {
+    content.contains(begin) && content.contains(end)
+}
+
 pub fn memory_install_pointers_impl(
     workspace_cwd: &str,
     agents: Vec<String>,
@@ -922,7 +946,7 @@ pub fn memory_install_pointers_impl(
     let ws = validate_workspace_cwd(workspace_cwd)?;
     let notes = collect_notes(&MemoryScope::Workspace, workspace_cwd);
     let mut results: Vec<PointerResult> = Vec::new();
-    let mut written: std::collections::BTreeSet<String> = Default::default();
+    let mut written: BTreeSet<String> = Default::default();
     for agent in agents {
         let Some(fname) = pointer_filename(&agent) else {
             results.push(PointerResult {
@@ -939,23 +963,21 @@ pub fn memory_install_pointers_impl(
                 agent,
                 path: path.to_string_lossy().into_owned(),
                 installed: false,
-                note: Some("shared file already handled".into()),
+                note: Some("shared file already written".into()),
             });
             continue;
         }
+        written.insert(fname.to_owned());
         if !path.exists() {
             results.push(PointerResult {
                 agent,
                 path: path.to_string_lossy().into_owned(),
                 installed: false,
-                note: Some(
-                    "skipped: file absent; blxcode does not auto-create root pointer files".into(),
-                ),
+                note: Some("file missing — create it first".into()),
             });
-            written.insert(fname.to_owned());
             continue;
         }
-        let cursor_style = agent == "cursor";
+        let cursor_style = pointer_cursor_style(&agent);
         let body = pointer_body(&ws, &notes, cursor_style);
         let (begin, end) = if cursor_style {
             (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
@@ -963,22 +985,9 @@ pub fn memory_install_pointers_impl(
             (POINTER_BEGIN, POINTER_END)
         };
         let existing = fs::read_to_string(&path).unwrap_or_default();
-        if !existing.contains(begin) {
-            results.push(PointerResult {
-                agent,
-                path: path.to_string_lossy().into_owned(),
-                installed: false,
-                note: Some(
-                    "skipped: existing file is user-owned and has no blxcode managed block".into(),
-                ),
-            });
-            written.insert(fname.to_owned());
-            continue;
-        }
         let updated = splice_block(&existing, begin, end, &body);
         match fs::write(&path, updated.as_bytes()) {
             Ok(()) => {
-                written.insert(fname.to_owned());
                 results.push(PointerResult {
                     agent,
                     path: path.to_string_lossy().into_owned(),
@@ -1004,7 +1013,7 @@ pub fn memory_uninstall_pointers_impl(
     use crate::agents_layout::validate_workspace_cwd;
     let ws = validate_workspace_cwd(workspace_cwd)?;
     let mut results = Vec::new();
-    let mut handled: std::collections::BTreeSet<String> = Default::default();
+    let mut handled: BTreeSet<String> = Default::default();
     for agent in agents {
         let Some(fname) = pointer_filename(&agent) else {
             results.push(PointerResult {
@@ -1025,14 +1034,8 @@ pub fn memory_uninstall_pointers_impl(
             continue;
         }
         let path = ws.join(fname);
-        let cursor_style = agent == "cursor";
-        let (begin, end) = if cursor_style {
-            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
-        } else {
-            (POINTER_BEGIN, POINTER_END)
-        };
-        let existing = fs::read_to_string(&path).unwrap_or_default();
-        if existing.is_empty() {
+        handled.insert(fname.to_owned());
+        if !path.exists() {
             results.push(PointerResult {
                 agent,
                 path: path.to_string_lossy().into_owned(),
@@ -1041,10 +1044,25 @@ pub fn memory_uninstall_pointers_impl(
             });
             continue;
         }
+        let cursor_style = pointer_cursor_style(&agent);
+        let (begin, end) = if cursor_style {
+            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
+        } else {
+            (POINTER_BEGIN, POINTER_END)
+        };
+        let existing = fs::read_to_string(&path).unwrap_or_default();
         let stripped = strip_block(&existing, begin, end);
         if stripped.trim().is_empty() {
-            let _ = fs::remove_file(&path);
-        } else if let Err(e) = fs::write(&path, stripped.as_bytes()) {
+            if let Err(e) = fs::remove_file(&path) {
+                results.push(PointerResult {
+                    agent,
+                    path: path.to_string_lossy().into_owned(),
+                    installed: false,
+                    note: Some(format!("remove failed: {e}")),
+                });
+                continue;
+            }
+        } else if let Err(e) = fs::write(&path, format!("{stripped}\n").as_bytes()) {
             results.push(PointerResult {
                 agent,
                 path: path.to_string_lossy().into_owned(),
@@ -1053,12 +1071,11 @@ pub fn memory_uninstall_pointers_impl(
             });
             continue;
         }
-        handled.insert(fname.to_owned());
         results.push(PointerResult {
             agent,
             path: path.to_string_lossy().into_owned(),
             installed: false,
-            note: Some("removed".into()),
+            note: None,
         });
     }
     Ok(results)
@@ -1069,24 +1086,120 @@ pub fn memory_pointer_status_impl(workspace_cwd: &str) -> Result<Vec<PointerResu
     let ws = validate_workspace_cwd(workspace_cwd)?;
     let agents = ["claude", "codex", "gemini", "cursor", "opencode"];
     let mut out = Vec::new();
+    let mut handled: BTreeSet<String> = Default::default();
     for a in agents {
         let Some(fname) = pointer_filename(a) else {
             continue;
         };
         let path = ws.join(fname);
+        if handled.contains(fname) {
+            out.push(PointerResult {
+                agent: a.to_owned(),
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some("shared file already handled".into()),
+            });
+            continue;
+        }
+        handled.insert(fname.to_owned());
+        if !path.exists() {
+            out.push(PointerResult {
+                agent: a.to_owned(),
+                path: path.to_string_lossy().into_owned(),
+                installed: false,
+                note: Some("file missing".into()),
+            });
+            continue;
+        }
         let body = fs::read_to_string(&path).unwrap_or_default();
-        let cursor_style = a == "cursor";
-        let begin = if cursor_style {
-            POINTER_BEGIN_CURSOR
+        let cursor_style = pointer_cursor_style(a);
+        let (begin, end) = if cursor_style {
+            (POINTER_BEGIN_CURSOR, POINTER_END_CURSOR)
         } else {
-            POINTER_BEGIN
+            (POINTER_BEGIN, POINTER_END)
         };
         out.push(PointerResult {
             agent: a.to_owned(),
             path: path.to_string_lossy().into_owned(),
-            installed: body.contains(begin),
+            installed: block_installed(&body, begin, end),
             note: None,
         });
     }
     Ok(out)
 }
+
+#[cfg(test)]
+mod pointer_tests {
+    use super::*;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_ws(name: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!("blxcode-pointer-{name}-{nonce}"));
+        fs::create_dir_all(&path).unwrap();
+        path
+    }
+
+    #[test]
+    fn splice_block_appends_to_user_owned_file() {
+        let updated = splice_block("existing\n", POINTER_BEGIN, POINTER_END, "body\n");
+        assert_eq!(
+            updated,
+            format!("existing\n\n{POINTER_BEGIN}\nbody\n{POINTER_END}\n")
+        );
+    }
+
+    #[test]
+    fn strip_block_removes_only_managed_block() {
+        let existing = format!("before\n\n{POINTER_BEGIN}\nbody\n{POINTER_END}\n\nafter\n");
+        let stripped = strip_block(&existing, POINTER_BEGIN, POINTER_END);
+        assert_eq!(stripped, "before\n\n\nafter");
+    }
+
+    #[test]
+    fn status_reports_missing_and_shared_agents() {
+        let ws = temp_ws("status");
+        fs::write(ws.join("AGENTS.md"), "").unwrap();
+        let status = memory_pointer_status_impl(ws.to_str().unwrap()).unwrap();
+        let codex = status.iter().find(|r| r.agent == "codex").unwrap();
+        let opencode = status.iter().find(|r| r.agent == "opencode").unwrap();
+        let claude = status.iter().find(|r| r.agent == "claude").unwrap();
+        assert_eq!(claude.note.as_deref(), Some("file missing"));
+        assert_eq!(codex.note, None);
+        assert_eq!(
+            opencode.note.as_deref(),
+            Some("shared file already handled")
+        );
+        let _ = fs::remove_dir_all(ws);
+    }
+
+    #[test]
+    fn install_replaces_block_and_uses_shared_notes() {
+        let ws = temp_ws("install");
+        fs::create_dir_all(ws.join(MEMORY_REL)).unwrap();
+        fs::write(ws.join(MEMORY_REL).join("README.md"), "# Memory\n").unwrap();
+        fs::write(
+            ws.join("AGENTS.md"),
+            format!("{POINTER_BEGIN}\nold\n{POINTER_END}\n"),
+        )
+        .unwrap();
+        let result = memory_install_pointers_impl(
+            ws.to_str().unwrap(),
+            vec!["codex".into(), "opencode".into()],
+        )
+        .unwrap();
+        assert!(result[0].installed);
+        assert_eq!(
+            result[1].note.as_deref(),
+            Some("shared file already written")
+        );
+        let content = fs::read_to_string(ws.join("AGENTS.md")).unwrap();
+        assert!(content.contains("Workspace memory:"));
+        assert!(content.contains("Global memory:"));
+        assert!(!content.contains("old"));
+        let _ = fs::remove_dir_all(ws);
+    }
+}
diff --git a/src-tauri/src/memory/types.rs b/src-tauri/src/memory/types.rs
index 699547f..9b4abd5 100644
--- a/src-tauri/src/memory/types.rs
+++ b/src-tauri/src/memory/types.rs
@@ -55,6 +55,9 @@ pub struct GraphEdge {
     pub source: String,
     pub target: String,
     pub cross_scope: bool,
+    /// Display label from `[[target|alias]]` wikilink syntax; `None` when no alias was written.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
diff --git a/src/i18n/keys.rs b/src/i18n/keys.rs
index b7c8f97..1d12242 100644
--- a/src/i18n/keys.rs
+++ b/src/i18n/keys.rs
@@ -79,6 +79,17 @@ pub enum I18nKey {
     SbDiffStatusRenamed,
     SbDiffStatusUntracked,
     SbDiffStatusConflicted,
+    SbDiffStageAll,
+    SbDiffUnstageAll,
+    SbDiffCommitAi,
+    SbDiffPushToBranch,
+    SbDiffPushDisabled,
+    SbDiffPushFailed,
+    SbDiffGroupStaged,
+    SbDiffGroupUnstaged,
+    SbDiffGroupExpand,
+    SbDiffGroupCollapse,
+    SbDiffListAria,
 
     RpRailAria,
     RpExpand,
@@ -378,6 +389,16 @@ pub enum I18nKey {
     FilePreviewPolicyChangelogSubtitle,
     FilePreviewPolicyReadmeTitle,
     FilePreviewPolicyReadmeSubtitle,
+    FilePreviewPolicySupportTitle,
+    FilePreviewPolicySupportSubtitle,
+    FilePreviewPolicyAgentsTitle,
+    FilePreviewPolicyAgentsSubtitle,
+    FilePreviewPolicyClaudeTitle,
+    FilePreviewPolicyClaudeSubtitle,
+    FilePreviewPolicyCodexTitle,
+    FilePreviewPolicyCodexSubtitle,
+    FilePreviewPolicyGeminiTitle,
+    FilePreviewPolicyGeminiSubtitle,
 
     CodeViewMenuAria,
     CodeViewMenuSectionSnippetTerminal,
diff --git a/src/i18n/locales/de_de.rs b/src/i18n/locales/de_de.rs
index 1feec6c..840d7cd 100644
--- a/src/i18n/locales/de_de.rs
+++ b/src/i18n/locales/de_de.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "umbenannt",
         I18nKey::SbDiffStatusUntracked => "untracked",
         I18nKey::SbDiffStatusConflicted => "Konflikt",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Rechtes Panel",
         I18nKey::RpExpand => "Rechtes Panel einblenden",
         I18nKey::RpCollapse => "Rechtes Panel ausblenden",
@@ -371,6 +382,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Wichtige Änderungen in den Releases dieses Projekts.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Readme",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Projektübersicht, Einrichtung und Kurzreferenz.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Hilfe, Fehlermeldungen und Community-Ressourcen.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Anweisungen und Projektkontext für KI-Coding-Agenten in diesem Repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Projektkontext und Anweisungen für Claude Code und verwandte Tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Projektkontext und Anweisungen für OpenAI Codex und kompatible Agenten.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Projektkontext und Anweisungen für Google-Gemini-Coding-Agenten.",
         I18nKey::CodeViewMenuAria => "Code-Vorschau-Aktionen",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Snippet — In Terminal einfügen",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Snippet — An Agent anhängen",
diff --git a/src/i18n/locales/en_us.rs b/src/i18n/locales/en_us.rs
index 8cd5b74..ac603ad 100644
--- a/src/i18n/locales/en_us.rs
+++ b/src/i18n/locales/en_us.rs
@@ -84,6 +84,17 @@ Add it to this project's `.gitignore` so it is not committed by mistake?"
         I18nKey::SbDiffStatusRenamed => "renamed",
         I18nKey::SbDiffStatusUntracked => "untracked",
         I18nKey::SbDiffStatusConflicted => "conflicted",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
 
         I18nKey::RpRailAria => "Right panel",
         I18nKey::RpExpand => "Show right panel",
@@ -408,6 +419,16 @@ Classic: Ctrl+O quick open, Ctrl+` new terminal, Ctrl+Shift+P palette."
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Notable changes across releases of this project.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Readme",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Project overview, setup instructions, and quick reference.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
 
         I18nKey::CodeViewMenuAria => "Code preview actions",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Snippet — Insert into terminal",
diff --git a/src/i18n/locales/es_es.rs b/src/i18n/locales/es_es.rs
index 84c7e2b..877658e 100644
--- a/src/i18n/locales/es_es.rs
+++ b/src/i18n/locales/es_es.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "renombrado",
         I18nKey::SbDiffStatusUntracked => "sin seguimiento",
         I18nKey::SbDiffStatusConflicted => "en conflicto",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Panel derecho",
         I18nKey::RpExpand => "Mostrar panel derecho",
         I18nKey::RpCollapse => "Ocultar panel derecho",
@@ -371,6 +382,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Cambios notables a lo largo de las versiones de este proyecto.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Léeme",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Resumen del proyecto, instrucciones de configuración y referencia rápida.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Acciones de la vista previa de código",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Fragmento — Insertar en terminal",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Fragmento — Adjuntar al agente",
diff --git a/src/i18n/locales/fr_fr.rs b/src/i18n/locales/fr_fr.rs
index e0069fb..8fd9a17 100644
--- a/src/i18n/locales/fr_fr.rs
+++ b/src/i18n/locales/fr_fr.rs
@@ -80,6 +80,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "renommé",
         I18nKey::SbDiffStatusUntracked => "non suivi",
         I18nKey::SbDiffStatusConflicted => "en conflit",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Panneau droit",
         I18nKey::RpExpand => "Afficher le panneau de droite",
         I18nKey::RpCollapse => "Masquer le panneau droit",
@@ -375,6 +386,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Changements notables au fil des versions de ce projet.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Lisez-moi",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Aperçu du projet, instructions d'installation et référence rapide.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Actions de l’aperçu du code",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Extrait — Insérer dans le terminal",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Extrait — Joindre à l’agent",
diff --git a/src/i18n/locales/hu_hu.rs b/src/i18n/locales/hu_hu.rs
index bddd285..f55265d 100644
--- a/src/i18n/locales/hu_hu.rs
+++ b/src/i18n/locales/hu_hu.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "átnevezve",
         I18nKey::SbDiffStatusUntracked => "nem követett",
         I18nKey::SbDiffStatusConflicted => "konfliktus",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Jobb panel",
         I18nKey::RpExpand => "Jobb oldali panel megjelenítése",
         I18nKey::RpCollapse => "A jobb oldali panel elrejtése",
@@ -371,6 +382,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Jelentős változások a projekt kiadásaiban.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Olvass engem",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Projekt áttekintés, beállítási utasítások és gyors hivatkozás.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Kódelőnézet műveletei",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Részlet — Beillesztés a terminálba",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Részlet — Csatolás az ügynökhöz",
diff --git a/src/i18n/locales/it_it.rs b/src/i18n/locales/it_it.rs
index 164ca78..450ee3a 100644
--- a/src/i18n/locales/it_it.rs
+++ b/src/i18n/locales/it_it.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "rinominato",
         I18nKey::SbDiffStatusUntracked => "non tracciato",
         I18nKey::SbDiffStatusConflicted => "in conflitto",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Pannello destro",
         I18nKey::RpExpand => "Mostra il pannello di destra",
         I18nKey::RpCollapse => "Nascondi il pannello destro",
@@ -371,6 +382,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Modifiche rilevanti nelle release di questo progetto.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Leggimi",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Panoramica del progetto, istruzioni di setup e riferimento rapido.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Azioni anteprima del codice",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Frammento — Inserisci nel terminale",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Frammento — Allega all’agente",
diff --git a/src/i18n/locales/ja_jp.rs b/src/i18n/locales/ja_jp.rs
index 432a880..f54c3eb 100644
--- a/src/i18n/locales/ja_jp.rs
+++ b/src/i18n/locales/ja_jp.rs
@@ -76,6 +76,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "リネーム",
         I18nKey::SbDiffStatusUntracked => "未追跡",
         I18nKey::SbDiffStatusConflicted => "競合",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "右パネル",
         I18nKey::RpExpand => "右パネルを表示",
         I18nKey::RpCollapse => "右パネルを非表示にする",
@@ -363,6 +374,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "このプロジェクトのリリースごとの主な変更点。",
         I18nKey::FilePreviewPolicyReadmeTitle => "お読みください",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "プロジェクト概要、セットアップ手順、クイックリファレンス。",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "コードプレビューの操作",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "スニペット — ターミナルに挿入",
         I18nKey::CodeViewMenuSectionSnippetAgent => "スニペット — エージェントに添付",
diff --git a/src/i18n/locales/ko_kr.rs b/src/i18n/locales/ko_kr.rs
index 77574b6..b22b9fd 100644
--- a/src/i18n/locales/ko_kr.rs
+++ b/src/i18n/locales/ko_kr.rs
@@ -76,6 +76,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "이름 변경됨",
         I18nKey::SbDiffStatusUntracked => "추적 안 됨",
         I18nKey::SbDiffStatusConflicted => "충돌",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "오른쪽 패널",
         I18nKey::RpExpand => "오른쪽 패널 표시",
         I18nKey::RpCollapse => "오른쪽 패널 숨기기",
@@ -363,6 +374,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "이 프로젝트 릴리스의 주요 변경 사항.",
         I18nKey::FilePreviewPolicyReadmeTitle => "읽어보기",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "프로젝트 개요, 설정 안내, 빠른 참조.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "코드 미리보기 작업",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "스니펫 — 터미널에 삽입",
         I18nKey::CodeViewMenuSectionSnippetAgent => "스니펫 — 에이전트에 첨부",
diff --git a/src/i18n/locales/pl_pl.rs b/src/i18n/locales/pl_pl.rs
index 6600247..800d744 100644
--- a/src/i18n/locales/pl_pl.rs
+++ b/src/i18n/locales/pl_pl.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "zmieniono nazwę",
         I18nKey::SbDiffStatusUntracked => "nieśledzone",
         I18nKey::SbDiffStatusConflicted => "konflikt",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Prawy panel",
         I18nKey::RpExpand => "Pokaż prawy panel",
         I18nKey::RpCollapse => "Ukryj prawy panel",
@@ -369,6 +380,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Istotne zmiany w wydaniach tego projektu.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Przeczytaj",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Przegląd projektu, instrukcje konfiguracji i szybkie odniesienie.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Akcje podglądu kodu",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Fragment — Wstaw do terminala",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Fragment — Dołącz do agenta",
diff --git a/src/i18n/locales/pt_br.rs b/src/i18n/locales/pt_br.rs
index 91c1023..395eccb 100644
--- a/src/i18n/locales/pt_br.rs
+++ b/src/i18n/locales/pt_br.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "renomeado",
         I18nKey::SbDiffStatusUntracked => "não rastreado",
         I18nKey::SbDiffStatusConflicted => "em conflito",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Painel direito",
         I18nKey::RpExpand => "Mostrar painel direito",
         I18nKey::RpCollapse => "Ocultar painel direito",
@@ -371,6 +382,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Mudanças notáveis nos releases deste projeto.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Leia-me",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Visão geral do projeto, instruções de configuração e referência rápida.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Ações da pré-visualização de código",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Trecho — Inserir no terminal",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Trecho — Anexar ao agente",
diff --git a/src/i18n/locales/ru_ru.rs b/src/i18n/locales/ru_ru.rs
index 1264a69..afd6fbb 100644
--- a/src/i18n/locales/ru_ru.rs
+++ b/src/i18n/locales/ru_ru.rs
@@ -78,6 +78,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "переименован",
         I18nKey::SbDiffStatusUntracked => "не отслеживается",
         I18nKey::SbDiffStatusConflicted => "конфликт",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "Правая панель",
         I18nKey::RpExpand => "Показать правую панель",
         I18nKey::RpCollapse => "Скрыть правую панель",
@@ -369,6 +380,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "Заметные изменения в выпусках этого проекта.",
         I18nKey::FilePreviewPolicyReadmeTitle => "Readme",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "Обзор проекта, инструкции по настройке и краткий справочник.",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "Действия предпросмотра кода",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "Фрагмент — Вставить в терминал",
         I18nKey::CodeViewMenuSectionSnippetAgent => "Фрагмент — Прикрепить к агенту",
diff --git a/src/i18n/locales/zh_cn.rs b/src/i18n/locales/zh_cn.rs
index b1ba3fc..09e3e95 100644
--- a/src/i18n/locales/zh_cn.rs
+++ b/src/i18n/locales/zh_cn.rs
@@ -76,6 +76,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "已重命名",
         I18nKey::SbDiffStatusUntracked => "未跟踪",
         I18nKey::SbDiffStatusConflicted => "冲突",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "右面板",
         I18nKey::RpExpand => "显示右侧面板",
         I18nKey::RpCollapse => "隐藏右侧面板",
@@ -361,6 +372,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "本项目各版本中的重要变更。",
         I18nKey::FilePreviewPolicyReadmeTitle => "自述文件",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "项目概述、设置说明和快速参考。",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "代码预览操作",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "片段 — 插入到终端",
         I18nKey::CodeViewMenuSectionSnippetAgent => "片段 — 附加到代理",
diff --git a/src/i18n/locales/zh_tw.rs b/src/i18n/locales/zh_tw.rs
index 9dff9a3..2cee925 100644
--- a/src/i18n/locales/zh_tw.rs
+++ b/src/i18n/locales/zh_tw.rs
@@ -76,6 +76,17 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::SbDiffStatusRenamed => "已重新命名",
         I18nKey::SbDiffStatusUntracked => "未追蹤",
         I18nKey::SbDiffStatusConflicted => "衝突",
+        I18nKey::SbDiffStageAll => "Stage all changes",
+        I18nKey::SbDiffUnstageAll => "Unstage all changes",
+        I18nKey::SbDiffCommitAi => "Commit with AI",
+        I18nKey::SbDiffPushToBranch => "Push to",
+        I18nKey::SbDiffPushDisabled => "Commit or discard local changes before pushing.",
+        I18nKey::SbDiffPushFailed => "Could not push to remote.",
+        I18nKey::SbDiffGroupStaged => "Staged Changes",
+        I18nKey::SbDiffGroupUnstaged => "Changes",
+        I18nKey::SbDiffGroupExpand => "Expand",
+        I18nKey::SbDiffGroupCollapse => "Collapse",
+        I18nKey::SbDiffListAria => "Changed files",
         I18nKey::RpRailAria => "右面板",
         I18nKey::RpExpand => "顯示右側面板",
         I18nKey::RpCollapse => "隱藏右側面板",
@@ -361,6 +372,16 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::FilePreviewPolicyChangelogSubtitle => "本專案各版本中的重要變更。",
         I18nKey::FilePreviewPolicyReadmeTitle => "自述文件",
         I18nKey::FilePreviewPolicyReadmeSubtitle => "專案概覽、設定說明與快速參考。",
+        I18nKey::FilePreviewPolicySupportTitle => "Support",
+        I18nKey::FilePreviewPolicySupportSubtitle => "Where to get help, report issues, and find community resources.",
+        I18nKey::FilePreviewPolicyAgentsTitle => "Agents",
+        I18nKey::FilePreviewPolicyAgentsSubtitle => "Instructions and project context for AI coding agents in this repository.",
+        I18nKey::FilePreviewPolicyClaudeTitle => "Claude",
+        I18nKey::FilePreviewPolicyClaudeSubtitle => "Project context and instructions for Claude Code and related tools.",
+        I18nKey::FilePreviewPolicyCodexTitle => "Codex",
+        I18nKey::FilePreviewPolicyCodexSubtitle => "Project context and instructions for OpenAI Codex and compatible agents.",
+        I18nKey::FilePreviewPolicyGeminiTitle => "Gemini",
+        I18nKey::FilePreviewPolicyGeminiSubtitle => "Project context and instructions for Google Gemini coding agents.",
         I18nKey::CodeViewMenuAria => "程式碼預覽動作",
         I18nKey::CodeViewMenuSectionSnippetTerminal => "片段 — 插入終端機",
         I18nKey::CodeViewMenuSectionSnippetAgent => "片段 — 附加到代理",
diff --git a/src/tauri_bridge.rs b/src/tauri_bridge.rs
index 0703805..33c2851 100644
--- a/src/tauri_bridge.rs
+++ b/src/tauri_bridge.rs
@@ -692,6 +692,11 @@ pub enum PolicyKind {
     Authors,
     Changelog,
     Readme,
+    Support,
+    Agents,
+    Claude,
+    Codex,
+    Gemini,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
@@ -1536,7 +1541,10 @@ pub async fn memory_search(ws: &str, query: &str) -> Result<Vec<SearchHit>, Stri
     .await
 }
 
-#[allow(dead_code)]
+pub async fn memory_pointer_status(ws: &str) -> Result<Vec<PointerResult>, String> {
+    invoke_typed("memory_pointer_status", WsArg { workspace_cwd: ws }).await
+}
+
 pub async fn memory_install_pointers(
     ws: &str,
     agents: Vec<String>,
@@ -1557,6 +1565,26 @@ pub async fn memory_install_pointers(
     .await
 }
 
+pub async fn memory_uninstall_pointers(
+    ws: &str,
+    agents: Vec<String>,
+) -> Result<Vec<PointerResult>, String> {
+    #[derive(Serialize)]
+    #[serde(rename_all = "camelCase")]
+    struct A<'a> {
+        workspace_cwd: &'a str,
+        agents: Vec<String>,
+    }
+    invoke_typed(
+        "memory_uninstall_pointers",
+        A {
+            workspace_cwd: ws,
+            agents,
+        },
+    )
+    .await
+}
+
 // ---------------------------------------------------------------------
 // Plans (workspace-scoped Markdown plans under .agents/plans/)
 
@@ -1935,6 +1963,13 @@ pub async fn git_commit_graph(cwd: String, limit: Option<u32>) -> Result<GitGrap
     invoke_typed("git_commit_graph", Args { cwd, limit }).await
 }
 
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LineStats {
+    pub added: u32,
+    pub removed: u32,
+}
+
 #[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ChangedFile {
@@ -1943,8 +1978,8 @@ pub struct ChangedFile {
     pub status: String,
     pub staged: bool,
     pub unstaged: bool,
-    pub added_lines: u32,
-    pub removed_lines: u32,
+    pub staged_stats: Option<LineStats>,
+    pub unstaged_stats: Option<LineStats>,
 }
 
 pub async fn git_status_changes(cwd: String) -> Result<Vec<ChangedFile>, String> {
diff --git a/src/workbench/agent_panel/mod.rs b/src/workbench/agent_panel/mod.rs
index f563a7d..77d3f71 100644
--- a/src/workbench/agent_panel/mod.rs
+++ b/src/workbench/agent_panel/mod.rs
@@ -27,7 +27,7 @@ use crate::workbench::agent_panel::subagent_debounce::{
 };
 use crate::workbench::agent_panel::task_list::TaskSection;
 use crate::workbench::agent_panel::timeline::{
-    apply_agent_event, compact_timeline, ChatLineIndexColumn, TimelineItem, TimelineRow,
+    apply_agent_event, timeline_display_rows, ChatLineIndexColumn, TimelineItem, TimelineRow,
 };
 use crate::workbench::agent_panel::voice_orb::{
     handle_voice_event, install_ptt_hotkey, VoiceOrb, VoiceOrbHandle,
@@ -78,6 +78,7 @@ pub fn AgentPanelDock() -> impl IntoView {
     // display timeline. Lives on the parent so streaming rerenders do not
     // remount the row and reset the local open flag.
     let thinking_open = RwSignal::new(HashMap::<usize, bool>::new());
+    let tool_detail_open = RwSignal::new(HashMap::<String, bool>::new());
 
     // Load authoritative timeline + compose draft when the active workspace
     // changes only (do not subscribe to `workspaces` — timeline writes would
@@ -87,12 +88,14 @@ pub fn AgentPanelDock() -> impl IntoView {
         let Some(id) = active else {
             timeline.set(Vec::new());
             thinking_open.set(HashMap::new());
+            tool_detail_open.set(HashMap::new());
             draft.set(String::new());
             image_mode.set(false);
             return;
         };
         timeline.set(wb.agent_timeline_for_workspace_untracked(id));
         thinking_open.set(HashMap::new());
+        tool_detail_open.set(HashMap::new());
         draft.set(wb.agent_compose_draft_for_workspace_untracked(id));
         image_mode.set(wb.agent_image_mode_for_workspace_untracked(id));
     });
@@ -173,10 +176,23 @@ pub fn AgentPanelDock() -> impl IntoView {
         context_open.set(count > 0);
     });
 
+    // Autoscroll while following the stream (near bottom or new row). Skip when
+    // the user scrolled up to read/expand older tool or thinking blocks.
+    const AUTOSCROLL_PX: i32 = 80;
+    let last_timeline_len = StoredValue::new(0usize);
     Effect::new(move |_| {
-        let _ = timeline.get().len();
-        if let Some(log) = chat_scroll_ref.get() {
-            log.set_scroll_top(log.scroll_height());
+        let len = timeline.with(|t| t.len());
+        let prev_len = last_timeline_len.get_value();
+        last_timeline_len.set_value(len);
+        let Some(log) = chat_scroll_ref.get() else {
+            return;
+        };
+        let scroll_top = log.scroll_top();
+        let scroll_height = log.scroll_height();
+        let client_height = log.client_height();
+        let near_bottom = scroll_height - scroll_top - client_height < AUTOSCROLL_PX;
+        if len > prev_len || near_bottom {
+            log.set_scroll_top(scroll_height);
         }
     });
 
@@ -196,6 +212,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                     timeline,
                     task_snapshot,
                     thinking_open,
+                    tool_detail_open,
                     voice_handle,
                 );
             } else {
@@ -253,6 +270,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                                 timeline,
                                 task_snapshot,
                                 thinking_open,
+                                tool_detail_open,
                                 voice_handle,
                             );
                         } else {
@@ -359,6 +377,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                                 let timeline = timeline;
                                 let draft = draft;
                                 let thinking_open = thinking_open;
+                                let tool_detail_open = tool_detail_open;
                                 leptos::task::spawn_local(async move {
                                     let Some(ws_id) = wb.active_id().get_untracked() else {
                                         status_line.set(Some("Select a workspace tab first.".into()));
@@ -368,6 +387,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                                         Ok(()) => {
                                             timeline.set(Vec::new());
                                             thinking_open.set(HashMap::new());
+                                            tool_detail_open.set(HashMap::new());
                                             draft.set(String::new());
                                             wb.set_workspace_agent_timeline(ws_id, Vec::new());
                                             wb.set_workspace_agent_compose_draft(ws_id, String::new());
@@ -406,22 +426,37 @@ pub fn AgentPanelDock() -> impl IntoView {
                         }
                     >
                         <ol class="agent-chat-list" aria-label=move || i18n.tr(I18nKey::AgTimelineAria)()>
-                            {move || {
+                            {
                                 let on_redo = Callback::new(move |text: String| {
                                     draft.set(text);
                                     submit_turn(
                                         wb, i18n, draft, busy, status_line,
-                                        timeline, task_snapshot, thinking_open, voice_handle,
+                                        timeline, task_snapshot, thinking_open, tool_detail_open, voice_handle,
                                     );
                                 });
-                                compact_timeline(timeline.get())
-                                    .into_iter()
-                                    .enumerate()
-                                    .map(|(idx, entry)| {
-                                        view! { <TimelineRow idx=idx entry=entry i18n=i18n thinking_open=thinking_open voice_handle=voice_handle on_redo=on_redo timeline=timeline wb=wb workspace_id=wb.active_id().get_untracked() /> }
-                                    })
-                                    .collect_view()
-                            }}
+                                view! {
+                                    <For
+                                        each=move || timeline_display_rows(timeline.get())
+                                        key=|row| row.idx
+                                        children=move |row| {
+                                            view! {
+                                                <TimelineRow
+                                                    idx=row.idx
+                                                    entry=row.entry
+                                                    i18n=i18n
+                                                    thinking_open=thinking_open
+                                                    tool_detail_open=tool_detail_open
+                                                    voice_handle=voice_handle
+                                                    on_redo=on_redo
+                                                    timeline=timeline
+                                                    wb=wb
+                                                    workspace_id=wb.active_id().get_untracked()
+                                                />
+                                            }
+                                        }
+                                    />
+                                }
+                            }
                         </ol>
                     </Show>
                 </div>
@@ -431,7 +466,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                 class="agent-compose"
                 on:submit=move |ev| {
                     ev.prevent_default();
-                    submit_turn(wb, i18n, draft, busy, status_line, timeline, task_snapshot, thinking_open, voice_handle);
+                    submit_turn(wb, i18n, draft, busy, status_line, timeline, task_snapshot, thinking_open, tool_detail_open, voice_handle);
                 }
             >
                 <input
@@ -455,7 +490,7 @@ pub fn AgentPanelDock() -> impl IntoView {
                     on:keydown=move |ev| {
                         if ev.key() == "Enter" && !ev.shift_key() && !ev.ctrl_key() && !ev.meta_key() {
                             ev.prevent_default();
-                            submit_turn(wb, i18n, draft, busy, status_line, timeline, task_snapshot, thinking_open, voice_handle);
+                            submit_turn(wb, i18n, draft, busy, status_line, timeline, task_snapshot, thinking_open, tool_detail_open, voice_handle);
                         }
                     }
                 />
@@ -523,6 +558,7 @@ fn submit_turn(
     timeline: RwSignal<Vec<TimelineItem>>,
     task_snapshot: RwSignal<TaskSnapshot>,
     thinking_open: RwSignal<HashMap<usize, bool>>,
+    tool_detail_open: RwSignal<HashMap<String, bool>>,
     voice_handle: VoiceOrbHandle,
 ) {
     if busy.get_untracked() {
@@ -551,6 +587,7 @@ fn submit_turn(
                 Ok(()) => {
                     timeline.set(Vec::new());
                     thinking_open.set(HashMap::new());
+                    tool_detail_open.set(HashMap::new());
                     wb.set_workspace_agent_timeline(ws_id, Vec::new());
                     wb.clear_chat_usage(ws_id);
                     status_line.set(None);
diff --git a/src/workbench/agent_panel/timeline.rs b/src/workbench/agent_panel/timeline.rs
index 64a56b1..96b0d08 100644
--- a/src/workbench/agent_panel/timeline.rs
+++ b/src/workbench/agent_panel/timeline.rs
@@ -14,6 +14,7 @@ use crate::workbench::agent_timeline::{
 };
 use crate::workbench::chat_markdown::render_markdown_to_html;
 use crate::workbench::WorkbenchService;
+use leptos::html;
 use leptos::prelude::*;
 use leptos_icons::Icon as LxIcon;
 use std::collections::HashMap;
@@ -736,6 +737,35 @@ fn group_consecutive_tools(tools: Vec<ToolActivity>) -> Vec<ToolActivity> {
     out
 }
 
+/// One rendered chat-log row (index in [`compact_timeline`] output).
+#[derive(Clone, Debug, PartialEq)]
+pub struct TimelineDisplayRow {
+    pub idx: usize,
+    pub entry: DisplayTimelineItem,
+}
+
+pub fn timeline_display_rows(items: Vec<TimelineItem>) -> Vec<TimelineDisplayRow> {
+    compact_timeline(items)
+        .into_iter()
+        .enumerate()
+        .map(|(idx, entry)| TimelineDisplayRow { idx, entry })
+        .collect()
+}
+
+/// Stable key for tool-detail expand state across streaming rerenders.
+pub fn tool_detail_key(
+    line_idx: usize,
+    tool: &str,
+    call_id: Option<&str>,
+    sub_idx: Option<usize>,
+) -> String {
+    if let Some(si) = sub_idx {
+        format!("{line_idx}-s{si}-{tool}")
+    } else {
+        format!("{line_idx}-{tool}-{}", call_id.unwrap_or(""))
+    }
+}
+
 pub fn compact_timeline(items: Vec<TimelineItem>) -> Vec<DisplayTimelineItem> {
     let mut out = Vec::with_capacity(items.len());
     let mut last_user_text: Option<String> = None;
@@ -915,6 +945,7 @@ pub fn TimelineRow(
     entry: DisplayTimelineItem,
     i18n: I18nService,
     thinking_open: RwSignal<HashMap<usize, bool>>,
+    tool_detail_open: RwSignal<HashMap<String, bool>>,
     voice_handle: VoiceOrbHandle,
     on_redo: Callback<String>,
     timeline: RwSignal<Vec<TimelineItem>>,
@@ -998,10 +1029,19 @@ pub fn TimelineRow(
         }
             .into_any()
         }
-        DisplayTimelineItem::Tool(tool) => view! {
-            <ToolActivityRow line_no=line_no tool=tool voice_handle=voice_handle />
+        DisplayTimelineItem::Tool(tool) => {
+            let detail_key = tool_detail_key(idx, &tool.tool, tool.call_id.as_deref(), None);
+            view! {
+                <ToolActivityRow
+                    line_no=line_no
+                    tool=tool
+                    detail_key=detail_key
+                    tool_detail_open=tool_detail_open
+                    voice_handle=voice_handle
+                />
+            }
+            .into_any()
         }
-        .into_any(),
         DisplayTimelineItem::ModelRound { metrics, tools } => {
             let loc = i18n.locale().get_untracked();
             let label = lookup(loc, I18nKey::AgMetricsModelRound).to_string();
@@ -1011,7 +1051,7 @@ pub fn TimelineRow(
                     <div class="agent-chat-body">
                         <span class="agent-chat-decision-label">{label}</span>
                         <ul class="model-round-tools">
-                            {tools.into_iter().map(|tool| {
+                            {tools.into_iter().enumerate().map(|(ti, tool)| {
                                 let status_class = match tool.status {
                                     ActivityStatus::Ok => "agent-tool-row--ok",
                                     ActivityStatus::Fail => "agent-tool-row--fail",
@@ -1042,7 +1082,13 @@ pub fn TimelineRow(
                                     || tool.detail.as_ref().is_some_and(|s| !s.is_empty());
                                 let detail_text = tool.detail.clone().unwrap_or_default();
                                 let paths_sv = StoredValue::new(tool.paths.clone());
-                                let detail_open = RwSignal::new(false);
+                                let detail_key =
+                                    tool_detail_key(idx, &tool_name, tool.call_id.as_deref(), Some(ti));
+                                let detail_key_memo = detail_key.clone();
+                                let detail_open = Memo::new(move |_| {
+                                    tool_detail_open
+                                        .with(|m| m.get(&detail_key_memo).copied().unwrap_or(false))
+                                });
                                 view! {
                                     <li class="model-round-tool-item">
                                         <div class=format!("agent-tool-row {status_class}") title=tool_name>
@@ -1052,7 +1098,13 @@ pub fn TimelineRow(
                                                 aria-expanded=move || detail_open.get().to_string()
                                                 prop:disabled=move || !has_detail
                                                 on:click=move |_| {
-                                                    if has_detail { detail_open.update(|o| *o = !*o); }
+                                                    if has_detail {
+                                                        tool_detail_open.update(|m| {
+                                                            let cur =
+                                                                m.get(&detail_key).copied().unwrap_or(false);
+                                                            m.insert(detail_key.clone(), !cur);
+                                                        });
+                                                    }
                                                 }
                                             >
                                                 <span class="agent-tool-row__icon" aria-hidden="true">
@@ -1347,6 +1399,19 @@ fn ThinkingRow(
     let has_content = !text.trim().is_empty();
     let label = if done { "Thinking" } else { "Thinking…" };
     let body = text.clone();
+    let body_ref = NodeRef::<html::Pre>::new();
+    let body_scroll_top = StoredValue::new(0i32);
+    Effect::new(move |_| {
+        let _ = text.len();
+        let Some(pre) = body_ref.get() else {
+            return;
+        };
+        let sh = pre.scroll_height();
+        let ch = pre.client_height();
+        let st = body_scroll_top.get_value();
+        let at_bottom = sh - st - ch < 8;
+        pre.set_scroll_top(if at_bottom { sh } else { st });
+    });
     view! {
         <li class="agent-chat-line agent-chat-line--thinking">
             <ChatLineIndexColumn line_no=line_no tts_text=None voice_handle=voice_handle />
@@ -1383,7 +1448,17 @@ fn ThinkingRow(
                     </Show>
                 </button>
                 <Show when=move || open.get() && has_content>
-                    <pre class="agent-thinking-card__body">{body.clone()}</pre>
+                    <pre
+                        class="agent-thinking-card__body"
+                        node_ref=body_ref
+                        on:scroll=move |_| {
+                            if let Some(pre) = body_ref.get() {
+                                body_scroll_top.set_value(pre.scroll_top());
+                            }
+                        }
+                    >
+                        {body.clone()}
+                    </pre>
                 </Show>
             </div>
         </li>
@@ -1394,6 +1469,8 @@ fn ThinkingRow(
 fn ToolActivityRow(
     line_no: String,
     tool: ToolActivity,
+    detail_key: String,
+    tool_detail_open: RwSignal<HashMap<String, bool>>,
     voice_handle: VoiceOrbHandle,
 ) -> impl IntoView {
     let status_class = match tool.status {
@@ -1407,7 +1484,11 @@ fn ToolActivityRow(
         ActivityStatus::Fail => icondata::LuTriangleAlert,
     };
 
-    let detail_open = RwSignal::new(false);
+    let detail_key_memo = detail_key.clone();
+    let detail_open = Memo::new(move |_| {
+        tool_detail_open
+            .with(|m| m.get(&detail_key_memo).copied().unwrap_or(false))
+    });
     let has_detail = tool.detail.as_ref().is_some_and(|s| !s.is_empty());
     let detail_text = tool.detail.clone().unwrap_or_default();
     let label = tool.label.clone();
@@ -1427,7 +1508,11 @@ fn ToolActivityRow(
                         prop:disabled=move || !has_detail
                         on:click=move |_| {
                             if has_detail {
-                                detail_open.update(|o| *o = !*o);
+                                let key = detail_key.clone();
+                                tool_detail_open.update(|m| {
+                                    let cur = m.get(&key).copied().unwrap_or(false);
+                                    m.insert(key, !cur);
+                                });
                             }
                         }
                     >
diff --git a/src/workbench/file_diff_section/file-diff-section.css b/src/workbench/file_diff_section/file-diff-section.css
index 45b6725..28a1f34 100644
--- a/src/workbench/file_diff_section/file-diff-section.css
+++ b/src/workbench/file_diff_section/file-diff-section.css
@@ -15,6 +15,57 @@
   padding: 0.15rem 0 0.3rem;
 }
 
+.file-diff-section__group {
+  list-style: none;
+}
+
+.file-diff-section__group-toggle {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  width: 100%;
+  min-height: 22px;
+  padding: 0.1rem 0.35rem 0.1rem 0.25rem;
+  border: none;
+  background: var(--surface-2, var(--overlay-1));
+  color: var(--text-muted);
+  font: inherit;
+  font-size: 0.66rem;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  text-align: left;
+  cursor: pointer;
+}
+
+.file-diff-section__group-toggle:hover,
+.file-diff-section__group-toggle:focus-visible {
+  background: var(--overlay-2);
+  color: var(--text);
+  outline: none;
+}
+
+.file-diff-section__group-title {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.file-diff-section__group-chev {
+  flex-shrink: 0;
+  font-size: 0.62rem;
+  line-height: 1;
+  opacity: 0.75;
+}
+
+.file-diff-section__group-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+}
+
 .file-diff-section__row {
   display: flex;
   align-items: center;
diff --git a/src/workbench/file_diff_section/mod.rs b/src/workbench/file_diff_section/mod.rs
index 8694128..28960a8 100644
--- a/src/workbench/file_diff_section/mod.rs
+++ b/src/workbench/file_diff_section/mod.rs
@@ -7,7 +7,8 @@ use crate::i18n::I18nKey;
 use crate::service::I18nService;
 use crate::tauri_bridge::{
     git_stage_file, git_status_changes, git_status_watch_start, git_status_watch_stop,
-    git_unstage_file, listen_git_status_dirty, ChangedFile, TauriEventListener, GIT_MISSING_CODE,
+    git_unstage_file, listen_git_status_dirty, ChangedFile, LineStats, TauriEventListener,
+    GIT_MISSING_CODE,
 };
 use crate::workbench::sidebar_view_section::{SidebarSectionIconBtn, SidebarViewSection};
 use crate::workbench::WorkbenchService;
@@ -215,29 +216,12 @@ fn FileDiffBody(
     reload: Callback<()>,
 ) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
+    let staged_open = RwSignal::new(true);
+    let unstaged_open = RwSignal::new(true);
 
     view! {
         <div class="file-diff-section">
-            <Show
-                when=move || error_kind.get().is_some()
-                fallback=move || {
-                    let Some(list) = entries.get() else {
-                        return view! {
-                            <p class="sidebar-view-section__empty">"…"</p>
-                        }
-                        .into_any();
-                    };
-                    if list.is_empty() {
-                        return view! {
-                            <p class="sidebar-view-section__empty">
-                                {move || i18n.tr(I18nKey::SbDiffEmpty)()}
-                            </p>
-                        }
-                        .into_any();
-                    }
-                    view! { <FileDiffList entries=list reload=reload /> }.into_any()
-                }
-            >
+            <Show when=move || error_kind.get().is_some()>
                 <p class="sidebar-view-section__empty">
                     {move || match error_kind.get() {
                         Some(DiffErrorKind::GitMissing) => i18n.tr(I18nKey::SbDiffGitMissing)(),
@@ -245,148 +229,167 @@ fn FileDiffBody(
                     }}
                 </p>
             </Show>
+            <Show when=move || error_kind.get().is_none()>
+                <FileDiffList
+                    entries=entries
+                    reload=reload
+                    staged_open=staged_open
+                    unstaged_open=unstaged_open
+                />
+            </Show>
         </div>
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum DiffGroupVariant {
+    Staged,
+    Unstaged,
+}
+
+fn partition_entries(entries: &[ChangedFile]) -> (Vec<ChangedFile>, Vec<ChangedFile>) {
+    let mut staged = Vec::new();
+    let mut unstaged = Vec::new();
+    for entry in entries {
+        if entry.staged {
+            staged.push(entry.clone());
+        }
+        if entry.unstaged {
+            unstaged.push(entry.clone());
+        }
+    }
+    (staged, unstaged)
+}
+
 #[component]
-fn FileDiffList(entries: Vec<ChangedFile>, reload: Callback<()>) -> impl IntoView {
-    let wb = expect_context::<WorkbenchService>();
+fn FileDiffList(
+    entries: RwSignal<Option<Vec<ChangedFile>>>,
+    reload: Callback<()>,
+    staged_open: RwSignal<bool>,
+    unstaged_open: RwSignal<bool>,
+) -> impl IntoView {
+    let i18n = expect_context::<I18nService>();
+
+    view! {
+        {move || match entries.get() {
+            None => {
+                view! { <p class="sidebar-view-section__empty">"…"</p> }.into_any()
+            }
+            Some(list) if list.is_empty() => {
+                view! {
+                    <p class="sidebar-view-section__empty">
+                        {i18n.tr(I18nKey::SbDiffEmpty)()}
+                    </p>
+                }
+                .into_any()
+            }
+            Some(list) => {
+                let (staged, unstaged) = partition_entries(&list);
+                view! {
+                    <ul
+                        class="file-diff-section__list"
+                        role="list"
+                        aria-label=i18n.tr(I18nKey::SbDiffListAria)()
+                    >
+                        <FileDiffGroup
+                            variant=DiffGroupVariant::Staged
+                            entries=staged
+                            open=staged_open
+                            reload=reload
+                        />
+                        <FileDiffGroup
+                            variant=DiffGroupVariant::Unstaged
+                            entries=unstaged
+                            open=unstaged_open
+                            reload=reload
+                        />
+                    </ul>
+                }
+                .into_any()
+            }
+        }}
+    }
+}
+
+#[component]
+fn FileDiffGroup(
+    variant: DiffGroupVariant,
+    entries: Vec<ChangedFile>,
+    open: RwSignal<bool>,
+    reload: Callback<()>,
+) -> impl IntoView {
     let i18n = expect_context::<I18nService>();
+    if entries.is_empty() {
+        return ().into_any();
+    }
+
+    let count = entries.len();
+    let panel_id = match variant {
+        DiffGroupVariant::Staged => "file-diff-staged",
+        DiffGroupVariant::Unstaged => "file-diff-unstaged",
+    };
+    let title_base = move || match variant {
+        DiffGroupVariant::Staged => i18n.tr(I18nKey::SbDiffGroupStaged)(),
+        DiffGroupVariant::Unstaged => i18n.tr(I18nKey::SbDiffGroupUnstaged)(),
+    };
+    let title = move || format!("{} ({count})", title_base());
 
     view! {
-        <ul class="file-diff-section__list" role="list">
+        <li class="file-diff-section__group">
+            <button
+                type="button"
+                class="file-diff-section__group-toggle"
+                id=format!("{panel_id}-header")
+                aria-expanded=move || open.get()
+                aria-controls=panel_id
+                aria-label=move || {
+                    let prefix = if open.get() {
+                        i18n.tr(I18nKey::SbDiffGroupCollapse)()
+                    } else {
+                        i18n.tr(I18nKey::SbDiffGroupExpand)()
+                    };
+                    format!("{prefix} {}", title())
+                }
+                on:click=move |_| open.update(|v| *v = !*v)
+            >
+                <span class="file-diff-section__group-title">{title}</span>
+                <span class="file-diff-section__group-chev" aria-hidden="true">
+                    {move || if open.get() { "▾" } else { "▸" }}
+                </span>
+            </button>
+            <Show when=move || open.get()>
+                <FileDiffGroupList
+                    entries=entries.clone()
+                    variant=variant
+                    reload=reload
+                    panel_id=panel_id
+                />
+            </Show>
+        </li>
+    }
+    .into_any()
+}
+
+#[component]
+fn FileDiffGroupList(
+    entries: Vec<ChangedFile>,
+    variant: DiffGroupVariant,
+    reload: Callback<()>,
+    panel_id: &'static str,
+) -> impl IntoView {
+    view! {
+        <ul
+            id=panel_id
+            role="list"
+            aria-labelledby=format!("{panel_id}-header")
+            class="file-diff-section__group-list"
+        >
             <For
                 each=move || entries.clone()
-                key=|e| (e.rel_path.clone(), e.staged, e.unstaged)
+                key=move |e| (e.rel_path.clone(), variant as u8)
                 children=move |entry: ChangedFile| {
-                    let rel = entry.rel_path.clone();
-                    let rel_for_open = rel.clone();
-                    let rel_for_stage = rel.clone();
-                    let rel_for_unstage = rel.clone();
-                    let staged = entry.staged;
-                    let unstaged = entry.unstaged;
-                    let status_kind = entry.status.clone();
-                    let status_label_key = match status_kind.as_str() {
-                        "added" => I18nKey::SbDiffStatusAdded,
-                        "deleted" => I18nKey::SbDiffStatusDeleted,
-                        "renamed" => I18nKey::SbDiffStatusRenamed,
-                        "untracked" => I18nKey::SbDiffStatusUntracked,
-                        "conflicted" => I18nKey::SbDiffStatusConflicted,
-                        _ => I18nKey::SbDiffStatusModified,
-                    };
-                    let status_marker = status_marker_for(&status_kind);
-                    let added = entry.added_lines;
-                    let removed = entry.removed_lines;
-                    let row_class = format!(
-                        "file-diff-section__row file-diff-section__row--{status_kind}"
-                    );
-                    let marker_class = format!(
-                        "file-diff-section__status file-diff-section__status--{status_kind}"
-                    );
-                    let on_open = move |_| {
-                        let workspace_id = wb.active_id().get_untracked();
-                        let Some(ws_id) = workspace_id else {
-                            return;
-                        };
-                        wb.open_center_diff_tab(ws_id, rel_for_open.clone(), staged && !unstaged);
-                    };
-                    let on_stage = {
-                        let rel = rel_for_stage.clone();
-                        move |ev: web_sys::MouseEvent| {
-                            ev.stop_propagation();
-                            let Some(cwd) = wb.default_workspace_cwd() else {
-                                return;
-                            };
-                            let rel = rel.clone();
-                            let reload = reload;
-                            spawn_local(async move {
-                                let _ = git_stage_file(cwd, rel).await;
-                                reload.run(());
-                            });
-                        }
-                    };
-                    let on_unstage = {
-                        let rel = rel_for_unstage.clone();
-                        move |ev: web_sys::MouseEvent| {
-                            ev.stop_propagation();
-                            let Some(cwd) = wb.default_workspace_cwd() else {
-                                return;
-                            };
-                            let rel = rel.clone();
-                            let reload = reload;
-                            spawn_local(async move {
-                                let _ = git_unstage_file(cwd, rel).await;
-                                reload.run(());
-                            });
-                        }
-                    };
-                    let stage_aria_label = {
-                        let prefix = i18n.tr(I18nKey::SbDiffStageAriaPrefix)();
-                        let path = rel.clone();
-                        move || format!("{prefix} {path}")
-                    };
-                    let unstage_aria_label = {
-                        let prefix = i18n.tr(I18nKey::SbDiffUnstageAriaPrefix)();
-                        let path = rel.clone();
-                        move || format!("{prefix} {path}")
-                    };
-                    let status_title_fn = i18n.tr(status_label_key);
-                    let status_title = StoredValue::new(status_title_fn());
                     view! {
-                        <li class=row_class>
-                            <button
-                                type="button"
-                                class="file-diff-section__row-btn"
-                                title=rel.clone()
-                                on:click=on_open
-                            >
-                                <span
-                                    class=marker_class
-                                    aria-label=move || status_title.get_value()
-                                    title=move || status_title.get_value()
-                                >
-                                    {status_marker}
-                                </span>
-                                <span class="file-diff-section__path">{rel.clone()}</span>
-                                <span class="file-diff-section__counts">
-                                    <Show when=move || { added > 0 }>
-                                        <span class="file-diff-section__count file-diff-section__count--add">
-                                            {format!("+{added}")}
-                                        </span>
-                                    </Show>
-                                    <Show when=move || { removed > 0 }>
-                                        <span class="file-diff-section__count file-diff-section__count--del">
-                                            {format!("-{removed}")}
-                                        </span>
-                                    </Show>
-                                </span>
-                            </button>
-                            <div class="file-diff-section__actions">
-                                <Show when=move || unstaged && status_kind != "conflicted">
-                                    <button
-                                        type="button"
-                                        class="file-diff-section__action file-diff-section__action--stage"
-                                        title=stage_aria_label.clone()
-                                        aria-label=stage_aria_label.clone()
-                                        on:click=on_stage.clone()
-                                    >
-                                        "+"
-                                    </button>
-                                </Show>
-                                <Show when=move || staged>
-                                    <button
-                                        type="button"
-                                        class="file-diff-section__action file-diff-section__action--unstage"
-                                        title=unstage_aria_label.clone()
-                                        aria-label=unstage_aria_label.clone()
-                                        on:click=on_unstage.clone()
-                                    >
-                                        "−"
-                                    </button>
-                                </Show>
-                            </div>
-                        </li>
+                        <FileDiffRow entry=entry variant=variant reload=reload />
                     }
                 }
             />
@@ -394,6 +397,147 @@ fn FileDiffList(entries: Vec<ChangedFile>, reload: Callback<()>) -> impl IntoVie
     }
 }
 
+#[component]
+fn FileDiffRow(
+    entry: ChangedFile,
+    variant: DiffGroupVariant,
+    reload: Callback<()>,
+) -> impl IntoView {
+    let wb = expect_context::<WorkbenchService>();
+    let i18n = expect_context::<I18nService>();
+
+    let rel = entry.rel_path.clone();
+    let rel_for_open = rel.clone();
+    let rel_for_stage = rel.clone();
+    let rel_for_unstage = rel.clone();
+    let staged = entry.staged;
+    let unstaged = entry.unstaged;
+    let status_kind = entry.status.clone();
+    let stats: Option<LineStats> = match variant {
+        DiffGroupVariant::Staged => entry.staged_stats,
+        DiffGroupVariant::Unstaged => entry.unstaged_stats,
+    };
+    let added = stats.as_ref().map(|s| s.added).unwrap_or(0);
+    let removed = stats.as_ref().map(|s| s.removed).unwrap_or(0);
+    let open_staged = variant == DiffGroupVariant::Staged;
+    let status_label_key = match status_kind.as_str() {
+        "added" => I18nKey::SbDiffStatusAdded,
+        "deleted" => I18nKey::SbDiffStatusDeleted,
+        "renamed" => I18nKey::SbDiffStatusRenamed,
+        "untracked" => I18nKey::SbDiffStatusUntracked,
+        "conflicted" => I18nKey::SbDiffStatusConflicted,
+        _ => I18nKey::SbDiffStatusModified,
+    };
+    let status_marker = status_marker_for(&status_kind);
+    let row_class = format!("file-diff-section__row file-diff-section__row--{status_kind}");
+    let marker_class = format!("file-diff-section__status file-diff-section__status--{status_kind}");
+    let on_open = move |_| {
+        let workspace_id = wb.active_id().get_untracked();
+        let Some(ws_id) = workspace_id else {
+            return;
+        };
+        wb.open_center_diff_tab(ws_id, rel_for_open.clone(), open_staged);
+    };
+    let on_stage = {
+        let rel = rel_for_stage.clone();
+        move |ev: web_sys::MouseEvent| {
+            ev.stop_propagation();
+            let Some(cwd) = wb.default_workspace_cwd() else {
+                return;
+            };
+            let rel = rel.clone();
+            let reload = reload;
+            spawn_local(async move {
+                let _ = git_stage_file(cwd, rel).await;
+                reload.run(());
+            });
+        }
+    };
+    let on_unstage = {
+        let rel = rel_for_unstage.clone();
+        move |ev: web_sys::MouseEvent| {
+            ev.stop_propagation();
+            let Some(cwd) = wb.default_workspace_cwd() else {
+                return;
+            };
+            let rel = rel.clone();
+            let reload = reload;
+            spawn_local(async move {
+                let _ = git_unstage_file(cwd, rel).await;
+                reload.run(());
+            });
+        }
+    };
+    let stage_aria_label = {
+        let prefix = i18n.tr(I18nKey::SbDiffStageAriaPrefix)();
+        let path = rel.clone();
+        move || format!("{prefix} {path}")
+    };
+    let unstage_aria_label = {
+        let prefix = i18n.tr(I18nKey::SbDiffUnstageAriaPrefix)();
+        let path = rel.clone();
+        move || format!("{prefix} {path}")
+    };
+    let status_title_fn = i18n.tr(status_label_key);
+    let status_title = StoredValue::new(status_title_fn());
+
+    view! {
+        <li class=row_class>
+            <button
+                type="button"
+                class="file-diff-section__row-btn"
+                title=rel.clone()
+                on:click=on_open
+            >
+                <span
+                    class=marker_class
+                    aria-label=move || status_title.get_value()
+                    title=move || status_title.get_value()
+                >
+                    {status_marker}
+                </span>
+                <span class="file-diff-section__path">{rel.clone()}</span>
+                <span class="file-diff-section__counts">
+                    <Show when=move || { added > 0 }>
+                        <span class="file-diff-section__count file-diff-section__count--add">
+                            {format!("+{added}")}
+                        </span>
+                    </Show>
+                    <Show when=move || { removed > 0 }>
+                        <span class="file-diff-section__count file-diff-section__count--del">
+                            {format!("-{removed}")}
+                        </span>
+                    </Show>
+                </span>
+            </button>
+            <div class="file-diff-section__actions">
+                <Show when=move || variant == DiffGroupVariant::Unstaged && unstaged && status_kind != "conflicted">
+                    <button
+                        type="button"
+                        class="file-diff-section__action file-diff-section__action--stage"
+                        title=stage_aria_label.clone()
+                        aria-label=stage_aria_label.clone()
+                        on:click=on_stage.clone()
+                    >
+                        "+"
+                    </button>
+                </Show>
+                <Show when=move || variant == DiffGroupVariant::Staged && staged>
+                    <button
+                        type="button"
+                        class="file-diff-section__action file-diff-section__action--unstage"
+                        title=unstage_aria_label.clone()
+                        aria-label=unstage_aria_label.clone()
+                        on:click=on_unstage.clone()
+                    >
+                        "−"
+                    </button>
+                </Show>
+            </div>
+        </li>
+    }
+}
+
 fn status_marker_for(kind: &str) -> &'static str {
     match kind {
         "modified" => "M",
diff --git a/src/workbench/file_preview/markdown_view.rs b/src/workbench/file_preview/markdown_view.rs
index 92f68f4..119acbb 100644
--- a/src/workbench/file_preview/markdown_view.rs
+++ b/src/workbench/file_preview/markdown_view.rs
@@ -135,6 +135,36 @@ fn policy_hero(kind: PolicyKind) -> PolicyHero {
             subtitle_key: I18nKey::FilePreviewPolicyReadmeSubtitle,
             modifier: "readme",
         },
+        PolicyKind::Support => PolicyHero {
+            icon: icondata::LuLifeBuoy,
+            title_key: I18nKey::FilePreviewPolicySupportTitle,
+            subtitle_key: I18nKey::FilePreviewPolicySupportSubtitle,
+            modifier: "support",
+        },
+        PolicyKind::Agents => PolicyHero {
+            icon: icondata::LuBot,
+            title_key: I18nKey::FilePreviewPolicyAgentsTitle,
+            subtitle_key: I18nKey::FilePreviewPolicyAgentsSubtitle,
+            modifier: "agents",
+        },
+        PolicyKind::Claude => PolicyHero {
+            icon: icondata::LuSparkles,
+            title_key: I18nKey::FilePreviewPolicyClaudeTitle,
+            subtitle_key: I18nKey::FilePreviewPolicyClaudeSubtitle,
+            modifier: "claude",
+        },
+        PolicyKind::Codex => PolicyHero {
+            icon: icondata::LuCode,
+            title_key: I18nKey::FilePreviewPolicyCodexTitle,
+            subtitle_key: I18nKey::FilePreviewPolicyCodexSubtitle,
+            modifier: "codex",
+        },
+        PolicyKind::Gemini => PolicyHero {
+            icon: icondata::LuSparkles,
+            title_key: I18nKey::FilePreviewPolicyGeminiTitle,
+            subtitle_key: I18nKey::FilePreviewPolicyGeminiSubtitle,
+            modifier: "gemini",
+        },
     }
 }
 
diff --git a/src/workbench/memory_panel.rs b/src/workbench/memory_panel.rs
index 6aad5a8..7c0fb02 100644
--- a/src/workbench/memory_panel.rs
+++ b/src/workbench/memory_panel.rs
@@ -6,7 +6,8 @@ use crate::i18n::I18nKey;
 use crate::memory_paths::slug_to_filename;
 use crate::service::I18nService;
 use crate::tauri_bridge::{
-    self, note_key, BacklinkRef, GraphData, MemoryScope, NoteContent, NoteMeta, SearchHit,
+    self, note_key, BacklinkRef, GraphData, MemoryScope, MemoryStatusResponse, NoteContent,
+    NoteMeta, PointerResult, SearchHit,
 };
 use crate::workbench::chat_markdown::render_markdown_to_html;
 use crate::workbench::memory_graph::{navigate_to_graph_node, MemoryGraphView};
@@ -27,6 +28,46 @@ const LEARNINGS_INDEX_PATHS: &[&str] = &["learnings/README.md"];
 /// Built-in pseudo categories — top-level memory files and the learnings root.
 const CATEGORY_MEMORY: &str = "memory";
 const CATEGORY_LEARNINGS: &str = "learnings";
+const POINTER_AGENTS: &[PointerAgent] = &[
+    PointerAgent {
+        id: "claude",
+        label: "Claude",
+        target: "CLAUDE.md",
+        icon: "/public/brand-icons/anthropic.svg",
+    },
+    PointerAgent {
+        id: "codex",
+        label: "Codex",
+        target: "AGENTS.md",
+        icon: "/public/brand-icons/openai.svg",
+    },
+    PointerAgent {
+        id: "gemini",
+        label: "Gemini",
+        target: "GEMINI.md",
+        icon: "/public/brand-icons/gemini.svg",
+    },
+    PointerAgent {
+        id: "cursor",
+        label: "Cursor",
+        target: ".cursorrules",
+        icon: "/public/brand-icons/cursor.svg",
+    },
+    PointerAgent {
+        id: "opencode",
+        label: "OpenCode",
+        target: "AGENTS.md",
+        icon: "/public/brand-icons/opencode.svg",
+    },
+];
+
+#[derive(Clone, Copy)]
+struct PointerAgent {
+    id: &'static str,
+    label: &'static str,
+    target: &'static str,
+    icon: &'static str,
+}
 
 /// Derive the category key for a given note API path.
 fn category_for_path(path: &str) -> String {
@@ -64,6 +105,13 @@ pub(crate) struct MemoryState {
     pub(crate) graph: RwSignal<Option<GraphData>>,
     pub(crate) search_query: RwSignal<String>,
     pub(crate) search_results: RwSignal<Vec<SearchHit>>,
+    pub(crate) memory_status: RwSignal<Option<MemoryStatusResponse>>,
+    pub(crate) pointer_status: RwSignal<Option<Vec<PointerResult>>>,
+    pub(crate) pointers_open: RwSignal<bool>,
+    pub(crate) pointers_notice_dismissed: RwSignal<bool>,
+    pub(crate) pointers_busy: RwSignal<bool>,
+    pub(crate) selected_pointer_agents: RwSignal<HashSet<String>>,
+    pub(crate) global_readme_preview: RwSignal<Option<String>>,
     /// Expanded category groups in the Files sidebar (keys: plain for workspace, "global:cat" for global).
     pub(crate) groups_open: RwSignal<HashSet<String>>,
     /// User-created workspace categories that have no notes yet.
@@ -97,6 +145,13 @@ impl MemoryState {
             graph: RwSignal::new(None),
             search_query: RwSignal::new(String::new()),
             search_results: RwSignal::new(Vec::new()),
+            memory_status: RwSignal::new(None),
+            pointer_status: RwSignal::new(None),
+            pointers_open: RwSignal::new(false),
+            pointers_notice_dismissed: RwSignal::new(false),
+            pointers_busy: RwSignal::new(false),
+            selected_pointer_agents: RwSignal::new(HashSet::new()),
+            global_readme_preview: RwSignal::new(None),
             groups_open: RwSignal::new(HashSet::new()),
             empty_categories: RwSignal::new(Vec::new()),
             global_subcategories: RwSignal::new(Vec::new()),
@@ -146,9 +201,32 @@ fn load_notes(state: MemoryState, ws: String) {
             Err(e) => state.error.set(Some(e)),
         }
         if let Ok(status) = tauri_bridge::memory_status(&ws).await {
+            state.memory_status.set(Some(status.clone()));
             state
                 .global_bootstrapped
-                .set(status.global.memory || status.global.learnings);
+                .set(status.global.memory && status.global.learnings);
+        }
+        load_global_readme_preview(state, ws);
+    });
+}
+
+fn load_pointer_status(state: MemoryState, ws: String) {
+    spawn_local(async move {
+        match tauri_bridge::memory_pointer_status(&ws).await {
+            Ok(results) => state.pointer_status.set(Some(results)),
+            Err(e) => {
+                state.pointer_status.set(Some(Vec::new()));
+                state.error.set(Some(e));
+            }
+        }
+    });
+}
+
+fn load_global_readme_preview(state: MemoryState, ws: String) {
+    spawn_local(async move {
+        match tauri_bridge::memory_read(&ws, &MemoryScope::Global, "README.md").await {
+            Ok(NoteContent { content, .. }) => state.global_readme_preview.set(Some(content)),
+            Err(_) => state.global_readme_preview.set(None),
         }
     });
 }
@@ -221,7 +299,7 @@ pub fn MemoryPanel() -> impl IntoView {
     let i18n = expect_context::<I18nService>();
     let state = MemoryState::new();
 
-    // Track active workspace cwd; bootstrap workspace memory and reload notes when it changes.
+    // Track active workspace cwd and reload memory state when it changes.
     let eff_state = state.clone();
     Effect::new(move |_| {
         let cwd = current_workspace_cwd(wb);
@@ -235,18 +313,39 @@ pub fn MemoryPanel() -> impl IntoView {
             eff_state.backlinks.set(Vec::new());
             eff_state.graph.set(None);
             eff_state.notes.set(Vec::new());
+            eff_state.memory_status.set(None);
             eff_state.global_bootstrapped.set(false);
+            eff_state.pointer_status.set(None);
+            eff_state.pointers_notice_dismissed.set(false);
+            eff_state.pointers_open.set(false);
+            eff_state.pointers_busy.set(false);
+            eff_state.selected_pointer_agents.set(HashSet::new());
+            eff_state.global_readme_preview.set(None);
             if let Some(ws) = cwd {
                 let st = eff_state.clone();
                 let ws2 = ws.clone();
                 spawn_local(async move {
-                    let _ = tauri_bridge::memory_bootstrap(&ws2, "workspace").await;
-                    load_notes(st, ws2);
+                    load_notes(st.clone(), ws2.clone());
+                    load_global_readme_preview(st.clone(), ws2.clone());
+                    load_pointer_status(st, ws2);
                 });
             }
         }
     });
 
+    Effect::new({
+        let st = state.clone();
+        move |_| {
+            if !st.pointers_open.get() {
+                return;
+            }
+            st.selected_pointer_agents.set(HashSet::new());
+            if let Some(ws) = st.workspace_cwd.get() {
+                load_pointer_status(st.clone(), ws);
+            }
+        }
+    });
+
     Effect::new({
         let wb = wb;
         let st = state.clone();
@@ -297,24 +396,44 @@ pub fn MemoryPanel() -> impl IntoView {
                 }
             </Show>
 
+            <Show when={
+                let s = state.clone();
+                move || {
+                    s.workspace_cwd.get().is_some()
+                        && !s.pointers_notice_dismissed.get()
+                        && s.pointer_status
+                            .get()
+                            .is_some_and(|status| !status.iter().any(|entry| entry.installed))
+                }
+            }>
+                <MemoryPointersNotice state=state.clone() />
+            </Show>
+
             <div class="workbench-memory__body">
                 <Show when={
                     let s = state.clone();
-                    move || s.view.get() == MemoryView::Files
-                }>
-                    <MemoryFilesView state=state.clone() />
-                </Show>
-                <Show when={
-                    let s = state.clone();
-                    move || s.view.get() == MemoryView::Graph
-                }>
-                    <MemoryGraphView state=state.clone() />
-                </Show>
-                <Show when={
-                    let s = state.clone();
-                    move || s.view.get() == MemoryView::Search
+                    move || memory_show_bootstrap_prompt(s)
+                } fallback=move || view! {
+                    <Show when={
+                        let s = state.clone();
+                        move || s.view.get() == MemoryView::Files
+                    }>
+                        <MemoryFilesView state=state.clone() />
+                    </Show>
+                    <Show when={
+                        let s = state.clone();
+                        move || s.view.get() == MemoryView::Graph
+                    }>
+                        <MemoryGraphView state=state.clone() />
+                    </Show>
+                    <Show when={
+                        let s = state.clone();
+                        move || s.view.get() == MemoryView::Search
+                    }>
+                        <MemorySearchView state=state.clone() />
+                    </Show>
                 }>
-                    <MemorySearchView state=state.clone() />
+                    <MemoryBootstrapView state=state.clone() />
                 </Show>
             </div>
             <Show when={
@@ -330,10 +449,362 @@ pub fn MemoryPanel() -> impl IntoView {
                     </p>
                 </div>
             </Show>
+            <Show when={
+                let s = state.clone();
+                move || s.pointers_open.get()
+            }>
+                <MemoryPointersDialog state=state.clone() />
+            </Show>
+        </div>
+    }
+}
+
+fn memory_needs_workspace_bootstrap(status: &MemoryStatusResponse) -> bool {
+    !status.workspace.memory || !status.workspace.learnings
+}
+
+fn memory_needs_global_bootstrap(status: &MemoryStatusResponse) -> bool {
+    !status.global.memory || !status.global.learnings
+}
+
+fn memory_show_bootstrap_prompt(state: MemoryState) -> bool {
+    if state.workspace_cwd.get().is_none() || !state.notes.get().is_empty() {
+        return false;
+    }
+    state.memory_status.get().is_some_and(|status| {
+        memory_needs_workspace_bootstrap(&status) || memory_needs_global_bootstrap(&status)
+    })
+}
+
+#[component]
+fn MemoryBootstrapView(state: MemoryState) -> impl IntoView {
+    view! {
+        {move || {
+            let Some(status) = state.memory_status.get() else {
+                return ().into_any();
+            };
+            let show_workspace = memory_needs_workspace_bootstrap(&status);
+            let show_global = memory_needs_global_bootstrap(&status);
+            view! {
+                <div class="workbench-memory-bootstrap">
+                    <Show when=move || show_workspace>
+                        <MemoryBootstrapCard
+                            state=state
+                            scope=MemoryScope::Workspace
+                            title="Create workspace memory"
+                            path=".agents/memory + .agents/learnings"
+                            description="Create the workspace memory and learnings folders with matching README.md overview files."
+                        />
+                    </Show>
+                    <Show when=move || show_workspace && show_global>
+                        <div class="workbench-memory-bootstrap__divider"></div>
+                    </Show>
+                    <Show when=move || show_global>
+                        <MemoryBootstrapCard
+                            state=state
+                            scope=MemoryScope::Global
+                            title="Create global memory"
+                            path="~/.blxcode/memory + ~/.blxcode/learnings"
+                            description="Create the global memory and learnings folders with matching README.md overview files."
+                        />
+                    </Show>
+                </div>
+            }
+            .into_any()
+        }}
+    }
+}
+
+#[component]
+fn MemoryBootstrapCard(
+    state: MemoryState,
+    scope: MemoryScope,
+    title: &'static str,
+    path: &'static str,
+    description: &'static str,
+) -> impl IntoView {
+    let target = match scope {
+        MemoryScope::Workspace => "workspace",
+        MemoryScope::Global => "global",
+    };
+    view! {
+        <section class="workbench-memory-bootstrap__card">
+            <div class="workbench-memory-bootstrap__icon" aria-hidden="true">
+                <LxIcon icon=icondata::LuFolderOpen width="1.3rem" height="1.3rem" />
+            </div>
+            <h3>{title}</h3>
+            <p>{description}</p>
+            <code>{path}</code>
+            <button
+                type="button"
+                class="workbench-memory-bootstrap__button"
+                on:click=move |_| bootstrap_memory_scope(state, target)
+            >
+                <LxIcon icon=icondata::LuFolderPlus width="0.85rem" height="0.85rem" />
+                <span>"Create folders"</span>
+            </button>
+        </section>
+    }
+}
+
+fn bootstrap_memory_scope(state: MemoryState, target: &'static str) {
+    let Some(ws) = state.workspace_cwd.get_untracked() else {
+        return;
+    };
+    spawn_local(async move {
+        match tauri_bridge::memory_bootstrap(&ws, target).await {
+            Ok(()) => {
+                load_notes(state.clone(), ws.clone());
+                load_global_readme_preview(state, ws);
+            }
+            Err(e) => state.error.set(Some(e)),
+        }
+    });
+}
+
+#[component]
+fn MemoryPointersNotice(state: MemoryState) -> impl IntoView {
+    view! {
+        <div class="workbench-memory-pointers-notice" role="status">
+            <span class="workbench-memory-pointers-notice__icon" aria-hidden="true">
+                <LxIcon icon=icondata::LuInfo width="0.9rem" height="0.9rem" />
+            </span>
+            <p>
+                "No agent memory pointers installed — external agents won't know where memory lives. "
+                <button
+                    type="button"
+                    class="workbench-memory-pointers-notice__setup"
+                    on:click=move |_| state.pointers_open.set(true)
+                >
+                    "Set up pointers"
+                </button>
+            </p>
+            <button
+                type="button"
+                class="workbench-memory-pointers-notice__close"
+                aria-label="Close"
+                on:click=move |_| state.pointers_notice_dismissed.set(true)
+            >
+                <LxIcon icon=icondata::LuX width="0.75rem" height="0.75rem" />
+            </button>
         </div>
     }
 }
 
+#[component]
+fn MemoryPointersDialog(state: MemoryState) -> impl IntoView {
+    view! {
+        <div
+            class="workspace-rename-backdrop"
+            on:click=move |_| {
+                if !state.pointers_busy.get_untracked() {
+                    state.pointers_open.set(false);
+                }
+            }
+        >
+            <section
+                class="workspace-rename-dialog memory-pointers-dialog"
+                role="dialog"
+                aria-modal="true"
+                aria-labelledby="memory-pointers-title"
+                on:click=move |ev| ev.stop_propagation()
+            >
+                <header class="memory-pointers-dialog__head">
+                    <div class="memory-pointers-dialog__title-icon" aria-hidden="true">
+                        <LxIcon icon=icondata::LuLink2 width="1.1rem" height="1.1rem" />
+                    </div>
+                    <div>
+                        <h2 id="memory-pointers-title">"Agent memory pointers"</h2>
+                        <p>
+                            "Install a marked block in CLAUDE.md, AGENTS.md, or similar so external agents know where memory lives. Target files must already exist."
+                        </p>
+                    </div>
+                    <button
+                        type="button"
+                        class="workspace-rename-dialog__close"
+                        disabled=move || state.pointers_busy.get()
+                        on:click=move |_| state.pointers_open.set(false)
+                    >
+                        "×"
+                    </button>
+                </header>
+                <ul class="memory-pointers-dialog__agents">
+                    <For
+                        each=move || POINTER_AGENTS.to_vec()
+                        key=|agent| agent.id
+                        children=move |agent: PointerAgent| view! {
+                            <MemoryPointerAgentRow state=state agent=agent />
+                        }
+                    />
+                </ul>
+                <footer class="workspace-rename-dialog__actions memory-pointers-dialog__actions">
+                    <button
+                        type="button"
+                        class="workspace-rename-dialog__btn workspace-rename-dialog__btn--ghost"
+                        disabled=move || {
+                            state.pointers_busy.get()
+                                || state.selected_pointer_agents.with(HashSet::is_empty)
+                        }
+                        on:click=move |_| run_pointer_action(state, false)
+                    >
+                        "Uninstall"
+                    </button>
+                    <button
+                        type="button"
+                        class="workspace-rename-dialog__btn workspace-rename-dialog__btn--primary"
+                        disabled=move || {
+                            state.pointers_busy.get()
+                                || state.selected_pointer_agents.with(HashSet::is_empty)
+                        }
+                        on:click=move |_| run_pointer_action(state, true)
+                    >
+                        "Install"
+                    </button>
+                </footer>
+            </section>
+        </div>
+    }
+}
+
+#[component]
+fn MemoryPointerAgentRow(state: MemoryState, agent: PointerAgent) -> impl IntoView {
+    let input_id = format!("memory-pointer-agent-{}", agent.id);
+    let id_for_status = agent.id;
+    let id_for_checked = agent.id;
+    let id_for_change = agent.id.to_owned();
+    view! {
+        <li>
+            <label class="memory-pointers-dialog__agent" for=input_id.clone()>
+                <input
+                    id=input_id.clone()
+                    type="checkbox"
+                    class="memory-pointers-dialog__checkbox"
+                    prop:checked=move || {
+                        state
+                            .selected_pointer_agents
+                            .with(|selected| selected.contains(id_for_checked))
+                    }
+                    disabled=move || state.pointers_busy.get()
+                    on:change=move |ev| {
+                        let checked = ev
+                            .target()
+                            .and_then(|target| target.dyn_into::<HtmlInputElement>().ok())
+                            .is_some_and(|input| input.checked());
+                        state.selected_pointer_agents.update(|selected| {
+                            if checked {
+                                selected.insert(id_for_change.clone());
+                            } else {
+                                selected.remove(&id_for_change);
+                            }
+                        });
+                    }
+                />
+                <span class="memory-pointers-dialog__brand">
+                    <img src=agent.icon alt="" prop:draggable=false />
+                </span>
+                <span class="memory-pointers-dialog__meta">
+                    <span class="memory-pointers-dialog__label">{agent.label}</span>
+                    <span class="memory-pointers-dialog__target">{agent.target}</span>
+                </span>
+                <PointerStatusBadge state=state agent_id=id_for_status />
+            </label>
+        </li>
+    }
+}
+
+#[component]
+fn PointerStatusBadge(state: MemoryState, agent_id: &'static str) -> impl IntoView {
+    view! {
+        {move || {
+            let entry = state
+                .pointer_status
+                .get()
+                .and_then(|status| status.into_iter().find(|item| item.agent == agent_id));
+            let (class, icon, label) = pointer_status_view(entry.as_ref());
+            view! {
+                <span class=class>
+                    {icon.map(|icon| view! {
+                        <LxIcon icon=icon width="0.7rem" height="0.7rem" />
+                    })}
+                    <span>{label}</span>
+                </span>
+            }
+        }}
+    }
+}
+
+fn pointer_status_view(
+    entry: Option<&PointerResult>,
+) -> (&'static str, Option<icondata::Icon>, &'static str) {
+    if entry.is_some_and(|result| result.installed) {
+        (
+            "memory-pointers-dialog__status memory-pointers-dialog__status--installed",
+            Some(icondata::LuCircleCheck),
+            "Installed",
+        )
+    } else if entry
+        .and_then(|result| result.note.as_deref())
+        .is_some_and(|note| note == "file missing")
+    {
+        (
+            "memory-pointers-dialog__status memory-pointers-dialog__status--missing",
+            Some(icondata::LuFileWarning),
+            "File missing",
+        )
+    } else {
+        (
+            "memory-pointers-dialog__status memory-pointers-dialog__status--pending",
+            None,
+            "Not installed",
+        )
+    }
+}
+
+fn run_pointer_action(state: MemoryState, install: bool) {
+    let Some(ws) = state.workspace_cwd.get_untracked() else {
+        return;
+    };
+    let selected = state.selected_pointer_agents.get_untracked();
+    let agents: Vec<String> = POINTER_AGENTS
+        .iter()
+        .filter(|agent| selected.contains(agent.id))
+        .map(|agent| agent.id.to_owned())
+        .collect();
+    if agents.is_empty() || state.pointers_busy.get_untracked() {
+        return;
+    }
+    state.pointers_busy.set(true);
+    spawn_local(async move {
+        let result = if install {
+            tauri_bridge::memory_install_pointers(&ws, agents).await
+        } else {
+            tauri_bridge::memory_uninstall_pointers(&ws, agents).await
+        };
+        match result {
+            Ok(results) => {
+                merge_pointer_results(state, results);
+                state.error.set(None);
+            }
+            Err(e) => state.error.set(Some(e)),
+        }
+        state.pointers_busy.set(false);
+    });
+}
+
+fn merge_pointer_results(state: MemoryState, results: Vec<PointerResult>) {
+    state.pointer_status.update(|status| {
+        let mut merged = status.take().unwrap_or_default();
+        for result in results {
+            if let Some(existing) = merged.iter_mut().find(|entry| entry.agent == result.agent) {
+                *existing = result;
+            } else {
+                merged.push(result);
+            }
+        }
+        *status = Some(merged);
+    });
+}
+
 #[component]
 fn MemoryTabBtn(
     label: I18nKey,
@@ -479,15 +950,6 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                     class="workbench-memory-files__new"
                     class:workbench-memory-files__new--collapsed=move || files_collapsed.get()
                 >
-                    <button
-                        type="button"
-                        class="workbench-memory-files__new-btn"
-                        title=move || i18n.tr(I18nKey::MemNewCategory)()
-                        aria-label=move || i18n.tr(I18nKey::MemNewCategory)()
-                        on:click=move |_| new_category_scope.set(Some(MemoryScope::Workspace))
-                    >
-                        <LxIcon icon=icondata::LuFolderPlus width="0.82rem" height="0.82rem" />
-                    </button>
                     <button
                         type="button"
                         class="workbench-memory-files__collapse-btn"
@@ -525,6 +987,15 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                 <div class="workbench-memory-files__scope-section">
                     <div class="workbench-memory-files__scope-head">
                         <span>"Projekt"</span>
+                        <button
+                            type="button"
+                            class="workbench-memory-files__scope-add"
+                            title=move || i18n.tr(I18nKey::MemNewCategory)()
+                            aria-label=move || i18n.tr(I18nKey::MemNewCategory)()
+                            on:click=move |_| new_category_scope.set(Some(MemoryScope::Workspace))
+                        >
+                            <LxIcon icon=icondata::LuPlus width="0.75rem" height="0.75rem" />
+                        </button>
                     </div>
                     {section(MemoryScope::Workspace)}
                 </div>
@@ -536,12 +1007,12 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         <Show when=move || state.global_bootstrapped.get()>
                             <button
                                 type="button"
-                                class="workbench-memory-files__new-btn"
+                                class="workbench-memory-files__scope-add"
                                 title=move || i18n.tr(I18nKey::MemNewCategory)()
                                 aria-label=move || i18n.tr(I18nKey::MemNewCategory)()
                                 on:click=move |_| new_category_scope.set(Some(MemoryScope::Global))
                             >
-                                <LxIcon icon=icondata::LuFolderPlus width="0.82rem" height="0.82rem" />
+                                <LxIcon icon=icondata::LuPlus width="0.75rem" height="0.75rem" />
                             </button>
                         </Show>
                     </div>
@@ -587,11 +1058,10 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         move || s.active_path.get().is_some()
                     }
                     fallback={
+                        let s = state.clone();
                         let i = i18n.clone();
                         move || view! {
-                            <div class="workbench-memory-editor__empty">
-                                <p>{move || i.tr(I18nKey::MemSelectNote)()}</p>
-                            </div>
+                            <MemoryEditorFallback state=s i18n=i />
                         }
                     }
                 >
@@ -780,6 +1250,34 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
     }
 }
 
+#[component]
+fn MemoryEditorFallback(state: MemoryState, i18n: I18nService) -> impl IntoView {
+    view! {
+        {move || {
+            if let Some(content) = state.global_readme_preview.get() {
+                view! {
+                    <header class="workbench-memory-editor__toolbar workbench-memory-editor__toolbar--readonly">
+                        <span class="workbench-memory-editor__path">"Global / README.md"</span>
+                        <span class="workbench-memory-editor__readonly">"Read-only preview"</span>
+                    </header>
+                    <div
+                        class="workbench-memory-editor__preview"
+                        inner_html=render_markdown_to_html(&content)
+                    />
+                }
+                .into_any()
+            } else {
+                view! {
+                    <div class="workbench-memory-editor__empty">
+                        <p>{i18n.tr(I18nKey::MemSelectNote)()}</p>
+                    </div>
+                }
+                .into_any()
+            }
+        }}
+    }
+}
+
 #[component]
 fn NewCategoryDialog(
     state: MemoryState,
diff --git a/styles.css b/styles.css
index d46e252..f2d9f35 100644
--- a/styles.css
+++ b/styles.css
@@ -1027,14 +1027,22 @@ body {
   background: var(--danger-soft);
 }
 
+/* Modal scrims: dim + blur so the workbench stays visible behind dialogs. */
+.workspace-rename-backdrop,
+.harness-scrim,
+.blx-sr-dialog__backdrop,
+.agent-image-preview-backdrop {
+  -webkit-backdrop-filter: blur(10px);
+  backdrop-filter: blur(10px);
+  background: var(--scrim-bg);
+}
+
 .workspace-rename-backdrop {
   position: fixed;
   inset: 0;
   z-index: 1100;
   display: grid;
   place-items: center;
-  background: var(--bg-app);
-  backdrop-filter: blur(3px);
 }
 
 .workspace-rename-dialog {
@@ -2543,8 +2551,6 @@ button.workbench-shortcut-row--action:focus-visible {
   display: grid;
   place-items: center;
   padding: 1.4rem;
-  background: var(--scrim-bg);
-  backdrop-filter: blur(3px);
 }
 
 .agent-image-preview-dialog {
@@ -4049,8 +4055,6 @@ button.workbench-shortcut-row--action:focus-visible {
   inset: 0;
   border: none;
   padding: 0;
-  background: var(--overlay-2);
-  backdrop-filter: blur(3px);
   cursor: pointer;
 }
 
@@ -5887,6 +5891,11 @@ button {
 .file-preview__stage--policy-authors { --policy-accent: var(--accent); }
 .file-preview__stage--policy-changelog { --policy-accent: var(--accent); }
 .file-preview__stage--policy-readme { --policy-accent: var(--accent); }
+.file-preview__stage--policy-support { --policy-accent: var(--info, var(--accent)); }
+.file-preview__stage--policy-agents { --policy-accent: var(--accent); }
+.file-preview__stage--policy-claude { --policy-accent: color-mix(in srgb, #d97706 55%, var(--accent)); }
+.file-preview__stage--policy-codex { --policy-accent: var(--accent); }
+.file-preview__stage--policy-gemini { --policy-accent: color-mix(in srgb, #2563eb 45%, var(--accent)); }
 
 .file-preview__policy-hero {
   display: flex;
@@ -7476,6 +7485,70 @@ button {
   padding: 0 0.2rem;
 }
 
+.workbench-memory-pointers-notice {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  margin: 0.5rem 0.55rem;
+  padding: 0.55rem 0.65rem;
+  color: var(--text-muted);
+  background: color-mix(in srgb, var(--accent, var(--accent-hover)) 8%, transparent);
+  border: 1px solid color-mix(in srgb, var(--accent, var(--accent-hover)) 15%, transparent);
+  border-radius: 8px;
+  font-size: 0.8rem;
+}
+
+.workbench-memory-pointers-notice__icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  color: var(--accent, var(--accent-hover));
+}
+
+.workbench-memory-pointers-notice p {
+  flex: 1;
+  min-width: 0;
+  margin: 0;
+  line-height: 1.35;
+}
+
+.workbench-memory-pointers-notice__setup {
+  padding: 0;
+  color: var(--accent, var(--accent-hover));
+  background: transparent;
+  border: none;
+  font: inherit;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.workbench-memory-pointers-notice__setup:hover,
+.workbench-memory-pointers-notice__setup:focus-visible {
+  text-decoration: underline;
+}
+
+.workbench-memory-pointers-notice__close {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  width: 1.55rem;
+  height: 1.55rem;
+  padding: 0;
+  color: var(--text-muted);
+  background: transparent;
+  border: none;
+  border-radius: 5px;
+  cursor: pointer;
+}
+
+.workbench-memory-pointers-notice__close:hover,
+.workbench-memory-pointers-notice__close:focus-visible {
+  color: var(--text);
+  background: var(--overlay-2);
+}
+
 .workbench-memory__body {
   flex: 1;
   min-height: 0;
@@ -7511,6 +7584,93 @@ button {
   color: var(--text-muted);
 }
 
+.workbench-memory-bootstrap {
+  flex: 1;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 1rem;
+  padding: 1.4rem;
+}
+
+.workbench-memory-bootstrap__card {
+  width: min(22rem, 100%);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.65rem;
+  text-align: center;
+}
+
+.workbench-memory-bootstrap__icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 3rem;
+  height: 3rem;
+  color: var(--text-muted);
+  background: var(--overlay-1);
+  border: 1px solid var(--overlay-2);
+  border-radius: 8px;
+}
+
+.workbench-memory-bootstrap__card h3 {
+  margin: 0;
+  color: var(--text);
+  font-size: 0.92rem;
+  font-weight: 650;
+}
+
+.workbench-memory-bootstrap__card p {
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 0.82rem;
+  line-height: 1.45;
+}
+
+.workbench-memory-bootstrap__card code {
+  max-width: 100%;
+  overflow: hidden;
+  padding: 0.18rem 0.45rem;
+  color: var(--text-muted);
+  background: var(--overlay-1);
+  border: 1px solid var(--overlay-2);
+  border-radius: 5px;
+  font-size: 0.72rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.workbench-memory-bootstrap__button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.35rem;
+  min-height: 2rem;
+  padding: 0.35rem 0.7rem;
+  color: var(--text);
+  background: var(--overlay-2);
+  border: 1px solid var(--overlay-3);
+  border-radius: 6px;
+  font: inherit;
+  font-size: 0.8rem;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.workbench-memory-bootstrap__button:hover,
+.workbench-memory-bootstrap__button:focus-visible {
+  background: var(--overlay-3);
+}
+
+.workbench-memory-bootstrap__divider {
+  width: min(18rem, 80%);
+  height: 1px;
+  background: var(--overlay-2);
+}
+
 /* --- Files view ----------------------------------------------------- */
 .workbench-memory-files {
   flex: 1;
@@ -7537,7 +7697,7 @@ button {
 
 .workbench-memory-files__new {
   display: flex;
-  gap: 0.3rem;
+  justify-content: flex-end;
   padding: 0.45rem 0.5rem;
   border-bottom: 1px solid var(--overlay-1);
 }
@@ -7562,19 +7722,6 @@ button {
   outline: none;
   border-color: var(--accent, var(--accent-hover));
 }
-.workbench-memory-files__new-btn {
-  padding: 0 0.6rem;
-  font: inherit;
-  color: inherit;
-  background: var(--overlay-2);
-  border: 1px solid var(--overlay-3);
-  border-radius: 4px;
-  cursor: pointer;
-}
-.workbench-memory-files__new-btn:hover {
-  background: var(--overlay-3);
-}
-
 .workbench-memory-files__collapse-btn {
   padding: 0;
   width: 1.8rem;
@@ -7618,6 +7765,31 @@ button {
 .workbench-memory-files__scope-head span {
   flex: 1;
 }
+.workbench-memory-files__scope-add {
+  flex: 0 0 auto;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.35rem;
+  height: 1.35rem;
+  padding: 0;
+  color: var(--text-muted);
+  background: transparent;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  opacity: 0;
+  transition: opacity 0.12s ease, background 0.12s ease, color 0.12s ease;
+}
+.workbench-memory-files__scope-head:hover .workbench-memory-files__scope-add,
+.workbench-memory-files__scope-head:focus-within .workbench-memory-files__scope-add,
+.workbench-memory-files__scope-add:focus-visible {
+  opacity: 1;
+}
+.workbench-memory-files__scope-add:hover {
+  background: var(--overlay-2);
+  color: var(--text);
+}
 /* "Create Global Memory" placeholder */
 .workbench-memory-files__global-init {
   padding: 0.4rem 0.5rem;
@@ -7863,6 +8035,160 @@ button {
   color: var(--text-muted);
   font-size: 0.78rem;
 }
+
+.memory-pointers-dialog {
+  width: min(42rem, calc(100vw - 2rem));
+  padding: 0;
+  overflow: hidden;
+}
+
+.memory-pointers-dialog__head {
+  display: grid;
+  grid-template-columns: 2.5rem minmax(0, 1fr) auto;
+  gap: 0.75rem;
+  align-items: start;
+  padding: 1rem 1.1rem 0.9rem;
+  border-bottom: 1px solid var(--overlay-2);
+  background: linear-gradient(180deg, var(--overlay-1), transparent);
+}
+
+.memory-pointers-dialog__title-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 2.35rem;
+  height: 2.35rem;
+  color: var(--accent, var(--accent-hover));
+  background: var(--accent-soft);
+  border: 1px solid color-mix(in srgb, var(--accent, var(--accent-hover)) 15%, transparent);
+  border-radius: 8px;
+}
+
+.memory-pointers-dialog__head h2 {
+  margin: 0;
+  font-size: 1rem;
+  font-weight: 650;
+}
+
+.memory-pointers-dialog__head p {
+  margin: 0.25rem 0 0;
+  color: var(--text-muted);
+  font-size: 0.82rem;
+  line-height: 1.45;
+}
+
+.memory-pointers-dialog__agents {
+  display: flex;
+  flex-direction: column;
+  gap: 0.45rem;
+  margin: 0;
+  padding: 0.85rem 1.1rem;
+  list-style: none;
+}
+
+.memory-pointers-dialog__agent {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.6rem 0.7rem;
+  background: color-mix(in srgb, var(--overlay-1) 55%, transparent);
+  border: 1px solid var(--overlay-2);
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 0.12s ease, border-color 0.12s ease;
+}
+
+.memory-pointers-dialog__agent:hover,
+.memory-pointers-dialog__agent:focus-within {
+  background: var(--overlay-1);
+  border-color: var(--overlay-3);
+}
+
+.memory-pointers-dialog__checkbox {
+  flex: 0 0 auto;
+  width: 0.95rem;
+  height: 0.95rem;
+  accent-color: var(--accent, var(--accent-hover));
+}
+
+.memory-pointers-dialog__brand {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  width: 2.25rem;
+  height: 2.25rem;
+  padding: 0.35rem;
+  background: rgba(255, 255, 255, 0.94);
+  border: 1px solid var(--overlay-2);
+  border-radius: 8px;
+}
+
+.memory-pointers-dialog__brand img {
+  display: block;
+  width: 100%;
+  height: 100%;
+  object-fit: contain;
+}
+
+.memory-pointers-dialog__meta {
+  display: flex;
+  flex: 1;
+  min-width: 0;
+  flex-direction: column;
+  gap: 0.1rem;
+}
+
+.memory-pointers-dialog__label {
+  color: var(--text);
+  font-size: 0.84rem;
+  font-weight: 600;
+}
+
+.memory-pointers-dialog__target {
+  overflow: hidden;
+  color: var(--text-muted);
+  font-family: ui-monospace, "JetBrains Mono", "Fira Code", monospace;
+  font-size: 0.72rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.memory-pointers-dialog__status {
+  display: inline-flex;
+  align-items: center;
+  flex: 0 0 auto;
+  gap: 0.25rem;
+  padding: 0.16rem 0.45rem;
+  border-radius: 6px;
+  border: 1px solid var(--overlay-2);
+  font-size: 0.68rem;
+  font-weight: 650;
+  line-height: 1.2;
+}
+
+.memory-pointers-dialog__status--installed {
+  color: var(--success, #4ade80);
+  background: color-mix(in srgb, var(--success, #4ade80) 10%, transparent);
+  border-color: color-mix(in srgb, var(--success, #4ade80) 18%, transparent);
+}
+
+.memory-pointers-dialog__status--missing {
+  color: #fbbf24;
+  background: rgba(251, 191, 36, 0.1);
+  border-color: rgba(251, 191, 36, 0.18);
+}
+
+.memory-pointers-dialog__status--pending {
+  color: var(--text-muted);
+  background: var(--overlay-1);
+}
+
+.memory-pointers-dialog__actions {
+  padding: 0.85rem 1.1rem;
+  background: color-mix(in srgb, var(--overlay-1) 40%, transparent);
+  border-top: 1px solid var(--overlay-2);
+}
 .workbench-memory-files__rename-form {
   flex: 1;
   display: flex;
@@ -7977,6 +8303,15 @@ button {
   justify-content: flex-end;
   padding: 0.35rem 0.55rem 0 0.55rem;
 }
+.workbench-memory-editor__toolbar--readonly {
+  justify-content: space-between;
+  padding-bottom: 0.35rem;
+  border-bottom: 1px solid var(--overlay-1);
+}
+.workbench-memory-editor__readonly {
+  color: var(--text-muted);
+  font-size: 0.7rem;
+}
 .workbench-memory-editor__backlinks {
   border-top: 1px solid var(--overlay-2);
   padding: 0.4rem 0.55rem 0.55rem;
@@ -9245,7 +9580,6 @@ button {
 .blx-sr-dialog__backdrop {
     position: fixed;
     inset: 0;
-    background: var(--scrim-bg);
     z-index: 90;
 }
 .blx-sr-dialog {

From 1fbf0d1118d9598fbc9c278c8b6ecd62a06c3ae4 Mon Sep 17 00:00:00 2001
From: Maik Roland Damm <maik.damm@bluewave-tech.de>
Date: Wed, 27 May 2026 02:16:59 +0200
Subject: [PATCH 4/8] =?UTF-8?q?fix(ci):=20remove=20sccache=20from=20repo?=
 =?UTF-8?q?=20config=20=E2=80=94=20set=20in=20user-level=20~/.cargo/config?=
 =?UTF-8?q?.toml=20instead?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

sccache is not available on CI runners; the rustc-wrapper must only be
set on developer machines via ~/.cargo/config.toml (not checked in).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .cargo/config.toml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.cargo/config.toml b/.cargo/config.toml
index 9927dcc..5d5a432 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,6 +1,3 @@
-[build]
-rustc-wrapper = "sccache"
-
 # Cross-linkers for Linux release builds (see scripts/release/build.sh).
 [target.aarch64-unknown-linux-gnu]
 linker = "aarch64-linux-gnu-gcc"

From 2c6f71c4e7c57b08a11a2ec3d3ae969ecf3612bb Mon Sep 17 00:00:00 2001
From: iptoux <iptoux@gmail.com>
Date: Wed, 27 May 2026 19:21:56 +0200
Subject: [PATCH 5/8] feat(linux): implement sticky lazy mount and iframe
 visibility gating for BrowserTabDock

- Added a new plan document for fixing the Linux-only boot crash related to BrowserTabDock.
- Introduced sticky lazy mount for the BrowserTabDock, ensuring it only mounts when the browser tab is active.
- Implemented visibility gating for iframe loads to prevent crashes in WebKitGTK.
- Updated PLANS.md to include the new Linux boot crash fix plan.
- Enhanced CSS styles for .blx-sr-card to improve hover effects and background handling.
---
 .agents/plans/PLANS.md                        |  1 +
 .../plans/linux-browser-iframe-boot-fix.md    | 31 +++++++++++++++++++
 src-tauri/tauri.conf.json                     |  6 ++--
 src/workbench/browser_tab.rs                  | 15 ++++++++-
 src/workbench/right_panel.rs                  | 15 +++++++--
 styles.css                                    | 14 +++++----
 6 files changed, 69 insertions(+), 13 deletions(-)
 create mode 100644 .agents/plans/linux-browser-iframe-boot-fix.md

diff --git a/.agents/plans/PLANS.md b/.agents/plans/PLANS.md
index 366799b..435b91a 100644
--- a/.agents/plans/PLANS.md
+++ b/.agents/plans/PLANS.md
@@ -6,6 +6,7 @@ Persistent plans for multi-step work on **blxcode**. Individual plans live as Ma
 
 | Status | Plan | Description |
 |--------|------|-------------|
+| planned | [linux-browser-iframe-boot-fix.md](linux-browser-iframe-boot-fix.md) | Linux Boot-Crash Fix: sticky Lazy Mount für BrowserTabDock + iframe-src-Gating (WebKitGTK nested iframe) |
 | planned | [performance-optimization.md](performance-optimization.md) | Performance-Audit: Agent-Streaming hot path, Auto-Save-Kaskade, Backend-Blocking, Boot/CDN, Terminal-Refit; Phasen P0–P3 |
 | planned | [security-hardening.md](security-hardening.md) | Security-Audit: Subagent shell_write-Bypass, Shell-Allowlist, XSS/CSP, Runtime-Tool-Allowlist, Symlink/URL/PTY-Hardening; Phasen P0–P3 |
 | planned | [v2-roadmap.md](v2-roadmap.md) | V2-Roadmap (Trust Repair): plan_context-Bug, Konversations-Persistenz, Kanban-MVP, web_fetch, Docs-Sync, CI; Phasen V2.0–V2.3+ |
diff --git a/.agents/plans/linux-browser-iframe-boot-fix.md b/.agents/plans/linux-browser-iframe-boot-fix.md
new file mode 100644
index 0000000..7ceb93b
--- /dev/null
+++ b/.agents/plans/linux-browser-iframe-boot-fix.md
@@ -0,0 +1,31 @@
+# Linux BrowserTabDock Boot-Crash Fix
+
+## Summary
+
+Behebt den Linux-only Boot-Crash: `BrowserTabDock` wurde beim Workbench-Start per CSS versteckt, mountete aber sofort `<iframe>`-Elemente mit der Standard-URL — WebKitGTK in der Tauri-Haupt-Webview stürzte ab. Fix: sticky Lazy Mount + Sichtbarkeits-Gating für iframe-Loads (analog zum `native_child`-Pfad auf Windows/macOS).
+
+## Decisions
+
+- Kein Linux-native Child-Webview in diesem Fix (separat: `linux-native-browser` in v2-roadmap).
+- Sticky Lazy Mount: Dock wird beim ersten Browser-Tab-Besuch gemountet und bleibt danach im DOM (Tab-State ohne Reload).
+- iframe-`src` und iframable-Effect nur bei sichtbarem Browser-Layer (`right_active_tab == Browser && !right_collapsed`).
+- Rein frontend-seitig; kein Backend-Change.
+
+## Implementation Notes
+
+- `src/workbench/right_panel.rs`: `browser_dock_mounted` Signal + `<Show>`-Wrapper um `BrowserTabDock`.
+- `src/workbench/browser_tab.rs`: `browser_layer_visible(wb)`; iframable-Effect und `prop:src` gated (`about:blank` wenn unsichtbar).
+
+## Tests
+
+- Linux: Boot ohne Browser-Tab; Browser-Tab öffnen, navigieren, Tab wechseln, Panel collapsen.
+- Windows/macOS: Keine Regression bei native Child-Webview.
+
+## Tasks
+
+- [x] `sticky-lazy-mount` - Sticky `<Show>` + Mount-Signal in right_panel.rs
+- [x] `visibility-helper` - browser_layer_visible(wb) Hilfsfunktion
+- [x] `gate-iframable-effect` - iframable-Effect nur bei sichtbarem Layer
+- [x] `gate-iframe-src` - iframe prop:src gated, sonst about:blank
+- [x] `manual-linux-test` - cargo check WASM + Tauri grün; GUI-Verifikation durch Nutzer
+- [x] `plan-doc` - Plan-Datei + PLANS.md Index
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 45364e0..2f4a162 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -15,9 +15,9 @@
       {
         "label": "main",
         "title": "BLXCode",
-        "width": 800,
-        "height": 600,
-        "transparent": true
+        "width": 1600,
+        "height": 900,
+        "transparent": false
       }
     ],
     "security": {
diff --git a/src/workbench/browser_tab.rs b/src/workbench/browser_tab.rs
index f92c6ab..4474207 100644
--- a/src/workbench/browser_tab.rs
+++ b/src/workbench/browser_tab.rs
@@ -95,6 +95,10 @@ fn embed_is_native(surface: BrowserEmbedSurface) -> bool {
     surface.0.get_untracked().as_deref() == Some("native_child")
 }
 
+fn browser_layer_visible(wb: WorkbenchService) -> bool {
+    !wb.right_collapsed().get() && wb.right_active_tab().get() == RightPanelTab::Browser
+}
+
 fn active_tab_url(wb: WorkbenchService) -> String {
     let aid = wb.embedded_browser_active_id().get_untracked();
     wb.embedded_browser_tabs()
@@ -291,6 +295,9 @@ pub fn BrowserTabDock() -> impl IntoView {
         if embed_is_native(surface) {
             return;
         }
+        if !browser_layer_visible(wb) {
+            return;
+        }
         let tabs = wb.embedded_browser_tabs().get();
         for tab in tabs {
             let tid = tab.id;
@@ -608,7 +615,13 @@ pub fn BrowserTabDock() -> impl IntoView {
                                                     id=iframe_id_for(tid)
                                                     class="workbench-browser-iframe"
                                                     title=move || i18n.tr(I18nKey::BrFrameTitle)()
-                                                    prop:src=move || url_memo.get()
+                                                    prop:src=move || {
+                                                        if browser_layer_visible(wb) {
+                                                            url_memo.get()
+                                                        } else {
+                                                            "about:blank".into()
+                                                        }
+                                                    }
                                                 ></iframe>
                                             </Show>
                                         </Show>
diff --git a/src/workbench/right_panel.rs b/src/workbench/right_panel.rs
index 5a69ea3..3a5dd92 100644
--- a/src/workbench/right_panel.rs
+++ b/src/workbench/right_panel.rs
@@ -143,6 +143,13 @@ pub fn RightPanel() -> impl IntoView {
         format!("{width:.0}px")
     });
     let active_tab = Memo::new(move |_| wb.right_active_tab().get());
+    let browser_dock_mounted = RwSignal::new(false);
+
+    Effect::new(move |_| {
+        if active_tab.get() == RightPanelTab::Browser {
+            browser_dock_mounted.set(true);
+        }
+    });
 
     view! {
         <div
@@ -426,9 +433,11 @@ pub fn RightPanel() -> impl IntoView {
                     <div class="workbench-right-tab-panel" class:workbench-right-tab-panel--hidden=move || active_tab.get() != RightPanelTab::Agent>
                         <AgentPanelDock />
                     </div>
-                    <div class="workbench-right-tab-panel" class:workbench-right-tab-panel--hidden=move || active_tab.get() != RightPanelTab::Browser>
-                        <BrowserTabDock />
-                    </div>
+                    <Show when=move || browser_dock_mounted.get()>
+                        <div class="workbench-right-tab-panel" class:workbench-right-tab-panel--hidden=move || active_tab.get() != RightPanelTab::Browser>
+                            <BrowserTabDock />
+                        </div>
+                    </Show>
                     <div class="workbench-right-tab-panel" class:workbench-right-tab-panel--hidden=move || active_tab.get() != RightPanelTab::Plans>
                         <PlansTabDock />
                     </div>
diff --git a/styles.css b/styles.css
index f2d9f35..d945d5b 100644
--- a/styles.css
+++ b/styles.css
@@ -9194,16 +9194,18 @@ button {
     transition: border-color 140ms ease, background 140ms ease,
         box-shadow 140ms ease, transform 140ms ease;
 }
-.blx-sr-card:hover {
+.blx-sr-card:hover:not(.blx-sr-card--open) {
     border-color: var(--border-strong);
-    background: var(--text-muted);
+    background: var(--overlay-2);
 }
 .blx-sr-card--open {
     border-color: var(--accent-soft);
-    background: var(--text-muted);
-    box-shadow:
-        0 0 0 1px var(--accent-cool-soft),
-        0 8px 24px var(--scrim-bg);
+    background: var(--accent-soft);
+    box-shadow: 0 0 0 1px var(--accent-cool-soft);
+}
+.blx-sr-card--open:hover {
+    border-color: var(--accent);
+    background: var(--accent-soft);
 }
 .blx-sr-card--composer {
     border-style: dashed;

From d03d0f9fc5d84a10698d1e0adab982430333bb97 Mon Sep 17 00:00:00 2001
From: iptoux <iptoux@gmail.com>
Date: Wed, 27 May 2026 19:26:43 +0200
Subject: [PATCH 6/8] feat(memory-panel): add memory selection clearing
 functionality and enhance UI spacing

- Implemented a new function to clear memory selection in the memory panel.
- Added click event handlers to clear selection when clicking on the memory files tree or spacer.
- Introduced a CSS class for the tree spacer to improve layout and user interaction.
---
 src/workbench/memory_panel.rs | 32 ++++++++++++++++++++++++++++++++
 styles.css                    |  6 ++++++
 2 files changed, 38 insertions(+)

diff --git a/src/workbench/memory_panel.rs b/src/workbench/memory_panel.rs
index 7c0fb02..2887d02 100644
--- a/src/workbench/memory_panel.rs
+++ b/src/workbench/memory_panel.rs
@@ -255,6 +255,18 @@ pub(crate) fn load_note(state: MemoryState, ws: String, scope: MemoryScope, path
     });
 }
 
+fn clear_memory_selection(state: MemoryState) {
+    if state.active_path.get_untracked().is_none() {
+        return;
+    }
+    state.active_path.set(None);
+    state.editor_content.set(String::new());
+    state.editor_dirty.set(false);
+    state.show_preview.set(false);
+    state.backlinks.set(Vec::new());
+    state.graph_selected_node.set(None);
+}
+
 fn schedule_save(state: MemoryState, ws: String) {
     let token = state.save_token.get_untracked() + 1;
     state.save_token.set(token);
@@ -945,6 +957,18 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
             <aside
                 class="workbench-memory-files__tree"
                 class:workbench-memory-files__tree--collapsed=move || files_collapsed.get()
+                on:click={
+                    let state = state.clone();
+                    move |ev: web_sys::MouseEvent| {
+                        let same = ev
+                            .target()
+                            .zip(ev.current_target())
+                            .is_some_and(|(t, c)| t == c);
+                        if same {
+                            clear_memory_selection(state.clone());
+                        }
+                    }
+                }
             >
                 <div
                     class="workbench-memory-files__new"
@@ -1050,6 +1074,14 @@ fn MemoryFilesView(state: MemoryState) -> impl IntoView {
                         {section(MemoryScope::Global)}
                     </Show>
                 </div>
+                <div
+                    class="workbench-memory-files__tree-spacer"
+                    aria-hidden="true"
+                    on:click={
+                        let state = state.clone();
+                        move |_| clear_memory_selection(state.clone())
+                    }
+                ></div>
             </aside>
             <section class="workbench-memory-editor">
                 <Show
diff --git a/styles.css b/styles.css
index d945d5b..762e556 100644
--- a/styles.css
+++ b/styles.css
@@ -7691,6 +7691,12 @@ button {
   background: var(--overlay-1);
 }
 
+.workbench-memory-files__tree-spacer {
+  flex: 1 1 auto;
+  min-height: 2rem;
+  cursor: default;
+}
+
 .workbench-memory-files__tree--collapsed {
   align-items: center;
 }

From b8807d47e856fe63cda6a62abbaf4168763cc626 Mon Sep 17 00:00:00 2001
From: iptoux <iptoux@gmail.com>
Date: Wed, 27 May 2026 20:08:58 +0200
Subject: [PATCH 7/8] feat(terminal): implement context menu for terminal
 actions and clipboard integration

- Added a right-click context menu for terminal interactions, allowing users to copy, paste, and select all text.
- Integrated clipboard functionality for reading and writing text, enhancing user experience with terminal selections.
- Updated CSS styles for the context menu to improve visibility and usability.
- Added internationalization support for new menu items and toast notifications related to clipboard actions.
- Refactored terminal glue functions to handle selection and clipboard operations more effectively.
---
 public/terminal_bootstrap.mjs          |  95 ++++++--
 src-tauri/Cargo.toml                   |   1 +
 src-tauri/src/clipboard.rs             |  13 ++
 src-tauri/src/lib.rs                   |   4 +
 src/i18n/keys.rs                       |   7 +
 src/i18n/locales/de_de.rs              |   7 +
 src/i18n/locales/en_us.rs              |   7 +
 src/i18n/locales/es_es.rs              |   7 +
 src/i18n/locales/fr_fr.rs              |   7 +
 src/i18n/locales/hu_hu.rs              |   7 +
 src/i18n/locales/it_it.rs              |   7 +
 src/i18n/locales/ja_jp.rs              |   7 +
 src/i18n/locales/ko_kr.rs              |   7 +
 src/i18n/locales/pl_pl.rs              |   7 +
 src/i18n/locales/pt_br.rs              |   7 +
 src/i18n/locales/ru_ru.rs              |   7 +
 src/i18n/locales/zh_cn.rs              |   7 +
 src/i18n/locales/zh_tw.rs              |   7 +
 src/tauri_bridge.rs                    |  44 ++++
 src/workbench/mod.rs                   |  23 ++
 src/workbench/terminal_context_menu.rs | 292 +++++++++++++++++++++++++
 src/workbench/terminal_glue.rs         |  64 ++++++
 src/workbench/workspace_panel.rs       |  22 ++
 styles.css                             |  40 ++++
 24 files changed, 683 insertions(+), 13 deletions(-)
 create mode 100644 src-tauri/src/clipboard.rs
 create mode 100644 src/workbench/terminal_context_menu.rs

diff --git a/public/terminal_bootstrap.mjs b/public/terminal_bootstrap.mjs
index 9e9c322..76b3239 100644
--- a/public/terminal_bootstrap.mjs
+++ b/public/terminal_bootstrap.mjs
@@ -244,33 +244,65 @@ window.__blxcodeTerminal = {
     term.loadAddon(webLinks);
     term.open(container);
 
-    // Windows CMD-style right-click: copy selection if text is selected,
-    // otherwise paste from clipboard. xterm.js swallows contextmenu by
-    // default so we need our own handler on the rendered element.
+    const dispatchTerminalEvent = (name, extra = {}) => {
+      window.dispatchEvent(
+        new CustomEvent(name, {
+          detail: { termId: id, ...extra },
+        }),
+      );
+    };
+
     const attachContextMenu = () => {
       const el = term.element;
       if (!el) return;
       el.addEventListener("contextmenu", (e) => {
         e.preventDefault();
-        const sel = term.getSelection();
-        if (sel && sel.length > 0) {
-          navigator.clipboard.writeText(sel).catch(() => {});
-          term.clearSelection();
-        } else {
-          navigator.clipboard
-            .readText()
-            .then((text) => { if (text) term.paste(text); })
-            .catch(() => {});
+        e.stopPropagation();
+        if (e.shiftKey) {
+          dispatchTerminalEvent("blxcode-terminal-paste-request");
+          return;
         }
+        const selection = term.getSelection() || "";
+        dispatchTerminalEvent("blxcode-terminal-contextmenu", {
+          clientX: e.clientX,
+          clientY: e.clientY,
+          selection,
+          hasSelection: selection.length > 0,
+        });
       });
     };
-    // term.element is available after open() but guard with rAF to be safe
     if (term.element) {
       attachContextMenu();
     } else {
       requestAnimationFrame(attachContextMenu);
     }
 
+    term.attachCustomKeyEventHandler((ev) => {
+      const key = ev.key;
+      const ctrl = ev.ctrlKey || ev.metaKey;
+      if (!ctrl) return true;
+      if (ev.shiftKey && (key === "C" || key === "c")) {
+        const sel = term.getSelection();
+        if (sel && sel.length > 0) {
+          dispatchTerminalEvent("blxcode-terminal-copy-request", { selection: sel });
+          return false;
+        }
+        return true;
+      }
+      if (ev.shiftKey && (key === "V" || key === "v")) {
+        dispatchTerminalEvent("blxcode-terminal-paste-request");
+        return false;
+      }
+      if (!ev.shiftKey && (key === "C" || key === "c")) {
+        const sel = term.getSelection();
+        if (sel && sel.length > 0) {
+          dispatchTerminalEvent("blxcode-terminal-copy-request", { selection: sel });
+          return false;
+        }
+      }
+      return true;
+    });
+
     const rec = {
       term,
       fit,
@@ -362,6 +394,43 @@ window.__blxcodeTerminal = {
       rec.term.options.disableStdin = !enabled;
     } catch (_) {}
   },
+  getSelection(termId) {
+    const rec = instances.get(termId);
+    if (!rec) return "";
+    try {
+      return rec.term.getSelection() || "";
+    } catch (_) {
+      return "";
+    }
+  },
+  paste(termId, text) {
+    const rec = instances.get(termId);
+    if (!rec || !text) return;
+    try {
+      rec.term.paste(text);
+    } catch (_) {}
+  },
+  selectAll(termId) {
+    const rec = instances.get(termId);
+    if (!rec) return;
+    try {
+      rec.term.selectAll();
+    } catch (_) {}
+  },
+  clearSelection(termId) {
+    const rec = instances.get(termId);
+    if (!rec) return;
+    try {
+      rec.term.clearSelection();
+    } catch (_) {}
+  },
+  focus(termId) {
+    const rec = instances.get(termId);
+    if (!rec) return;
+    try {
+      rec.term.focus();
+    } catch (_) {}
+  },
   observeWorkspaceGrid(container, workspaceId) {
     return observeWorkspaceGrid(container, workspaceId);
   },
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index d290542..7f20249 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -38,5 +38,6 @@ hound = "3.5"
 uuid = { version = "1", features = ["v4"] }
 tauri-plugin-updater = "2"
 tauri-plugin-process = "2"
+arboard = "3"
 notify = "6"
 dirs = "5"
diff --git a/src-tauri/src/clipboard.rs b/src-tauri/src/clipboard.rs
new file mode 100644
index 0000000..b8f6db0
--- /dev/null
+++ b/src-tauri/src/clipboard.rs
@@ -0,0 +1,13 @@
+use arboard::Clipboard;
+
+#[tauri::command]
+pub fn clipboard_read_text() -> Result<String, String> {
+    let mut clipboard = Clipboard::new().map_err(|e| e.to_string())?;
+    clipboard.get_text().map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+pub fn clipboard_write_text(text: String) -> Result<(), String> {
+    let mut clipboard = Clipboard::new().map_err(|e| e.to_string())?;
+    clipboard.set_text(text).map_err(|e| e.to_string())
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 457a8ed..c528c15 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -4,6 +4,7 @@ mod agent_settings;
 mod agents_layout;
 mod api_keys;
 mod browser_host;
+mod clipboard;
 mod commands;
 mod fs_entries;
 mod git_graph;
@@ -28,6 +29,7 @@ use agent_hooks::{agent_hooks_status, install_agent_hooks, uninstall_agent_hooks
 use agent_settings::{agent_provider_models, agent_settings_get, agent_settings_save};
 use api_keys::{api_keys_apply, api_keys_status};
 use browser_host::BrowserHost;
+use clipboard::{clipboard_read_text, clipboard_write_text};
 use commands::*;
 use image::{image_curated_models, image_settings_get, image_settings_save};
 use pty_host::PtyManager;
@@ -239,6 +241,8 @@ pub fn run() {
             agent_environment_invalidate,
             image_curated_models,
             crate::image::commands::generated_image_preview,
+            clipboard_read_text,
+            clipboard_write_text,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
diff --git a/src/i18n/keys.rs b/src/i18n/keys.rs
index 1d12242..68fce89 100644
--- a/src/i18n/keys.rs
+++ b/src/i18n/keys.rs
@@ -660,6 +660,13 @@ pub enum I18nKey {
     WsTermDropCreateNewAria,
     WsTermDragMaxSlots,
     WsTermBootstrapFailed,
+    WsTermMenuCopy,
+    WsTermMenuPaste,
+    WsTermMenuSelectAll,
+    WsTermMenuAria,
+    WsTermToastCopied,
+    WsTermToastPasteFailed,
+    WsTermToastCopyFailed,
 
     // Voice subsystem
     VoicePaneTitle,
diff --git a/src/i18n/locales/de_de.rs b/src/i18n/locales/de_de.rs
index 840d7cd..70e0423 100644
--- a/src/i18n/locales/de_de.rs
+++ b/src/i18n/locales/de_de.rs
@@ -654,6 +654,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Die Terminal-Benutzeroberfläche konnte nicht geladen werden. Überprüfen Sie die Browserkonsole. Das Bootstrap-Skript oder das xterm-CDN sind möglicherweise blockiert."
         }
+        I18nKey::WsTermMenuCopy => "Kopieren",
+        I18nKey::WsTermMenuPaste => "Einfügen",
+        I18nKey::WsTermMenuSelectAll => "Alles markieren",
+        I18nKey::WsTermMenuAria => "Terminal-Kontextmenü",
+        I18nKey::WsTermToastCopied => "Auswahl in Zwischenablage kopiert",
+        I18nKey::WsTermToastPasteFailed => "Einfügen aus Zwischenablage fehlgeschlagen: {error}",
+        I18nKey::WsTermToastCopyFailed => "Kopieren in Zwischenablage fehlgeschlagen: {error}",
         I18nKey::EulaAccepted => "Akzeptiert",
         I18nKey::EulaUnknown => "Unbekannt",
         I18nKey::VoicePaneTitle => "Stimme",
diff --git a/src/i18n/locales/en_us.rs b/src/i18n/locales/en_us.rs
index ac603ad..37482d3 100644
--- a/src/i18n/locales/en_us.rs
+++ b/src/i18n/locales/en_us.rs
@@ -692,6 +692,13 @@ Classic: Ctrl+O quick open, Ctrl+` new terminal, Ctrl+Shift+P palette."
         I18nKey::WsTermBootstrapFailed => {
             "Terminal UI failed to load. Check the browser console; the bootstrap script or xterm CDN may be blocked."
         }
+        I18nKey::WsTermMenuCopy => "Copy",
+        I18nKey::WsTermMenuPaste => "Paste",
+        I18nKey::WsTermMenuSelectAll => "Select all",
+        I18nKey::WsTermMenuAria => "Terminal context menu",
+        I18nKey::WsTermToastCopied => "Selection copied to clipboard",
+        I18nKey::WsTermToastPasteFailed => "Could not paste from clipboard: {error}",
+        I18nKey::WsTermToastCopyFailed => "Could not copy to clipboard: {error}",
 
         I18nKey::EulaAccepted => "Accepted",
         I18nKey::EulaUnknown => "Unknown",
diff --git a/src/i18n/locales/es_es.rs b/src/i18n/locales/es_es.rs
index 877658e..4f7294b 100644
--- a/src/i18n/locales/es_es.rs
+++ b/src/i18n/locales/es_es.rs
@@ -656,6 +656,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "La interfaz de usuario del terminal no se pudo cargar. Verifique la consola del navegador; Es posible que el script de arranque o la CDN de xterm estén bloqueados."
         }
+        I18nKey::WsTermMenuCopy => "Copiar",
+        I18nKey::WsTermMenuPaste => "Pegar",
+        I18nKey::WsTermMenuSelectAll => "Seleccionar todo",
+        I18nKey::WsTermMenuAria => "Menú contextual del terminal",
+        I18nKey::WsTermToastCopied => "Selección copiada al portapapeles",
+        I18nKey::WsTermToastPasteFailed => "No se pudo pegar desde el portapapeles: {error}",
+        I18nKey::WsTermToastCopyFailed => "No se pudo copiar al portapapeles: {error}",
         I18nKey::EulaAccepted => "Aceptado",
         I18nKey::EulaUnknown => "Desconocido",
         I18nKey::VoicePaneTitle => "Voz",
diff --git a/src/i18n/locales/fr_fr.rs b/src/i18n/locales/fr_fr.rs
index 8fd9a17..7a3b343 100644
--- a/src/i18n/locales/fr_fr.rs
+++ b/src/i18n/locales/fr_fr.rs
@@ -660,6 +660,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "L'interface utilisateur du terminal n'a pas pu se charger. Vérifiez la console du navigateur ; le script d'amorçage ou le CDN xterm peut être bloqué."
         }
+        I18nKey::WsTermMenuCopy => "Copier",
+        I18nKey::WsTermMenuPaste => "Coller",
+        I18nKey::WsTermMenuSelectAll => "Tout sélectionner",
+        I18nKey::WsTermMenuAria => "Menu contextuel du terminal",
+        I18nKey::WsTermToastCopied => "Sélection copiée dans le presse-papiers",
+        I18nKey::WsTermToastPasteFailed => "Impossible de coller depuis le presse-papiers : {error}",
+        I18nKey::WsTermToastCopyFailed => "Impossible de copier dans le presse-papiers : {error}",
         I18nKey::EulaAccepted => "Accepté",
         I18nKey::EulaUnknown => "Inconnu",
         I18nKey::VoicePaneTitle => "Voix",
diff --git a/src/i18n/locales/hu_hu.rs b/src/i18n/locales/hu_hu.rs
index f55265d..9a7a2c7 100644
--- a/src/i18n/locales/hu_hu.rs
+++ b/src/i18n/locales/hu_hu.rs
@@ -654,6 +654,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Nem sikerült betölteni a terminál felhasználói felületét. Ellenőrizze a böngésző konzolját; a bootstrap szkript vagy az xterm CDN blokkolva lehet."
         }
+        I18nKey::WsTermMenuCopy => "Másolás",
+        I18nKey::WsTermMenuPaste => "Beillesztés",
+        I18nKey::WsTermMenuSelectAll => "Összes kijelölése",
+        I18nKey::WsTermMenuAria => "Terminál helyi menü",
+        I18nKey::WsTermToastCopied => "Kijelölés a vágólapra másolva",
+        I18nKey::WsTermToastPasteFailed => "Nem sikerült beilleszteni a vágólapról: {error}",
+        I18nKey::WsTermToastCopyFailed => "Nem sikerült a vágólapra másolni: {error}",
         I18nKey::EulaAccepted => "Elfogadott",
         I18nKey::EulaUnknown => "Ismeretlen",
         I18nKey::VoicePaneTitle => "Hang",
diff --git a/src/i18n/locales/it_it.rs b/src/i18n/locales/it_it.rs
index 450ee3a..bb253bf 100644
--- a/src/i18n/locales/it_it.rs
+++ b/src/i18n/locales/it_it.rs
@@ -652,6 +652,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Impossibile caricare l'interfaccia utente del terminale. Controlla la console del browser; lo script bootstrap o il CDN xterm potrebbero essere bloccati."
         }
+        I18nKey::WsTermMenuCopy => "Copia",
+        I18nKey::WsTermMenuPaste => "Incolla",
+        I18nKey::WsTermMenuSelectAll => "Seleziona tutto",
+        I18nKey::WsTermMenuAria => "Menu contestuale del terminale",
+        I18nKey::WsTermToastCopied => "Selezione copiata negli appunti",
+        I18nKey::WsTermToastPasteFailed => "Impossibile incollare dagli appunti: {error}",
+        I18nKey::WsTermToastCopyFailed => "Impossibile copiare negli appunti: {error}",
         I18nKey::EulaAccepted => "Accettato",
         I18nKey::EulaUnknown => "Sconosciuto",
         I18nKey::VoicePaneTitle => "Voce",
diff --git a/src/i18n/locales/ja_jp.rs b/src/i18n/locales/ja_jp.rs
index f54c3eb..055bf80 100644
--- a/src/i18n/locales/ja_jp.rs
+++ b/src/i18n/locales/ja_jp.rs
@@ -640,6 +640,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermDropCreateNewAria => "ドロップして端子スロットを追加します",
         I18nKey::WsTermDragMaxSlots => "最大端子スロットに達しました (16)",
         I18nKey::WsTermBootstrapFailed => "ターミナル UI のロードに失敗しました。ブラウザコンソールを確認してください。ブートストラップ スクリプトまたは xterm CDN がブロックされる可能性があります。",
+        I18nKey::WsTermMenuCopy => "コピー",
+        I18nKey::WsTermMenuPaste => "貼り付け",
+        I18nKey::WsTermMenuSelectAll => "すべて選択",
+        I18nKey::WsTermMenuAria => "ターミナルのコンテキストメニュー",
+        I18nKey::WsTermToastCopied => "選択範囲をクリップボードにコピーしました",
+        I18nKey::WsTermToastPasteFailed => "クリップボードから貼り付けできませんでした: {error}",
+        I18nKey::WsTermToastCopyFailed => "クリップボードにコピーできませんでした: {error}",
         I18nKey::EulaAccepted => "承認されました",
         I18nKey::EulaUnknown => "未知",
         I18nKey::VoicePaneTitle => "声",
diff --git a/src/i18n/locales/ko_kr.rs b/src/i18n/locales/ko_kr.rs
index b22b9fd..efac3f1 100644
--- a/src/i18n/locales/ko_kr.rs
+++ b/src/i18n/locales/ko_kr.rs
@@ -638,6 +638,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermDropCreateNewAria => "터미널 슬롯을 추가하려면 드롭하세요.",
         I18nKey::WsTermDragMaxSlots => "최대 터미널 슬롯에 도달함(16)",
         I18nKey::WsTermBootstrapFailed => "터미널 UI를 로드하지 못했습니다. 브라우저 콘솔을 확인하세요. 부트스트랩 스크립트 또는 xterm CDN이 차단되었을 수 있습니다.",
+        I18nKey::WsTermMenuCopy => "복사",
+        I18nKey::WsTermMenuPaste => "붙여넣기",
+        I18nKey::WsTermMenuSelectAll => "모두 선택",
+        I18nKey::WsTermMenuAria => "터미널 컨텍스트 메뉴",
+        I18nKey::WsTermToastCopied => "선택 영역이 클립보드에 복사되었습니다",
+        I18nKey::WsTermToastPasteFailed => "클립보드에서 붙여넣지 못했습니다: {error}",
+        I18nKey::WsTermToastCopyFailed => "클립보드에 복사하지 못했습니다: {error}",
         I18nKey::EulaAccepted => "수락됨",
         I18nKey::EulaUnknown => "알려지지 않은",
         I18nKey::VoicePaneTitle => "목소리",
diff --git a/src/i18n/locales/pl_pl.rs b/src/i18n/locales/pl_pl.rs
index 800d744..bd0d60e 100644
--- a/src/i18n/locales/pl_pl.rs
+++ b/src/i18n/locales/pl_pl.rs
@@ -652,6 +652,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Nie udało się załadować interfejsu terminala. Sprawdź konsolę przeglądarki; skrypt startowy lub xterm CDN mogą być zablokowane."
         }
+        I18nKey::WsTermMenuCopy => "Kopiuj",
+        I18nKey::WsTermMenuPaste => "Wklej",
+        I18nKey::WsTermMenuSelectAll => "Zaznacz wszystko",
+        I18nKey::WsTermMenuAria => "Menu kontekstowe terminala",
+        I18nKey::WsTermToastCopied => "Zaznaczenie skopiowano do schowka",
+        I18nKey::WsTermToastPasteFailed => "Nie udało się wkleić ze schowka: {error}",
+        I18nKey::WsTermToastCopyFailed => "Nie udało się skopiować do schowka: {error}",
         I18nKey::EulaAccepted => "Przyjęty",
         I18nKey::EulaUnknown => "Nieznany",
         I18nKey::VoicePaneTitle => "Głos",
diff --git a/src/i18n/locales/pt_br.rs b/src/i18n/locales/pt_br.rs
index 395eccb..edb0de9 100644
--- a/src/i18n/locales/pt_br.rs
+++ b/src/i18n/locales/pt_br.rs
@@ -654,6 +654,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Falha ao carregar a interface do terminal. Verifique o console do navegador; o script de inicialização ou CDN xterm pode estar bloqueado."
         }
+        I18nKey::WsTermMenuCopy => "Copiar",
+        I18nKey::WsTermMenuPaste => "Colar",
+        I18nKey::WsTermMenuSelectAll => "Selecionar tudo",
+        I18nKey::WsTermMenuAria => "Menu de contexto do terminal",
+        I18nKey::WsTermToastCopied => "Seleção copiada para a área de transferência",
+        I18nKey::WsTermToastPasteFailed => "Não foi possível colar da área de transferência: {error}",
+        I18nKey::WsTermToastCopyFailed => "Não foi possível copiar para a área de transferência: {error}",
         I18nKey::EulaAccepted => "Aceito",
         I18nKey::EulaUnknown => "Desconhecido",
         I18nKey::VoicePaneTitle => "Voz",
diff --git a/src/i18n/locales/ru_ru.rs b/src/i18n/locales/ru_ru.rs
index afd6fbb..c28fb2c 100644
--- a/src/i18n/locales/ru_ru.rs
+++ b/src/i18n/locales/ru_ru.rs
@@ -652,6 +652,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermBootstrapFailed => {
             "Не удалось загрузить пользовательский интерфейс терминала. Проверьте консоль браузера; сценарий начальной загрузки или xterm CDN могут быть заблокированы."
         }
+        I18nKey::WsTermMenuCopy => "Копировать",
+        I18nKey::WsTermMenuPaste => "Вставить",
+        I18nKey::WsTermMenuSelectAll => "Выделить всё",
+        I18nKey::WsTermMenuAria => "Контекстное меню терминала",
+        I18nKey::WsTermToastCopied => "Выделение скопировано в буфер обмена",
+        I18nKey::WsTermToastPasteFailed => "Не удалось вставить из буфера обмена: {error}",
+        I18nKey::WsTermToastCopyFailed => "Не удалось скопировать в буфер обмена: {error}",
         I18nKey::EulaAccepted => "Принял",
         I18nKey::EulaUnknown => "Неизвестный",
         I18nKey::VoicePaneTitle => "Голос",
diff --git a/src/i18n/locales/zh_cn.rs b/src/i18n/locales/zh_cn.rs
index 09e3e95..9dc017c 100644
--- a/src/i18n/locales/zh_cn.rs
+++ b/src/i18n/locales/zh_cn.rs
@@ -636,6 +636,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermDropCreateNewAria => "下拉添加端子槽",
         I18nKey::WsTermDragMaxSlots => "已达到最大端子槽位 (16)",
         I18nKey::WsTermBootstrapFailed => "终端 UI 无法加载。检查浏览器控制台；引导脚本或 xterm CDN 可能被阻止。",
+        I18nKey::WsTermMenuCopy => "复制",
+        I18nKey::WsTermMenuPaste => "粘贴",
+        I18nKey::WsTermMenuSelectAll => "全选",
+        I18nKey::WsTermMenuAria => "终端上下文菜单",
+        I18nKey::WsTermToastCopied => "所选内容已复制到剪贴板",
+        I18nKey::WsTermToastPasteFailed => "无法从剪贴板粘贴：{error}",
+        I18nKey::WsTermToastCopyFailed => "无法复制到剪贴板：{error}",
         I18nKey::EulaAccepted => "公认",
         I18nKey::EulaUnknown => "未知",
         I18nKey::VoicePaneTitle => "嗓音",
diff --git a/src/i18n/locales/zh_tw.rs b/src/i18n/locales/zh_tw.rs
index 2cee925..2aab730 100644
--- a/src/i18n/locales/zh_tw.rs
+++ b/src/i18n/locales/zh_tw.rs
@@ -636,6 +636,13 @@ pub fn msg(key: I18nKey) -> &'static str {
         I18nKey::WsTermDropCreateNewAria => "下拉添加端子槽",
         I18nKey::WsTermDragMaxSlots => "已達最大端子槽位 (16)",
         I18nKey::WsTermBootstrapFailed => "終端 UI 無法載入。檢查瀏覽器控制台；引導腳本或 xterm CDN 可能會被封鎖。",
+        I18nKey::WsTermMenuCopy => "複製",
+        I18nKey::WsTermMenuPaste => "貼上",
+        I18nKey::WsTermMenuSelectAll => "全選",
+        I18nKey::WsTermMenuAria => "終端機內容功能表",
+        I18nKey::WsTermToastCopied => "選取範圍已複製到剪貼簿",
+        I18nKey::WsTermToastPasteFailed => "無法從剪貼簿貼上：{error}",
+        I18nKey::WsTermToastCopyFailed => "無法複製到剪貼簿：{error}",
         I18nKey::EulaAccepted => "公認",
         I18nKey::EulaUnknown => "未知",
         I18nKey::VoicePaneTitle => "嗓音",
diff --git a/src/tauri_bridge.rs b/src/tauri_bridge.rs
index 33c2851..5c454e0 100644
--- a/src/tauri_bridge.rs
+++ b/src/tauri_bridge.rs
@@ -585,6 +585,50 @@ pub async fn exit_app_ipc() -> Result<(), String> {
     invoke_unit_js("exit_app", JsValue::UNDEFINED).await
 }
 
+pub async fn clipboard_read_text() -> Result<String, String> {
+    invoke_typed("clipboard_read_text", ()).await
+}
+
+pub async fn clipboard_write_text(text: String) -> Result<(), String> {
+    #[derive(Serialize)]
+    struct Args {
+        text: String,
+    }
+    invoke_unit_js("clipboard_write_text", args_value(Args { text })?).await
+}
+
+/// Tauri native clipboard when available; otherwise Web Clipboard API.
+pub async fn clipboard_read_text_compat() -> Result<String, String> {
+    if is_tauri_shell() {
+        return clipboard_read_text().await;
+    }
+    let Some(window) = web_sys::window() else {
+        return Err("no window".into());
+    };
+    let clipboard = window.navigator().clipboard();
+    let promise = clipboard.read_text();
+    wasm_bindgen_futures::JsFuture::from(promise)
+        .await
+        .map_err(|e| js_error_to_string(e))
+        .and_then(|v| v.as_string().ok_or_else(|| "clipboard read returned non-string".into()))
+}
+
+/// Tauri native clipboard when available; otherwise Web Clipboard API.
+pub async fn clipboard_write_text_compat(text: String) -> Result<(), String> {
+    if is_tauri_shell() {
+        return clipboard_write_text(text).await;
+    }
+    let Some(window) = web_sys::window() else {
+        return Err("no window".into());
+    };
+    let clipboard = window.navigator().clipboard();
+    let promise = clipboard.write_text(&text);
+    wasm_bindgen_futures::JsFuture::from(promise)
+        .await
+        .map_err(|e| js_error_to_string(e))?;
+    Ok(())
+}
+
 #[allow(dead_code)]
 #[derive(Debug, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
diff --git a/src/workbench/mod.rs b/src/workbench/mod.rs
index 9e05885..a38760a 100644
--- a/src/workbench/mod.rs
+++ b/src/workbench/mod.rs
@@ -33,6 +33,7 @@ mod sidebar_view_section;
 pub mod skills_rules_panel;
 pub mod state;
 mod terminal_cell;
+mod terminal_context_menu;
 mod terminal_glue;
 mod terminal_slot_dnd;
 mod theme_service;
@@ -292,6 +293,9 @@ pub fn WorkbenchShell() -> impl IntoView {
 
     let contextmenu_handle =
         leptos::leptos_dom::helpers::window_event_listener_untyped("contextmenu", move |ev| {
+            if event_target_in_terminal_xterm(&ev) {
+                return;
+            }
             ev.prevent_default();
         });
     on_cleanup(move || drop(contextmenu_handle));
@@ -493,3 +497,22 @@ pub fn WorkbenchShell() -> impl IntoView {
         </Show>
     }
 }
+
+fn event_target_in_terminal_xterm(ev: &web_sys::Event) -> bool {
+    let Some(target) = ev
+        .target()
+        .and_then(|t| t.dyn_into::<web_sys::Element>().ok())
+    else {
+        return false;
+    };
+    target
+        .closest(".ws-term-cell__xterm")
+        .ok()
+        .flatten()
+        .is_some()
+        || target
+            .closest(".xterm")
+            .ok()
+            .flatten()
+            .is_some()
+}
diff --git a/src/workbench/terminal_context_menu.rs b/src/workbench/terminal_context_menu.rs
new file mode 100644
index 0000000..31592d3
--- /dev/null
+++ b/src/workbench/terminal_context_menu.rs
@@ -0,0 +1,292 @@
+//! Right-click context menu for workspace xterm terminals.
+
+use crate::i18n::I18nKey;
+use crate::service::I18nService;
+use crate::tauri_bridge::{clipboard_read_text_compat, clipboard_write_text_compat};
+use crate::workbench::terminal_glue::{
+    terminal_clear_selection, terminal_focus, terminal_get_selection, terminal_paste,
+    terminal_select_all,
+};
+use crate::workbench::toast::ToastService;
+use leptos::prelude::*;
+use wasm_bindgen::JsCast;
+
+#[derive(Clone, Debug)]
+pub enum TerminalMenuAction {
+    Copy,
+    Paste,
+    SelectAll,
+}
+
+#[derive(Clone, Debug)]
+pub struct TerminalContextMenuState {
+    pub term_id: f64,
+    pub anchor_x: i32,
+    pub anchor_y: i32,
+    pub has_selection: bool,
+}
+
+#[component]
+pub fn TerminalContextMenu(
+    state: RwSignal<Option<TerminalContextMenuState>>,
+    on_action: Callback<TerminalMenuAction>,
+) -> impl IntoView {
+    let i18n = expect_context::<I18nService>();
+
+    view! {
+        <Show when=move || state.get().is_some()>
+            {move || {
+                let Some(s) = state.get() else {
+                    return view! {}.into_any();
+                };
+                let style = format!("left: {}px; top: {}px;", s.anchor_x, s.anchor_y);
+                let has_selection = s.has_selection;
+                view! {
+                    <div
+                        class="terminal-context-menu"
+                        role="menu"
+                        aria-label=move || i18n.tr(I18nKey::WsTermMenuAria)()
+                        style=style
+                        on:mousedown=|ev| ev.stop_propagation()
+                        on:click=|ev| ev.stop_propagation()
+                        on:contextmenu=|ev| ev.prevent_default()
+                    >
+                        <button
+                            type="button"
+                            class="terminal-context-menu__item"
+                            role="menuitem"
+                            disabled=move || !has_selection
+                            on:click=move |_| on_action.run(TerminalMenuAction::Copy)
+                        >
+                            {move || i18n.tr(I18nKey::WsTermMenuCopy)()}
+                        </button>
+                        <button
+                            type="button"
+                            class="terminal-context-menu__item"
+                            role="menuitem"
+                            on:click=move |_| on_action.run(TerminalMenuAction::Paste)
+                        >
+                            {move || i18n.tr(I18nKey::WsTermMenuPaste)()}
+                        </button>
+                        <button
+                            type="button"
+                            class="terminal-context-menu__item"
+                            role="menuitem"
+                            on:click=move |_| on_action.run(TerminalMenuAction::SelectAll)
+                        >
+                            {move || i18n.tr(I18nKey::WsTermMenuSelectAll)()}
+                        </button>
+                    </div>
+                }
+                .into_any()
+            }}
+        </Show>
+    }
+}
+
+pub fn paste_terminal_from_clipboard(term_id: f64, i18n: I18nService, toast: ToastService) {
+    leptos::task::spawn_local(async move {
+        match clipboard_read_text_compat().await {
+            Ok(text) if !text.is_empty() => {
+                terminal_focus(term_id);
+                terminal_paste(term_id, &text);
+            }
+            Ok(_) => {}
+            Err(err) => {
+                let msg = i18n
+                    .tr(I18nKey::WsTermToastPasteFailed)()
+                    .replace("{error}", &err);
+                toast.error(msg);
+            }
+        }
+    });
+}
+
+pub fn dispatch_terminal_menu_action(
+    action: TerminalMenuAction,
+    term_id: f64,
+    i18n: I18nService,
+    toast: ToastService,
+) {
+    match action {
+        TerminalMenuAction::Copy => {
+            let text = terminal_get_selection(term_id);
+            if text.is_empty() {
+                return;
+            }
+            leptos::task::spawn_local(async move {
+                match clipboard_write_text_compat(text.clone()).await {
+                    Ok(()) => {
+                        terminal_clear_selection(term_id);
+                        toast.success(i18n.tr(I18nKey::WsTermToastCopied)());
+                    }
+                    Err(err) => {
+                        let msg = i18n
+                            .tr(I18nKey::WsTermToastCopyFailed)()
+                            .replace("{error}", &err);
+                        toast.error(msg);
+                    }
+                }
+            });
+        }
+        TerminalMenuAction::Paste => paste_terminal_from_clipboard(term_id, i18n, toast),
+        TerminalMenuAction::SelectAll => {
+            terminal_focus(term_id);
+            terminal_select_all(term_id);
+        }
+    }
+}
+
+pub fn copy_terminal_selection(
+    term_id: f64,
+    selection: Option<String>,
+    i18n: I18nService,
+    toast: ToastService,
+) {
+    let text = selection.unwrap_or_else(|| terminal_get_selection(term_id));
+    if text.is_empty() {
+        return;
+    }
+    leptos::task::spawn_local(async move {
+        match clipboard_write_text_compat(text.clone()).await {
+            Ok(()) => {
+                terminal_clear_selection(term_id);
+                toast.success(i18n.tr(I18nKey::WsTermToastCopied)());
+            }
+            Err(err) => {
+                let msg = i18n
+                    .tr(I18nKey::WsTermToastCopyFailed)()
+                    .replace("{error}", &err);
+                toast.error(msg);
+            }
+        }
+    });
+}
+
+fn detail_f64(detail: &wasm_bindgen::JsValue, key: &str) -> Option<f64> {
+    js_sys::Reflect::get(detail, &wasm_bindgen::JsValue::from_str(key))
+        .ok()
+        .and_then(|v| v.as_f64())
+}
+
+fn detail_i32(detail: &wasm_bindgen::JsValue, key: &str) -> Option<i32> {
+    detail_f64(detail, key).map(|v| v as i32)
+}
+
+fn detail_bool(detail: &wasm_bindgen::JsValue, key: &str) -> bool {
+    js_sys::Reflect::get(detail, &wasm_bindgen::JsValue::from_str(key))
+        .ok()
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+}
+
+fn detail_string(detail: &wasm_bindgen::JsValue, key: &str) -> Option<String> {
+    js_sys::Reflect::get(detail, &wasm_bindgen::JsValue::from_str(key))
+        .ok()
+        .and_then(|v| v.as_string())
+}
+
+pub fn install_terminal_clipboard_listeners(
+    menu_state: RwSignal<Option<TerminalContextMenuState>>,
+    i18n: I18nService,
+    toast: ToastService,
+) -> impl FnOnce() + 'static {
+    let contextmenu_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped(
+            "blxcode-terminal-contextmenu",
+            {
+                move |ev| {
+                    let Some(ce) = ev.dyn_ref::<web_sys::CustomEvent>() else {
+                        return;
+                    };
+                    let detail = ce.detail();
+                    let Some(term_id) = detail_f64(&detail, "termId") else {
+                        return;
+                    };
+                    let Some(anchor_x) = detail_i32(&detail, "clientX") else {
+                        return;
+                    };
+                    let Some(anchor_y) = detail_i32(&detail, "clientY") else {
+                        return;
+                    };
+                    let has_selection = detail_bool(&detail, "hasSelection")
+                        || detail_string(&detail, "selection")
+                            .is_some_and(|s| !s.is_empty());
+                    menu_state.set(Some(TerminalContextMenuState {
+                        term_id,
+                        anchor_x,
+                        anchor_y,
+                        has_selection,
+                    }));
+                }
+            },
+        );
+
+    let paste_handle = leptos::leptos_dom::helpers::window_event_listener_untyped(
+        "blxcode-terminal-paste-request",
+        {
+            let i18n = i18n.clone();
+            let toast = toast.clone();
+            move |ev| {
+                let Some(ce) = ev.dyn_ref::<web_sys::CustomEvent>() else {
+                    return;
+                };
+                let detail = ce.detail();
+                let Some(term_id) = detail_f64(&detail, "termId") else {
+                    return;
+                };
+                paste_terminal_from_clipboard(term_id, i18n.clone(), toast.clone());
+            }
+        },
+    );
+
+    let copy_handle = leptos::leptos_dom::helpers::window_event_listener_untyped(
+        "blxcode-terminal-copy-request",
+        {
+            let i18n = i18n.clone();
+            let toast = toast.clone();
+            move |ev| {
+                let Some(ce) = ev.dyn_ref::<web_sys::CustomEvent>() else {
+                    return;
+                };
+                let detail = ce.detail();
+                let Some(term_id) = detail_f64(&detail, "termId") else {
+                    return;
+                };
+                let selection = detail_string(&detail, "selection");
+                copy_terminal_selection(term_id, selection, i18n.clone(), toast.clone());
+            }
+        },
+    );
+
+    let click_close_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped("mousedown", {
+            let menu_state = menu_state;
+            move |_| {
+                if menu_state.get_untracked().is_some() {
+                    menu_state.set(None);
+                }
+            }
+        });
+
+    let escape_handle =
+        leptos::leptos_dom::helpers::window_event_listener_untyped("keydown", {
+            let menu_state = menu_state;
+            move |ev| {
+                let Some(kev) = ev.dyn_ref::<web_sys::KeyboardEvent>() else {
+                    return;
+                };
+                if kev.key() == "Escape" && menu_state.get_untracked().is_some() {
+                    menu_state.set(None);
+                }
+            }
+        });
+
+    move || {
+        drop(contextmenu_handle);
+        drop(paste_handle);
+        drop(copy_handle);
+        drop(click_close_handle);
+        drop(escape_handle);
+    }
+}
diff --git a/src/workbench/terminal_glue.rs b/src/workbench/terminal_glue.rs
index 582d40d..4e24f06 100644
--- a/src/workbench/terminal_glue.rs
+++ b/src/workbench/terminal_glue.rs
@@ -177,6 +177,70 @@ pub fn terminal_set_stdin_enabled(term_id: f64, enabled: bool) {
     }
 }
 
+fn call_term_id_method(term_id: f64, method: &str) {
+    let Some(w) = web_sys::window() else {
+        return;
+    };
+    let Ok(root) = Reflect::get(&w, &wasm_bindgen::JsValue::from_str("__blxcodeTerminal")) else {
+        return;
+    };
+    let Ok(method_fn) = Reflect::get(&root, &wasm_bindgen::JsValue::from_str(method)) else {
+        return;
+    };
+    if let Some(f) = method_fn.dyn_ref::<Function>() {
+        let _ = f.call1(&root, &wasm_bindgen::JsValue::from_f64(term_id));
+    }
+}
+
+pub fn terminal_get_selection(term_id: f64) -> String {
+    let Some(w) = web_sys::window() else {
+        return String::new();
+    };
+    let Ok(root) = Reflect::get(&w, &wasm_bindgen::JsValue::from_str("__blxcodeTerminal")) else {
+        return String::new();
+    };
+    let Ok(get_sel) = Reflect::get(&root, &wasm_bindgen::JsValue::from_str("getSelection")) else {
+        return String::new();
+    };
+    if let Some(f) = get_sel.dyn_ref::<Function>() {
+        if let Ok(v) = f.call1(&root, &wasm_bindgen::JsValue::from_f64(term_id)) {
+            return v.as_string().unwrap_or_default();
+        }
+    }
+    String::new()
+}
+
+pub fn terminal_paste(term_id: f64, text: &str) {
+    let Some(w) = web_sys::window() else {
+        return;
+    };
+    let Ok(root) = Reflect::get(&w, &wasm_bindgen::JsValue::from_str("__blxcodeTerminal")) else {
+        return;
+    };
+    let Ok(paste_fn) = Reflect::get(&root, &wasm_bindgen::JsValue::from_str("paste")) else {
+        return;
+    };
+    if let Some(f) = paste_fn.dyn_ref::<Function>() {
+        let _ = f.call2(
+            &root,
+            &wasm_bindgen::JsValue::from_f64(term_id),
+            &wasm_bindgen::JsValue::from_str(text),
+        );
+    }
+}
+
+pub fn terminal_select_all(term_id: f64) {
+    call_term_id_method(term_id, "selectAll");
+}
+
+pub fn terminal_clear_selection(term_id: f64) {
+    call_term_id_method(term_id, "clearSelection");
+}
+
+pub fn terminal_focus(term_id: f64) {
+    call_term_id_method(term_id, "focus");
+}
+
 pub fn terminal_observe_workspace_grid(container: &HtmlElement, workspace_id: u64) {
     let Some(w) = web_sys::window() else {
         return;
diff --git a/src/workbench/workspace_panel.rs b/src/workbench/workspace_panel.rs
index 53f9b15..26eef5c 100644
--- a/src/workbench/workspace_panel.rs
+++ b/src/workbench/workspace_panel.rs
@@ -14,6 +14,10 @@ use crate::workbench::state::{
     RightPanelTab, TerminalSplitAxis, WorkspaceEntry, CENTER_TERMINALS_TAB_ID,
 };
 use crate::workbench::terminal_cell::WorkspaceTerminalCell;
+use crate::workbench::terminal_context_menu::{
+    dispatch_terminal_menu_action, install_terminal_clipboard_listeners, TerminalContextMenu,
+    TerminalContextMenuState, TerminalMenuAction,
+};
 use crate::workbench::terminal_glue::{
     terminal_observe_workspace_grid, terminal_unobserve_workspace_grid,
 };
@@ -22,6 +26,7 @@ use crate::workbench::terminal_slot_dnd::{
     TerminalSlotDragService,
 };
 use crate::workbench::WorkbenchService;
+use crate::workbench::toast::ToastService;
 use gloo_timers::future::TimeoutFuture;
 use leptos::callback::Callback;
 use leptos::html;
@@ -56,8 +61,24 @@ struct TerminalRenderSlot {
 pub fn WorkspacePanel() -> impl IntoView {
     let wb = expect_context::<WorkbenchService>();
     let i18n = expect_context::<I18nService>();
+    let toast = expect_context::<ToastService>();
     let workspaces = wb.workspaces();
     let active_id = wb.active_id();
+    let term_menu_state: RwSignal<Option<TerminalContextMenuState>> = RwSignal::new(None);
+
+    on_cleanup(install_terminal_clipboard_listeners(
+        term_menu_state,
+        i18n,
+        toast,
+    ));
+
+    let on_term_menu_action = Callback::new(move |action: TerminalMenuAction| {
+        let Some(menu) = term_menu_state.get_untracked() else {
+            return;
+        };
+        term_menu_state.set(None);
+        dispatch_terminal_menu_action(action, menu.term_id, i18n, toast);
+    });
 
     view! {
         <section
@@ -84,6 +105,7 @@ pub fn WorkspacePanel() -> impl IntoView {
                     />
                 </Show>
             </div>
+            <TerminalContextMenu state=term_menu_state on_action=on_term_menu_action />
         </section>
     }
 }
diff --git a/styles.css b/styles.css
index 762e556..047578c 100644
--- a/styles.css
+++ b/styles.css
@@ -5704,6 +5704,46 @@ button {
   background: var(--overlay-2);
 }
 
+.terminal-context-menu {
+  position: fixed;
+  z-index: 1100;
+  min-width: 11rem;
+  padding: 0.25rem;
+  border: 1px solid var(--border-strong);
+  border-radius: 6px;
+  background: var(--bg-panel);
+  box-shadow: 0 16px 40px var(--scrim-bg);
+  font-size: 0.78rem;
+  color: var(--text);
+  user-select: none;
+  -webkit-user-select: none;
+}
+
+.terminal-context-menu__item {
+  display: flex;
+  align-items: center;
+  width: 100%;
+  border: 0;
+  border-radius: 4px;
+  padding: 0.35rem 0.55rem;
+  text-align: left;
+  font: inherit;
+  font-size: 0.78rem;
+  color: var(--text);
+  background: transparent;
+  cursor: pointer;
+}
+
+.terminal-context-menu__item:hover:not(:disabled),
+.terminal-context-menu__item:focus-visible:not(:disabled) {
+  background: var(--overlay-2);
+}
+
+.terminal-context-menu__item:disabled {
+  opacity: 0.45;
+  cursor: default;
+}
+
 /* highlight.js token color mapping (works for both blxcode-dark and -light
    themes thanks to color-mix on the accent / text tokens). */
 .code-view.hljs {

From 746842c0a3e48a6e2d17bdc11b9707109014e03c Mon Sep 17 00:00:00 2001
From: iptoux <iptoux@gmail.com>
Date: Wed, 27 May 2026 20:10:45 +0200
Subject: [PATCH 8/8] docs(changelog): document windows_and branch features and
 fixes

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 CHANGELOG.md | 42 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 41 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f505944..f32223e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,14 +9,54 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- **Sidebar File Diff section + center diff viewer**: new collapsible **File Diff** panel sits between Project Files and Git Commits in the sidebar. Backend module `src-tauri/src/git_status.rs` exposes `git_status_changes` (`git status --porcelain=v1 -z` + merged `--numstat` for staged/unstaged, untracked line counts via file read), `git_file_diff` (unified diff, synthetic `+++` body for untracked files), `git_stage_file` / `git_unstage_file`, and `git_status_watch_start` / `git_status_watch_stop` — a `notify`-based recursive watcher on the work tree (debounced 300 ms) emits `git_status_dirty` via Tauri so the UI refreshes without manual polling. `ChangedFile` rows show a status marker (`M`/`A`/`D`/`R`/`?`/`C`), path, and `+N`/`-N` counts; hover reveals **stage** (`+`) and **unstage** (`−`) actions. Clicking a row opens (or focuses) a `CenterTabKind::FileDiff { rel_path, staged }` tab with an inline diff viewer (`src/workbench/file_diff/`) that classifies lines (`@@` hunk headers, `+`/`-`/`---`/`+++`). Frontend bridge mirrors all types and adds `listen_git_status_dirty` with an RAII `TauriEventListener`. Per-workspace `sidebar_diff_open` (default **open**) persists expand/collapse; `open_center_diff_tab` deduplicates tabs per path. Sidebar panels block is now a **three-slot** layout (Explorer → Diff → Graph) with two `SidebarResizer` handles and `SIDEBAR_DIFF_HEIGHT_PCT_*` in `localStorage`. 18 new `SbDiff*` i18n keys in all 13 locales. Component CSS in `file_diff_section/file-diff-section.css` and `file_diff/file-diff.css` (theme tokens only).
+- **Sidebar File Diff section + center diff viewer**: new collapsible **File Diff** panel sits between Project Files and Git Commits in the sidebar. Backend module `src-tauri/src/git_status.rs` exposes `git_status_changes` (`git status --porcelain=v1 -z` + merged `--numstat` for staged/unstaged, untracked line counts via file read), `git_file_diff` (unified diff, synthetic `+++` body for untracked files), `git_stage_file` / `git_unstage_file`, and `git_status_watch_start` / `git_status_watch_stop` — a `notify`-based recursive watcher on the work tree (debounced 300 ms) emits `git_status_dirty` via Tauri so the UI refreshes without manual polling. `ChangedFile` rows show a status marker (`M`/`A`/`D`/`R`/`?`/`C`), path, and `+N`/`-N` counts; hover reveals **stage** (`+`) and **unstage** (`−`) actions. Clicking a row opens (or focuses) a `CenterTabKind::FileDiff { rel_path, staged }` tab with an inline diff viewer (`src/workbench/file_diff/`) that classifies lines (`@@` hunk headers, `+`/`-`/`---`/`+++`). Frontend bridge mirrors all types and adds `listen_git_status_dirty` with an RAII `TauriEventListener`. Per-workspace `sidebar_diff_open` (default **open**) persists expand/collapse; `open_center_diff_tab` deduplicates tabs per path. Sidebar panels block is now a **three-slot** layout (Explorer → Diff → Graph) with two `SidebarResizer` handles and `SIDEBAR_DIFF_HEIGHT_PCT_*` in `localStorage`. 18+ new `SbDiff*` i18n keys in all 13 locales. Component CSS in `file_diff_section/file-diff-section.css` and `file_diff/file-diff.css` (theme tokens only).
+
+- **Terminal context menu + native clipboard (Linux-safe)**: workspace xterm terminals now expose a right-click context menu with **Copy**, **Paste**, and **Select all** (`src/workbench/terminal_context_menu.rs`, mounted from `WorkspacePanel`). **Shift+right-click** pastes directly (Linux terminal convention). Keyboard shortcuts: **Ctrl+Shift+C/V** for copy/paste; **Ctrl+C** copies only when text is selected, otherwise SIGINT goes to the shell. Clipboard I/O bypasses the unreliable WebKitGTK `navigator.clipboard` path via new Tauri commands `clipboard_read_text` / `clipboard_write_text` backed by **`arboard`** (`src-tauri/src/clipboard.rs`, X11 + Wayland); the frontend uses `clipboard_*_text_compat()` in `tauri_bridge.rs` with a Web Clipboard fallback for `trunk serve`. `public/terminal_bootstrap.mjs` dispatches `blxcode-terminal-contextmenu`, `blxcode-terminal-paste-request`, and `blxcode-terminal-copy-request` custom events; `terminal_glue.rs` gained `getSelection`, `paste`, `selectAll`, `clearSelection`, and `focus` wrappers. Copy clears selection only after a successful write; failures surface as toasts (`WsTermToastCopyFailed` / `WsTermToastPasteFailed`). Global `contextmenu` suppression in `workbench/mod.rs` skips `.ws-term-cell__xterm` / `.xterm` targets. 7 new `WsTermMenu*` / `WsTermToast*` i18n keys in all 13 locales. CSS: `.terminal-context-menu` in `styles.css`.
+
+- **Linux browser boot-crash fix (sticky lazy mount + iframe visibility gating)**: `BrowserTabDock` no longer mounts `<iframe>` elements at workbench boot when the Browser tab is inactive — WebKitGTK in the Tauri main webview previously crashed on immediate iframe loads with the default URL. `right_panel.rs` wraps `BrowserTabDock` in a sticky `<Show>` driven by `browser_dock_mounted` (first Browser-tab visit mounts; DOM node stays for tab switches without reload). `browser_tab.rs` gates iframe `src` and the iframable probe behind `browser_layer_visible(wb)` (`right_active_tab == Browser && !right_collapsed`); hidden state uses `about:blank`. Plan documented in `.agents/plans/linux-browser-iframe-boot-fix.md`.
+
+- **Memory panel: agent pointers + bootstrap onboarding**: new **Agent memory pointers** flow installs marked blocks into existing agent policy files (`CLAUDE.md`, `AGENTS.md`, etc.) so external agents know where BLXCode memory lives. Backend `memory_pointer_status` / `memory_install_pointers` / `memory_uninstall_pointers` in the refactored memory store; frontend adds `MemoryPointersNotice`, `MemoryPointersDialog`, and per-agent checkbox rows (`PointerAgent` catalog incl. OpenCode brand icon). **Bootstrap cards** (`MemoryBootstrapView` / `MemoryBootstrapCard`) prompt workspace + global memory setup when directories are empty. `memory_status` drives pointer-status signals; global README preview loads on panel open.
+
+- **Memory backend module split**: monolithic `src-tauri/src/memory.rs` (~1.3k lines) refactored into `memory/{mod,store,paths,types,graph,frontmatter,wikilinks}.rs` — same Tauri command surface, clearer separation of CRUD, graph, wikilink parsing, and path resolution.
+
+- **Agent timeline: tool activity paths**: tool rows in the agent chat timeline now show workspace-relative **file paths** touched by each tool call (`tool.paths`, rendered as `tool-row-paths` with filename tails via `path_tail()`). `TurnUsageKind::ToolExec` metrics attach per tool row for main-agent and subagent cards.
+
+- **Right-panel settings shortcut**: gear button in the right-panel header and collapsed rail opens **Settings → App** via `open_center_settings_tab(HarnessSettingsCategory::App)` without hunting the command palette.
+
+- **Extension-less policy doc preview types**: `classify_policy` / `FilePreviewDock` now recognize `SUPPORT`, `AGENTS`, `CLAUDE`, `CODEX`, and `GEMINI` stems (plus existing LICENSE/CONTRIBUTING/README variants) with dedicated hero banners (`FilePreviewPolicySupport/Agents/Claude/Codex/Gemini` title + subtitle keys in all locales).
+
+- **Memory search scope filters + global note creation**: search tab adds **Workspace** / **Global** filter toggles (`MemSearchFilterWorkspace`, `MemSearchFilterGlobal`); Files tab header gains **Create global note** (`MemGlobalCreate`).
+
+- **Sidebar Git Graph height floor**: new `SIDEBAR_GRAPH_HEIGHT_PCT_MIN` (12 %) in `app.config.rs`; sidebar resizer logic accounts for the three-slot layout (Explorer → Diff → Graph) when computing drag bounds.
 
 ### Changed
 
+- **File Diff sidebar: staged / unstaged groups**: the File Diff section now partitions changed files into collapsible **Staged** and **Unstaged** groups (`DiffGroupVariant`, `SbDiffGroupStaged/Unstaged`, expand/collapse labels, `SbDiffListAria`). Two-tier debounce on `git_status_dirty` (200 ms frontend + 300 ms backend) prevents duplicate reloads during fast index churn.
+
 - **Git Commits auto-refresh**: `GitGraphSection` now listens to the same `git_status_dirty` event (400 ms debounced reload) so the commit graph updates when the index or working tree changes, without a manual refresh.
 
+- **Terminal UX polish**: xterm `selectionBackground` uses `--accent-soft` for clearer drag-selection feedback; scrollback raised to **5000** lines (`terminal_bootstrap.mjs`).
+
+- **Browser host: main-thread navigation**: `browser_navigate` / `browser_sync_bounds` / `browser_close_tab` Tauri commands now run on the main thread (`run_on_main_thread`) for stable WebKitGTK / wry behavior on Linux.
+
+- **Memory panel layout refresh**: expanded Files-tree spacing, grouped Memory/Learnings sections with expand/collapse, editor/preview toggle refinements, and `.workbench-memory-files__*` CSS overhaul (~370 lines in `styles.css`). Clicking the tree spacer or background clears the active note selection (`clear_memory_selection`).
+
+- **File Diff section styling**: toolbar + list chrome aligned with other sidebar view sections; group headers, row hover, and stage/unstage affordances restyled in `file-diff-section.css`.
+
+- **Agent / subagent Rust modules**: broad `thiserror` + `Display` cleanup across `src-tauri/src/agent/*`, `skills_rules`, `plans`, `image`, and `voice` — consistent `{err}` formatting instead of `{err:?}` in user-facing strings; subagent runner prompt and tool-group wiring tightened.
+
+- **CI / developer tooling**: removed repo-level `rustc-wrapper = "sccache"` from `.cargo/config.toml` (sccache unavailable on CI runners); developers opt in via user-level `~/.cargo/config.toml` instead.
+
 ### Fixed
 
+- **Linux workbench boot crash (embedded browser iframe)**: see *sticky lazy mount* entry above — prevents WebKitGTK crash when Browser tab was never opened.
+
+- **Terminal copy/paste silently failing on Linux**: replaced swallowed `navigator.clipboard` calls with native `arboard` IPC; see *Terminal context menu* entry above.
+
+- **PTY spawn with null-padded cwd**: `pty_host.rs` trims `\0` bytes from the working-directory string before `PathBuf` conversion, fixing spurious spawn failures when the cwd arrives null-terminated from IPC.
+
+- **Browser navigate empty URL**: `browser_host.rs` rejects blank URLs early instead of passing them to WebKit.
+
 - **Git commit graph `git log` invocation**: `fetch_graph_entries` passed `-c log.graphWidth=14` as a single argv token, which Git rejects (`unknown option: -c log.graphWidth=14`) and surfaced in the UI as "Could not load commit history." even though the repository was detected and File Diff worked. Split into `-c` + `log.graphWidth=14` as separate arguments.
 
 ### Removed