diff --git a/CHANGELOG.md b/CHANGELOG.md
index 97f3bf5..535a710 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+### Added
+- **Funplay > MCP Settings > Recent Activity** now includes a per-project **Expand all entries by default** preference. It is enabled by default for new and previously unconfigured projects, persists across Editor reloads (including an explicit off choice), and updates the open panel immediately without restarting MCP. Manually expanded or collapsed rows retain their state until the panel is reopened.
+
+### Changed
+- The MCP Server window's Recent Activity panel supports collapsing entries to one-line summaries by clicking their headers, and reopening them from either the header or summary. With **Expand all entries by default** disabled, history is collapsed and only the latest result expands automatically; manually expanded or collapsed rows keep their state as new entries arrive. Summaries resize with the panel's available width in both directions, and hovering either the header or summary consistently shows the same formatted, multi-line detail text.
+
+- Collapsed summaries use the human-readable formatted result instead of raw JSON and retain text beyond the compact resource summary's 200-character limit, while keeping the existing 4,000-character display bound. Plain-text results use that same display budget.
+- Detail controls and screenshot textures are created only when a row expands and released when it collapses, is cleared, or is evicted. The panel mirrors the activity log's bounded capacity, and queued callbacks cannot resurrect cleared rows or duplicate rows after a rebuild.
+
+### Pull requests and issues
+- [PR #57](https://github.com/FunplayAI/funplay-unity-mcp/pull/57): collapsible Recent Activity, with a persistent expand-all preference, readable summaries, lazy detail loading, resource cleanup, and Editor UI regression tests.
+- No GitHub issues were closed by these changes.
+
+### Contributors
+- Thanks [@dehuaichendragonplus](https://github.com/dehuaichendragonplus) for PR #57.
+
 ## [0.6.6] - 2026-09-07
 
 ### Added
diff --git a/Editor/MCP/Server/FunplayMCPRecentActivityPanel.cs b/Editor/MCP/Server/FunplayMCPRecentActivityPanel.cs
index 43638d2..6982a7c 100644
--- a/Editor/MCP/Server/FunplayMCPRecentActivityPanel.cs
+++ b/Editor/MCP/Server/FunplayMCPRecentActivityPanel.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using Funplay.Editor.Settings;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.UIElements;
@@ -50,18 +51,47 @@ internal sealed class FunplayMCPRecentActivityPanel : IDisposable
         private static readonly Color PendingValueColor = new Color(0.95f, 0.68f, 0.25f);
         private static readonly Color MutedValueColor = new Color(0.56f, 0.56f, 0.56f);
 
-        private readonly MCPServerService _server;
-        private readonly List<Texture2D> _previewTextures = new List<Texture2D>();
+        private readonly MCPInteractionLog _interactionLog;
+        private readonly ISettingsController _settingsController;
+        private readonly Action<Action> _defer;
+        private readonly List<RowExpandState> _rows = new List<RowExpandState>();
         private ScrollView _scrollView;
+        private RowExpandState _autoExpandedRow;
+        private int _generation;
+        private bool _expandAllByDefault;
+
+        // Tracks one row's expand/collapse so the "latest entry auto-expands" behavior can
+        // later collapse it again once a newer entry arrives - but only if the user never
+        // touched it themselves in the meantime (manual choices always win).
+        private sealed class RowExpandState
+        {
+            public VisualElement Card;
+            public bool ManuallyToggled;
+            public Action<bool> ApplyExpanded;
+            public Action ReleaseDetails;
+        }
 
-        public FunplayMCPRecentActivityPanel(MCPServerService server)
+        public FunplayMCPRecentActivityPanel(MCPServerService server, ISettingsController settingsController)
+            : this(server.InteractionLog, settingsController: settingsController)
         {
-            _server = server;
+        }
+
+        internal FunplayMCPRecentActivityPanel(
+            MCPInteractionLog interactionLog,
+            Action<Action> defer = null,
+            ISettingsController settingsController = null)
+        {
+            _interactionLog = interactionLog ?? throw new ArgumentNullException(nameof(interactionLog));
+            _defer = defer ?? (callback => EditorApplication.delayCall += () => callback());
+            _settingsController = settingsController;
+            _expandAllByDefault = _settingsController?.MCPRecentActivityExpandedByDefault ?? true;
+            if (_settingsController != null)
+                _settingsController.OnSettingsChanged += RefreshExpansionDefaults;
         }
 
         public void AddTo(VisualElement parent)
         {
-            ClearPreviewTextures();
+            ClearRows();
 
             var header = new VisualElement();
             header.style.flexDirection = FlexDirection.Row;
@@ -78,10 +108,10 @@ public void AddTo(VisualElement parent)
 
             var clearButton = new Button(() =>
             {
-                _server.InteractionLog.Clear();
-                ClearPreviewTextures();
-                _scrollView?.contentContainer.Clear();
+                _interactionLog.Clear();
+                ClearRows();
             });
+            clearButton.name = "recent-activity-clear";
             clearButton.text = "Clear";
             clearButton.style.height = 20;
             clearButton.style.width = 50;
@@ -90,6 +120,7 @@ public void AddTo(VisualElement parent)
             parent.Add(header);
 
             _scrollView = new ScrollView(ScrollViewMode.Vertical);
+            _scrollView.name = "recent-activity-scroll";
             _scrollView.style.flexGrow = 1;
             _scrollView.style.backgroundColor = new Color(0.14f, 0.14f, 0.14f);
             _scrollView.style.borderTopLeftRadius = 4;
@@ -102,39 +133,62 @@ public void AddTo(VisualElement parent)
             _scrollView.style.paddingBottom = 4;
             parent.Add(_scrollView);
 
-            var entries = _server.InteractionLog.GetEntries();
+            _autoExpandedRow = null;
+            // GetEntries() returns newest-first (index 0 = most recent); this loop walks it
+            // back-to-front so the oldest row is added (and rendered) first, newest last/bottom.
+            var entries = _interactionLog.GetEntries();
             for (int i = entries.Count - 1; i >= 0; i--)
-                AddRow(entries[i]);
+                AddRow(entries[i], isLatest: i == 0);
         }
 
         public void OnEntryAdded(MCPLogEntry entry)
         {
-            EditorApplication.delayCall += () =>
+            var generation = _generation;
+            _defer(() =>
             {
-                if (_scrollView == null)
+                // Clear/rebuild/dispose invalidates already-queued entries and scroll requests.
+                if (_scrollView == null || generation != _generation)
                     return;
 
-                AddRow(entry);
-                EditorApplication.delayCall += () =>
+                AddRow(entry, isLatest: true);
+                _defer(() =>
                 {
-                    if (_scrollView != null)
+                    if (_scrollView != null && generation == _generation)
                         _scrollView.scrollOffset = new Vector2(0, float.MaxValue);
-                };
-            };
+                });
+            });
         }
 
         public void Dispose()
         {
-            ClearPreviewTextures();
+            if (_settingsController != null)
+                _settingsController.OnSettingsChanged -= RefreshExpansionDefaults;
+            ClearRows();
             _scrollView = null;
         }
 
-        private void AddRow(MCPLogEntry entry)
+        private void RefreshExpansionDefaults()
+        {
+            var expandAll = _settingsController.MCPRecentActivityExpandedByDefault;
+            if (expandAll == _expandAllByDefault)
+                return;
+
+            _expandAllByDefault = expandAll;
+            // Apply the preference live without rebuilding rows or discarding manual choices.
+            foreach (var row in _rows)
+            {
+                if (!row.ManuallyToggled)
+                    row.ApplyExpanded?.Invoke(expandAll || row == _autoExpandedRow);
+            }
+        }
+
+        private void AddRow(MCPLogEntry entry, bool isLatest = false)
         {
             var badgeText = GetBadgeText(entry.Status);
             var accentColor = GetAccentColor(entry.Status);
 
             var card = new VisualElement();
+            card.name = "recent-activity-row";
             card.style.backgroundColor = new Color(0.19f, 0.19f, 0.19f);
             card.style.borderTopLeftRadius = 4;
             card.style.borderTopRightRadius = 4;
@@ -149,9 +203,17 @@ private void AddRow(MCPLogEntry entry)
             card.style.marginBottom = 3;
 
             var topRow = new VisualElement();
+            topRow.name = "recent-activity-header";
             topRow.style.flexDirection = FlexDirection.Row;
             topRow.style.alignItems = Align.Center;
 
+            var expandArrow = new Label("▸");
+            expandArrow.style.fontSize = 10;
+            expandArrow.style.color = new Color(0.5f, 0.5f, 0.5f);
+            expandArrow.style.marginRight = 4;
+            expandArrow.style.width = 10;
+            topRow.Add(expandArrow);
+
             var timeLabel = new Label(entry.Timestamp.ToString("HH:mm:ss"));
             timeLabel.style.fontSize = 10;
             timeLabel.style.color = new Color(0.5f, 0.5f, 0.5f);
@@ -198,28 +260,143 @@ private void AddRow(MCPLogEntry entry)
                 isStructuredResult = true;
             }
 
-            if (!string.IsNullOrEmpty(displayResult))
+            var detailsContainer = new VisualElement { name = "recent-activity-details" };
+            var hasDetails = !string.IsNullOrEmpty(displayResult) || !string.IsNullOrEmpty(entry.ImageDataUri);
+            var rowState = new RowExpandState { Card = card };
+
+            if (isLatest)
             {
-                if (isStructuredResult)
+                // A new entry became the latest: collapse whichever row was auto-expanded for
+                // that reason before, unless the user has since touched it themselves -
+                // manual choices are never overridden by the "latest" auto-expand behavior.
+                if (!_expandAllByDefault && _autoExpandedRow != null && !_autoExpandedRow.ManuallyToggled)
+                    _autoExpandedRow.ApplyExpanded(false);
+                _autoExpandedRow = null;
+            }
+
+            if (hasDetails)
+            {
+                // DisplayResult is readable text with a larger, bounded display budget. The
+                // compact ResultSummary is raw protocol text capped at 200 chars for resources.
+                var collapsedSummary = CreateCollapsedSummaryLabel(displayResult);
+                card.Add(collapsedSummary);
+
+                card.Add(detailsContainer);
+
+                // Native Editor tooltip: show the same formatted detail text the expanded view
+                // renders, everywhere in the card. Plain `card.tooltip` is not enough: an ellipsis-
+                // truncated Label (the collapsed summary line) supplies its own default tooltip
+                // (its raw, unformatted text) at the moment it is hovered, which pre-empts an
+                // ancestor's tooltip and made the header and the summary line disagree. Intercept
+                // the TooltipEvent during the trickle-down (capture) phase instead, before it
+                // reaches any such child, so this one formatted value always wins.
+                card.RegisterCallback<TooltipEvent>(evt =>
                 {
-                    card.Add(CreateStructuredResult(displayResult));
-                }
-                else
+                    evt.tooltip = displayResult;
+                    evt.rect = card.worldBound;
+                    evt.StopImmediatePropagation();
+                }, TrickleDown.TrickleDown);
+
+                var expanded = false;
+                Texture2D previewTexture = null;
+                rowState.ReleaseDetails = () =>
                 {
-                    var summaryLabel = CreateWrappedLabel(displayResult, new Color(0.6f, 0.6f, 0.6f));
-                    summaryLabel.style.fontSize = 11;
-                    summaryLabel.style.marginTop = 3;
-                    card.Add(summaryLabel);
-                }
-            }
+                    detailsContainer.Clear();
+                    if (previewTexture != null)
+                        UnityEngine.Object.DestroyImmediate(previewTexture);
+                    previewTexture = null;
+                };
+                rowState.ApplyExpanded = value =>
+                {
+                    if (value && !expanded)
+                    {
+                        if (!string.IsNullOrEmpty(displayResult))
+                        {
+                            if (isStructuredResult)
+                                detailsContainer.Add(CreateStructuredResult(displayResult));
+                            else
+                            {
+                                var text = CreateWrappedLabel(displayResult, new Color(0.6f, 0.6f, 0.6f));
+                                text.style.fontSize = 11;
+                                text.style.marginTop = 3;
+                                detailsContainer.Add(text);
+                            }
+                        }
+
+                        if (TryCreateImagePreview(entry.ImageDataUri, out var preview))
+                        {
+                            previewTexture = preview.image as Texture2D;
+                            detailsContainer.Add(preview);
+                        }
+                    }
+                    else if (!value && expanded)
+                    {
+                        // Hiding the subtree alone retains its Labels and decoded GPU texture.
+                        // Recreate on demand so collapsed history stays lightweight.
+                        rowState.ReleaseDetails();
+                    }
+                    expanded = value;
+                    expandArrow.text = expanded ? "▾" : "▸";
+                    detailsContainer.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None;
+                    collapsedSummary.style.display = expanded ? DisplayStyle.None : DisplayStyle.Flex;
+                };
+
+                EventCallback<ClickEvent> toggle = evt =>
+                {
+                    if (evt.button != 0)
+                        return;
+                    rowState.ManuallyToggled = true;
+                    rowState.ApplyExpanded(!expanded);
+                };
+                // Both the header row and the collapsed summary line must open the card -
+                // they are siblings, not nested, so each needs its own click registration.
+                topRow.RegisterCallback(toggle);
+                collapsedSummary.RegisterCallback(toggle);
 
-            if (!string.IsNullOrEmpty(entry.ImageDataUri) &&
-                TryCreateImagePreview(entry.ImageDataUri, out var preview))
+                if (isLatest)
+                    _autoExpandedRow = rowState;
+
+                rowState.ApplyExpanded(_expandAllByDefault || isLatest);
+            }
+            else
             {
-                card.Add(preview);
+                expandArrow.style.display = DisplayStyle.None;
             }
 
+            _rows.Add(rowState);
             _scrollView?.contentContainer.Add(card);
+            // The log is a ring buffer; mirror its bound instead of retaining evicted UI rows.
+            while (_rows.Count > _interactionLog.Capacity)
+            {
+                var oldest = _rows[0];
+                oldest.ReleaseDetails?.Invoke();
+                oldest.Card.RemoveFromHierarchy();
+                if (_autoExpandedRow == oldest)
+                    _autoExpandedRow = null;
+                _rows.RemoveAt(0);
+            }
+        }
+
+        private static Label CreateCollapsedSummaryLabel(string resultSummary)
+        {
+            var text = string.IsNullOrEmpty(resultSummary) ? "" : resultSummary.Replace('\r', ' ').Replace('\n', ' ').Trim();
+
+            var label = new Label(text);
+            label.name = "recent-activity-summary";
+            label.enableRichText = false;
+            label.style.fontSize = 10;
+            label.style.color = new Color(0.55f, 0.55f, 0.55f);
+            label.style.marginTop = 2;
+            label.style.whiteSpace = WhiteSpace.NoWrap;
+            label.style.overflow = Overflow.Hidden;
+            label.style.textOverflow = TextOverflow.Ellipsis;
+            // No manual char cap and no explicit width: the label relies on the default
+            // stretch-to-parent cross-axis sizing (same as topRow) so it tracks the card's
+            // actual width on every relayout, growing back on widen as well as shrinking on
+            // narrow. minWidth=0 stops the NoWrap text's intrinsic width from acting as a
+            // lower bound that would otherwise fight that resize in one direction.
+            label.style.minWidth = 0;
+            return label;
         }
 
         private static VisualElement CreateStructuredResult(string displayResult)
@@ -502,25 +679,24 @@ private static Color GetAccentColor(MCPToolCallStatus status)
             }
         }
 
-        private bool TryCreateImagePreview(string imageDataUri, out Image preview)
+        private static bool TryCreateImagePreview(string imageDataUri, out Image preview)
         {
             preview = null;
             const string prefix = "data:image/png;base64,";
             if (string.IsNullOrEmpty(imageDataUri) || !imageDataUri.StartsWith(prefix, StringComparison.Ordinal))
                 return false;
 
+            Texture2D texture = null;
             try
             {
                 var bytes = Convert.FromBase64String(imageDataUri.Substring(prefix.Length));
-                var texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
+                texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
                 if (!texture.LoadImage(bytes))
                 {
                     UnityEngine.Object.DestroyImmediate(texture);
                     return false;
                 }
 
-                _previewTextures.Add(texture);
-
                 preview = new Image
                 {
                     image = texture,
@@ -537,19 +713,20 @@ private bool TryCreateImagePreview(string imageDataUri, out Image preview)
             }
             catch
             {
+                if (texture != null)
+                    UnityEngine.Object.DestroyImmediate(texture);
                 return false;
             }
         }
 
-        private void ClearPreviewTextures()
+        private void ClearRows()
         {
-            foreach (var texture in _previewTextures)
-            {
-                if (texture != null)
-                    UnityEngine.Object.DestroyImmediate(texture);
-            }
-
-            _previewTextures.Clear();
+            _generation++;
+            foreach (var row in _rows)
+                row.ReleaseDetails?.Invoke();
+            _rows.Clear();
+            _autoExpandedRow = null;
+            _scrollView?.contentContainer.Clear();
         }
     }
 }
diff --git a/Editor/MCP/Server/FunplayMCPWindow.cs b/Editor/MCP/Server/FunplayMCPWindow.cs
index ec18319..2a050aa 100644
--- a/Editor/MCP/Server/FunplayMCPWindow.cs
+++ b/Editor/MCP/Server/FunplayMCPWindow.cs
@@ -99,7 +99,7 @@ private void BuildUI()
                     BuildUI)
                 .AddTo(mainContainer);
 
-            _activityPanel = new FunplayMCPRecentActivityPanel(_mcpServer);
+            _activityPanel = new FunplayMCPRecentActivityPanel(_mcpServer, _settingsController);
             _activityPanel.AddTo(mainContainer);
         }
 
diff --git a/Editor/MCP/Server/FunplayPluginSettingsWindow.cs b/Editor/MCP/Server/FunplayPluginSettingsWindow.cs
index 7f57a8f..a38b90c 100644
--- a/Editor/MCP/Server/FunplayPluginSettingsWindow.cs
+++ b/Editor/MCP/Server/FunplayPluginSettingsWindow.cs
@@ -19,6 +19,7 @@ namespace Funplay.Editor.MCP.Server
     internal class FunplayPluginSettingsWindow : EditorWindow
     {
         private ISettingsController _settingsController;
+        private Toggle _recentActivityExpandedToggle;
         private Toggle _debugLoggingToggle;
         private Label _debugStatusLabel;
 
@@ -32,6 +33,8 @@ public static void ShowWindow()
 
         public void CreateGUI()
         {
+            if (_settingsController != null)
+                _settingsController.OnSettingsChanged -= RefreshStatus;
             _settingsController = RootScopeServices.Services?.GetService(typeof(ISettingsController))
                 as ISettingsController;
 
@@ -68,17 +71,41 @@ private void BuildUI()
             title.style.marginBottom = 4;
             rootVisualElement.Add(title);
 
-            var hint = new Label("Project-level settings for the Funplay Unity MCP plugin. Safety checks and debug logging are stored per project.");
+            var hint = new Label("Project-level settings for the Funplay Unity MCP plugin. Preferences are saved per project.");
             hint.style.fontSize = 11;
             hint.style.color = new Color(0.65f, 0.65f, 0.65f);
             hint.style.whiteSpace = WhiteSpace.Normal;
             hint.style.marginBottom = 10;
             rootVisualElement.Add(hint);
 
+            var content = new ScrollView(ScrollViewMode.Vertical) { name = "mcp-settings-scroll" };
+            content.style.flexGrow = 1;
+            content.style.minHeight = 0;
+            rootVisualElement.Add(content);
+
             var safetySection = CreateSection();
             safetySection.style.marginBottom = 8;
             FunplayMCPSafetyPanel.AddTo(safetySection, _settingsController);
-            rootVisualElement.Add(safetySection);
+            content.Add(safetySection);
+
+            var activitySection = CreateSection();
+            activitySection.style.marginBottom = 8;
+            activitySection.Add(CreateSectionHeader("Recent Activity"));
+            _recentActivityExpandedToggle = new Toggle("Expand all entries by default")
+            {
+                name = "recent-activity-expanded-by-default"
+            };
+            _recentActivityExpandedToggle.style.marginBottom = 5;
+            _recentActivityExpandedToggle.labelElement.style.whiteSpace = WhiteSpace.Normal;
+            _recentActivityExpandedToggle.labelElement.style.flexShrink = 1;
+            _recentActivityExpandedToggle.SetValueWithoutNotify(_settingsController.MCPRecentActivityExpandedByDefault);
+            _recentActivityExpandedToggle.RegisterValueChangedCallback(evt =>
+                _settingsController.MCPRecentActivityExpandedByDefault = evt.newValue);
+            activitySection.Add(_recentActivityExpandedToggle);
+            activitySection.Add(CreateHint(
+                "On: expand all entries. Off: collapse history and expand only the latest entry. " +
+                "Applies immediately; manually expanded or collapsed entries keep your choice until the panel is reopened."));
+            content.Add(activitySection);
 
             var debugSection = CreateSection();
             debugSection.Add(CreateSectionHeader("Debug"));
@@ -96,7 +123,7 @@ private void BuildUI()
             _debugStatusLabel = CreateHint(string.Empty);
             debugSection.Add(_debugStatusLabel);
 
-            rootVisualElement.Add(debugSection);
+            content.Add(debugSection);
             RefreshStatus();
         }
 
@@ -105,6 +132,8 @@ private void RefreshStatus()
             if (_settingsController == null)
                 return;
 
+            _recentActivityExpandedToggle?.SetValueWithoutNotify(_settingsController.MCPRecentActivityExpandedByDefault);
+
             var enabled = _settingsController.PluginDebugLoggingEnabled;
             if (_debugLoggingToggle != null)
                 _debugLoggingToggle.SetValueWithoutNotify(enabled);
@@ -123,6 +152,7 @@ private void RefreshStatus()
         private static VisualElement CreateSection()
         {
             var section = new VisualElement();
+            section.style.flexShrink = 0;
             section.style.backgroundColor = new Color(0.14f, 0.14f, 0.14f);
             section.style.borderTopLeftRadius = 4;
             section.style.borderTopRightRadius = 4;
diff --git a/Editor/MCP/Server/MCPInteractionLog.cs b/Editor/MCP/Server/MCPInteractionLog.cs
index cf87bd6..8271e00 100644
--- a/Editor/MCP/Server/MCPInteractionLog.cs
+++ b/Editor/MCP/Server/MCPInteractionLog.cs
@@ -43,6 +43,7 @@ internal class MCPInteractionLog
         private readonly object _lock = new object();
 
         public event Action<MCPLogEntry> OnEntryAdded;
+        internal int Capacity => _buffer.Length;
 
         public MCPInteractionLog(int capacity = 200)
         {
@@ -57,7 +58,11 @@ public void Add(string toolName, MCPToolCallStatus status, string resultSummary)
             var compactSummary = imageDataUri != null
                 ? "Screenshot captured successfully."
                 : CreateCompactSummary(resultSummary);
-            var displayResult = compactSummary;
+            // Keep the compact resource/log summary bounded at 200 characters, but do not
+            // irreversibly truncate the panel's plain-text display at that smaller limit.
+            var displayResult = imageDataUri != null
+                ? compactSummary
+                : TruncateDisplayResult(resultSummary ?? "");
             var isJsonResult = false;
 
             if (imageDataUri == null && TryFormatJsonForDisplay(resultSummary, out var formattedJson))
diff --git a/Editor/Settings/ISettingsController.cs b/Editor/Settings/ISettingsController.cs
index 440738f..997c8dd 100644
--- a/Editor/Settings/ISettingsController.cs
+++ b/Editor/Settings/ISettingsController.cs
@@ -30,6 +30,7 @@ internal interface ISettingsController
         bool ExecuteCodeStrictFilesystemSafetyEnabled { get; set; }
         bool ExecuteCodeProjectNamespaceInjectionEnabled { get; set; }
         bool PluginDebugLoggingEnabled { get; set; }
+        bool MCPRecentActivityExpandedByDefault { get; set; }
         bool MCPBrokerModeEnabled { get; set; }
         string MCPBrokerMonoPath { get; set; }
 
diff --git a/Editor/Settings/SettingsController.cs b/Editor/Settings/SettingsController.cs
index 534a09f..10aa5c4 100644
--- a/Editor/Settings/SettingsController.cs
+++ b/Editor/Settings/SettingsController.cs
@@ -23,6 +23,7 @@ internal class SettingsController : ISettingsController
         private const bool DefaultExecuteCodeStrictFilesystemSafetyEnabled = true;
         private const bool DefaultExecuteCodeProjectNamespaceInjectionEnabled = false;
         private const bool DefaultPluginDebugLoggingEnabled = false;
+        private const bool DefaultMCPRecentActivityExpandedByDefault = true;
         private const bool DefaultMCPBrokerModeEnabled = false;
 
         private readonly string _settingsPath;
@@ -254,6 +255,23 @@ public bool PluginDebugLoggingEnabled
             }
         }
 
+        public bool MCPRecentActivityExpandedByDefault
+        {
+            get
+            {
+                lock (_lock)
+                    return _settings.mcpRecentActivityExpandedByDefault;
+            }
+            set
+            {
+                UpdateSettings(data =>
+                {
+                    data.mcpRecentActivityExpandedByDefault = value;
+                    data.mcpRecentActivityExpansionConfigured = true;
+                });
+            }
+        }
+
         public bool MCPBrokerModeEnabled
         {
             get
@@ -413,6 +431,8 @@ private static SettingsData CreateDefaultSettings()
                 executeCodeProjectNamespaceInjectionConfigured = true,
                 pluginDebugLoggingEnabled = DefaultPluginDebugLoggingEnabled,
                 pluginDebugLoggingConfigured = true,
+                mcpRecentActivityExpandedByDefault = DefaultMCPRecentActivityExpandedByDefault,
+                mcpRecentActivityExpansionConfigured = true,
                 mcpBrokerModeEnabled = DefaultMCPBrokerModeEnabled,
                 mcpBrokerMonoPath = string.Empty
             };
@@ -468,6 +488,11 @@ private static void NormalizeInPlace(SettingsData settings)
                 settings.pluginDebugLoggingEnabled = DefaultPluginDebugLoggingEnabled;
                 settings.pluginDebugLoggingConfigured = true;
             }
+            if (!settings.mcpRecentActivityExpansionConfigured)
+            {
+                settings.mcpRecentActivityExpandedByDefault = DefaultMCPRecentActivityExpandedByDefault;
+                settings.mcpRecentActivityExpansionConfigured = true;
+            }
         }
 
         private static string NormalizeToolExportProfile(string value)
@@ -519,6 +544,8 @@ private class SettingsData
             public bool executeCodeProjectNamespaceInjectionConfigured = false;
             public bool pluginDebugLoggingEnabled = DefaultPluginDebugLoggingEnabled;
             public bool pluginDebugLoggingConfigured = false;
+            public bool mcpRecentActivityExpandedByDefault = DefaultMCPRecentActivityExpandedByDefault;
+            public bool mcpRecentActivityExpansionConfigured = false;
             public bool mcpBrokerModeEnabled = DefaultMCPBrokerModeEnabled;
             public string mcpBrokerMonoPath = string.Empty;
             public List<string> mcpLastClientConfigKeys;
diff --git a/Tests/Editor/RecentActivityPanelTests.cs b/Tests/Editor/RecentActivityPanelTests.cs
new file mode 100644
index 0000000..30bffc2
--- /dev/null
+++ b/Tests/Editor/RecentActivityPanelTests.cs
@@ -0,0 +1,499 @@
+// Copyright (C) Funplay. Licensed under MIT.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Funplay.Editor.MCP.Server;
+using Funplay.Editor.Services;
+using Funplay.Editor.Settings;
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.UIElements;
+
+namespace Funplay.Editor.Tests
+{
+    public sealed class RecentActivityPanelTests
+    {
+        private EditorWindow _window;
+        private MCPInteractionLog _log;
+        private FunplayMCPRecentActivityPanel _panel;
+        private string _settingsProjectPath;
+        private readonly Queue<Action> _callbacks = new Queue<Action>();
+
+        [UnitySetUp]
+        public IEnumerator SetUp()
+        {
+            if (Application.isBatchMode ||
+                SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Null)
+                Assert.Ignore("These UI tests require a graphics-enabled interactive Unity Editor.");
+            _log = null;
+            _panel = null;
+            _settingsProjectPath = null;
+            _callbacks.Clear();
+            _window = ScriptableObject.CreateInstance<EditorWindow>();
+            _window.titleContent = new GUIContent("Funplay Activity Tests");
+            _window.ShowUtility();
+            _window.position = new Rect(80, 80, 480, 640);
+            yield return null;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (_log != null && _panel != null)
+                _log.OnEntryAdded -= _panel.OnEntryAdded;
+            _panel?.Dispose();
+            _callbacks.Clear();
+            if (_window != null)
+                _window.Close();
+            if (_settingsProjectPath != null && Directory.Exists(_settingsProjectPath))
+                Directory.Delete(_settingsProjectPath, true);
+        }
+
+        [Test]
+        public void History_OnlyLatestBuildsDetails_AndSummariesAreReadable()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("first", MCPToolCallStatus.Success,
+                "{\"success\":true,\"message\":\"Imported assets.\",\"data\":{\"count\":3}}");
+            _log.Add("second", MCPToolCallStatus.Success, "Second result");
+            BuildPanel();
+
+            var rows = Rows();
+            Assert.AreEqual(2, rows.Length);
+            AssertCollapsed(rows[0]);
+            AssertExpanded(rows[1]);
+            StringAssert.Contains("Imported assets.", Summary(rows[0]).text);
+            StringAssert.Contains("Count: 3", Summary(rows[0]).text);
+            StringAssert.DoesNotContain("\"success\"", Summary(rows[0]).text);
+            StringAssert.DoesNotContain("{", Summary(rows[0]).text);
+
+            Click(Summary(rows[0]));
+            AssertExpanded(rows[0]);
+            Assert.IsTrue(Details(rows[0]).Query<Label>().ToList().Any(label => label.text == "Count:"));
+            Click(Header(rows[0]));
+            AssertCollapsed(rows[0]);
+        }
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void Display_KeepsTextBeyondCompactResourceSummary(bool json)
+        {
+            var message = new string('x', 320) + " visible tail";
+            _log = new MCPInteractionLog();
+            _log.Add("long", MCPToolCallStatus.Success,
+                json ? "{\"success\":true,\"message\":\"" + message + "\"}" : message);
+            var entry = _log.GetEntries()[0];
+            Assert.LessOrEqual(entry.ResultSummary.Length, 200);
+            Assert.AreEqual(message, entry.DisplayResult);
+            BuildPanel();
+            Assert.AreEqual(message, Summary(Rows()[0]).text);
+
+            _log.Add("bounded", MCPToolCallStatus.Success, new string('x', 9000));
+            Assert.LessOrEqual(_log.GetEntries()[0].DisplayResult.Length,
+                MCPInteractionLog.MaxDisplayResultCharacters);
+        }
+
+        [Test]
+        public void NewEntry_CollapsesAutomaticLatest_ButKeepsManualChoices()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("old", MCPToolCallStatus.Success, "Old");
+            _log.Add("latest", MCPToolCallStatus.Success, "Latest");
+            BuildPanel();
+            var old = Rows()[0];
+            var previousLatest = Rows()[1];
+            Click(Summary(old));
+
+            _log.Add("next", MCPToolCallStatus.Success, "Next");
+            FlushCallbacks();
+            Assert.AreEqual(3, Rows().Length);
+            AssertExpanded(old);
+            AssertCollapsed(previousLatest);
+            var latest = Rows().Last();
+            AssertExpanded(latest);
+
+            // Manually reopening an auto-expanded row pins it across later entries.
+            Click(Header(latest));
+            Click(Summary(latest));
+            _log.Add("another", MCPToolCallStatus.Success, "Another");
+            FlushCallbacks();
+            Assert.AreEqual(4, Rows().Length);
+            AssertExpanded(latest);
+            var manuallyCollapsed = Rows().Last();
+            Click(Header(manuallyCollapsed));
+            _log.Add("last", MCPToolCallStatus.Success, "Last");
+            FlushCallbacks();
+            Assert.AreEqual(5, Rows().Length);
+            AssertCollapsed(manuallyCollapsed);
+            AssertExpanded(old);
+            AssertExpanded(latest);
+            AssertExpanded(Rows().Last());
+        }
+
+        [Test]
+        public void ExpandAll_ExpandsHistoryAndNewEntries_ButKeepsManualCollapse()
+        {
+            var settings = CreateSettings(expandAll: true);
+            _log = new MCPInteractionLog();
+            _log.Add("old", MCPToolCallStatus.Success, "Old");
+            _log.Add("latest", MCPToolCallStatus.Success, "Latest");
+            BuildPanel(settings);
+            foreach (var row in Rows())
+                AssertExpanded(row);
+            var manuallyCollapsed = Rows()[0];
+            Click(Header(manuallyCollapsed));
+
+            _log.Add("new", MCPToolCallStatus.Success, "New");
+            FlushCallbacks();
+            AssertCollapsed(manuallyCollapsed);
+            AssertExpanded(Rows()[1]);
+            AssertExpanded(Rows()[2]);
+        }
+
+        [Test]
+        public void ExpansionPreference_AppliesLiveWithoutOverridingManualChoices()
+        {
+            var settings = CreateSettings(expandAll: false);
+            _log = new MCPInteractionLog();
+            _log.Add("manual-open", MCPToolCallStatus.Success, "Manually open");
+            _log.Add("automatic", MCPToolCallStatus.Success, "Follow the preference");
+            _log.Add("manual-closed", MCPToolCallStatus.Success, "Manually closed");
+            BuildPanel(settings);
+            var rows = Rows();
+            Click(Summary(rows[0]));
+            Click(Header(rows[2]));
+
+            settings.MCPRecentActivityExpandedByDefault = true;
+            AssertExpanded(rows[0]);
+            AssertExpanded(rows[1]);
+            AssertCollapsed(rows[2]);
+            _log.Add("latest", MCPToolCallStatus.Success, "Latest");
+            FlushCallbacks();
+
+            settings.MCPRecentActivityExpandedByDefault = false;
+            AssertExpanded(rows[0]);
+            AssertCollapsed(rows[1]);
+            AssertCollapsed(rows[2]);
+            AssertExpanded(Rows().Last());
+            settings.MCPRecentActivityExpandedByDefault = true;
+            AssertExpanded(rows[1]);
+            AssertCollapsed(rows[2]);
+        }
+
+        [Test]
+        public void DisablingExpandAll_ReleasesHistoricalTextures_AndHandlesEmptyLatest()
+        {
+            var settings = CreateSettings(expandAll: true);
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            _log.Add("empty", MCPToolCallStatus.Success, string.Empty);
+            BuildPanel(settings);
+            var imageRow = Rows()[0];
+            var texture = imageRow.Q<Image>().image as Texture2D;
+            Assert.IsTrue(texture != null);
+
+            settings.MCPRecentActivityExpandedByDefault = false;
+            AssertCollapsed(imageRow);
+            Assert.IsTrue(texture == null);
+            settings.MCPRecentActivityExpandedByDefault = true;
+            AssertExpanded(imageRow);
+        }
+
+        [Test]
+        public void ReopeningPanel_ReadsPersistedPreference_AndResetsManualOverrides()
+        {
+            var settings = CreateSettings(expandAll: true);
+            _log = new MCPInteractionLog();
+            _log.Add("old", MCPToolCallStatus.Success, "Old");
+            _log.Add("latest", MCPToolCallStatus.Success, "Latest");
+            BuildPanel(settings);
+            Click(Header(Rows()[0]));
+            AssertCollapsed(Rows()[0]);
+
+            _log.OnEntryAdded -= _panel.OnEntryAdded;
+            _panel.Dispose();
+            _window.rootVisualElement.Clear();
+            var reloaded = new SettingsController(new TestApplicationPaths(_settingsProjectPath));
+            BuildPanel(reloaded);
+            foreach (var row in Rows())
+                AssertExpanded(row);
+        }
+
+        [Test]
+        public void UnrelatedSettingsChange_DoesNotRebuildExpandedDetails()
+        {
+            var settings = CreateSettings(expandAll: true);
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            BuildPanel(settings);
+            var image = Rows()[0].Q<Image>();
+            var texture = image.image;
+
+            settings.PluginDebugLoggingEnabled = true;
+            Assert.AreSame(image, Rows()[0].Q<Image>());
+            Assert.AreSame(texture, image.image);
+            AssertExpanded(Rows()[0]);
+        }
+
+        [Test]
+        public void Screenshot_IsDecodedOnExpand_AndDestroyedOnCollapse()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            _log.Add("latest", MCPToolCallStatus.Success, "Latest");
+            BuildPanel();
+            var row = Rows()[0];
+            AssertCollapsed(row);
+            Assert.IsNull(row.Q<Image>());
+
+            Click(Summary(row));
+            var firstTexture = row.Q<Image>().image as Texture2D;
+            Assert.IsNotNull(firstTexture);
+            Assert.AreEqual(4, firstTexture.width);
+            Click(Header(row));
+            AssertCollapsed(row);
+            Assert.IsTrue(firstTexture == null, "Collapsing must destroy the decoded Unity texture.");
+
+            Click(Summary(row));
+            var nextTexture = row.Q<Image>().image as Texture2D;
+            Assert.IsTrue(nextTexture != null);
+            _panel.Dispose();
+            Assert.IsTrue(nextTexture == null, "Disposing must release manually expanded previews.");
+        }
+
+        [Test]
+        public void AutomaticCollapse_ReleasesScreenshot()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            BuildPanel();
+            var row = Rows()[0];
+            var texture = row.Q<Image>().image as Texture2D;
+            Assert.IsTrue(texture != null);
+            _log.Add("next", MCPToolCallStatus.Success, "Next");
+            FlushCallbacks();
+            Assert.AreEqual(2, Rows().Length);
+            AssertCollapsed(row);
+            Assert.IsTrue(texture == null);
+        }
+
+        [Test]
+        public void Clear_RemovesRowsAndTextures_AndInvalidatesQueuedEntries()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            BuildPanel();
+            var texture = Rows()[0].Q<Image>().image as Texture2D;
+            _log.Add("queued", MCPToolCallStatus.Success, "Must not reappear after Clear");
+
+            var button = _window.rootVisualElement.Q<Button>("recent-activity-clear");
+            using (var evt = NavigationSubmitEvent.GetPooled())
+            {
+                evt.target = button;
+                button.SendEvent(evt);
+            }
+            Assert.IsEmpty(_log.GetEntries());
+            Assert.IsEmpty(Rows());
+            Assert.IsTrue(texture == null);
+            FlushCallbacks();
+            Assert.IsEmpty(Rows());
+
+            _log.Add("fresh", MCPToolCallStatus.Success, "Fresh");
+            FlushCallbacks();
+            Assert.AreEqual(1, Rows().Length);
+            AssertExpanded(Rows()[0]);
+        }
+
+        [Test]
+        public void Capacity_EvictsOldRowsAndTheirTextures()
+        {
+            _log = new MCPInteractionLog(2);
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            _log.Add("second", MCPToolCallStatus.Success, "Second");
+            BuildPanel();
+            var oldest = Rows()[0];
+            Click(Summary(oldest));
+            var texture = oldest.Q<Image>().image as Texture2D;
+
+            _log.Add("third", MCPToolCallStatus.Success, "Third");
+            FlushCallbacks();
+            Assert.AreEqual(2, Rows().Length);
+            Assert.IsNull(oldest.parent);
+            Assert.IsTrue(texture == null);
+            Assert.AreEqual("Third", Summary(Rows().Last()).text);
+        }
+
+        [Test]
+        public void RebuildAndDispose_InvalidateQueuedCallbacks()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("image", MCPToolCallStatus.Success, MakeImage());
+            BuildPanel();
+            var texture = Rows()[0].Q<Image>().image as Texture2D;
+            _log.Add("queued", MCPToolCallStatus.Success, "Queued");
+            _window.rootVisualElement.Clear();
+            _panel.AddTo(_window.rootVisualElement);
+            Assert.IsTrue(texture == null);
+            FlushCallbacks();
+            Assert.AreEqual(2, Rows().Length, "The history rebuild already includes the queued entry.");
+
+            _log.Add("disposed", MCPToolCallStatus.Success, "Must not appear");
+            _panel.Dispose();
+            FlushCallbacks();
+            Assert.IsEmpty(Rows());
+        }
+
+        [UnityTest]
+        public IEnumerator Tooltip_UsesSameReadableTextOnHeaderChildAndSummary()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("json", MCPToolCallStatus.Error,
+                "{\"success\":false,\"code\":\"EXAMPLE_ERROR\",\"error\":\"Readable error\"}");
+            BuildPanel();
+            var row = Rows()[0];
+            Click(Header(row));
+            yield return WaitFor(() => row.worldBound.width > 0);
+            foreach (var target in new VisualElement[] { Header(row), Header(row).Q<Label>(), Summary(row) })
+            {
+                using (var evt = TooltipEvent.GetPooled())
+                {
+                    evt.target = target;
+                    target.SendEvent(evt);
+                    Assert.AreEqual(_log.GetEntries()[0].DisplayResult, evt.tooltip);
+                    Assert.Greater(evt.rect.width, 0);
+                }
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator Summary_ResizesNarrowWideAndBackWithoutLosingText()
+        {
+            var message = new string('x', 320) + " visible tail";
+            _log = new MCPInteractionLog();
+            _log.Add("long", MCPToolCallStatus.Success, message);
+            BuildPanel();
+            Click(Header(Rows()[0]));
+            var label = Summary(Rows()[0]);
+            yield return WaitFor(() => label.resolvedStyle.width > 0);
+            var narrow = label.resolvedStyle.width;
+            Assert.Greater(narrow, 0);
+            _window.position = new Rect(80, 80, 1100, 640);
+            yield return WaitFor(() => label.resolvedStyle.width > narrow + 400);
+            var wide = label.resolvedStyle.width;
+            Assert.Greater(wide, narrow + 400);
+            _window.position = new Rect(80, 80, 450, 640);
+            yield return WaitFor(() => label.resolvedStyle.width < wide - 400);
+            Assert.Less(label.resolvedStyle.width, wide - 400);
+            Assert.AreEqual(message, label.text);
+        }
+
+        [Test]
+        public void InvalidScreenshot_DoesNotPreventDetailsOrToggling()
+        {
+            _log = new MCPInteractionLog();
+            _log.Add("bad-image", MCPToolCallStatus.Success, "data:image/png;base64,not base64!");
+            BuildPanel();
+            var row = Rows()[0];
+            AssertExpanded(row);
+            Assert.IsNull(row.Q<Image>());
+            Click(Header(row));
+            AssertCollapsed(row);
+            Click(Summary(row));
+            AssertExpanded(row);
+        }
+
+        private void BuildPanel(ISettingsController settings = null)
+        {
+            // Do not invoke Unity's global delayCall (which may contain unrelated project
+            // callbacks). Control only this panel's queue to test clear/rebuild races exactly.
+            _panel = new FunplayMCPRecentActivityPanel(_log, callback => _callbacks.Enqueue(callback),
+                settings ?? CreateSettings(expandAll: false));
+            _panel.AddTo(_window.rootVisualElement);
+            _log.OnEntryAdded += _panel.OnEntryAdded;
+        }
+
+        private SettingsController CreateSettings(bool expandAll)
+        {
+            _settingsProjectPath = Path.Combine(Path.GetTempPath(), "FunplayActivityTests_" + Guid.NewGuid().ToString("N"));
+            return new SettingsController(new TestApplicationPaths(_settingsProjectPath))
+            {
+                MCPRecentActivityExpandedByDefault = expandAll
+            };
+        }
+
+        private sealed class TestApplicationPaths : IApplicationPaths
+        {
+            public TestApplicationPaths(string projectPath) { ProjectPath = projectPath; }
+            public string ProjectPath { get; }
+            public string AssetsPath => Path.Combine(ProjectPath, "Assets");
+            public string TempPath => Path.Combine(ProjectPath, "Temp", "Funplay");
+            public string DataPath => AssetsPath;
+            public string PersistentDataPath => Path.Combine(ProjectPath, "PersistentData");
+        }
+
+        private VisualElement[] Rows() => _window.rootVisualElement
+            .Q<ScrollView>("recent-activity-scroll").contentContainer.Children().ToArray();
+        private static VisualElement Header(VisualElement row) => row.Q("recent-activity-header");
+        private static VisualElement Details(VisualElement row) => row.Q("recent-activity-details");
+        private static Label Summary(VisualElement row) => row.Q<Label>("recent-activity-summary");
+
+        private static void Click(VisualElement target)
+        {
+            using (var evt = ClickEvent.GetPooled(new Event { type = EventType.MouseUp, button = 0, clickCount = 1 }))
+            {
+                evt.target = target;
+                target.SendEvent(evt);
+            }
+        }
+
+        private static IEnumerator WaitFor(Func<bool> ready)
+        {
+            var deadline = EditorApplication.timeSinceStartup + 5;
+            while (!ready())
+            {
+                Assert.Less(EditorApplication.timeSinceStartup, deadline, "Timed out waiting for the Editor UI.");
+                yield return null;
+            }
+        }
+
+        private void FlushCallbacks()
+        {
+            while (_callbacks.Count > 0)
+                _callbacks.Dequeue()();
+        }
+
+        private static void AssertCollapsed(VisualElement row)
+        {
+            Assert.AreEqual(DisplayStyle.None, Details(row).style.display.value);
+            Assert.AreEqual(0, Details(row).childCount, "Hidden rows must not retain detail subtrees.");
+            Assert.AreEqual(DisplayStyle.Flex, Summary(row).style.display.value);
+        }
+
+        private static void AssertExpanded(VisualElement row)
+        {
+            Assert.AreEqual(DisplayStyle.Flex, Details(row).style.display.value);
+            Assert.Greater(Details(row).childCount, 0);
+            Assert.AreEqual(DisplayStyle.None, Summary(row).style.display.value);
+        }
+
+        private static string MakeImage()
+        {
+            var texture = new Texture2D(4, 4, TextureFormat.RGBA32, false);
+            try
+            {
+                texture.SetPixels(Enumerable.Repeat(Color.cyan, 16).ToArray());
+                texture.Apply();
+                return "data:image/png;base64," + Convert.ToBase64String(texture.EncodeToPNG());
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(texture);
+            }
+        }
+    }
+}
diff --git a/Tests/Editor/RecentActivityPanelTests.cs.meta b/Tests/Editor/RecentActivityPanelTests.cs.meta
new file mode 100644
index 0000000..53adb89
--- /dev/null
+++ b/Tests/Editor/RecentActivityPanelTests.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 859ea778cd7f5478bae839db353667ca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:
diff --git a/Tests/Editor/SettingsControllerTests.cs b/Tests/Editor/SettingsControllerTests.cs
index 2e8eb3d..ea61d40 100644
--- a/Tests/Editor/SettingsControllerTests.cs
+++ b/Tests/Editor/SettingsControllerTests.cs
@@ -23,6 +23,7 @@ public void NewSettings_EnableExecuteCodeSafetyChecksByDefault()
                 Assert.IsTrue(controller.ExecuteCodeStrictFilesystemSafetyEnabled);
                 Assert.IsFalse(controller.ExecuteCodeProjectNamespaceInjectionEnabled);
                 Assert.IsFalse(controller.PluginDebugLoggingEnabled);
+                Assert.IsTrue(controller.MCPRecentActivityExpandedByDefault);
                 Assert.IsFalse(controller.MCPBrokerModeEnabled);
                 Assert.AreEqual(string.Empty, controller.MCPBrokerMonoPath);
                 StringAssert.Contains("\"executeCodeSafetyChecksEnabled\": true", ReadSettingsJson(projectPath));
@@ -33,6 +34,8 @@ public void NewSettings_EnableExecuteCodeSafetyChecksByDefault()
                 StringAssert.Contains("\"executeCodeProjectNamespaceInjectionConfigured\": true", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"pluginDebugLoggingEnabled\": false", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"pluginDebugLoggingConfigured\": true", ReadSettingsJson(projectPath));
+                StringAssert.Contains("\"mcpRecentActivityExpandedByDefault\": true", ReadSettingsJson(projectPath));
+                StringAssert.Contains("\"mcpRecentActivityExpansionConfigured\": true", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"mcpBrokerModeEnabled\": false", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"mcpBrokerMonoPath\": \"\"", ReadSettingsJson(projectPath));
             }
@@ -61,6 +64,7 @@ public void ExistingSettingsWithoutSafetyField_MigrateToEnabledDefault()
                 Assert.IsTrue(controller.ExecuteCodeStrictFilesystemSafetyEnabled);
                 Assert.IsFalse(controller.ExecuteCodeProjectNamespaceInjectionEnabled);
                 Assert.IsFalse(controller.PluginDebugLoggingEnabled);
+                Assert.IsTrue(controller.MCPRecentActivityExpandedByDefault);
                 Assert.IsFalse(controller.MCPBrokerModeEnabled);
                 Assert.AreEqual(string.Empty, controller.MCPBrokerMonoPath);
                 StringAssert.Contains("\"executeCodeSafetyChecksEnabled\": true", ReadSettingsJson(projectPath));
@@ -71,6 +75,8 @@ public void ExistingSettingsWithoutSafetyField_MigrateToEnabledDefault()
                 StringAssert.Contains("\"executeCodeProjectNamespaceInjectionConfigured\": true", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"pluginDebugLoggingEnabled\": false", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"pluginDebugLoggingConfigured\": true", ReadSettingsJson(projectPath));
+                StringAssert.Contains("\"mcpRecentActivityExpandedByDefault\": true", ReadSettingsJson(projectPath));
+                StringAssert.Contains("\"mcpRecentActivityExpansionConfigured\": true", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"mcpBrokerModeEnabled\": false", ReadSettingsJson(projectPath));
                 StringAssert.Contains("\"mcpBrokerMonoPath\": \"\"", ReadSettingsJson(projectPath));
             }
@@ -168,6 +174,43 @@ public void PluginDebugLoggingSetting_PersistsTrueValue()
             }
         }
 
+        [Test]
+        public void RecentActivityExpansion_PersistsBothValuesAndNotifiesOnlyOnChanges()
+        {
+            var projectPath = CreateTempProjectPath();
+            try
+            {
+                var paths = new TestApplicationPaths(projectPath);
+                var controller = new SettingsController(paths);
+                controller.MCPRecentActivityExpandedByDefault = false;
+                controller.MCPServerEnabled = true;
+                controller.MCPServerPort = 14321;
+                var notifications = 0;
+                controller.OnSettingsChanged += () => notifications++;
+
+                controller.MCPRecentActivityExpandedByDefault = false;
+                Assert.AreEqual(0, notifications);
+                controller.MCPRecentActivityExpandedByDefault = true;
+                controller.MCPRecentActivityExpandedByDefault = true;
+                Assert.AreEqual(1, notifications);
+                var reloaded = new SettingsController(paths);
+                Assert.IsTrue(reloaded.MCPRecentActivityExpandedByDefault);
+                StringAssert.Contains("\"mcpRecentActivityExpandedByDefault\": true", ReadSettingsJson(projectPath));
+
+                reloaded.MCPRecentActivityExpandedByDefault = false;
+                var reloadedAgain = new SettingsController(paths);
+                Assert.IsFalse(reloadedAgain.MCPRecentActivityExpandedByDefault);
+                Assert.IsTrue(reloadedAgain.MCPServerEnabled);
+                Assert.AreEqual(14321, reloadedAgain.MCPServerPort);
+                Assert.IsTrue(reloadedAgain.MCPServerPortConfigured);
+                StringAssert.Contains("\"mcpRecentActivityExpandedByDefault\": false", ReadSettingsJson(projectPath));
+            }
+            finally
+            {
+                DeleteTempProjectPath(projectPath);
+            }
+        }
+
         [Test]
         public void BrokerSettings_PersistValues()
         {