diff --git a/crates/labby-gateway/src/gateway/manager/config_ops.rs b/crates/labby-gateway/src/gateway/manager/config_ops.rs
index f7f0d7461..448adbd94 100644
--- a/crates/labby-gateway/src/gateway/manager/config_ops.rs
+++ b/crates/labby-gateway/src/gateway/manager/config_ops.rs
@@ -1,7 +1,7 @@
 //! Config reads/writes for upstream entries: `add`, `batch_add`, `update`,
 //! `remove`, service env config, and the code-mode config mutation.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 use tokio::time::Instant;
 
@@ -98,6 +98,17 @@ impl GatewayManager {
         self.config.read().await.clone()
     }
 
+    /// Return the configured upstream names without cloning the full gateway config.
+    pub async fn upstream_names(&self) -> BTreeSet<String> {
+        self.config
+            .read()
+            .await
+            .upstream
+            .iter()
+            .map(|upstream| upstream.name.clone())
+            .collect()
+    }
+
     /// Return the current visibility switches for Labby-owned MCP Apps.
     pub async fn mcp_apps_config(&self) -> McpAppsConfig {
         self.config.read().await.mcp_apps
@@ -532,6 +543,7 @@ impl GatewayManager {
         match target {
             "manager" => cfg.mcp_apps.manager = enabled,
             "codemode" => cfg.code_mode.mcp_ui_enabled = enabled,
+            "skill_library" => cfg.mcp_apps.skill_library = enabled,
             "gateway_status" => cfg.mcp_apps.gateway_status = enabled,
             "server_logs" => cfg.mcp_apps.server_logs = enabled,
             "add_server" => cfg.mcp_apps.add_server = enabled,
@@ -539,6 +551,7 @@ impl GatewayManager {
             "all" => {
                 cfg.mcp_apps.manager = enabled;
                 cfg.code_mode.mcp_ui_enabled = enabled;
+                cfg.mcp_apps.skill_library = enabled;
                 cfg.mcp_apps.gateway_status = enabled;
                 cfg.mcp_apps.server_logs = enabled;
                 cfg.mcp_apps.add_server = enabled;
@@ -581,6 +594,7 @@ impl GatewayManager {
             enabled,
             manager = current.mcp_apps.manager,
             code_mode = current.code_mode.mcp_ui_enabled,
+            skill_library = current.mcp_apps.skill_library,
             add_server = current.mcp_apps.add_server,
             server_logs = current.mcp_apps.server_logs,
             gateway_status = current.mcp_apps.gateway_status,
diff --git a/crates/labby-gateway/src/gateway/manager/tests/config_ops.rs b/crates/labby-gateway/src/gateway/manager/tests/config_ops.rs
index 6ddf1b83a..bc8521160 100644
--- a/crates/labby-gateway/src/gateway/manager/tests/config_ops.rs
+++ b/crates/labby-gateway/src/gateway/manager/tests/config_ops.rs
@@ -904,6 +904,7 @@ async fn mcp_app_visibility_setting_persists_notifies_and_skips_pool_rebuild() {
     let mut initial = GatewayConfig::default();
     initial.code_mode.mcp_ui_enabled = true;
     initial.mcp_apps.manager = true;
+    initial.mcp_apps.skill_library = true;
     initial.mcp_apps.gateway_status = true;
     initial.mcp_apps.server_logs = true;
     initial.mcp_apps.add_server = true;
@@ -922,6 +923,7 @@ async fn mcp_app_visibility_setting_persists_notifies_and_skips_pool_rebuild() {
 
     assert!(!updated.mcp_apps.manager);
     assert!(!updated.code_mode.mcp_ui_enabled);
+    assert!(!updated.mcp_apps.skill_library);
     assert!(!updated.mcp_apps.gateway_status);
     assert!(!updated.mcp_apps.server_logs);
     assert!(!updated.mcp_apps.add_server);
@@ -951,6 +953,7 @@ async fn mcp_app_visibility_setting_persists_notifies_and_skips_pool_rebuild() {
     let persisted = load_gateway_config(&path).expect("load persisted config");
     assert!(!persisted.mcp_apps.manager);
     assert!(!persisted.code_mode.mcp_ui_enabled);
+    assert!(!persisted.mcp_apps.skill_library);
     assert!(!persisted.mcp_apps.gateway_status);
     assert!(!persisted.mcp_apps.server_logs);
     assert!(!persisted.mcp_apps.add_server);
@@ -961,6 +964,7 @@ async fn mcp_app_visibility_setting_persists_notifies_and_skips_pool_rebuild() {
     assert!(!restarted.code_mode_app_state().is_enabled());
     let restarted_apps = restarted.mcp_apps_config().await;
     assert!(!restarted_apps.manager);
+    assert!(!restarted_apps.skill_library);
     assert!(!restarted_apps.gateway_status);
     assert!(!restarted_apps.server_logs);
     assert!(!restarted_apps.add_server);
diff --git a/crates/labby-runtime/src/gateway_config.rs b/crates/labby-runtime/src/gateway_config.rs
index 3ff030458..8a61fba85 100644
--- a/crates/labby-runtime/src/gateway_config.rs
+++ b/crates/labby-runtime/src/gateway_config.rs
@@ -107,43 +107,34 @@ fn default_mcp_scopes() -> Vec<String> {
 /// control tool stays available when its manager UI is disabled. Code Mode keeps
 /// its existing `CodeModeConfig::mcp_ui_enabled` field for backward-compatible
 /// config.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
 pub struct McpAppsConfig {
     /// Attach MCP App metadata to the always-available `mcp_app` control tool and advertise its UI resources.
-    /// The control tool itself remains available when this is false.
-    /// Fresh installs expose the manager UI by default.
-    #[serde(default = "default_true")]
+    /// The control tool itself remains available when this is false. Fresh installs keep the UI opt-in.
+    #[serde(default)]
     pub manager: bool,
+    /// Attach the Skill Library UI metadata/resources to the `artifacts` service.
+    /// The underlying text service remains available when this is false.
+    #[serde(default)]
+    pub skill_library: bool,
     /// Advertise the synthetic Add Server app tool and its UI resources.
-    /// Fresh installs expose the complete Labby app surface by default.
-    #[serde(default = "default_true")]
+    /// Fresh installs keep Labby-owned MCP App UIs opt-in.
+    #[serde(default)]
     pub add_server: bool,
     /// Attach the Server Logs app metadata and advertise its UI resources.
-    /// Fresh installs expose the complete Labby app surface by default.
-    #[serde(default = "default_true")]
+    /// Fresh installs keep Labby-owned MCP App UIs opt-in.
+    #[serde(default)]
     pub server_logs: bool,
     /// Advertise the synthetic Gateway Status app tool and its UI resources.
-    /// Fresh installs expose the complete Labby app surface by default.
-    #[serde(default = "default_true")]
+    /// Fresh installs keep Labby-owned MCP App UIs opt-in.
+    #[serde(default)]
     pub gateway_status: bool,
     /// Advertise the schema-backed Settings app tool and its UI resources.
-    /// Fresh installs expose the complete Labby app surface by default.
-    #[serde(default = "default_true")]
+    /// Fresh installs keep Labby-owned MCP App UIs opt-in.
+    #[serde(default)]
     pub settings: bool,
 }
 
-impl Default for McpAppsConfig {
-    fn default() -> Self {
-        Self {
-            manager: true,
-            add_server: true,
-            server_logs: true,
-            gateway_status: true,
-            settings: true,
-        }
-    }
-}
-
 // ─── Code Mode ───────────────────────────────────────────────────────────────
 
 /// Model-facing policy applied to oversized final Code Mode results.
@@ -216,8 +207,8 @@ pub struct CodeModeConfig {
     pub trusted_read_only_tools: Vec<String>,
     /// Whether the explicit `codemode_ui` MCP App tool and resources are advertised.
     /// The text-only `codemode` executor remains available when this is false.
-    /// The inspector is enabled by default so Code Mode has a useful first-run UI.
-    #[serde(default = "default_true")]
+    /// The inspector is opt-in on fresh installs, like the other Labby-owned MCP App UIs.
+    #[serde(default)]
     pub mcp_ui_enabled: bool,
     /// Whether Code Mode call traces include redacted/capped tool params.
     #[serde(default = "default_code_mode_trace_params")]
@@ -287,7 +278,7 @@ impl Default for CodeModeConfig {
         Self {
             enabled: true,
             trusted_read_only_tools: Vec::new(),
-            mcp_ui_enabled: true,
+            mcp_ui_enabled: false,
             trace_params: default_code_mode_trace_params(),
             result_shape_policy: CodeModeResultShapePolicy::Off,
             timeout_ms: default_code_mode_timeout_ms(),
@@ -2397,7 +2388,7 @@ client_secret_env = "SECRET"
         assert_eq!(cfg, expected);
         assert!(cfg.enabled);
         assert!(cfg.trusted_read_only_tools.is_empty());
-        assert!(cfg.mcp_ui_enabled);
+        assert!(!cfg.mcp_ui_enabled);
         assert!(cfg.trace_params);
         assert_eq!(cfg.timeout_ms, 30_000);
         assert_eq!(cfg.token_estimate_divisor, 4);
@@ -2458,51 +2449,50 @@ client_secret_env = "SECRET"
     }
 
     #[test]
-    fn mcp_apps_config_defaults_all_managed_apps_enabled() {
+    fn mcp_apps_config_defaults_all_managed_apps_disabled() {
         let cfg: McpAppsConfig = toml::from_str("").unwrap();
         assert_eq!(cfg, McpAppsConfig::default());
-        assert!(cfg.manager);
-        assert!(cfg.add_server);
-        assert!(cfg.server_logs);
-        assert!(cfg.gateway_status);
-        assert!(cfg.settings);
+        assert!(!cfg.manager);
+        assert!(!cfg.skill_library);
+        assert!(!cfg.add_server);
+        assert!(!cfg.server_logs);
+        assert!(!cfg.gateway_status);
+        assert!(!cfg.settings);
     }
 
     #[test]
     fn documented_labby_app_defaults_match_code() {
         // GATEWAY.md is the operator-facing statement of the Labby-owned app
-        // surface defaults. Code Mode and every managed MCP App now default
-        // on, so the doc must not still promise an off-by-default posture.
+        // surface defaults. Code Mode execution stays on, while every Labby-owned
+        // MCP App UI is opt-in by default.
         let doc = include_str!("../../../docs/services/GATEWAY.md");
         assert!(CodeModeConfig::default().enabled);
-        assert!(CodeModeConfig::default().mcp_ui_enabled);
+        assert!(!CodeModeConfig::default().mcp_ui_enabled);
         assert_eq!(
             McpAppsConfig::default(),
             McpAppsConfig {
-                manager: true,
-                add_server: true,
-                server_logs: true,
-                gateway_status: true,
-                settings: true,
+                manager: false,
+                skill_library: false,
+                add_server: false,
+                server_logs: false,
+                gateway_status: false,
+                settings: false,
             }
         );
         assert!(
-            !doc.contains("defaults to `false` and must be explicitly enabled"),
-            "docs/services/GATEWAY.md still documents the retired off-by-default app posture"
-        );
-        assert!(
-            doc.contains("defaults to `true`") || doc.contains("enabled by default"),
-            "docs/services/GATEWAY.md must state that Labby-owned app surfaces default on"
+            doc.contains("default to `false`") || doc.contains("opt-in"),
+            "docs/services/GATEWAY.md must state that Labby-owned app surfaces default off"
         );
     }
 
     #[test]
     fn mcp_apps_config_supports_independent_visibility_switches() {
         let cfg: McpAppsConfig = toml::from_str(
-            "manager = true\nadd_server = false\nserver_logs = true\ngateway_status = false\nsettings = false\n",
+            "manager = true\nskill_library = true\nadd_server = false\nserver_logs = true\ngateway_status = false\nsettings = false\n",
         )
         .unwrap();
         assert!(cfg.manager);
+        assert!(cfg.skill_library);
         assert!(!cfg.add_server);
         assert!(cfg.server_logs);
         assert!(!cfg.gateway_status);
diff --git a/crates/labby/src/app_assets.rs b/crates/labby/src/app_assets.rs
index 6c4a7caab..ffa3ee3f0 100644
--- a/crates/labby/src/app_assets.rs
+++ b/crates/labby/src/app_assets.rs
@@ -44,7 +44,8 @@ pub(crate) const SETTINGS_APP_URI: &str = "ui://lab/settings/editor";
 pub(crate) const SETTINGS_APP_SKYBRIDGE_URI: &str = "ui://lab/settings/editor.skybridge";
 pub(crate) const SETTINGS_APP_HTML: &str = include_str!("mcp/assets/settings_app.html");
 
-/// Always-on MCP App manager used to control the other Labby-owned app surfaces.
+/// Opt-in MCP App manager UI used to control the other Labby-owned app surfaces.
+/// The text-only `mcp_app` control tool remains always available.
 #[cfg(feature = "gateway")]
 pub(crate) const MCP_APPS_APP_URI: &str = "ui://lab/apps/manage";
 #[cfg(feature = "gateway")]
diff --git a/crates/labby/src/app_catalog.rs b/crates/labby/src/app_catalog.rs
index 79a283a40..5fb7e8d02 100644
--- a/crates/labby/src/app_catalog.rs
+++ b/crates/labby/src/app_catalog.rs
@@ -67,7 +67,9 @@ pub(crate) fn enabled_versions(
         add("server-logs", &SERVER_LOGS_APP_VERSION);
     }
     #[cfg(feature = "skills")]
-    add("skill-library", &SKILL_LIBRARY_APP_VERSION);
+    if config.skill_library {
+        add("skill-library", &SKILL_LIBRARY_APP_VERSION);
+    }
     #[cfg(feature = "gateway")]
     {
         if config.add_server {
@@ -85,3 +87,31 @@ pub(crate) fn enabled_versions(
     }
     rows
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_visibility_publishes_no_labby_app_revisions() {
+        assert!(enabled_versions(false, McpAppsConfig::default()).is_empty());
+    }
+
+    #[cfg(feature = "skills")]
+    #[test]
+    fn skill_library_revision_follows_visibility_switch() {
+        let mut config = McpAppsConfig::default();
+        assert!(
+            enabled_versions(false, config)
+                .iter()
+                .all(|(id, _)| id != "skill-library")
+        );
+
+        config.skill_library = true;
+        assert!(
+            enabled_versions(false, config)
+                .iter()
+                .any(|(id, _)| id == "skill-library")
+        );
+    }
+}
diff --git a/crates/labby/src/cli/serve.rs b/crates/labby/src/cli/serve.rs
index 898c932fa..83790d496 100644
--- a/crates/labby/src/cli/serve.rs
+++ b/crates/labby/src/cli/serve.rs
@@ -992,10 +992,9 @@ fn resolve_web_ui_auth_disabled(
 
 /// Name the Labby-owned app surfaces whose `config.toml` section is absent
 /// and which therefore run at their on-by-default posture. One INFO line at
-/// startup, only when something is inherited, so an install upgraded from a
-/// release where Code Mode and the MCP App UIs defaulted off can see why they
-/// appeared. A missing file inherits everything; an unreadable one is the
-/// loader's error to report.
+/// startup, only when something is inherited, so an operator can see which
+/// surface defaults were applied. A missing file inherits everything; an
+/// unreadable one is the loader's error to report.
 fn log_inherited_app_surface_defaults(config_path: &Path, config: &LabConfig) {
     let raw = match std::fs::read_to_string(config_path) {
         Ok(raw) => raw,
@@ -1013,13 +1012,13 @@ fn log_inherited_app_surface_defaults(config_path: &Path, config: &LabConfig) {
         code_mode_enabled = config.code_mode.enabled,
         code_mode_ui_enabled = config.code_mode.mcp_ui_enabled,
         mcp_apps_manager = config.mcp_apps.manager,
+        mcp_apps_skill_library = config.mcp_apps.skill_library,
         mcp_apps_add_server = config.mcp_apps.add_server,
         mcp_apps_server_logs = config.mcp_apps.server_logs,
         mcp_apps_gateway_status = config.mcp_apps.gateway_status,
         mcp_apps_settings = config.mcp_apps.settings,
-        "config.toml declares no [code_mode] or [mcp_apps] section; Code Mode and \
-         the Labby-owned MCP App UIs default to enabled — set the switches to \
-         false to opt out"
+        "config.toml inherits app surface defaults: text Code Mode stays enabled, \
+         while Labby-owned MCP App UIs default off and must be explicitly enabled"
     );
 }
 
diff --git a/crates/labby/src/config.rs b/crates/labby/src/config.rs
index fab0ca6f9..cb1b70ec0 100644
--- a/crates/labby/src/config.rs
+++ b/crates/labby/src/config.rs
@@ -2147,10 +2147,10 @@ fn load_toml_from_paths(candidates: &[PathBuf]) -> Result<LabConfig> {
 }
 
 /// Labby-owned app-surface sections that `raw` (a `config.toml` document)
-/// does not declare and therefore inherits at their on-by-default posture:
-/// `code_mode` (Code Mode plus its inspector UI) and `mcp_apps` (every
-/// Labby-owned MCP App UI). Startup names these once so an install upgraded
-/// from a release where they defaulted off sees the change. Unparseable input
+/// does not declare and therefore inherits from code defaults. `code_mode`
+/// keeps text execution enabled while its inspector UI defaults off; `mcp_apps`
+/// keeps every Labby-owned MCP App UI opt-in. Startup names inherited sections
+/// once so operators can see which defaults were applied. Unparseable input
 /// yields nothing; the config loader owns that error.
 #[must_use]
 pub fn inherited_app_surface_sections(raw: &str) -> Vec<&'static str> {
diff --git a/crates/labby/src/mcp/CLAUDE.md b/crates/labby/src/mcp/CLAUDE.md
index 54075b998..56f496b01 100644
--- a/crates/labby/src/mcp/CLAUDE.md
+++ b/crates/labby/src/mcp/CLAUDE.md
@@ -77,10 +77,9 @@ For normal services, `dispatch/<service>/dispatch.rs` owns action routing, catal
   when an upstream call launches a nested MCP App. `codemode_ui` shares the
   same execution backend and owns the Code Mode inspector metadata. `mcp_app`
   is the always-available root-gateway control tool for the manager UI,
-  inspector, Gateway Status, Server Logs, Add Server, and Settings surfaces; it
+  inspector, Skill Library, Gateway Status, Server Logs, Add Server, and Settings surfaces; it
   supports per-app and `all` `status|enable|disable` operations. Its own manager
-  UI is enabled by default and may be disabled, but the text-only control tool remains
-  available. App mutations require `lab:admin`, are gateway-scoped, and schedule
+  UI is opt-in by default, while the text-only control tool remains available. App mutations require `lab:admin`, are gateway-scoped, and schedule
   coalesced
   `tools/list_changed` plus `resources/list_changed` notifications after the
   open tool turn drains. `server_logs` keeps its text/service capability when
@@ -220,9 +219,9 @@ Resources are read-only. Do not use them for mutations.
 - `ui://lab/code-mode/*` — Lab's own Code Mode app resources, served locally
   from bundled HTML (`read_code_mode_app_resource_impl`). The app descriptors
   bind only to `codemode_ui`; disabling the app hides that tool and these
-  resources, and direct reads fail as unknown. All Labby-owned app UIs are
-  enabled by default; a disabled surface must not remain reachable through a cached URI.
-- `ui://lab/mcp-apps/manager` — the default-enabled UI for the always-available `mcp_app`
+  resources, and direct reads fail as unknown. Labby-owned app UIs are opt-in;
+  a disabled surface must not remain reachable through a cached URI.
+- `ui://lab/apps/manage` — the opt-in UI for the always-available `mcp_app`
   control tool. Disabling this manager UI strips its tool metadata and resource
   but does not remove the text-only control tool needed to restore app surfaces.
 - `ui://lab/gateway/add-server` — the admin-only Add Server app bound to the
diff --git a/crates/labby/src/mcp/assets/mcp_apps_app.html b/crates/labby/src/mcp/assets/mcp_apps_app.html
index 0b7733c12..239095508 100644
--- a/crates/labby/src/mcp/assets/mcp_apps_app.html
+++ b/crates/labby/src/mcp/assets/mcp_apps_app.html
@@ -24,7 +24,7 @@
 <script>
 (()=>{"use strict";
 const host=window.LabbyAppHost,shell=document.getElementById("shell"),appsEl=document.getElementById("apps"),statusEl=document.getElementById("status"),summaryEl=document.getElementById("summary"),enableAll=document.getElementById("enableAll"),disableAll=document.getElementById("disableAll");
-const catalog=[{id:"manager",title:"App switchboard",description:"Show or hide Labby-owned app surfaces.",tool:"mcp_app"},{id:"codemode",title:"Code Mode inspector",description:"Inspect tool calls, timing, results, and nested apps.",tool:"codemode_ui"},{id:"gateway_status",title:"Gateway status",description:"See upstream health and capability counts.",tool:"gateway_status"},{id:"server_logs",title:"Server logs",description:"Search Labby's rolling process logs.",tool:"server_logs"},{id:"add_server",title:"Add server",description:"Test and connect a new MCP upstream.",tool:"add_server"},{id:"settings",title:"Settings",description:"Change safe runtime and feature settings.",tool:"settings"}];
+const catalog=[{id:"manager",title:"App switchboard",description:"Show or hide Labby-owned app surfaces.",tool:"mcp_app"},{id:"codemode",title:"Code Mode inspector",description:"Inspect tool calls, timing, results, and nested apps.",tool:"codemode_ui"},{id:"skill_library",title:"Skill Library",description:"Browse and manage artifacts, skills, and revisions.",tool:"artifacts"},{id:"gateway_status",title:"Gateway status",description:"See upstream health and capability counts.",tool:"gateway_status"},{id:"server_logs",title:"Server logs",description:"Search Labby's rolling process logs.",tool:"server_logs"},{id:"add_server",title:"Add server",description:"Test and connect a new MCP upstream.",tool:"add_server"},{id:"settings",title:"Settings",description:"Change safe runtime and feature settings.",tool:"settings"}];
 let state={},disposed=false,frame=null,pending=new Set();
 function normalize(value){if(value==null)return value;if(value.structuredContent!=null)return normalize(value.structuredContent);if(value.ok===false)throw new Error(value.error&&value.error.message||"The MCP App request failed.");if(value.ok===true)return normalize(value.data);if(value.isError===true&&Array.isArray(value.content)){const message=value.content.map(item=>item&&item.text).filter(Boolean).join(String.fromCharCode(10));throw new Error(message||"The MCP App request failed.")}if(Array.isArray(value.content)&&value.content[0]&&value.content[0].text){try{return normalize(JSON.parse(value.content[0].text))}catch(_){}}return value}
 function enabledFor(id){const item=state[id];return typeof item==="boolean"?item:!!(item&&item.enabled)}
diff --git a/crates/labby/src/mcp/call_tool.rs b/crates/labby/src/mcp/call_tool.rs
index e28b79943..79e262c78 100644
--- a/crates/labby/src/mcp/call_tool.rs
+++ b/crates/labby/src/mcp/call_tool.rs
@@ -999,6 +999,7 @@ impl LabMcpServer {
                     target,
                     "manager"
                         | "codemode"
+                        | "skill_library"
                         | "gateway_status"
                         | "server_logs"
                         | "add_server"
@@ -1011,7 +1012,7 @@ impl LabMcpServer {
                         "invalid_param",
                         &format!("unsupported MCP App target `{target}`"),
                         &serde_json::json!({
-                            "valid": ["manager", "codemode", "gateway_status", "server_logs", "add_server", "settings", "all"]
+                            "valid": ["manager", "codemode", "skill_library", "gateway_status", "server_logs", "add_server", "settings", "all"]
                         }),
                     );
                     return Ok(error_result_from_envelope(envelope).into());
@@ -1108,6 +1109,7 @@ impl LabMcpServer {
                 let enabled = match target {
                     "manager" => enabled_apps.manager,
                     "codemode" => enabled_code_mode,
+                    "skill_library" => enabled_apps.skill_library,
                     "gateway_status" => enabled_apps.gateway_status,
                     "server_logs" => enabled_apps.server_logs,
                     "add_server" => enabled_apps.add_server,
@@ -1115,6 +1117,7 @@ impl LabMcpServer {
                     "all" => {
                         enabled_apps.manager
                             && enabled_code_mode
+                            && enabled_apps.skill_library
                             && enabled_apps.gateway_status
                             && enabled_apps.server_logs
                             && enabled_apps.add_server
@@ -1126,6 +1129,9 @@ impl LabMcpServer {
                     && match target {
                         "manager" => previous_apps.manager != enabled_apps.manager,
                         "codemode" => previous_code_mode != enabled_code_mode,
+                        "skill_library" => {
+                            previous_apps.skill_library != enabled_apps.skill_library
+                        }
                         "gateway_status" => {
                             previous_apps.gateway_status != enabled_apps.gateway_status
                         }
@@ -1169,6 +1175,10 @@ impl LabMcpServer {
                             "tool": CODE_MODE_UI_TOOL_NAME,
                             "text_tool": CODE_MODE_TOOL_NAME,
                         },
+                        "skill_library": {
+                            "enabled": enabled_apps.skill_library,
+                            "tool": "artifacts",
+                        },
                         "gateway_status": {
                             "enabled": enabled_apps.gateway_status,
                             "tool": GATEWAY_STATUS_TOOL_NAME,
diff --git a/crates/labby/src/mcp/call_tool_codemode.rs b/crates/labby/src/mcp/call_tool_codemode.rs
index 1fe44791c..4de1a4d78 100644
--- a/crates/labby/src/mcp/call_tool_codemode.rs
+++ b/crates/labby/src/mcp/call_tool_codemode.rs
@@ -514,11 +514,53 @@ pub(crate) fn code_arg(
     Ok(code)
 }
 
+fn canonicalize_upstream_filter(
+    requested: &str,
+    available: &BTreeSet<String>,
+) -> Result<String, DispatchToolError> {
+    let requested = requested.trim();
+    if requested.is_empty() || available.contains(requested) {
+        return Ok(requested.to_string());
+    }
+
+    let mut matches = available
+        .iter()
+        .filter(|candidate| candidate.eq_ignore_ascii_case(requested));
+    let Some(first) = matches.next() else {
+        return Ok(requested.to_string());
+    };
+    if matches.next().is_some() {
+        return Err(DispatchToolError::Sdk {
+            sdk_kind: "invalid_param".to_string(),
+            message: format!(
+                "Code Mode upstream `{requested}` is ambiguous by case; use the exact configured casing"
+            ),
+        });
+    }
+    Ok(first.clone())
+}
+
+fn canonicalize_tool_filter(
+    requested: &str,
+    available: &BTreeSet<String>,
+) -> Result<String, DispatchToolError> {
+    let requested = requested.trim();
+    let Some((namespace, tool)) = requested.split_once("::") else {
+        return Ok(requested.to_string());
+    };
+    let namespace = canonicalize_upstream_filter(namespace, available)?;
+    Ok(format!("{namespace}::{tool}"))
+}
+
 fn route_scoped_capability_filter(
     args: &JsonObject,
     route_allowed: Option<&BTreeSet<String>>,
+    available_upstreams: &BTreeSet<String>,
 ) -> Result<ToolScope, DispatchToolError> {
-    let requested_upstreams = string_array_arg(args, "upstreams")?;
+    let requested_upstreams = string_array_arg(args, "upstreams")?
+        .into_iter()
+        .map(|name| canonicalize_upstream_filter(&name, available_upstreams))
+        .collect::<Result<Vec<_>, _>>()?;
     if let Some(allowed) = route_allowed
         && requested_upstreams
             .iter()
@@ -531,7 +573,10 @@ fn route_scoped_capability_filter(
         });
     }
 
-    let tools = string_array_arg(args, "tools")?;
+    let tools = string_array_arg(args, "tools")?
+        .into_iter()
+        .map(|name| canonicalize_tool_filter(&name, available_upstreams))
+        .collect::<Result<Vec<_>, _>>()?;
     let Some(allowed) = route_allowed else {
         return Ok(ToolScope::new(requested_upstreams, tools));
     };
@@ -628,14 +673,18 @@ impl LabMcpServer {
                 return Ok(error_result_from_envelope(env));
             }
         };
-        let capability_filter =
-            match route_scoped_capability_filter(args, self.route_scope.allowed_upstreams()) {
-                Ok(filter) => filter,
-                Err(err) => {
-                    let env = tool_error_envelope(service, "call_tool", &err);
-                    return Ok(error_result_from_envelope(env));
-                }
-            };
+        let available_upstreams = manager.upstream_names().await;
+        let capability_filter = match route_scoped_capability_filter(
+            args,
+            self.route_scope.allowed_upstreams(),
+            &available_upstreams,
+        ) {
+            Ok(filter) => filter,
+            Err(err) => {
+                let env = tool_error_envelope(service, "call_tool", &err);
+                return Ok(error_result_from_envelope(env));
+            }
+        };
         let capability_filter = if read_only {
             capability_filter.read_only()
         } else {
diff --git a/crates/labby/src/mcp/call_tool_codemode/tests.rs b/crates/labby/src/mcp/call_tool_codemode/tests.rs
index 18388f19f..59ddfacc7 100644
--- a/crates/labby/src/mcp/call_tool_codemode/tests.rs
+++ b/crates/labby/src/mcp/call_tool_codemode/tests.rs
@@ -132,19 +132,74 @@ fn scoped_capability_filter_rejects_disallowed_requested_upstreams() {
     let mut args = serde_json::Map::new();
     args.insert("upstreams".to_string(), json!(["beta"]));
     let allowed = std::collections::BTreeSet::from(["alpha".to_string()]);
+    let available = std::collections::BTreeSet::from(["alpha".to_string(), "beta".to_string()]);
 
-    let err = route_scoped_capability_filter(&args, Some(&allowed))
+    let err = route_scoped_capability_filter(&args, Some(&allowed), &available)
         .expect_err("disallowed explicit upstream must fail");
 
     assert_eq!(err.kind(), "route_scope_denied");
 }
 
+#[test]
+fn scoped_capability_filter_canonicalizes_unique_case_variant() {
+    let mut args = serde_json::Map::new();
+    args.insert("upstreams".to_string(), json!(["axon"]));
+    let allowed = std::collections::BTreeSet::from(["Axon".to_string()]);
+    let available = allowed.clone();
+
+    let filter = route_scoped_capability_filter(&args, Some(&allowed), &available)
+        .expect("unique case variant should canonicalize before authorization");
+
+    assert!(filter.allows("Axon", "axon"));
+    assert!(!filter.allows("axon", "axon"));
+}
+
+#[test]
+fn capability_filter_canonicalizes_namespaced_tool_filter() {
+    let mut args = serde_json::Map::new();
+    args.insert("tools".to_string(), json!(["axon::axon"]));
+    let available = std::collections::BTreeSet::from(["Axon".to_string()]);
+
+    let filter = route_scoped_capability_filter(&args, None, &available)
+        .expect("namespaced tool filter should canonicalize its namespace");
+
+    assert!(filter.allows("Axon", "axon"));
+    assert!(!filter.allows("axon", "axon"));
+}
+
+#[test]
+fn capability_filter_rejects_ambiguous_case_alias() {
+    let mut args = serde_json::Map::new();
+    args.insert("upstreams".to_string(), json!(["aXoN"]));
+    let available = std::collections::BTreeSet::from(["Axon".to_string(), "axon".to_string()]);
+
+    let err = route_scoped_capability_filter(&args, None, &available)
+        .expect_err("ambiguous case-only alias must fail closed");
+
+    assert_eq!(err.kind(), "invalid_param");
+    assert!(err.to_string().contains("ambiguous by case"));
+}
+
+#[test]
+fn capability_filter_prefers_exact_case_over_alias_matching() {
+    let mut args = serde_json::Map::new();
+    args.insert("upstreams".to_string(), json!(["Axon"]));
+    let available = std::collections::BTreeSet::from(["Axon".to_string(), "axon".to_string()]);
+
+    let filter = route_scoped_capability_filter(&args, None, &available)
+        .expect("exact namespace must remain usable even with a case-only sibling");
+
+    assert!(filter.allows("Axon", "axon"));
+    assert!(!filter.allows("axon", "axon"));
+}
+
 #[test]
 fn scoped_capability_filter_defaults_to_route_allowed_upstreams() {
     let args = serde_json::Map::new();
     let allowed = std::collections::BTreeSet::from(["alpha".to_string()]);
+    let available = allowed.clone();
 
-    let filter = route_scoped_capability_filter(&args, Some(&allowed))
+    let filter = route_scoped_capability_filter(&args, Some(&allowed), &available)
         .expect("omitted upstreams should default to route scope");
 
     assert!(filter.allows("alpha", "search"));
diff --git a/crates/labby/src/mcp/handlers_resources.rs b/crates/labby/src/mcp/handlers_resources.rs
index 4bc805978..65f6a8b47 100644
--- a/crates/labby/src/mcp/handlers_resources.rs
+++ b/crates/labby/src/mcp/handlers_resources.rs
@@ -651,6 +651,10 @@ impl LabMcpServer {
         let server_logs_app_enabled = mcp_apps_config.server_logs;
         #[cfg(not(feature = "gateway"))]
         let server_logs_app_enabled = true;
+        #[cfg(all(feature = "skills", feature = "gateway"))]
+        let skill_library_app_enabled = mcp_apps_config.skill_library;
+        #[cfg(all(feature = "skills", not(feature = "gateway")))]
+        let skill_library_app_enabled = false;
         let mut page_collector = match PageCollector::new(request) {
             Ok(collector) => collector,
             Err(error) => {
@@ -858,6 +862,7 @@ impl LabMcpServer {
 
         #[cfg(feature = "skills")]
         if !resources.finished()
+            && skill_library_app_enabled
             && self.route_scope.exposes_skills()
             && code_mode_read_scope_allowed(auth)
             && self.route_scope.allows_service("artifacts")
@@ -1600,6 +1605,19 @@ impl LabMcpServer {
 
         #[cfg(feature = "skills")]
         if uri.starts_with(SKILL_LIBRARY_APP_URI_PREFIX) {
+            let app_enabled = {
+                #[cfg(feature = "gateway")]
+                {
+                    self.mcp_apps_config().await.skill_library
+                }
+                #[cfg(not(feature = "gateway"))]
+                {
+                    false
+                }
+            };
+            if !app_enabled {
+                return Err(unknown_resource_error(&uri, true));
+            }
             return self
                 .read_skill_library_app_resource_impl(&uri, &subject, start, &context)
                 .await
@@ -3480,6 +3498,7 @@ Object.assign(globalThis, {{ document, window, requestAnimationFrame, confirm }}
                     },
                     mcp_apps: crate::config::McpAppsConfig {
                         manager: true,
+                        skill_library: true,
                         add_server: true,
                         server_logs: true,
                         gateway_status: true,
diff --git a/crates/labby/src/mcp/handlers_tools.rs b/crates/labby/src/mcp/handlers_tools.rs
index f58e43d3b..d663644cd 100644
--- a/crates/labby/src/mcp/handlers_tools.rs
+++ b/crates/labby/src/mcp/handlers_tools.rs
@@ -244,13 +244,18 @@ impl LabMcpServer {
             && self.route_scope.allows_service("setup")
             && self.service_visible_on_mcp("setup").await;
         let mut builtin_names = HashSet::new();
+        #[cfg(all(feature = "skills", feature = "gateway"))]
+        let skill_library_app_enabled = mcp_apps_config.skill_library;
+        #[cfg(all(feature = "skills", not(feature = "gateway")))]
+        let skill_library_app_enabled = false;
         #[cfg(feature = "skills")]
         let skill_library_allowed_actions = self.allowed_mcp_actions("artifacts").await;
         #[cfg(feature = "skills")]
         let skill_library_mode = if self.skill_library_http_management_visible(&context) {
             let skills_auth = auth_context_from_extensions(&context.extensions);
             SkillLibraryDescriptorMode::Management {
-                app_visible: code_mode_read_scope_allowed(skills_auth)
+                app_visible: skill_library_app_enabled
+                    && code_mode_read_scope_allowed(skills_auth)
                     && self.route_scope.exposes_resources(),
                 allowed_actions: skill_library_allowed_actions.as_deref(),
             }
@@ -710,7 +715,7 @@ pub(crate) fn code_mode_ui_description(upstreams: &[CodeModeUpstreamDescription]
 /// Description for the always-available `mcp_app` control tool.
 #[cfg(feature = "gateway")]
 pub(crate) const fn mcp_app_tool_description() -> &'static str {
-    "Enable, disable, and inspect Labby-owned MCP App surfaces. The control tool remains available even when its own manager UI is disabled. Targets include the manager UI, Code Mode inspector, gateway status, server logs, Add Server, Settings, or all managed apps."
+    "Enable, disable, and inspect Labby-owned MCP App surfaces. The control tool remains available even when its own manager UI is disabled. Targets include the manager UI, Code Mode inspector, Skill Library, gateway status, server logs, Add Server, Settings, or all managed apps."
 }
 
 #[cfg(feature = "gateway")]
@@ -727,7 +732,7 @@ pub(crate) fn mcp_app_tool_schema() -> Arc<serde_json::Map<String, Value>> {
                 },
                 "target": {
                     "type": "string",
-                    "enum": ["manager", "codemode", "gateway_status", "server_logs", "add_server", "settings", "all"],
+                    "enum": ["manager", "codemode", "skill_library", "gateway_status", "server_logs", "add_server", "settings", "all"],
                     "default": "codemode",
                     "description": "Legacy direct target shape. Use all for the switchboard snapshot or a bulk change."
                 },
@@ -736,7 +741,7 @@ pub(crate) fn mcp_app_tool_schema() -> Arc<serde_json::Map<String, Value>> {
                     "properties": {
                         "target": {
                             "type": "string",
-                            "enum": ["manager", "codemode", "gateway_status", "server_logs", "add_server", "settings", "all"],
+                            "enum": ["manager", "codemode", "skill_library", "gateway_status", "server_logs", "add_server", "settings", "all"],
                             "default": "codemode",
                             "description": "Labby-owned MCP App target used by the shared app host."
                         }
@@ -835,10 +840,19 @@ fn owned_app_tool_meta(resource_uri: String, skybridge_uri: Option<String>) -> M
 
 /// Agent-readable fallback for hosts that do not render the attached app.
 #[cfg(feature = "skills")]
-pub(crate) fn skill_library_tool_description(service_description: &str) -> String {
-    format!(
-        "{service_description} This tool also opens Labby's Artifact Library app on compatible hosts. On non-App hosts, call the documented artifacts.* actions directly with the same action and params envelope. Save and import do not activate an Artifact."
-    )
+pub(crate) fn skill_library_tool_description(
+    service_description: &str,
+    app_visible: bool,
+) -> String {
+    if app_visible {
+        format!(
+            "{service_description} This tool also opens Labby's Artifact Library app on compatible hosts. On non-App hosts, call the documented artifacts.* actions directly with the same action and params envelope. Save and import do not activate an Artifact."
+        )
+    } else {
+        format!(
+            "{service_description} Call the documented artifacts.* actions directly with the same action and params envelope. Save and import do not activate an Artifact."
+        )
+    }
 }
 
 /// Bind the canonical `skills` service descriptor to both supported app hosts.
diff --git a/crates/labby/src/mcp/handlers_tools/tests.rs b/crates/labby/src/mcp/handlers_tools/tests.rs
index 04714fd28..120b317a8 100644
--- a/crates/labby/src/mcp/handlers_tools/tests.rs
+++ b/crates/labby/src/mcp/handlers_tools/tests.rs
@@ -5,6 +5,8 @@
 //! self-contained (per the test-distribution plan's minimal-duplication
 //! guidance).
 
+#[cfg(feature = "skills")]
+use crate::app_assets::{SKILL_LIBRARY_APP_URI, SKILL_LIBRARY_APP_URI_PREFIX};
 use crate::config::{
     GatewayLoadoutConfig, ProtectedGatewaySubsetTarget, ProtectedMcpRouteConfig,
     ProtectedMcpRouteTarget,
@@ -317,6 +319,7 @@ async fn code_mode_manager(
                 },
                 mcp_apps: crate::config::McpAppsConfig {
                     manager: true,
+                    skill_library: true,
                     add_server: true,
                     server_logs: true,
                     gateway_status: true,
@@ -374,6 +377,7 @@ async fn code_mode_manager_with_test_runner(
                 },
                 mcp_apps: crate::config::McpAppsConfig {
                     manager: true,
+                    skill_library: true,
                     add_server: true,
                     server_logs: true,
                     gateway_status: true,
@@ -506,6 +510,7 @@ async fn code_mode_manager_with_pool_and_upstreams(
                 },
                 mcp_apps: crate::config::McpAppsConfig {
                     manager: true,
+                    skill_library: true,
                     add_server: true,
                     server_logs: true,
                     gateway_status: true,
@@ -1202,6 +1207,7 @@ fn mcp_app_schema_and_meta_cover_managed_apps() {
         serde_json::json!([
             "manager",
             "codemode",
+            "skill_library",
             "gateway_status",
             "server_logs",
             "add_server",
@@ -1889,13 +1895,21 @@ async fn mcp_app_individual_disable_only_changes_selected_surface() {
     assert_eq!(structured["enabled"], false);
     assert_eq!(structured["changed"], true);
     assert_eq!(structured["apps"]["server_logs"]["enabled"], false);
-    for target in ["manager", "codemode", "gateway_status", "add_server"] {
+    for target in [
+        "manager",
+        "codemode",
+        "skill_library",
+        "gateway_status",
+        "add_server",
+        "settings",
+    ] {
         assert_eq!(structured["apps"][target]["enabled"], true, "{target}");
     }
 
     let cfg = manager.current_config().await;
     assert!(cfg.mcp_apps.manager);
     assert!(cfg.code_mode.mcp_ui_enabled);
+    assert!(cfg.mcp_apps.skill_library);
     assert!(cfg.mcp_apps.gateway_status);
     assert!(!cfg.mcp_apps.server_logs);
     assert!(cfg.mcp_apps.add_server);
@@ -2060,6 +2074,7 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
     for target in [
         "manager",
         "codemode",
+        "skill_library",
         "gateway_status",
         "server_logs",
         "add_server",
@@ -2071,6 +2086,7 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
     let cfg = manager.current_config().await;
     assert!(!cfg.mcp_apps.manager);
     assert!(!cfg.code_mode.mcp_ui_enabled);
+    assert!(!cfg.mcp_apps.skill_library);
     assert!(!cfg.mcp_apps.gateway_status);
     assert!(!cfg.mcp_apps.server_logs);
     assert!(!cfg.mcp_apps.add_server);
@@ -2116,7 +2132,6 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
             .is_some_and(|meta| !meta.0.contains_key("ui")),
         "server_logs app metadata must be disabled"
     );
-
     let resources = running
         .service()
         .list_resources_impl(None, scoped_context(peer.clone(), &["lab:admin"]))
@@ -2138,6 +2153,14 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
             "managed resource remained listed: {hidden_prefix}"
         );
     }
+    #[cfg(feature = "skills")]
+    assert!(
+        resources
+            .resources
+            .iter()
+            .all(|resource| !resource.uri.starts_with(SKILL_LIBRARY_APP_URI_PREFIX)),
+        "Skill Library resource remained listed after bulk disable"
+    );
     for stale_uri in [
         MCP_APPS_APP_URI,
         CODE_MODE_APP_URI,
@@ -2156,6 +2179,18 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
             .expect_err("disabled app resource must be unreadable");
         assert!(stale.message.contains("unknown UI resource"), "{stale:?}");
     }
+    #[cfg(feature = "skills")]
+    {
+        let stale = running
+            .service()
+            .read_resource_impl(
+                ReadResourceRequestParams::new(SKILL_LIBRARY_APP_URI),
+                scoped_context(peer.clone(), &["lab:admin"]),
+            )
+            .await
+            .expect_err("disabled Skill Library resource must be unreadable");
+        assert!(stale.message.contains("unknown UI resource"), "{stale:?}");
+    }
 
     let enable = running
         .service()
@@ -2174,6 +2209,7 @@ async fn mcp_app_bulk_disable_hides_managed_apps_but_keeps_manager() {
     let cfg = manager.current_config().await;
     assert!(cfg.mcp_apps.manager);
     assert!(cfg.code_mode.mcp_ui_enabled);
+    assert!(cfg.mcp_apps.skill_library);
     assert!(cfg.mcp_apps.gateway_status);
     assert!(cfg.mcp_apps.server_logs);
     assert!(cfg.mcp_apps.add_server);
diff --git a/crates/labby/src/mcp/peer_contract.rs b/crates/labby/src/mcp/peer_contract.rs
index 5b5863b92..a368ee6fc 100644
--- a/crates/labby/src/mcp/peer_contract.rs
+++ b/crates/labby/src/mcp/peer_contract.rs
@@ -543,11 +543,16 @@ impl PeerContract {
             Some(manager) => manager.allowed_mcp_actions_for_service("artifacts").await,
             None => None,
         };
+        #[cfg(feature = "gateway")]
+        let skill_library_app_enabled = mcp_apps_config.skill_library;
+        #[cfg(not(feature = "gateway"))]
+        let skill_library_app_enabled = false;
         #[cfg(not(feature = "gateway"))]
         let skill_library_allowed_actions: Option<Vec<String>> = None;
         let skill_library_mode = if self.audience.skill_library_management_visible {
             SkillLibraryDescriptorMode::Management {
-                app_visible: self.audience.skill_library_app_visible
+                app_visible: skill_library_app_enabled
+                    && self.audience.skill_library_app_visible
                     && self.route_scope.exposes_resources(),
                 allowed_actions: skill_library_allowed_actions.as_deref(),
             }
diff --git a/crates/labby/src/mcp/permanent_tools.rs b/crates/labby/src/mcp/permanent_tools.rs
index d1a266650..fe1db09a3 100644
--- a/crates/labby/src/mcp/permanent_tools.rs
+++ b/crates/labby/src/mcp/permanent_tools.rs
@@ -334,6 +334,13 @@ impl PermanentToolRegistry {
             } => allowed_actions,
             SkillLibraryDescriptorMode::Hidden => None,
         };
+        let app_visible = matches!(
+            mode,
+            SkillLibraryDescriptorMode::Management {
+                app_visible: true,
+                ..
+            }
+        );
         let annotations = ToolAnnotations::new()
             .read_only(false)
             .destructive(true)
@@ -341,7 +348,7 @@ impl PermanentToolRegistry {
             .open_world(true);
         let tool = Tool::new(
             service.name,
-            skill_library_tool_description(service.description),
+            skill_library_tool_description(service.description, app_visible),
             skill_action_schema(allowed_actions),
         )
         .with_annotations(annotations)
@@ -955,6 +962,12 @@ mod tests {
                 .as_ref()
                 .is_some_and(|meta| !meta.0.contains_key("ui"))
         );
+        assert!(
+            hidden_app.description.as_deref().is_some_and(
+                |description| !description.contains("opens Labby's Artifact Library app")
+            ),
+            "a disabled Skill Library must not advertise an app binding"
+        );
         assert_eq!(hidden_app.input_schema, tool.input_schema);
     }
 
diff --git a/docs/services/GATEWAY.md b/docs/services/GATEWAY.md
index 38cdbb744..41702ee99 100644
--- a/docs/services/GATEWAY.md
+++ b/docs/services/GATEWAY.md
@@ -335,15 +335,14 @@ disabled, but the text-only control tool remains available on the root gateway.
 
 The Code Mode Inspector keeps its compatibility switch at
 `code_mode.mcp_ui_enabled`. The other visibility switches are
-`mcp_apps.manager`, `mcp_apps.gateway_status`, `mcp_apps.server_logs`,
-`mcp_apps.add_server`, and `mcp_apps.settings`. Every Labby-owned app surface
-defaults to `true`, as does `code_mode.enabled`, so a fresh install exposes the
-complete Labby app surface. Existing installs whose `config.toml` has no
-`[code_mode]` or `[mcp_apps]` section inherit those defaults on upgrade; Labby
-logs one startup line naming the defaults in force so the change is visible.
-Set the individual switches to `false` to opt out. The `mcp_app` control tool
-remains available without UI metadata so an administrator can inspect or restore
-any app, including its own manager UI. App-only mutations persist without
+`mcp_apps.manager`, `mcp_apps.skill_library`, `mcp_apps.gateway_status`,
+`mcp_apps.server_logs`, `mcp_apps.add_server`, and `mcp_apps.settings`. Labby-owned MCP App UIs default
+to `false` and are opt-in on a fresh install; `code_mode.enabled` remains `true`
+so the text-only Code Mode execution surface stays available. Existing installs
+with explicit visibility settings keep those values, while configs that omit the
+UI switches inherit the off defaults. Enable only the app surfaces a client
+actually needs. The `mcp_app` control tool remains available without UI metadata
+so an administrator can inspect or restore any app, including its own manager UI. App-only mutations persist without
 rebuilding the upstream pool and publish both tool and resource list-changed
 notifications. Upstream MCP Apps are not governed by these switches. Their app
 tools/callbacks pass through only when an allowed upstream exposes a real
diff --git a/docs/surfaces/MCP.md b/docs/surfaces/MCP.md
index 9f5ca4b80..500b76209 100644
--- a/docs/surfaces/MCP.md
+++ b/docs/surfaces/MCP.md
@@ -109,10 +109,10 @@ inspect the current route-scoped tool catalog.
 ### Labby MCP App manager
 
 The root gateway always advertises the `mcp_app` control tool, but its own MCP
-App UI is enabled by default. The tool manages `manager`, `codemode`, `gateway_status`,
-`server_logs`, `add_server`, `settings`, or `all`. Every Labby-owned app surface
-defaults on; the text-only control tool remains available so an
-administrator can disable or restore individual surfaces, including the manager UI
+App UI is opt-in. The tool manages `manager`, `codemode`, `skill_library`,
+`gateway_status`, `server_logs`, `add_server`, `settings`, or `all`. Every managed Labby-owned app
+UI defaults off; the text-only control tool remains available so an administrator
+can enable, disable, or restore individual surfaces, including the manager UI
 itself. The default target remains `codemode` for backward compatibility with the
 original inspector-only control contract.