diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3fd84dd..135bab0 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -110,7 +110,7 @@ jobs:
           releaseBody: |
             See the assets below to download this version.
           releaseDraft: false
-          prerelease: false
+          prerelease: ${{ contains(github.ref_name, '-') }}
           updaterJsonPreferNsis: true
           updaterKeepSingleGroup: true
           args: ${{ matrix.settings.args }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 72da518..882b38a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,22 @@
+## [0.3.1-beta.1] — 2026-07-09
+
+### Added
+- **Document tree UX overhaul** — full hierarchy view with folder/file icons, recursive tree, and slide transitions (#157)
+- **Clickable breadcrumbs** — every ancestor crumb navigates to its parent/sub-doc; resolves the materialized path client-side with no extra requests (#161)
+
+### Fixed
+- **Document tree only showed ~5 docs** — `doc_list` now defaults `limit` to 1000 (uteke-serve's `/doc/list` default of 5 was capping the client-side tree) (#159)
+- **Folders couldn't be expanded/collapsed** — Svelte 5 reactivity bug: in-place `Set` mutation + same-ref reassign did not re-render `{@const}` reads; switched to immutable updates (#160)
+- **Delete failed with `400 Bad Request`** — require uteke ≥ 0.7.1 (0.7.0 lacks `/doc/delete`); the version gate now rejects 0.7.0 up front with an upgrade prompt (#159)
+- **False "uteke upgrade required" for remote users** — version gate used the local CLI version; now probes the remote server via `GET /health` and treats unknown remote versions leniently (#159)
+- View scroll reset + document namespace/version gate for uteke v0.7.0 (#154)
+
+### Changed
+- Removed the Participants tab from Rooms (#158)
+- Release workflow now marks hyphenated tags (e.g. `-beta.1`, `-rc.1`) as GitHub prereleases automatically
+
+---
+
 ## [0.3.0] — 2026-07-07
 
 ### Added
diff --git a/package-lock.json b/package-lock.json
index d209d70..8b2a154 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "corin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "corin",
-      "version": "0.2.0",
+      "version": "0.3.0",
       "dependencies": {
         "@codemirror/autocomplete": "^6.20.1",
         "@codemirror/commands": "^6.10.4",
diff --git a/package.json b/package.json
index 9c7d7af..7c989d3 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "corin",
   "private": true,
-  "version": "0.3.0",
+  "version": "0.3.1-beta.1",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 99107e4..6f51b32 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -400,7 +400,7 @@ dependencies = [
 
 [[package]]
 name = "corin"
-version = "0.2.0"
+version = "0.3.1-beta.1"
 dependencies = [
  "chrono",
  "dirs",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 854ef08..c1dd6f8 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "corin"
-version = "0.2.0"
+version = "0.3.1-beta.1"
 edition = "2024"
 description = "CorIn — Cora Intelligence. Desktop knowledge workstation."
 
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
index 0898954..dd04aaa 100644
--- a/src-tauri/src/commands.rs
+++ b/src-tauri/src/commands.rs
@@ -114,6 +114,17 @@ pub struct AppState {
     /// HTTP client for uteke-serve (all memory CRUD + graph operations).
     /// None if server is not running.
     pub uteke_client: Option<crate::uteke_client::UtekeClient>,
+    /// Cached installed uteke version ("X.Y.Z"), probed once at startup.
+    /// For local servers this is the `uteke --version` CLI output; for remote
+    /// servers it is the version reported by the server's `/health` (if any).
+    /// `None` if unknown. Used to gate features that require a minimum server
+    /// version (e.g. Documents → 0.7.1).
+    pub uteke_version: Option<String>,
+    /// `true` when Corin talks to a remote uteke-serve (https/host URL).
+    /// Remote servers are user-managed, so an unknown version is treated
+    /// leniently (no upgrade banner, no hard gate) — the server's own
+    /// responses surface any real incompatibility.
+    pub uteke_remote: bool,
 }
 
 // ---------------------------------------------------------------------------
@@ -2662,16 +2673,171 @@ pub async fn disconnect_connection(
 }
 
 // ── Document Engine (uteke-serve /doc/*) ─────────────────────────────
+//
+// Since uteke v0.7.0 (#614) documents are global — unique slugs across all
+// namespaces. `namespace` is no longer accepted. Every command gates on
+// `MIN_UTEKE_FOR_DOCS` ("0.7.1") so older servers never get ambiguous
+// global-slug requests. Frontend reads `uteke_version_status` to render an
+// upgrade banner; `uteke_self_update` runs `uteke upgrade` and re-detects.
+
+/// Installed vs required uteke version (for the Documents feature).
+#[derive(Debug, Clone, Serialize)]
+pub struct VersionStatus {
+    /// Detected `X.Y.Z`, or `None` if the `uteke` CLI couldn't be probed.
+    pub current: Option<String>,
+    /// Minimum uteke version that supports global documents ("0.7.1").
+    pub required: String,
+    /// `true` iff `current >= required` (false when current is unknown).
+    pub supported: bool,
+}
+
+/// Resolve the effective uteke version for gating.
+///
+/// - **Remote server**: probe the server's self-reported version via
+///   `/health` (authoritative for a user-managed server). The local CLI
+///   version is irrelevant — it may be older or newer than the server.
+/// - **Local server**: use the cached `uteke --version` output.
+async fn resolve_uteke_version(
+    state: &tauri::State<'_, Arc<Mutex<AppState>>>,
+) -> (bool, Option<String>) {
+    let (is_remote, client, cached) = {
+        let s = state.lock().await;
+        (
+            s.uteke_remote,
+            s.uteke_client.clone(),
+            s.uteke_version.clone(),
+        )
+    };
+    if is_remote {
+        if let Some(client) = client
+            && client.is_available().await
+        {
+            let v = client.server_version().await;
+            return (true, v);
+        }
+        // Remote unreachable during this probe — fall back to whatever we know.
+        (true, cached)
+    } else {
+        (false, cached)
+    }
+}
+
+/// Reject the call unless the effective uteke version meets `min`.
+///
+/// For **remote** servers with an unknown version (e.g. an older server
+/// that doesn't report version in `/health`) the call is allowed through —
+/// remote servers are user-managed, and the server's own response surfaces
+/// any real incompatibility (e.g. a 404/400 for a missing route).
+async fn require_uteke_version(
+    state: &tauri::State<'_, Arc<Mutex<AppState>>>,
+    min: &str,
+) -> Result<(), CommandError> {
+    let (is_remote, current) = resolve_uteke_version(state).await;
+    let ok = current
+        .as_ref()
+        .map(|c| crate::version_meets(c, min))
+        // Remote + unknown version → don't block (user-managed server).
+        // Local + unknown version → block (we can't confirm capability).
+        .unwrap_or(is_remote);
+    if ok {
+        Ok(())
+    } else {
+        let hint = if is_remote {
+            "upgrade the uteke-serve on the remote host"
+        } else {
+            "run 'uteke upgrade' or use the Update button in Documents"
+        };
+        Err(CommandError::Uteke(format!(
+            "uteke {min} or newer is required for documents (current: {}). Please {hint}.",
+            current.as_deref().unwrap_or("unknown")
+        )))
+    }
+}
+
+/// Report the effective uteke version and whether it supports Documents.
+///
+/// Drives the Documents upgrade banner. For remote servers with an unknown
+/// version, `supported` is `true` so users are not nagged to upgrade a server
+/// they manage (and which may well be newer than the local CLI).
+#[tauri::command]
+pub async fn uteke_version_status(
+    state: tauri::State<'_, Arc<Mutex<AppState>>>,
+) -> Result<VersionStatus, CommandError> {
+    let (is_remote, current) = resolve_uteke_version(&state).await;
+    let supported = current
+        .as_ref()
+        .map(|c| crate::version_meets(c, crate::MIN_UTEKE_FOR_DOCS))
+        .unwrap_or(is_remote);
+    Ok(VersionStatus {
+        current,
+        required: crate::MIN_UTEKE_FOR_DOCS.to_string(),
+        supported,
+    })
+}
+
+/// Run `uteke upgrade`, then re-detect and cache the version.
+///
+/// Returns the post-upgrade `VersionStatus`. Errors if the `uteke` CLI is
+/// missing or the upgrade exits non-zero.
+#[tauri::command]
+pub async fn uteke_self_update(
+    state: tauri::State<'_, Arc<Mutex<AppState>>>,
+) -> Result<VersionStatus, CommandError> {
+    let is_remote = state.lock().await.uteke_remote;
+    if is_remote {
+        // Upgrading the local CLI won't affect a user-managed remote server.
+        // Just re-probe the server's version so the banner can refresh.
+        let (_, current) = resolve_uteke_version(&state).await;
+        let supported = current
+            .as_ref()
+            .map(|c| crate::version_meets(c, crate::MIN_UTEKE_FOR_DOCS))
+            .unwrap_or(true);
+        return Ok(VersionStatus {
+            current,
+            required: crate::MIN_UTEKE_FOR_DOCS.to_string(),
+            supported,
+        });
+    }
+    let uteke = crate::find_uteke_cli().ok_or_else(|| {
+        CommandError::Uteke("uteke CLI not found — install via the setup script".into())
+    })?;
+    let out = tokio::process::Command::new(&uteke)
+        .arg("upgrade")
+        .stdin(std::process::Stdio::null())
+        .output()
+        .await
+        .map_err(|e| CommandError::Uteke(format!("failed to run 'uteke upgrade': {e}")))?;
+    if !out.status.success() {
+        let stderr = String::from_utf8_lossy(&out.stderr);
+        return Err(CommandError::Uteke(format!(
+            "'uteke upgrade' failed: {stderr}"
+        )));
+    }
+    let new_version = crate::detect_uteke_version();
+    {
+        let mut s = state.lock().await;
+        s.uteke_version = new_version.clone();
+    }
+    let supported = new_version
+        .as_ref()
+        .map(|c| crate::version_meets(c, crate::MIN_UTEKE_FOR_DOCS))
+        .unwrap_or(false);
+    Ok(VersionStatus {
+        current: new_version,
+        required: crate::MIN_UTEKE_FOR_DOCS.to_string(),
+        supported,
+    })
+}
 
 /// List documents via uteke-serve POST /doc/list.
 #[tauri::command]
 pub async fn doc_list(
     state: tauri::State<'_, Arc<Mutex<AppState>>>,
-    namespace: Option<String>,
     limit: Option<usize>,
     roots_only: Option<bool>,
     parent: Option<String>,
 ) -> Result<Vec<serde_json::Value>, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let client = {
         let s = state.lock().await;
         s.uteke_client.clone()
@@ -2682,8 +2848,11 @@ pub async fn doc_list(
     if !client.is_available().await {
         return Err(CommandError::Uteke("uteke-serve not reachable".into()));
     }
+    // uteke-serve defaults /doc/list limit to 5 (shared with memory pagination).
+    // The document tree needs the full set client-side, so default high here.
+    let limit = Some(limit.unwrap_or(1000));
     let docs = client
-        .doc_list(namespace.as_deref(), limit, roots_only, parent.as_deref())
+        .doc_list(limit, roots_only, parent.as_deref())
         .await
         .map_err(|e| CommandError::Uteke(e.to_string()))?;
     Ok(docs
@@ -2698,8 +2867,8 @@ pub async fn doc_get(
     state: tauri::State<'_, Arc<Mutex<AppState>>>,
     slug: Option<String>,
     id: Option<String>,
-    namespace: Option<String>,
 ) -> Result<serde_json::Value, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let client = {
         let s = state.lock().await;
         s.uteke_client.clone()
@@ -2708,7 +2877,7 @@ pub async fn doc_get(
         return Err(CommandError::Uteke("uteke-serve not running".into()));
     };
     let doc = client
-        .doc_get(slug.as_deref(), id.as_deref(), namespace.as_deref())
+        .doc_get(slug.as_deref(), id.as_deref())
         .await
         .map_err(|e| CommandError::Uteke(e.to_string()))?;
     Ok(serde_json::to_value(doc).unwrap_or_default())
@@ -2721,10 +2890,10 @@ pub async fn doc_create(
     slug: String,
     title: String,
     content: String,
-    namespace: Option<String>,
     tags: Option<Vec<String>>,
     parent: Option<String>,
 ) -> Result<serde_json::Value, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let tags = tags.unwrap_or_default();
     let client = {
         let s = state.lock().await;
@@ -2734,14 +2903,7 @@ pub async fn doc_create(
         return Err(CommandError::Uteke("uteke-serve not running".into()));
     };
     let doc = client
-        .doc_create(
-            &slug,
-            &title,
-            &content,
-            namespace.as_deref(),
-            &tags,
-            parent.as_deref(),
-        )
+        .doc_create(&slug, &title, &content, &tags, parent.as_deref())
         .await
         .map_err(|e| CommandError::Uteke(e.to_string()))?;
     Ok(serde_json::to_value(doc).unwrap_or_default())
@@ -2756,8 +2918,8 @@ pub async fn doc_update(
     title: Option<String>,
     content: Option<String>,
     tags: Option<Vec<String>>,
-    namespace: Option<String>,
 ) -> Result<serde_json::Value, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let id_or_slug = id
         .or(slug)
         .ok_or_else(|| CommandError::Uteke("provide either 'id' or 'slug'".into()))?;
@@ -2771,7 +2933,6 @@ pub async fn doc_update(
     let doc = client
         .doc_update(
             &id_or_slug,
-            namespace.as_deref(),
             title.as_deref(),
             content.as_deref(),
             tags.as_deref(),
@@ -2787,10 +2948,10 @@ pub async fn doc_update(
 pub async fn doc_search(
     state: tauri::State<'_, Arc<Mutex<AppState>>>,
     query: String,
-    namespace: Option<String>,
     limit: Option<usize>,
     mode: Option<String>,
 ) -> Result<Vec<serde_json::Value>, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let client = {
         let s = state.lock().await;
         s.uteke_client.clone()
@@ -2799,7 +2960,7 @@ pub async fn doc_search(
         return Err(CommandError::Uteke("uteke-serve not running".into()));
     };
     let results = client
-        .doc_search(&query, namespace.as_deref(), limit, mode.as_deref())
+        .doc_search(&query, limit, mode.as_deref())
         .await
         .map_err(|e| CommandError::Uteke(e.to_string()))?;
     Ok(results
@@ -2815,6 +2976,7 @@ pub async fn doc_delete(
     id: Option<String>,
     slug: Option<String>,
 ) -> Result<(), CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let client = {
         let s = state.lock().await;
         s.uteke_client.clone()
@@ -2835,8 +2997,8 @@ pub async fn doc_move(
     id: Option<String>,
     slug: Option<String>,
     new_parent: Option<String>,
-    namespace: Option<String>,
 ) -> Result<serde_json::Value, CommandError> {
+    require_uteke_version(&state, crate::MIN_UTEKE_FOR_DOCS).await?;
     let client = {
         let s = state.lock().await;
         s.uteke_client.clone()
@@ -2845,12 +3007,7 @@ pub async fn doc_move(
         return Err(CommandError::Uteke("uteke-serve not running".into()));
     };
     let result = client
-        .doc_move(
-            id.as_deref(),
-            slug.as_deref(),
-            new_parent.as_deref(),
-            namespace.as_deref(),
-        )
+        .doc_move(id.as_deref(), slug.as_deref(), new_parent.as_deref())
         .await
         .map_err(|e| CommandError::Uteke(e.to_string()))?;
     Ok(result)
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 19c28ae..c292ac1 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -195,6 +195,67 @@ fn find_uteke_serve() -> Option<std::path::PathBuf> {
     None
 }
 
+/// Minimum uteke version required for the global Documents feature.
+/// v0.7.0 introduced global docs (#614), but document delete/move landed in
+/// v0.7.1 — require it so the full doc feature set is available.
+pub(crate) const MIN_UTEKE_FOR_DOCS: &str = "0.7.1";
+
+/// Find the `uteke` CLI binary in PATH or ~/.local/bin.
+pub(crate) fn find_uteke_cli() -> Option<std::path::PathBuf> {
+    if let Some(p) = find_in_path("uteke") {
+        return Some(p);
+    }
+    if let Some(home) = dirs::home_dir() {
+        let candidate = home.join(".local/bin/uteke");
+        if candidate.is_file() {
+            return Some(candidate);
+        }
+    }
+    None
+}
+
+/// Detect the installed uteke CLI version by shelling `uteke --version`.
+///
+/// Returns the parsed `X.Y.Z` string (e.g. `"0.7.0"`), or `None` if the
+/// binary is missing or the output can't be parsed. The HTTP server exposes
+/// no version endpoint, so the CLI is the only source of truth.
+pub(crate) fn detect_uteke_version() -> Option<String> {
+    let uteke = find_uteke_cli()?;
+    let out = std::process::Command::new(uteke)
+        .arg("--version")
+        .stdin(std::process::Stdio::null())
+        .output()
+        .ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    // Output looks like "uteke 0.7.0". Take the last whitespace-separated token
+    // that contains a '.' so stray suffixes don't leak in.
+    String::from_utf8_lossy(&out.stdout)
+        .split_whitespace()
+        .last()
+        .filter(|s| s.contains('.'))
+        .map(|s| s.to_string())
+}
+
+/// Compare two `X.Y.Z` version strings. Returns `true` if `current >= min`.
+///
+/// If either side fails to parse, returns `false` — conservative, so an
+/// unknown/unparseable version prompts an upgrade rather than passing.
+pub(crate) fn version_meets(current: &str, min: &str) -> bool {
+    fn parse(v: &str) -> Option<(u32, u32, u32)> {
+        let mut parts = v.split('.');
+        let major = parts.next()?.parse().ok()?;
+        let minor = parts.next()?.parse().ok()?;
+        let patch = parts.next().and_then(|p| p.parse().ok()).unwrap_or(0);
+        Some((major, minor, patch))
+    }
+    match (parse(current), parse(min)) {
+        (Some(c), Some(m)) => c >= m,
+        _ => false,
+    }
+}
+
 /// Run the official uteke install script.
 ///
 /// Downloads `install.sh` from GitHub and pipes it to `sh`.
@@ -369,6 +430,8 @@ pub fn run() {
             commands::reconnect_connection,
             commands::disconnect_connection,
             // Document Engine (#137)
+            commands::uteke_version_status,
+            commands::uteke_self_update,
             commands::doc_list,
             commands::doc_get,
             commands::doc_create,
@@ -447,6 +510,17 @@ pub fn run() {
                                 let client = UtekeClient::with_auth(&server_url, auth_token);
                                 s.uteke_client = Some(client);
                             }
+
+                            // Cache whether we're talking to a user-managed remote
+                            // server (vs. a locally spawned uteke-serve).
+                            s.uteke_remote = config::is_remote_url(&server_url);
+
+                            // Cache the installed uteke version for feature
+                            // gating (e.g. Documents requires >= 0.7.1).
+                            // For remote servers the authoritative version is
+                            // probed live from /health in the gating commands;
+                            // the local CLI version is only a fallback there.
+                            s.uteke_version = detect_uteke_version();
                         }
                         Err(e) => {
                             eprintln!("Failed to open database: {e}");
@@ -524,3 +598,39 @@ fn init_schema(conn: &rusqlite::Connection) -> Result<(), rusqlite::Error> {
     )?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn version_meets_equal_or_higher() {
+        assert!(version_meets("0.7.0", "0.7.0"));
+        assert!(version_meets("0.7.1", "0.7.0"));
+        assert!(version_meets("0.8.0", "0.7.0"));
+        assert!(version_meets("1.0.0", "0.7.0"));
+    }
+
+    #[test]
+    fn docs_gate_requires_0_7_1() {
+        // Document delete/move landed in 0.7.1; 0.7.0 must be rejected so the
+        // UI prompts for an upgrade instead of hitting a missing /doc/delete.
+        assert!(!version_meets("0.7.0", MIN_UTEKE_FOR_DOCS));
+        assert!(version_meets("0.7.1", MIN_UTEKE_FOR_DOCS));
+        assert!(version_meets("0.8.0", MIN_UTEKE_FOR_DOCS));
+    }
+
+    #[test]
+    fn version_meets_lower_rejected() {
+        assert!(!version_meets("0.6.7", "0.7.0"));
+        assert!(!version_meets("0.6.0", "0.7.0"));
+    }
+
+    #[test]
+    fn version_meets_unparseable_is_conservative() {
+        // A fully unparseable current must NOT pass the gate.
+        // (Pre-release suffixes like "0.7.0-rc" parse to 0.7.0 and are accepted —
+        // acceptable, since uteke ships clean semver tags in practice.)
+        assert!(!version_meets("unknown", "0.7.0"));
+    }
+}
diff --git a/src-tauri/src/uteke_client.rs b/src-tauri/src/uteke_client.rs
index 6d6ca0e..f5d99b0 100644
--- a/src-tauri/src/uteke_client.rs
+++ b/src-tauri/src/uteke_client.rs
@@ -286,6 +286,27 @@ impl UtekeClient {
             .unwrap_or(false)
     }
 
+    /// Probe the server's self-reported version via `/health`.
+    ///
+    /// Returns `Some("X.Y.Z")` when the server includes a `version` field
+    /// (uteke ≥ the /health-version patch), otherwise `None`. Used to gate
+    /// features for remote servers where the local `uteke` CLI version is
+    /// irrelevant — the server may be newer or older than the CLI.
+    pub async fn server_version(&self) -> Option<String> {
+        let resp = self
+            .authed(self.client.get(format!("{}/health", self.base_url)))
+            .send()
+            .await
+            .ok()?;
+        if !resp.status().is_success() {
+            return None;
+        }
+        let body: serde_json::Value = resp.json().await.ok()?;
+        body.get("version")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string())
+    }
+
     /// Semantic recall (vector + FTS5 hybrid search via RRF).
     pub async fn recall(
         &self,
@@ -928,6 +949,11 @@ impl UtekeClient {
     }
 
     // ── Documents (uteke-serve /doc/*) ─────────────────────────────────
+    //
+    // Since uteke v0.7.0 (#614) documents are GLOBAL — unique slugs across all
+    // namespaces. These methods send no `namespace`. Callers MUST gate access
+    // on `crate::MIN_UTEKE_FOR_DOCS` ("0.7.1") so older servers (where docs
+    // were namespace-scoped) never receive ambiguous global-slug requests.
 
     /// List documents via POST /doc/list.
     ///
@@ -935,15 +961,11 @@ impl UtekeClient {
     /// `parent` returns direct children of a specific document.
     pub async fn doc_list(
         &self,
-        namespace: Option<&str>,
         limit: Option<usize>,
         roots_only: Option<bool>,
         parent: Option<&str>,
     ) -> Result<Vec<UtekeDoc>, String> {
         let mut body = serde_json::json!({});
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
         if let Some(limit) = limit {
             body["limit"] = serde_json::json!(limit);
         }
@@ -966,12 +988,7 @@ impl UtekeClient {
     /// Get a single document via POST /doc/get.
     ///
     /// Accepts either `slug` or `id`. Returns full document with content.
-    pub async fn doc_get(
-        &self,
-        slug: Option<&str>,
-        id: Option<&str>,
-        namespace: Option<&str>,
-    ) -> Result<UtekeDoc, String> {
+    pub async fn doc_get(&self, slug: Option<&str>, id: Option<&str>) -> Result<UtekeDoc, String> {
         let mut body = serde_json::json!({});
         if let Some(s) = slug {
             body["slug"] = serde_json::Value::String(s.to_string());
@@ -979,9 +996,6 @@ impl UtekeClient {
         if let Some(i) = id {
             body["id"] = serde_json::Value::String(i.to_string());
         }
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
 
         let resp = self
             .authed(self.client.post(format!("{}/doc/get", self.base_url)))
@@ -998,7 +1012,6 @@ impl UtekeClient {
         slug: &str,
         title: &str,
         content: &str,
-        namespace: Option<&str>,
         tags: &[String],
         parent: Option<&str>,
     ) -> Result<UtekeDoc, String> {
@@ -1008,9 +1021,6 @@ impl UtekeClient {
             "content": content,
             "tags": tags,
         });
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
         if let Some(pid) = parent {
             body["parent"] = serde_json::Value::String(pid.to_string());
         }
@@ -1028,7 +1038,6 @@ impl UtekeClient {
     pub async fn doc_update(
         &self,
         id_or_slug: &str,
-        namespace: Option<&str>,
         title: Option<&str>,
         content: Option<&str>,
         tags: Option<&[String]>,
@@ -1045,9 +1054,6 @@ impl UtekeClient {
         } else {
             body["slug"] = serde_json::Value::String(id_or_slug.to_string());
         }
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
         if let Some(t) = title {
             body["title"] = serde_json::Value::String(t.to_string());
         }
@@ -1074,16 +1080,12 @@ impl UtekeClient {
     pub async fn doc_search(
         &self,
         query: &str,
-        namespace: Option<&str>,
         limit: Option<usize>,
         mode: Option<&str>,
     ) -> Result<Vec<DocSearchHit>, String> {
         let mut body = serde_json::json!({
             "query": query,
         });
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
         if let Some(limit) = limit {
             body["limit"] = serde_json::json!(limit);
         }
@@ -1127,7 +1129,6 @@ impl UtekeClient {
         id: Option<&str>,
         slug: Option<&str>,
         new_parent: Option<&str>,
-        namespace: Option<&str>,
     ) -> Result<serde_json::Value, String> {
         let mut body = serde_json::json!({});
         if let Some(i) = id {
@@ -1139,9 +1140,6 @@ impl UtekeClient {
         if let Some(np) = new_parent {
             body["new_parent"] = serde_json::Value::String(np.to_string());
         }
-        if let Some(ns) = namespace {
-            body["namespace"] = serde_json::Value::String(ns.to_string());
-        }
 
         let resp = self
             .authed(self.client.post(format!("{}/doc/move", self.base_url)))
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 1c74675..4fdb943 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-config-schema/schema.json",
   "productName": "CorIn",
-  "version": "0.3.0",
+  "version": "0.3.1-beta.1",
   "identifier": "dev.codecora.corin",
   "build": {
     "frontendDist": "../dist",
diff --git a/src/App.svelte b/src/App.svelte
index e30251d..0fe1d53 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -164,7 +164,7 @@
           {:else if activeView === 'rooms'}
             <RoomsView {namespace} onmemoryclick={openDetail} />
           {:else if activeView === 'documents'}
-            <DocumentsView {namespace} />
+            <DocumentsView />
           {/if}
         </div>
       {/key}
diff --git a/src/lib/components/Dashboard.svelte b/src/lib/components/Dashboard.svelte
index 49a71ff..ac6428c 100644
--- a/src/lib/components/Dashboard.svelte
+++ b/src/lib/components/Dashboard.svelte
@@ -82,7 +82,8 @@
     </button>
   </div>
 
-  {#if loading}
+  <div class="scroll-area">
+    {#if loading}
     <div class="loading">Loading...</div>
   {:else}
     <!-- Uteke stats -->
@@ -145,15 +146,27 @@
       {/if}
     </div>
   {/if}
+  </div>
 </div>
 
 <style>
   .dashboard {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
     padding: 24px;
     max-width: 960px;
     margin: 0 auto;
   }
 
+  .scroll-area {
+    flex: 1;
+    overflow-y: auto;
+    min-height: 0;
+  }
+
   .section-title {
     font-size: 1rem;
     color: var(--text-secondary);
diff --git a/src/lib/components/DocumentsView.svelte b/src/lib/components/DocumentsView.svelte
index 0cd45da..4dc40e7 100644
--- a/src/lib/components/DocumentsView.svelte
+++ b/src/lib/components/DocumentsView.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import { docs } from '../ts/ipc';
-  import type { DocEntry, DocSearchResult } from '../ts/types';
+  import type { DocEntry, DocSearchResult, VersionStatus } from '../ts/types';
   import { EditorView, keymap, lineNumbers, highlightActiveLineGutter, highlightSpecialChars, drawSelection, dropCursor, rectangularSelection, crosshairCursor, highlightActiveLine } from '@codemirror/view';
   import { EditorState } from '@codemirror/state';
   import { defaultKeymap, history, historyKeymap, indentWithTab } from '@codemirror/commands';
@@ -17,6 +17,8 @@
     Eye,
     ChevronDown,
     FileText,
+    Folder,
+    FolderOpen,
     Save,
     Download,
     Trash2,
@@ -75,11 +77,7 @@
   ]);
 
   // ─── Props ─────────────────────────────────────────────────────────
-  interface Props {
-    namespace: string | null;
-  }
-
-  let { namespace }: Props = $props();
+  // No props — documents are global since uteke v0.7.0 (#614).
 
   // ─── Editor / Preview mode ─────────────────────────────────────────
   type ViewMode = 'edit' | 'preview' | 'split';
@@ -89,6 +87,8 @@
   let rootDocs = $state<DocEntry[]>([]);
   let expandedIds = $state<Set<string>>(new Set());
   let childrenCache = $state<Map<string, DocEntry[]>>(new Map());
+  // Flat id → DocEntry lookup for ancestor lookups (breadcrumb navigation).
+  let docById = $state<Map<string, DocEntry>>(new Map());
   let selectedDoc = $state<DocEntry | null>(null);
   let editorContent = $state('');
   let editorTitle = $state('');
@@ -110,6 +110,10 @@
   let editorView = $state<EditorView | null>(null);
   let showProps = $state(false);
 
+  // Uteke version gate — documents require >= 0.7.0 (#614).
+  let versionStatus = $state<VersionStatus | null>(null);
+  let updating = $state(false);
+
   // ─── Bound DOM elements for scroll reset ───────────────────────────
   let editorContainer: HTMLElement | null = null;
   let previewContainer: HTMLElement | null = null;
@@ -142,21 +146,39 @@
     successTimeout = setTimeout(() => { success = ''; }, 3000);
   }
 
-  // ─── Load root documents ──────────────────────────────────────────
+  /** Whether a doc has children in the loaded tree (authoritative, from cache). */
+  function hasKids(doc: DocEntry): boolean {
+    return childrenCache.has(doc.id) && (childrenCache.get(doc.id)?.length ?? 0) > 0;
+  }
+
+  // ─── Load all documents & build the tree client-side ──────────────
+  // Fetches the full flat doc list once and assembles parent→children so the
+  // entire hierarchy is visible upfront (Obsidian/Outline-like), rather than
+  // only roots with lazy-expanded children.
   async function loadRootDocs() {
     loading = true;
     try {
-      rootDocs = await docs.list({ roots_only: true, namespace: namespace ?? undefined });
-      // Auto-expand root nodes that have children
-      for (const doc of rootDocs) {
-        if (doc.has_children) {
-          expandedIds.add(doc.id);
-          loadChildren(doc.id);
+      const all = await docs.list();
+      // Group by parent_id; roots have no parent_id.
+      const byParent = new Map<string, DocEntry[]>();
+      const byId = new Map<string, DocEntry>();
+      const roots: DocEntry[] = [];
+      for (const d of all) {
+        byId.set(d.id, d);
+        const pid = d.parent_id ?? null;
+        if (pid) {
+          const arr = byParent.get(pid) ?? [];
+          arr.push(d);
+          byParent.set(pid, arr);
+        } else {
+          roots.push(d);
         }
       }
-      if (rootDocs.some(d => d.has_children)) {
-        expandedIds = expandedIds;
-      }
+      childrenCache = byParent;
+      rootDocs = roots;
+      docById = byId;
+      // Expand every folder by default so the full tree is visible.
+      expandedIds = new Set(byParent.keys());
     } catch (e: any) {
       showError(e.toString());
     } finally {
@@ -168,9 +190,12 @@
   async function loadChildren(docId: string) {
     if (childrenCache.has(docId)) return;
     try {
-      const children = await docs.list({ parent: docId, namespace: namespace ?? undefined });
-      childrenCache.set(docId, children);
-      childrenCache = childrenCache;
+      const children = await docs.list({ parent: docId });
+      // Immutable update — Svelte 5 does not re-render {@const} reads when a
+      // $state Map is mutated in place + reassigned to the same ref.
+      const next = new Map(childrenCache);
+      next.set(docId, children);
+      childrenCache = next;
     } catch (e: any) {
       showError(`Failed to load children: ${e}`);
     }
@@ -178,41 +203,41 @@
 
   // ─── Load all descendants (for selected doc's tree path) ─────────
   async function expandPathToDoc(docId: string) {
-    // Load root children first
-    for (const root of rootDocs) {
-      if (root.has_children && !childrenCache.has(root.id)) {
-        await loadChildren(root.id);
-      }
-    }
-    // Recursively expand down the path to find and expand the target
+    // Children are pre-built; walk the cached tree and expand the path.
+    // Collect into a new Set and reassign once — Svelte 5 needs a new ref
+    // to re-render {@const} reads of a $state Set.
+    const next = new Set(expandedIds);
     function searchLevel(entries: DocEntry[]): boolean {
       for (const entry of entries) {
         if (entry.id === docId) return true;
-        if (entry.has_children) {
-          if (childrenCache.has(entry.id)) {
-            const kids = childrenCache.get(entry.id) ?? [];
-            if (!expandedIds.has(entry.id)) {
-              expandedIds.add(entry.id);
-              expandedIds = expandedIds;
-            }
-            if (searchLevel(kids)) return true;
-          }
+        if (hasKids(entry)) {
+          const kids = childrenCache.get(entry.id) ?? [];
+          next.add(entry.id);
+          if (searchLevel(kids)) return true;
         }
       }
       return false;
     }
     searchLevel(rootDocs);
+    expandedIds = next;
   }
 
   // ─── Toggle tree node ─────────────────────────────────────────────
   async function toggleNode(doc: DocEntry) {
-    if (expandedIds.has(doc.id)) {
-      expandedIds.delete(doc.id);
-      expandedIds = expandedIds;
+    // Immutable update (new Set) — required for Svelte 5 to re-render the
+    // {@const expanded = expandedIds.has(...)} reads in the tree snippet.
+    // Mutating in place + reassigning the same ref does NOT trigger updates.
+    const next = new Set(expandedIds);
+    if (next.has(doc.id)) {
+      next.delete(doc.id);
+      expandedIds = next;
     } else {
-      expandedIds.add(doc.id);
-      expandedIds = expandedIds;
-      await loadChildren(doc.id);
+      next.add(doc.id);
+      expandedIds = next;
+      // Children are pre-built in loadRootDocs(); load lazily only if missing.
+      if (!childrenCache.has(doc.id) && doc.has_children) {
+        await loadChildren(doc.id);
+      }
     }
   }
 
@@ -231,11 +256,9 @@
       showNewDoc = false;
       // Default to preview mode when opening an existing document
       viewMode = 'preview';
-      // Auto-load and expand children of this document in the tree
-      if (full.has_children) {
-        expandedIds.add(full.id);
-        expandedIds = expandedIds;
-        await loadChildren(full.id);
+      // Auto-expand this document's subtree (children pre-built in loadRootDocs).
+      if (hasKids(full)) {
+        expandedIds = new Set([...expandedIds, full.id]);
       }
       // Auto-expand tree path to this document
       await expandPathToDoc(full.id);
@@ -283,7 +306,7 @@
     searching = true;
     showSearchResults = true;
     try {
-      searchResults = await docs.search(searchQuery, { namespace: namespace ?? undefined, limit: 20 });
+      searchResults = await docs.search(searchQuery, { limit: 20 });
     } catch (e: any) {
       showError(e.toString());
     } finally {
@@ -312,7 +335,6 @@
     saving = true;
     try {
       const tags = editorTags.split(',').map(t => t.trim()).filter(Boolean);
-      const ns = namespace ?? undefined;
       if (selectedDoc && !showNewDoc) {
         // Existing document → update
         try {
@@ -322,7 +344,6 @@
             title: editorTitle || editorSlug,
             content: editorContent,
             tags,
-            namespace: selectedDoc.namespace ?? ns,
           });
           selectedDoc = updated;
         } catch (e: any) {
@@ -333,7 +354,7 @@
               editorSlug,
               editorTitle || editorSlug,
               editorContent,
-              { namespace: selectedDoc.namespace ?? ns, tags },
+              { tags },
             );
             // create returns only {id, slug} — re-fetch for full state
             const full = await docs.get({ id: selectedDoc.id });
@@ -346,7 +367,6 @@
         // New document → create via /doc/create
         const parent = selectedDoc?.id ?? undefined;
         await docs.create(editorSlug, editorTitle || editorSlug, editorContent, {
-          namespace: ns,
           tags,
           parent,
         });
@@ -501,13 +521,16 @@
   }
 
   // ─── Build breadcrumb path ────────────────────────────────────────
-  function getBreadcrumb(): string[] {
-    if (!selectedDoc) return [];
-    if (selectedDoc.path && selectedDoc.path.length > 0) {
-      const parts = selectedDoc.path.split('/').filter(Boolean);
-      return parts.length > 0 ? parts : [];
-    }
-    return [];
+  // `selectedDoc.path` is a materialized ancestor chain of UUIDs
+  // ("/uuid/uuid/"). Map each segment to its DocEntry via the flat lookup so
+  // each crumb is clickable and shows a real title.
+  function getBreadcrumb(): DocEntry[] {
+    if (!selectedDoc?.path) return [];
+    return selectedDoc.path
+      .split('/')
+      .filter(Boolean)
+      .map((id) => docById.get(id))
+      .filter((d): d is DocEntry => !!d);
   }
 
   // ─── Word count & reading time ────────────────────────────────────
@@ -515,9 +538,42 @@
 
   // ─── Lifecycle ───────────────────────────────────────────────────
   $effect(() => {
-    loadRootDocs();
+    init();
   });
 
+  /** Probe the installed uteke version; load docs only if supported. */
+  async function init() {
+    try {
+      versionStatus = await docs.versionStatus();
+    } catch {
+      versionStatus = null;
+    }
+    if (versionStatus?.supported !== false) {
+      await loadRootDocs();
+    } else {
+      loading = false;
+    }
+  }
+
+  /** Run `uteke upgrade`, then re-probe and (if supported) load docs. */
+  async function updateUteke() {
+    updating = true;
+    try {
+      versionStatus = await docs.selfUpdate();
+      if (versionStatus.supported) {
+        success = 'Uteke updated — documents enabled.';
+        successTimeout = setTimeout(() => { success = ''; }, 3000);
+        await loadRootDocs();
+      } else {
+        showError(`Still on ${versionStatus.current ?? 'unknown'} after update.`);
+      }
+    } catch (e: any) {
+      showError(`Update failed: ${e}`);
+    } finally {
+      updating = false;
+    }
+  }
+
   // Cleanup on destroy
   $effect(() => {
     return () => {
@@ -546,6 +602,18 @@
     </div>
   </div>
 
+  {#if versionStatus && !versionStatus.supported}
+    <div class="version-banner">
+      <div class="vb-text">
+        <strong>Uteke {versionStatus.required}+ required for documents.</strong>
+        Detected: {versionStatus.current ?? 'unknown'}.
+      </div>
+      <button class="vb-btn" onclick={updateUteke} disabled={updating}>
+        {updating ? 'Updating…' : 'Update uteke'}
+      </button>
+    </div>
+  {/if}
+
   {#if error}
     <div class="error-bar">
       <span class="error-text">{error}</span>
@@ -621,9 +689,9 @@
           <div class="breadcrumb">
             {#if selectedDoc && !showNewDoc}
               <button class="crumb-link" onclick={() => { selectedDoc = null; showNewDoc = false; }}>Documents</button>
-              {#each getBreadcrumb() as part, i}
+              {#each getBreadcrumb() as ancestor, i}
                 <span class="crumb-sep">/</span>
-                <button class="crumb-link">{part.slice(0, 8)}</button>
+                <button class="crumb-link" title={ancestor.title || ancestor.slug} onclick={() => selectDoc(ancestor)}>{ancestor.title || ancestor.slug}</button>
               {/each}
               <span class="crumb-sep">/</span>
               <span class="crumb-current">{selectedDoc.title}</span>
@@ -673,7 +741,7 @@
           </div>
         {/if}
 
-        <!-- Meta bar: version, date, namespace + actions -->
+        <!-- Meta bar: version, date + actions -->
         <div class="meta-bar">
           <div class="meta-left">
             <button class="props-toggle" onclick={() => (showProps = !showProps)}>
@@ -685,9 +753,6 @@
               {#if selectedDoc.updated_at}
                 <span class="meta-item">{formatDate(selectedDoc.updated_at)}</span>
               {/if}
-              {#if selectedDoc.namespace}
-                <span class="ns-badge">{selectedDoc.namespace}</span>
-              {/if}
             {:else}
               <span class="meta-item">New draft</span>
             {/if}
@@ -761,28 +826,42 @@
 {/if}
 
 {#snippet treeNode(doc: DocEntry)}
+  {@const kids = childrenCache.get(doc.id) ?? []}
+  {@const isFolder = kids.length > 0}
+  {@const expanded = expandedIds.has(doc.id)}
   <div class="tree-node">
-    <div class="tree-row" class:active={selectedDoc?.id === doc.id}>
+    <div class="tree-row" class:active={selectedDoc?.id === doc.id} class:folder={isFolder}>
       <button
         class="tree-toggle"
-        class:has-children={doc.has_children}
-        class:expanded={expandedIds.has(doc.id)}
-        onclick={(e: MouseEvent) => { e.stopPropagation(); if (doc.has_children) toggleNode(doc); }}
-        tabindex={doc.has_children ? 0 : -1}
-        aria-label={doc.has_children ? 'Toggle children' : ''}
+        class:has-children={isFolder}
+        class:expanded={expanded}
+        onclick={(e: MouseEvent) => { e.stopPropagation(); if (isFolder) toggleNode(doc); }}
+        tabindex={isFolder ? 0 : -1}
+        aria-label={isFolder ? 'Toggle children' : ''}
       >
-        {#if doc.has_children}
+        {#if isFolder}
           <ChevronDown size={14} strokeWidth={2} class="chevron-icon" />
         {/if}
       </button>
       <button class="tree-label" onclick={() => selectDoc(doc)}>
-        <FileText size={13} strokeWidth={1.75} class="tree-doc-icon" />
+        {#if isFolder}
+          {#if expanded}
+            <FolderOpen size={13} strokeWidth={1.75} class="tree-doc-icon" />
+          {:else}
+            <Folder size={13} strokeWidth={1.75} class="tree-doc-icon" />
+          {/if}
+        {:else}
+          <FileText size={13} strokeWidth={1.75} class="tree-doc-icon" />
+        {/if}
         <span class="tree-title" title={doc.title}>{doc.title || doc.slug}</span>
+        {#if isFolder}
+          <span class="tree-count">{kids.length}</span>
+        {/if}
       </button>
     </div>
-    {#if expandedIds.has(doc.id) && childrenCache.has(doc.id)}
+    {#if expanded && kids.length > 0}
       <div class="tree-children" transition:slide={{ duration: 180 }}>
-        {#each childrenCache.get(doc.id) ?? [] as child (child.id)}
+        {#each kids as child (child.id)}
           {@render treeNode(child)}
         {/each}
       </div>
@@ -842,6 +921,31 @@
     flex-shrink: 0;
     animation: slideDown 0.15s ease;
   }
+  .version-banner {
+    padding: 10px 20px;
+    background: rgba(245, 208, 135, 0.12);
+    border-bottom: 1px solid rgba(245, 208, 135, 0.3);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    flex-shrink: 0;
+  }
+  .vb-text { font-size: 0.85rem; color: var(--text-secondary); }
+  .vb-text strong { color: var(--yellow); }
+  .vb-btn {
+    padding: 6px 14px;
+    background: var(--accent);
+    color: var(--bg-primary);
+    border: none;
+    border-radius: 6px;
+    font-size: 0.82rem;
+    font-weight: 600;
+    cursor: pointer;
+    white-space: nowrap;
+  }
+  .vb-btn:hover:not(:disabled) { opacity: 0.85; }
+  .vb-btn:disabled { opacity: 0.6; cursor: not-allowed; }
   @keyframes slideDown { from { opacity: 0; transform: translateY(-4px); } }
   .error-text {
     color: #f38ba8;
@@ -922,7 +1026,11 @@
   .doc-tree { flex: 1; overflow-y: auto; padding: 4px 0; }
 
   .tree-node { user-select: none; }
-  .tree-children { padding-left: 14px; }
+  .tree-children {
+    padding-left: 16px;
+    margin-left: 10px;
+    border-left: 1px solid var(--border);
+  }
 
   .tree-row {
     display: flex;
@@ -940,6 +1048,18 @@
   }
   .tree-row.active .tree-title { color: var(--accent); }
   .tree-row.active .tree-doc-icon { color: var(--accent); }
+  .tree-row.folder .tree-doc-icon { color: var(--accent); }
+  .tree-row.folder.active .tree-doc-icon { color: var(--accent); }
+  .tree-count {
+    font-size: 0.6rem;
+    color: var(--text-muted);
+    background: var(--bg-hover);
+    padding: 1px 6px;
+    border-radius: 8px;
+    margin-left: 2px;
+    flex-shrink: 0;
+    line-height: 1.4;
+  }
 
   .tree-toggle {
     display: flex;
diff --git a/src/lib/components/MemoryList.svelte b/src/lib/components/MemoryList.svelte
index 8e392b6..04472d1 100644
--- a/src/lib/components/MemoryList.svelte
+++ b/src/lib/components/MemoryList.svelte
@@ -157,7 +157,8 @@
     <NamespaceFilter selected={selectedNamespaces} onchange={(ns) => (selectedNamespaces = ns)} />
   </div>
 
-  {#if isLoading && list.length === 0}
+  <div class="scroll-area">
+    {#if isLoading && list.length === 0}
     <div class="loading">Loading...</div>
   {:else if list.length === 0}
     <div class="empty-state">
@@ -210,15 +211,27 @@
       </div>
     {/if}
   {/if}
+  </div>
 </div>
 
 <style>
   .memory-list-view {
+    position: absolute;
+    inset: 0;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
     padding: 16px 24px;
     max-width: 900px;
     margin: 0 auto;
   }
 
+  .scroll-area {
+    flex: 1;
+    overflow-y: auto;
+    min-height: 0;
+  }
+
   .toolbar {
     display: flex;
     gap: 8px;
diff --git a/src/lib/components/RoomsView.svelte b/src/lib/components/RoomsView.svelte
index 26724b6..c33e400 100644
--- a/src/lib/components/RoomsView.svelte
+++ b/src/lib/components/RoomsView.svelte
@@ -10,16 +10,10 @@
     title: string | null;
     namespace: string;
     memory_count: number;
-    participant_count: number;
     created_at: string;
     updated_at: string;
   }
 
-  interface Participant {
-    namespace: string;
-    count: number;
-  }
-
   interface Props {
     namespace: string | null;
     onmemoryclick: (id: string) => void;
@@ -36,7 +30,7 @@
   let showCreateForm = $state(false);
 
   // Tab state
-  let activeTab = $state<'summary' | 'timeline' | 'participants'>('summary');
+  let activeTab = $state<'summary' | 'timeline'>('summary');
 
   // Summary state
   let roomDocument = $state('');
@@ -46,10 +40,6 @@
   // Confirm delete state
   let showDeleteConfirm = $state(false);
 
-  // Participants state (authoritative from server)
-  let roomStatsData = $state<{ memory_count: number; participant_count: number; participant_namespaces?: string[] } | null>(null);
-  let participantsLoading = $state(false);
-
   async function loadRooms() {
     loading = true;
     try {
@@ -77,7 +67,6 @@
     activeTab = 'summary';
     documentLoaded = false;
     roomDocument = '';
-    roomStatsData = null;
     if (utekeReady) {
       // Use chronological room_memories (uteke >= 0.6.7) with fallback to recall
       try {
@@ -88,46 +77,6 @@
     }
   }
 
-  /** Load participants from server stats (authoritative) */
-  async function loadParticipants() {
-    if (!selectedRoom || !utekeReady) return;
-    participantsLoading = true;
-    try {
-      roomStatsData = await uteke.roomStats(selectedRoom);
-    } catch {
-      roomStatsData = null;
-    }
-    participantsLoading = false;
-  }
-
-  /**
-   * Get participants — authoritative from server stats when available,
-   * falls back to client-side grouping from roomMemories.
-   */
-  function getParticipants(): Participant[] {
-    // Prefer server-provided participant_namespaces list
-    if (roomStatsData?.participant_namespaces?.length) {
-      const memCounts: Record<string, number> = {};
-      for (const m of roomMemories) {
-        const ns = m.namespace ?? 'default';
-        memCounts[ns] = (memCounts[ns] ?? 0) + 1;
-      }
-      return roomStatsData.participant_namespaces
-        .map((ns) => ({ namespace: ns, count: memCounts[ns] ?? 0 }))
-        .sort((a, b) => b.count - a.count);
-    }
-
-    // Fallback: derive from roomMemories (may undercount if limit truncates)
-    const counts: Record<string, number> = {};
-    for (const m of roomMemories) {
-      const ns = m.namespace ?? 'default';
-      counts[ns] = (counts[ns] ?? 0) + 1;
-    }
-    return Object.entries(counts)
-      .map(([namespace, count]) => ({ namespace, count }))
-      .sort((a, b) => b.count - a.count);
-  }
-
   async function loadDocument(roomId: string) {
     if (documentLoaded) return;
     documentLoading = true;
@@ -147,12 +96,6 @@
     }
   });
 
-  $effect(() => {
-    if (selectedRoom && activeTab === 'participants') {
-      loadParticipants();
-    }
-  });
-
   function toggleCreateForm() {
     showCreateForm = !showCreateForm;
   }
@@ -238,8 +181,6 @@
             <div class="room-meta">
               <span>{room.memory_count} memories</span>
               <span>·</span>
-              <span>{room.participant_count} agents</span>
-              <span>·</span>
               <span>{relativeTime(room.created_at)}</span>
             </div>
             <div class="room-ns">{room.namespace}</div>
@@ -280,7 +221,6 @@
           <div class="tabs">
             <button class="tab" class:active={activeTab === 'summary'} onclick={() => activeTab = 'summary'}>Summary</button>
             <button class="tab" class:active={activeTab === 'timeline'} onclick={() => activeTab = 'timeline'}>Memories</button>
-            <button class="tab" class:active={activeTab === 'participants'} onclick={() => activeTab = 'participants'}>Participants</button>
           </div>
 
           <!-- Tab: Summary -->
@@ -328,36 +268,6 @@
             {/if}
           {/if}
 
-          <!-- Tab: Participants -->
-          {#if activeTab === 'participants'}
-            {@const participants = getParticipants()}
-            {@const serverParticipantCount = roomStatsData?.participant_count ?? currentRoom?.participant_count ?? 0}
-            {#if participantsLoading}
-              <div class="tab-loading">Loading participants…</div>
-            {:else if participants.length === 0}
-              <div class="tab-empty">
-                <p>No participants yet.</p>
-                <p class="sub">Agents will appear here when they contribute memories to this room.</p>
-              </div>
-            {:else}
-              <div class="participant-list">
-                {#each participants as p (p.namespace)}
-                  <div class="participant-card">
-                    <div class="participant-info">
-                      <span class="participant-avatar">{'🤖'}</span>
-                      <div class="participant-detail">
-                        <span class="participant-ns">{p.namespace}</span>
-                        <span class="participant-count">{p.count} {p.count === 1 ? 'memory' : 'memories'}</span>
-                      </div>
-                    </div>
-                  </div>
-                {/each}
-                <div class="participant-summary">
-                  <span>{participants.length} {participants.length === 1 ? 'participant' : 'participants'} · {serverParticipantCount > participants.length ? `(server reports ${serverParticipantCount} total)` : ''} · {roomMemories.length} memories loaded</span>
-                </div>
-              </div>
-            {/if}
-          {/if}
         {/if}
       </div>
     </div>
@@ -446,16 +356,6 @@
   .tag { font-size: 0.7rem; padding: 2px 6px; background: var(--bg-hover); color: var(--text-secondary); border-radius: 3px; }
   .ns { font-size: 0.7rem; padding: 2px 6px; background: rgba(137,180,250,0.15); color: var(--accent); border-radius: 3px; }
 
-  /* Participants */
-  .participant-list { display: flex; flex-direction: column; gap: 8px; }
-  .participant-card { padding: 10px 14px; background: var(--bg-tertiary); border: 1px solid var(--border); border-radius: 6px; }
-  .participant-info { display: flex; align-items: center; gap: 10px; }
-  .participant-avatar { font-size: 1.2rem; }
-  .participant-detail { display: flex; flex-direction: column; gap: 2px; }
-  .participant-ns { font-size: 0.9rem; color: var(--accent); font-family: var(--font-mono); }
-  .participant-count { font-size: 0.75rem; color: var(--text-muted); }
-  .participant-summary { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); font-size: 0.8rem; color: var(--text-muted); text-align: center; }
-
   /* General */
   .msg { flex: 1; display: flex; flex-direction: column; align-items: center; justify-content: center; color: var(--text-muted); text-align: center; gap: 8px; }
   .msg .sub { font-size: 0.85rem; opacity: 0.7; line-height: 1.6; }
diff --git a/src/lib/components/__tests__/TreeRepro.svelte b/src/lib/components/__tests__/TreeRepro.svelte
new file mode 100644
index 0000000..95ebf6f
--- /dev/null
+++ b/src/lib/components/__tests__/TreeRepro.svelte
@@ -0,0 +1,30 @@
+<script lang="ts">
+  let expanded = $state<Set<string>>(new Set(['a']));
+  let kids: Record<string, string[]> = { a: ['a1', 'a2'] };
+
+  export function toggle(id: string) {
+    const next = new Set(expanded);
+    if (next.has(id)) {
+      next.delete(id);
+    } else {
+      next.add(id);
+    }
+    expanded = next;
+  }
+
+  export function isOpen(id: string) {
+    return expanded.has(id);
+  }
+</script>
+
+{#snippet node(id: string)}
+  {@const open = expanded.has(id)}
+  <button data-testid="toggle-{id}" onclick={() => toggle(id)}>tog</button>
+  {#if open}
+    <ul data-testid="kids-{id}">
+      {#each kids[id] ?? [] as c}{@render node(c)}{/each}
+    </ul>
+  {/if}
+{/snippet}
+
+{#each Object.keys(kids) as id}{@render node(id)}{/each}
diff --git a/src/lib/components/__tests__/set-reactivity.test.ts b/src/lib/components/__tests__/set-reactivity.test.ts
new file mode 100644
index 0000000..83fa6b1
--- /dev/null
+++ b/src/lib/components/__tests__/set-reactivity.test.ts
@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { render, fireEvent } from '@testing-library/svelte';
+import TreeRepro from './TreeRepro.svelte';
+
+describe('doc-tree toggle: $state Set needs immutable update', () => {
+  it('toggles open/closed on click', async () => {
+    const { getByTestId, queryByTestId } = render(TreeRepro);
+    // starts expanded
+    expect(queryByTestId('kids-a')).toBeTruthy();
+    await fireEvent.click(getByTestId('toggle-a'));
+    expect(queryByTestId('kids-a')).toBeNull();
+    await fireEvent.click(getByTestId('toggle-a'));
+    expect(queryByTestId('kids-a')).toBeTruthy();
+  });
+});
diff --git a/src/lib/ts/ipc.ts b/src/lib/ts/ipc.ts
index c45bbf0..c5f8daa 100644
--- a/src/lib/ts/ipc.ts
+++ b/src/lib/ts/ipc.ts
@@ -3,7 +3,7 @@ import { save } from '@tauri-apps/plugin-dialog';
 import { writeTextFile } from '@tauri-apps/plugin-fs';
 import type {
   MemoryEntry, SearchResult, GraphData, GraphEdge,
-  RoomEntry, StatsResponse, DocEntry, DocSearchResult,
+  RoomEntry, StatsResponse, DocEntry, DocSearchResult, VersionStatus,
 } from './types';
 
 export const memory = {
@@ -255,28 +255,35 @@ export const connection = {
 };
 
 // Document Engine (#137) — uteke-serve /doc/* API
+//
+// Since uteke v0.7.0 (#614) documents are global — no namespace. The backend
+// gates all doc commands on uteke >= 0.7.0; use `versionStatus()` to detect an
+// outdated install and `selfUpdate()` to run `uteke upgrade`.
 export const docs = {
-  list: (opts?: { namespace?: string; limit?: number; roots_only?: boolean; parent?: string }) =>
+  /** Installed uteke version + whether it meets the Documents requirement. */
+  versionStatus: () => invoke<VersionStatus>('uteke_version_status'),
+
+  /** Run `uteke upgrade`, then re-detect. Resolves with the new status. */
+  selfUpdate: () => invoke<VersionStatus>('uteke_self_update'),
+
+  list: (opts?: { limit?: number; roots_only?: boolean; parent?: string }) =>
     invoke<DocEntry[]>('doc_list', {
-      namespace: opts?.namespace ?? null,
       limit: opts?.limit ?? null,
       roots_only: opts?.roots_only ?? null,
       parent: opts?.parent ?? null,
     }),
 
-  get: (opts: { slug?: string; id?: string; namespace?: string }) =>
+  get: (opts: { slug?: string; id?: string }) =>
     invoke<DocEntry>('doc_get', {
       slug: opts.slug ?? null,
       id: opts.id ?? null,
-      namespace: opts.namespace ?? null,
     }),
 
-  create: (slug: string, title: string, content: string, opts?: { namespace?: string; tags?: string[]; parent?: string }) =>
+  create: (slug: string, title: string, content: string, opts?: { tags?: string[]; parent?: string }) =>
     invoke<DocEntry>('doc_create', {
       slug,
       title,
       content,
-      namespace: opts?.namespace ?? null,
       tags: opts?.tags ?? null,
       parent: opts?.parent ?? null,
     }),
@@ -288,7 +295,6 @@ export const docs = {
     title?: string;
     content?: string;
     tags?: string[];
-    namespace?: string;
   }) =>
     invoke<DocEntry>('doc_update', {
       id: opts.id ?? null,
@@ -296,13 +302,11 @@ export const docs = {
       title: opts.title ?? null,
       content: opts.content ?? null,
       tags: opts.tags ?? null,
-      namespace: opts.namespace ?? null,
     }),
 
-  search: (query: string, opts?: { namespace?: string; limit?: number; mode?: string }) =>
+  search: (query: string, opts?: { limit?: number; mode?: string }) =>
     invoke<DocSearchResult[]>('doc_search', {
       query,
-      namespace: opts?.namespace ?? null,
       limit: opts?.limit ?? null,
       mode: opts?.mode ?? null,
     }),
@@ -313,12 +317,11 @@ export const docs = {
       slug: opts.slug ?? null,
     }),
 
-  move: (opts: { id?: string; slug?: string; new_parent?: string; namespace?: string }) =>
+  move: (opts: { id?: string; slug?: string; new_parent?: string }) =>
     invoke<unknown>('doc_move', {
       id: opts.id ?? null,
       slug: opts.slug ?? null,
       new_parent: opts.new_parent ?? null,
-      namespace: opts.namespace ?? null,
     }),
 
   /** Export document content as a downloadable .md file via native save dialog. */
diff --git a/src/lib/ts/types.ts b/src/lib/ts/types.ts
index a70f8e6..0ac3745 100644
--- a/src/lib/ts/types.ts
+++ b/src/lib/ts/types.ts
@@ -44,13 +44,22 @@ export interface RoomEntry {
   created_at: string | null;
 }
 
+// Installed uteke version vs the minimum required for Documents.
+export interface VersionStatus {
+  /** Detected "X.Y.Z", or null if the uteke CLI couldn't be probed. */
+  current: string | null;
+  /** Minimum uteke version supporting global documents ("0.7.0"). */
+  required: string;
+  /** True iff current >= required (false when current is unknown). */
+  supported: boolean;
+}
+
 // Document entry from uteke-serve /doc/* API
 export interface DocEntry {
   id: string;
   slug: string;
   title: string;
   content?: string;
-  namespace?: string | null;
   tags?: string[];
   metadata?: Record<string, unknown>;
   version?: number | null;