diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 151bbfb..938e8cb 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -10,6 +10,18 @@ All notable changes to MandoCode will be documented in this file.
   and the answer that follows as a second block. Before, everything waited until the end and came
   out as one merged block. Auto-continued turns also print as each one finishes. Apps built on the
   engine, like MandoCode Desktop, can now follow a reply as it streams.
+- **Watch the reply being written.** While a reply streams, its latest lines show dimmed above the
+  spinner, so a long answer no longer looks like a frozen "Thinking…". The finished reply still
+  prints as formatted markdown.
+- **Long diffs no longer bury the approval menu.** A change over 30 lines now shows in a scrollable
+  window above the approve/deny choices (PgUp/PgDn, Home/End to scroll), with a one-line summary
+  left in your scrollback. Before, hundreds of diff lines pushed the menu off screen. Short diffs
+  print as they always have.
+- **A context meter above the prompt.** A bar shows how full the model's context window is, turning
+  yellow and then red as it fills, so you can `/compact` before a small model starts forgetting the
+  start of the conversation. Cloud models, which manage their own window, show the token count.
+- **`/history` to look back.** Browse this session's conversation in a scrollable window and
+  filter it as you type.
 
 ### Fixed
 - **Numbered lists keep each number beside its text.** When a model left blank lines between list
diff --git a/src/MandoCode/Components/App.razor b/src/MandoCode/Components/App.razor
index d252175..24f8175 100644
--- a/src/MandoCode/Components/App.razor
+++ b/src/MandoCode/Components/App.razor
@@ -53,6 +53,11 @@
    Hidden while an instruction prompt is active so the two text inputs don't fight for focus. *@
 @if (_showPrompt && !InstructionCoordinator.IsActive)
 {
+    @if (Config.EnableTokenTracking && TokenTracker.LastOperation is { } lastOp)
+    {
+        <ContextMeterLine UsedTokens="@lastOp.PromptTokens"
+                          WindowTokens="@ContextMeter.KnownWindow(Config.GetEffectiveModelName(), Config.ContextLength)" />
+    }
     <PromptInput OnSubmit="HandleVdomSubmit"
                  OnAutocompleteRequested="HandleAutocompleteRequested"
                  InitialValue="@_promptInitialValue"
@@ -78,8 +83,25 @@
    ApprovalSelectCoordinator (TCS). *@
 @if (ApprovalMenu.IsActive)
 {
+    @* A decision on something too long to print (a long diff) shows it here, scrolled with
+       PgUp/PgDn from the menu, which keeps focus. *@
+    @if (ApprovalMenu.Preview.Count > 0)
+    {
+        <ScrollPreview Title="@ApprovalMenu.PreviewTitle"
+                       Lines="@ApprovalMenu.Preview"
+                       Offset="@_approvalPreviewOffset"
+                       PageSize="@ApprovalPreviewPageSize" />
+    }
     <ApprovalSelect Options="@_approvalMenuOptions"
-                    OnSubmit="HandleApprovalMenuSubmit" />
+                    OnSubmit="HandleApprovalMenuSubmit"
+                    OnScroll="HandleApprovalPreviewScroll" />
+}
+
+@* /history — this session's conversation in a scrollable, filterable window. Idle-only, like the
+   prompt it replaces while open. *@
+@if (_historyActive)
+{
+    <HistoryView Messages="@_historyMessages" OnClose="CloseHistory" />
 }
 
 @* Wizard primitives — bare RazorConsole TextInput / Select that bypass PromptInput's slash/at
@@ -830,20 +852,31 @@
     private void CloseReply()
     {
         lock (_replyLock) _replyOpen = false;
+        Spinner.UpdatePreview(null);
     }
 
+    // The spinner's live preview only needs the tail of the reply, and copying the whole buffer on
+    // every chunk would make a long reply quadratic.
+    private const int PreviewTailChars = 4000;
+
     private void OnResponseTextDelta(string text)
     {
+        string preview;
         lock (_replyLock)
         {
-            if (_replyOpen) _replyUnprinted.Append(text);
+            if (!_replyOpen) return;
+            _replyUnprinted.Append(text);
+            var start = Math.Max(0, _replyUnprinted.Length - PreviewTailChars);
+            preview = _replyUnprinted.ToString(start, _replyUnprinted.Length - start);
         }
+        Spinner.UpdatePreview(preview);
     }
 
     // A retried model call streams its reply again from the start.
     private void OnResponseStreamStarted()
     {
         lock (_replyLock) _replyUnprinted.Clear();
+        Spinner.UpdatePreview(null);
     }
 
     /// <summary>
@@ -863,6 +896,7 @@
             if (text.Length == 0) return;
             _replyPrinted.Add(text);
         }
+        Spinner.UpdatePreview(null);
         AnsiConsole.MarkupLine("[green]MandoCode:[/]");
         RenderMarkdownGuarded(text);
     }
@@ -878,6 +912,7 @@
             _replyPrinted.Clear();
             _replyUnprinted.Clear();
         }
+        Spinner.UpdatePreview(null);
         return ReplyText.Unshown(turnText, printed);
     }
 
@@ -1068,6 +1103,12 @@
                     continue;
                 }
 
+                if (command == "history")
+                {
+                    await ShowHistoryAsync();
+                    continue;
+                }
+
                 if (command == "help")
                 {
                     Console.WriteLine();
@@ -1108,6 +1149,7 @@
                     table.AddRow("/plan-discard", "Forget an unfinished plan");
                     table.AddRow("/compact", "Compress context into a recap; keeps the transcript");
                     table.AddRow("/clear", "Wipe all conversation context and start fresh");
+                    table.AddRow("/history", "Browse this session's conversation, filtered as you type");
                     table.AddRow("/exit", "Exit MandoCode");
                     AnsiConsole.Write(table);
                     AnsiConsole.WriteLine();
@@ -1377,14 +1419,79 @@
     /// re-renders. Done here (on state change) rather than inline in markup so the option
     /// list isn't rebuilt on every unrelated render pass.
     /// </summary>
+    private bool _historyActive;
+    private IReadOnlyList<ChatMsg> _historyMessages = Array.Empty<ChatMsg>();
+    private TaskCompletionSource? _historyTcs;
+
+    /// <summary>Opens /history and waits for it to close. The loop is idle while it's open, so the
+    /// view owns the screen's live region the way the prompt normally does.</summary>
+    private async Task ShowHistoryAsync()
+    {
+        if (_messages.Count == 0)
+        {
+            AnsiConsole.MarkupLine("[dim]Nothing in this session's history yet.[/]");
+            AnsiConsole.WriteLine();
+            return;
+        }
+
+        // A snapshot: the view builds its lines once, and the list mustn't change under it.
+        _historyMessages = _messages.ToList();
+        // Async continuations, so closing from a Blazor event resumes the loop off the dispatcher
+        // thread (see WaitForVdomInputAsync).
+        _historyTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        _historyActive = true;
+        _showPrompt = false;
+        await InvokeAsync(StateHasChanged);
+
+        await _historyTcs.Task;
+
+        _historyActive = false;
+        _historyMessages = Array.Empty<ChatMsg>();
+        await InvokeAsync(StateHasChanged);
+        // Let the VDOM remove the view before anything prints below it.
+        await Task.Delay(100);
+    }
+
+    private void CloseHistory() => _historyTcs?.TrySetResult();
+
     private void OnApprovalMenuStateChanged()
     {
         _approvalMenuOptions = ApprovalMenu.Options
             .Select(o => new ApprovalSelect.Option(o.Text, o.Color))
             .ToList();
+        _approvalPreviewOffset = 0;   // every request starts at the top of its preview
         InvokeAsync(StateHasChanged);
     }
 
+    private int _approvalPreviewOffset;
+
+    // Room for the menu's options, the panel's borders and footer, and the question above it.
+    private static int ApprovalPreviewPageSize
+    {
+        get
+        {
+            try { return Math.Clamp(Console.WindowHeight - 16, 6, 30); }
+            catch { return 20; }
+        }
+    }
+
+    private void HandleApprovalPreviewScroll(ApprovalSelect.ScrollKey key)
+    {
+        var count = ApprovalMenu.Preview.Count;
+        if (count == 0) return;
+
+        var page = ApprovalPreviewPageSize;
+        var max = Math.Max(0, count - page);
+        _approvalPreviewOffset = key switch
+        {
+            ApprovalSelect.ScrollKey.PageUp => Math.Max(0, _approvalPreviewOffset - page),
+            ApprovalSelect.ScrollKey.PageDown => Math.Min(max, _approvalPreviewOffset + page),
+            ApprovalSelect.ScrollKey.Home => 0,
+            _ => max,
+        };
+        StateHasChanged();
+    }
+
     /// <summary>
     /// Bound to the wizard's Select.ValueChanged — fires when the user presses Enter on a
     /// highlighted option (RazorConsole's Select uses Enter as the commit signal).
diff --git a/src/MandoCode/Components/ApprovalSelect.razor b/src/MandoCode/Components/ApprovalSelect.razor
index fb833dc..ef5690b 100644
--- a/src/MandoCode/Components/ApprovalSelect.razor
+++ b/src/MandoCode/Components/ApprovalSelect.razor
@@ -40,6 +40,12 @@
     [Parameter] public IReadOnlyList<Option> Options { get; set; } = Array.Empty<Option>();
     [Parameter] public EventCallback<string> OnSubmit { get; set; }
 
+    /// <summary>Scroll keys for a preview shown above the menu. The menu keeps focus so the arrows
+    /// still choose; PageUp/PageDown/Home/End arrive here as a <see cref="ScrollKey"/> instead.</summary>
+    [Parameter] public EventCallback<ScrollKey> OnScroll { get; set; }
+
+    public enum ScrollKey { PageUp, PageDown, Home, End }
+
     private int _focusedIndex;
 
     // Accept both naming conventions, mirroring RazorConsole's own Select component:
@@ -56,8 +62,23 @@
         key.Equals("Enter", StringComparison.OrdinalIgnoreCase) ||
         key.Equals("Return", StringComparison.OrdinalIgnoreCase);
 
+    private static ScrollKey? AsScrollKey(string key) => key switch
+    {
+        _ when key.Equals("PageUp", StringComparison.OrdinalIgnoreCase) => ScrollKey.PageUp,
+        _ when key.Equals("PageDown", StringComparison.OrdinalIgnoreCase) => ScrollKey.PageDown,
+        _ when key.Equals("Home", StringComparison.OrdinalIgnoreCase) => ScrollKey.Home,
+        _ when key.Equals("End", StringComparison.OrdinalIgnoreCase) => ScrollKey.End,
+        _ => null,
+    };
+
     private async Task HandleKeyDown(KeyboardEventArgs e)
     {
+        if (AsScrollKey(e.Key) is { } scroll)
+        {
+            await OnScroll.InvokeAsync(scroll);
+            return;
+        }
+
         if (Options.Count == 0) return;
 
         if (IsUp(e.Key))
diff --git a/src/MandoCode/Components/ContextMeterLine.razor b/src/MandoCode/Components/ContextMeterLine.razor
new file mode 100644
index 0000000..35d88e0
--- /dev/null
+++ b/src/MandoCode/Components/ContextMeterLine.razor
@@ -0,0 +1,36 @@
+@using Spectre.Console
+@using RazorConsole.Components
+@using MandoCode.Services
+@using RazorConsole.Core.Renderables
+@using Markup = RazorConsole.Components.Markup
+
+@* How full the context window is, one line above the prompt. Only rendered while the prompt is
+   waiting (App.razor gates it with the prompt itself), when nothing prints to scrollback, so a
+   VDOM line here can't collide with imperative output. Same four-Markup shape every render.
+
+   Only the used part carries the level color; the unused part is a darker grey, so the bar's
+   length reads by contrast rather than by shade alone. The two halves sit in a gapless FlexBox row:
+   Columns would put a space between them and split the bar. *@
+
+<Columns>
+    <Markup Content="Context" Foreground="Color.Grey" Decoration="Decoration.Dim" />
+    <FlexBox Direction="FlexDirection.Row" Gap="0" Width="@Math.Max(1, Reading.Bar.Length)">
+        <Markup Content="@Reading.Filled" Foreground="@BarColor" />
+        <Markup Content="@Reading.Empty" Foreground="Color.Grey42" />
+    </FlexBox>
+    <Markup Content="@Reading.Label" Foreground="Color.Grey" Decoration="Decoration.Dim" />
+</Columns>
+
+@code {
+    [Parameter] public long UsedTokens { get; set; }
+    [Parameter] public int WindowTokens { get; set; }
+
+    private ContextMeter.Reading Reading => ContextMeter.Read(UsedTokens, WindowTokens);
+
+    private Color BarColor => Reading.Level switch
+    {
+        ContextMeter.Level.Full => Color.Red,
+        ContextMeter.Level.Warm => Color.Yellow,
+        _ => Color.Green,
+    };
+}
diff --git a/src/MandoCode/Components/HistoryView.razor b/src/MandoCode/Components/HistoryView.razor
new file mode 100644
index 0000000..1ede45d
--- /dev/null
+++ b/src/MandoCode/Components/HistoryView.razor
@@ -0,0 +1,165 @@
+@using Microsoft.AspNetCore.Components.Web
+@using Spectre.Console
+@using RazorConsole.Components
+@using MandoCode.Models
+@using MandoCode.Services
+@using Panel = RazorConsole.Components.Panel
+@using Markup = RazorConsole.Components.Markup
+
+@* /history: this session's conversation in a scrollable window, filtered as you type.
+
+   Two focusable parts, switched with Tab: the search box (RazorConsole's TextInput, which owns
+   typing and paste) and the list (a div that takes the scroll keys). The list is RazorConsole's
+   Scrollable driven through ScrollOffset only — its scrollbar and key handler would add a third
+   focus stop. Only shown while the app is idle, so nothing prints underneath it. Rows keep one
+   Markup shape per line, as ApprovalSelect does, so the VDOM diff stays stable. *@
+
+<Panel Title="@Title" Border="BoxBorder.Rounded" BorderColor="Color.Purple" Expand="true">
+    <Rows>
+        <TextInput @bind-Value="_query"
+                   OnInput="HandleQuery"
+                   OnSubmit="HandleSearchSubmit"
+                   Placeholder="Type to filter messages"
+                   ValueColor="@(new Color(255, 200, 80))"
+                   PlaceholderColor="Color.Grey"
+                   BorderColor="Color.Grey"
+                   FocusedBorderColor="Color.Purple"
+                   BorderStyle="BoxBorder.Rounded"
+                   Expand="true"
+                   FocusOrder="0" />
+        <div @onkeydown="HandleListKey" data-focusable="true" data-focus-order="1">
+            <Scrollable TItem="Line" Items="@_lines" PageSize="@PageSize" ScrollOffset="@_offset">
+                <Rows>
+                    @foreach (var line in context)
+                    {
+                        <Markup Content="@line.Text" Foreground="@line.Color" Decoration="@line.Decoration" />
+                    }
+                </Rows>
+            </Scrollable>
+        </div>
+        <Markup Content="@Footer" Foreground="Color.Grey" Decoration="Decoration.Dim" />
+    </Rows>
+</Panel>
+
+@code {
+    [Parameter] public IReadOnlyList<ChatMsg> Messages { get; set; } = Array.Empty<ChatMsg>();
+    [Parameter] public EventCallback OnClose { get; set; }
+
+    private sealed record Line(string Text, Color Color, Decoration Decoration = Decoration.None);
+
+    private static readonly Color UserColor = new(255, 200, 80);
+    private static readonly Color AgentColor = Color.Green;
+
+    private string _query = string.Empty;
+    private List<Line> _lines = new();
+    private int _matches;
+    private int _offset;
+    private IReadOnlyList<ChatMsg>? _builtFrom;
+
+    private static int PageSize
+    {
+        get
+        {
+            try { return Math.Clamp(Console.WindowHeight - 12, 6, 40); }
+            catch { return 20; }
+        }
+    }
+
+    private string Title => string.IsNullOrWhiteSpace(_query)
+        ? $"History · {Messages.Count} message{(Messages.Count == 1 ? "" : "s")}"
+        : $"History · {_matches} of {Messages.Count} match \"{_query.Trim()}\"";
+
+    private string Footer
+    {
+        get
+        {
+            var position = _lines.Count <= PageSize
+                ? $"{_lines.Count} lines"
+                : $"lines {_offset + 1}–{Math.Min(_lines.Count, _offset + PageSize)} of {_lines.Count}";
+            return $"{position} · Tab to the list, then ↑/↓ PgUp/PgDn Home/End · Esc in the list or Enter on an empty search closes";
+        }
+    }
+
+    protected override void OnParametersSet()
+    {
+        if (!ReferenceEquals(_builtFrom, Messages))
+        {
+            _builtFrom = Messages;
+            Rebuild();
+            _offset = MaxOffset;   // open at the newest messages
+        }
+    }
+
+    private int MaxOffset => Math.Max(0, _lines.Count - PageSize);
+
+    private void Rebuild()
+    {
+        int width;
+        try { width = Math.Max(20, Console.WindowWidth - 8); }
+        catch { width = 72; }
+
+        var query = _query.Trim();
+        _lines = new List<Line>();
+        _matches = 0;
+        foreach (var message in Messages)
+        {
+            if (query.Length > 0 && !message.Text.Contains(query, StringComparison.OrdinalIgnoreCase))
+                continue;
+            _matches++;
+
+            var isUser = message.Role == "user";
+            if (_lines.Count > 0) _lines.Add(new Line(string.Empty, Color.Default));
+            _lines.Add(new Line(isUser ? "You" : "MandoCode", isUser ? UserColor : AgentColor, Decoration.Bold));
+            foreach (var text in ReplyPreview.Tail(message.Text, width, int.MaxValue))
+            {
+                var hit = query.Length > 0 && text.Contains(query, StringComparison.OrdinalIgnoreCase);
+                _lines.Add(new Line(text, hit ? UserColor : Color.Default));
+            }
+        }
+
+        if (_lines.Count == 0)
+            _lines.Add(new Line("No messages match.", Color.Grey, Decoration.Dim));
+    }
+
+    private void HandleQuery(string? value)
+    {
+        _query = value ?? string.Empty;
+        Rebuild();
+        _offset = 0;   // a new filter starts from its first match
+        StateHasChanged();
+    }
+
+    private async Task HandleSearchSubmit(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value)) await OnClose.InvokeAsync();
+    }
+
+    private async Task HandleListKey(KeyboardEventArgs e)
+    {
+        var key = e.Key;
+        var page = PageSize;
+        int? next = key switch
+        {
+            _ when Is(key, "UpArrow", "ArrowUp") => _offset - 1,
+            _ when Is(key, "DownArrow", "ArrowDown") => _offset + 1,
+            _ when Is(key, "PageUp") => _offset - page,
+            _ when Is(key, "PageDown") => _offset + page,
+            _ when Is(key, "Home") => 0,
+            _ when Is(key, "End") => MaxOffset,
+            _ => null,
+        };
+
+        if (next is { } offset)
+        {
+            _offset = Math.Clamp(offset, 0, MaxOffset);
+            StateHasChanged();
+        }
+        else if (Is(key, "Escape", "Esc", "Q"))
+        {
+            await OnClose.InvokeAsync();
+        }
+    }
+
+    private static bool Is(string key, params string[] names) =>
+        names.Any(n => key.Equals(n, StringComparison.OrdinalIgnoreCase));
+}
diff --git a/src/MandoCode/Components/ScrollPreview.razor b/src/MandoCode/Components/ScrollPreview.razor
new file mode 100644
index 0000000..b219c7f
--- /dev/null
+++ b/src/MandoCode/Components/ScrollPreview.razor
@@ -0,0 +1,72 @@
+@using Spectre.Console
+@using RazorConsole.Components
+@using MandoCode.Services
+@using Panel = RazorConsole.Components.Panel
+@using Markup = RazorConsole.Components.Markup
+
+@* A long diff (or anything else an approval decides on) in a fixed-height window above the
+   approval menu, so the menu stays on screen instead of below hundreds of printed lines.
+
+   The window is RazorConsole's Scrollable, driven only through ScrollOffset: its own key handler
+   and scrollbar are left off, because either would make it focusable, and a focusable preview
+   would take the arrow keys away from the menu under it. The menu forwards PageUp/PageDown/Home/
+   End instead (see ApprovalSelect.OnScroll).
+
+   Every row is one Markup with only its values changing, the shape ApprovalSelect keeps for the
+   same reason: swapping element shapes between renders breaks the VDOM diff. *@
+
+<Panel Title="@Title" Border="BoxBorder.Rounded" BorderColor="Color.Grey" Expand="true">
+    <Rows>
+        <Scrollable TItem="ApprovalSelectCoordinator.PreviewLine" Items="@Lines" PageSize="@PageSize" ScrollOffset="@Offset">
+            <Rows>
+                @foreach (var line in context)
+                {
+                    <Markup Content="@Fit(line.Text)" Foreground="@line.Color" Decoration="@line.Decoration" />
+                }
+            </Rows>
+        </Scrollable>
+        <Markup Content="@Footer" Foreground="Color.Grey" Decoration="Decoration.Dim" />
+    </Rows>
+</Panel>
+
+@code {
+    [Parameter] public string? Title { get; set; }
+    [Parameter] public IReadOnlyList<ApprovalSelectCoordinator.PreviewLine> Lines { get; set; } = Array.Empty<ApprovalSelectCoordinator.PreviewLine>();
+    [Parameter] public int Offset { get; set; }
+    [Parameter] public int PageSize { get; set; } = 20;
+
+    private string Footer
+    {
+        get
+        {
+            if (Lines.Count == 0) return string.Empty;
+            var first = Math.Clamp(Offset, 0, Math.Max(0, Lines.Count - PageSize)) + 1;
+            var last = Math.Min(Lines.Count, first + PageSize - 1);
+            return Lines.Count <= PageSize
+                ? $"{Lines.Count} lines"
+                : $"lines {first}–{last} of {Lines.Count} · PgUp/PgDn to scroll · Home/End · ↑/↓ and Enter to choose";
+        }
+    }
+
+    // One terminal row per line keeps the window a fixed height; a wrapped line would make it jump.
+    private static string Fit(string text)
+    {
+        int width;
+        try { width = Math.Max(20, Console.WindowWidth - 8); }
+        catch { width = 72; }
+        if (ReplyPreview.Cells(text) <= width) return text;
+
+        var sb = new System.Text.StringBuilder();
+        var cells = 0;
+        var elements = System.Globalization.StringInfo.GetTextElementEnumerator(text);
+        while (elements.MoveNext())
+        {
+            var element = (string)elements.Current;
+            var w = ReplyPreview.Cells(element);
+            if (cells + w > width - 1) break;
+            sb.Append(element);
+            cells += w;
+        }
+        return sb.Append('…').ToString();
+    }
+}
diff --git a/src/MandoCode/Models/SlashCommands.cs b/src/MandoCode/Models/SlashCommands.cs
index 1949b7f..c67fd29 100644
--- a/src/MandoCode/Models/SlashCommands.cs
+++ b/src/MandoCode/Models/SlashCommands.cs
@@ -26,6 +26,7 @@ public static class SlashCommands
         { "/plan-discard", "Forget an unfinished plan" },
         { "/compact", "Compress conversation context into a recap (keeps this transcript)" },
         { "/clear", "Wipe all conversation context and start fresh" },
+        { "/history", "Browse this session's conversation, filtered as you type" },
         { "/learn", "Learn about LLMs and local AI models" },
         { "/retry", "Retry Ollama connection" },
         { "/music", "Play music" },
diff --git a/src/MandoCode/Services/Approval/DiffApprovalHandler.cs b/src/MandoCode/Services/Approval/DiffApprovalHandler.cs
index bbb91e1..2c12b6b 100644
--- a/src/MandoCode/Services/Approval/DiffApprovalHandler.cs
+++ b/src/MandoCode/Services/Approval/DiffApprovalHandler.cs
@@ -84,11 +84,17 @@ public async Task<DiffApprovalResult> HandleDiffApproval(string relativePath, st
         var deletions = diffLines.Count(l => l.LineType == DiffLineType.Removed);
         var fileName = Path.GetFileName(relativePath);
 
-        // Always show the diff so the user can see what's changing
-        RenderDiffPanel(relativePath, displayLines, additions, deletions, isNewFile);
+        // Always show the diff so the user can see what's changing. A long one that needs a decision
+        // goes in the menu's scroll view instead, so the menu isn't pushed below hundreds of lines.
+        var autoApproved = _globalWriteBypass || _approvedFiles.Contains(relativePath);
+        var scrollDiff = !autoApproved && displayLines.Count > ScrollPreviewMinLines;
+        if (scrollDiff)
+            RenderDiffSummary(relativePath, displayLines.Count, additions, deletions, isNewFile);
+        else
+            RenderDiffPanel(relativePath, displayLines, additions, deletions, isNewFile);
 
         // If globally bypassed or this file is already approved, auto-approve without prompting
-        if (_globalWriteBypass || _approvedFiles.Contains(relativePath))
+        if (autoApproved)
         {
             AnsiConsole.MarkupLine($"[green]\u2713 Auto-approved[/]");
             AnsiConsole.WriteLine();
@@ -126,7 +132,9 @@ public async Task<DiffApprovalResult> HandleDiffApproval(string relativePath, st
         DiffApprovalResult result;
         using (_keyCoordinator.Suppress())
         {
-            var approvalChoice = await _approvalSelect.RequestAsync(choices);
+            var approvalChoice = await _approvalSelect.RequestAsync(choices,
+                scrollDiff ? BuildDiffPreview(displayLines) : null,
+                scrollDiff ? $"Diff: {relativePath}" : null);
 
             if (approvalChoice == ApproveLabel)
             {
@@ -287,6 +295,7 @@ public async Task<DiffApprovalResult> HandleDeleteApproval(string relativePath,
 
         var fileName = Path.GetFileName(relativePath);
         var isFolder = existingContent != null && existingContent.StartsWith("Folder:");
+        List<ApprovalSelectCoordinator.PreviewLine>? deletePreview = null;
 
         if (isFolder)
         {
@@ -331,7 +340,15 @@ public async Task<DiffApprovalResult> HandleDeleteApproval(string relativePath,
             var deletions = diffLines.Count;
             var displayLines = DiffService.CollapseContext(diffLines, 3);
 
-            RenderDiffPanel(relativePath, displayLines, 0, deletions, false);
+            if (!_globalWriteBypass && displayLines.Count > ScrollPreviewMinLines)
+            {
+                RenderDiffSummary(relativePath, displayLines.Count, 0, deletions, false);
+                deletePreview = BuildDiffPreview(displayLines);
+            }
+            else
+            {
+                RenderDiffPanel(relativePath, displayLines, 0, deletions, false);
+            }
             AnsiConsole.MarkupLine($"[red]This will DELETE the file: {Spectre.Console.Markup.Escape(relativePath)}[/]");
             Console.WriteLine();
         }
@@ -361,7 +378,8 @@ public async Task<DiffApprovalResult> HandleDeleteApproval(string relativePath,
         DiffApprovalResult result;
         using (_keyCoordinator.Suppress())
         {
-            var approvalChoice = await _approvalSelect.RequestAsync(delChoices);
+            var approvalChoice = await _approvalSelect.RequestAsync(delChoices,
+                deletePreview, deletePreview != null ? $"Delete: {relativePath}" : null);
 
             if (approvalChoice == ApproveDeletionLabel)
             {
@@ -405,6 +423,44 @@ public async Task<DiffApprovalResult> HandleDeleteApproval(string relativePath,
         return result;
     }
 
+    /// <summary>A diff longer than this goes in the approval menu's scroll view rather than
+    /// scrollback, when there is a decision to make.</summary>
+    private const int ScrollPreviewMinLines = 30;
+
+    private static readonly Color AddedColor = new(135, 206, 250);
+
+    /// <summary>The diff as plain preview lines, colored like <see cref="RenderDiffPanel"/>.</summary>
+    private static List<ApprovalSelectCoordinator.PreviewLine> BuildDiffPreview(List<DiffLine> displayLines)
+    {
+        var lines = new List<ApprovalSelectCoordinator.PreviewLine>(displayLines.Count);
+        foreach (var line in displayLines)
+        {
+            lines.Add(line.LineType switch
+            {
+                DiffLineType.Removed => new(
+                    $"{(line.OldLineNumber.HasValue ? $"{line.OldLineNumber,4}" : "    ")} - {line.Content}", Color.Red),
+                DiffLineType.Added => new(
+                    $"{(line.NewLineNumber.HasValue ? $"{line.NewLineNumber,4}" : "    ")} + {line.Content}", AddedColor),
+                _ => new(
+                    $"{(line.OldLineNumber.HasValue ? $"{line.OldLineNumber,4}" : "    ")}   {line.Content}",
+                    Color.Grey, Decoration.Dim),
+            });
+        }
+        return lines;
+    }
+
+    /// <summary>The one line a scrolled diff leaves in scrollback: which file, and how much changed.</summary>
+    private void RenderDiffSummary(string relativePath, int lineCount, int additions, int deletions, bool isNewFile)
+    {
+        var fullPath = Path.GetFullPath(Path.Combine(_projectRoot.ProjectRoot, relativePath));
+        var fileUri = new Uri(fullPath).AbsoluteUri;
+        var summary = $"{deletions} deletion(s), {additions} addition(s){(isNewFile ? " (new file)" : "")}";
+        AnsiConsole.WriteLine();
+        AnsiConsole.MarkupLine(
+            $"[deepskyblue1]Diff: [link={fileUri}]{Markup.Escape(relativePath)}[/][/] " +
+            $"[dim]· {Markup.Escape(summary)} · {lineCount} lines, shown in the scroll view below[/]");
+    }
+
     private void RenderDiffPanel(string relativePath, List<DiffLine> displayLines, int additions, int deletions, bool isNewFile)
     {
         var fullPath = Path.GetFullPath(Path.Combine(_projectRoot.ProjectRoot, relativePath));
diff --git a/src/MandoCode/Services/Input/ApprovalSelectCoordinator.cs b/src/MandoCode/Services/Input/ApprovalSelectCoordinator.cs
index 2bb2c21..60c6947 100644
--- a/src/MandoCode/Services/Input/ApprovalSelectCoordinator.cs
+++ b/src/MandoCode/Services/Input/ApprovalSelectCoordinator.cs
@@ -24,18 +24,32 @@ public sealed class ApprovalSelectCoordinator
     /// <summary>A selectable entry: display text plus its palette color.</summary>
     public sealed record Option(string Text, Color Color);
 
+    /// <summary>One line of the scrollable preview shown above the menu: plain text (never parsed
+    /// as markup) with its color and decoration.</summary>
+    public sealed record PreviewLine(string Text, Color Color, Decoration Decoration = Decoration.None);
+
     private TaskCompletionSource<string>? _tcs;
     private readonly object _gate = new();
 
     public bool IsActive { get; private set; }
     public IReadOnlyList<Option> Options { get; private set; } = Array.Empty<Option>();
 
+    /// <summary>What the menu is deciding on, when it's too long to print above the menu — a long
+    /// diff. Empty when the details were printed to scrollback instead.</summary>
+    public IReadOnlyList<PreviewLine> Preview { get; private set; } = Array.Empty<PreviewLine>();
+
+    /// <summary>Title for <see cref="Preview"/>.</summary>
+    public string? PreviewTitle { get; private set; }
+
     /// <summary>
     /// Fires when <see cref="IsActive"/> changes so App.razor can re-render.
     /// </summary>
     public event Action? StateChanged;
 
-    public Task<string> RequestAsync(IReadOnlyList<Option> options)
+    public Task<string> RequestAsync(
+        IReadOnlyList<Option> options,
+        IReadOnlyList<PreviewLine>? preview = null,
+        string? previewTitle = null)
     {
         TaskCompletionSource<string> tcs;
         lock (_gate)
@@ -48,6 +62,8 @@ public Task<string> RequestAsync(IReadOnlyList<Option> options)
             tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
             _tcs = tcs;
             Options = options;
+            Preview = preview ?? Array.Empty<PreviewLine>();
+            PreviewTitle = previewTitle;
             IsActive = true;
         }
 
@@ -64,6 +80,8 @@ public void Submit(string value)
             _tcs = null;
             IsActive = false;
             Options = Array.Empty<Option>();
+            Preview = Array.Empty<PreviewLine>();
+            PreviewTitle = null;
         }
 
         StateChanged?.Invoke();
diff --git a/src/MandoCode/Services/Rendering/ContextMeter.cs b/src/MandoCode/Services/Rendering/ContextMeter.cs
new file mode 100644
index 0000000..16d5cbb
--- /dev/null
+++ b/src/MandoCode/Services/Rendering/ContextMeter.cs
@@ -0,0 +1,49 @@
+using MandoCode.Models;
+
+namespace MandoCode.Services;
+
+/// <summary>
+/// How full the model's context window is, for the meter above the prompt. "Used" is the last
+/// request's prompt tokens: every request resends the whole conversation, so that is what the next
+/// one starts from.
+/// </summary>
+public static class ContextMeter
+{
+    public enum Level { Ok, Warm, Full }
+
+    /// <param name="Filled">The used part of the bar, or empty when the window is unknown.</param>
+    /// <param name="Empty">The unused part, kept separate so it can be drawn without the level color:
+    /// in one color, shaded cells read as nearly full on bright or glowing themes.</param>
+    /// <param name="Label">"18k / 32k (56%)", or "~18k tokens in context" without a window.</param>
+    public sealed record Reading(string Filled, string Empty, string Label, Level Level)
+    {
+        public string Bar => Filled + Empty;
+    }
+
+    public const int BarCells = 20;
+
+    /// <param name="usedTokens">The last request's prompt tokens.</param>
+    /// <param name="windowTokens">The context window, or 0 when it isn't known here (cloud models
+    /// manage theirs server-side).</param>
+    public static Reading Read(long usedTokens, int windowTokens)
+    {
+        var used = TokenTrackingService.FormatTokenCount(Math.Max(0, usedTokens));
+        if (windowTokens <= 0)
+            return new Reading(string.Empty, string.Empty, $"~{used} tokens in context", Level.Ok);
+
+        var fraction = Math.Clamp((double)usedTokens / windowTokens, 0, 1);
+        var filled = (int)Math.Round(fraction * BarCells);
+        var percent = (int)Math.Round(fraction * 100);
+        var level = percent >= 85 ? Level.Full : percent >= 60 ? Level.Warm : Level.Ok;
+        return new Reading(
+            new string('█', filled),
+            new string('░', BarCells - filled),
+            $"{used} / {TokenTrackingService.FormatTokenCount(windowTokens)} ({percent}%)",
+            level);
+    }
+
+    /// <summary>The window this app knows for <paramref name="modelTag"/>: the configured context
+    /// length for a local model, 0 for a cloud model or when the daemon's own setting governs.</summary>
+    public static int KnownWindow(string? modelTag, int configuredContextLength) =>
+        MandoCodeConfig.IsCloudModel(modelTag) ? 0 : Math.Max(0, configuredContextLength);
+}
diff --git a/src/MandoCode/Services/Rendering/ReplyPreview.cs b/src/MandoCode/Services/Rendering/ReplyPreview.cs
new file mode 100644
index 0000000..434d09d
--- /dev/null
+++ b/src/MandoCode/Services/Rendering/ReplyPreview.cs
@@ -0,0 +1,121 @@
+using System.Globalization;
+using System.Text;
+
+namespace MandoCode.Services;
+
+/// <summary>
+/// Lays out the live reply preview the spinner shows while a reply streams: the last few lines of
+/// the text, wrapped to the terminal and cut so no line can wrap on its own. A line that wrapped
+/// would take two rows while the spinner counts one, and its cursor-up redraws would then land on
+/// the wrong row and eat scrollback.
+/// </summary>
+public static class ReplyPreview
+{
+    /// <summary>The last <paramref name="maxLines"/> display lines of <paramref name="text"/>, each at
+    /// most <paramref name="width"/> terminal cells wide, with control characters removed.</summary>
+    public static IReadOnlyList<string> Tail(string? text, int width, int maxLines)
+    {
+        if (string.IsNullOrWhiteSpace(text) || width < 1 || maxLines < 1)
+            return Array.Empty<string>();
+
+        var lines = new List<string>();
+        foreach (var raw in text.Replace("\r\n", "\n").Split('\n'))
+        {
+            var clean = Clean(raw);
+            if (clean.Length == 0)
+            {
+                lines.Add(string.Empty);
+                continue;
+            }
+            Wrap(clean, width, lines);
+        }
+
+        // Blank lines at either end carry nothing a preview needs; inner ones keep paragraphs apart.
+        while (lines.Count > 0 && lines[^1].Length == 0) lines.RemoveAt(lines.Count - 1);
+        while (lines.Count > 0 && lines[0].Length == 0) lines.RemoveAt(0);
+
+        return lines.Count <= maxLines ? lines : lines.GetRange(lines.Count - maxLines, maxLines);
+    }
+
+    private static string Clean(string line)
+    {
+        var sb = new StringBuilder(line.Length);
+        foreach (var c in line)
+        {
+            if (c == '\t') sb.Append("    ");
+            else if (!char.IsControl(c)) sb.Append(c);
+        }
+        return sb.ToString().TrimEnd();
+    }
+
+    // Greedy word wrap by terminal cells; a word wider than the line is split hard.
+    private static void Wrap(string line, int width, List<string> into)
+    {
+        var current = new StringBuilder();
+        int currentCells = 0;
+
+        foreach (var word in line.Split(' '))
+        {
+            int wordCells = Cells(word);
+            int needed = currentCells == 0 ? wordCells : currentCells + 1 + wordCells;
+            if (needed <= width)
+            {
+                if (currentCells > 0) { current.Append(' '); currentCells++; }
+                current.Append(word);
+                currentCells += wordCells;
+                continue;
+            }
+
+            if (currentCells > 0)
+            {
+                into.Add(current.ToString());
+                current.Clear();
+                currentCells = 0;
+            }
+
+            // Split a word that can't fit even on its own line.
+            var elements = StringInfo.GetTextElementEnumerator(word);
+            while (elements.MoveNext())
+            {
+                var element = (string)elements.Current;
+                int cells = Cells(element);
+                if (currentCells + cells > width && currentCells > 0)
+                {
+                    into.Add(current.ToString());
+                    current.Clear();
+                    currentCells = 0;
+                }
+                current.Append(element);
+                currentCells += cells;
+            }
+        }
+
+        if (currentCells > 0 || current.Length > 0) into.Add(current.ToString());
+    }
+
+    /// <summary>Terminal cells a string takes, counting wide characters (CJK, emoji) as two.</summary>
+    public static int Cells(string s)
+    {
+        int cells = 0;
+        var elements = StringInfo.GetTextElementEnumerator(s);
+        while (elements.MoveNext())
+        {
+            var element = (string)elements.Current;
+            var rune = System.Text.Rune.GetRuneAt(element, 0);
+            cells += IsWide(rune.Value) || element.Length > rune.Utf16SequenceLength ? 2 : 1;
+        }
+        return cells;
+    }
+
+    private static bool IsWide(int cp) =>
+        cp >= 0x1100 && (
+            cp <= 0x115F ||
+            (cp >= 0x2E80 && cp <= 0xA4CF) ||
+            (cp >= 0xAC00 && cp <= 0xD7A3) ||
+            (cp >= 0xF900 && cp <= 0xFAFF) ||
+            (cp >= 0xFE30 && cp <= 0xFE4F) ||
+            (cp >= 0xFF00 && cp <= 0xFF60) ||
+            (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+            (cp >= 0x1F300 && cp <= 0x1FAFF) ||
+            (cp >= 0x20000 && cp <= 0x3FFFD));
+}
diff --git a/src/MandoCode/Services/Rendering/SpinnerService.cs b/src/MandoCode/Services/Rendering/SpinnerService.cs
index 912285f..f74246b 100644
--- a/src/MandoCode/Services/Rendering/SpinnerService.cs
+++ b/src/MandoCode/Services/Rendering/SpinnerService.cs
@@ -21,6 +21,13 @@ public class SpinnerService
     // streamed updates are signal worth keeping; the static initial activity isn't.
     private volatile bool _activityWasUpdated;
 
+    // The reply streaming right now, shown as its last few lines between the activity line and the
+    // spinner. Read by the animation loop each frame, which is what throttles the redraws.
+    private volatile string? _livePreview;
+
+    /// <summary>How many lines of a streaming reply the preview shows.</summary>
+    public const int PreviewLines = 5;
+
     // How often to rotate the random "fun" message so long waits don't feel frozen.
     private static readonly TimeSpan MessageRotationInterval = TimeSpan.FromSeconds(15);
 
@@ -55,6 +62,10 @@ public void Start(string? activity = null)
                 var i = 0;
                 var lastRenderedActivity = activity;
                 var activityLineReserved = hasActivity;
+                // The preview sits directly above the spinner. Its region only grows while spinning
+                // (a shrinking reply is padded with blank rows) so every redraw moves the same rows.
+                string? lastRenderedPreview = null;
+                var drawnPreview = 0;
                 try
                 {
                     while (!token.IsCancellationRequested)
@@ -77,10 +88,18 @@ public void Start(string? activity = null)
                             // Move up to the activity line, clear it, rewrite, drop back down.
                             //  = up one, \r = col 0,  = clear line,  = down one.
                             var redraw = currentActivity ?? string.Empty;
-                            Console.Write($"\r\r  {redraw}\r");
+                            var up = 1 + drawnPreview;
+                            Console.Write($"\r[{up}A\r  {redraw}[{up}B\r");
                             lastRenderedActivity = currentActivity;
                         }
 
+                        var currentPreview = _livePreview;
+                        if (!ReferenceEquals(currentPreview, lastRenderedPreview))
+                        {
+                            drawnPreview = DrawPreview(currentPreview, drawnPreview);
+                            lastRenderedPreview = currentPreview;
+                        }
+
                         var frame = frames[i++ % frames.Length];
                         var elapsed = FormatElapsed(now - startTime);
 
@@ -100,6 +119,8 @@ public void Start(string? activity = null)
                 {
                     // Clear the spinner line - animation is ephemeral, never preserved.
                     Console.Write($"\r");
+                    for (var row = 0; row < drawnPreview; row++)
+                        Console.Write($"");
                     if (activityLineReserved)
                     {
                         // Move up to the activity line and clear it.
@@ -130,6 +151,50 @@ public void UpdateActivity(string? activity)
         _liveActivity = activity;
     }
 
+    /// <summary>
+    /// Shows the reply streaming right now as its last <see cref="PreviewLines"/> lines above the
+    /// spinner; null clears it. Safe to call from any thread and as often as chunks arrive: the
+    /// spinner picks up only the newest text on its next frame. The preview is never kept — it is
+    /// cleared with the spinner, and the finished reply prints as rendered markdown instead.
+    /// </summary>
+    public void UpdatePreview(string? text)
+    {
+        _livePreview = text;
+    }
+
+    /// <summary>
+    /// Redraws the preview rows above the spinner line, with the cursor starting and ending at the
+    /// start of the spinner line. Returns the region's new height.
+    /// </summary>
+    private static int DrawPreview(string? text, int drawn)
+    {
+        // Two cells of indent, and a spare column so a full-width row can't wrap on terminals that
+        // wrap at the last column.
+        var width = Math.Max(20, SafeWindowWidth() - 3);
+        var lines = ReplyPreview.Tail(text, width, PreviewLines);
+        var height = Math.Max(drawn, lines.Count);
+        if (height == 0) return 0;
+
+        var sb = new System.Text.StringBuilder();
+        sb.Append($"\r");
+        if (drawn > 0) sb.Append($"[{drawn}A");
+        var blank = height - lines.Count;
+        for (var row = 0; row < height; row++)
+        {
+            sb.Append($"\r");
+            if (row >= blank) sb.Append($"  {lines[row - blank]}");
+            sb.Append('\n');
+        }
+        Console.Write(sb.ToString());
+        return height;
+    }
+
+    private static int SafeWindowWidth()
+    {
+        try { return Console.WindowWidth > 0 ? Console.WindowWidth : 80; }
+        catch { return 80; }
+    }
+
     /// <summary>
     /// Compact elapsed-time formatter: "3s", "45s", "1m 20s", "12m 5s".
     /// </summary>
diff --git a/tests/MandoCode.Tests/ContextMeterTests.cs b/tests/MandoCode.Tests/ContextMeterTests.cs
new file mode 100644
index 0000000..bb5dc32
--- /dev/null
+++ b/tests/MandoCode.Tests/ContextMeterTests.cs
@@ -0,0 +1,53 @@
+using MandoCode.Services;
+using Xunit;
+
+namespace MandoCode.Tests;
+
+public class ContextMeterTests
+{
+    [Fact]
+    public void Read_FillsTheBarInProportion()
+    {
+        var reading = ContextMeter.Read(8_000, 16_000);
+
+        Assert.Equal(ContextMeter.BarCells, reading.Bar.Length);
+        Assert.Equal(new string('█', 10), reading.Filled);
+        Assert.Equal(new string('░', 10), reading.Empty);
+        Assert.Equal("8k / 16k (50%)", reading.Label);
+        Assert.Equal(ContextMeter.Level.Ok, reading.Level);
+    }
+
+    [Theory]
+    [InlineData(9_000, ContextMeter.Level.Ok)]      // 56%
+    [InlineData(10_000, ContextMeter.Level.Warm)]   // 63%
+    [InlineData(14_000, ContextMeter.Level.Full)]   // 88%
+    public void Read_WarnsAsTheWindowFills(long used, ContextMeter.Level expected)
+    {
+        Assert.Equal(expected, ContextMeter.Read(used, 16_000).Level);
+    }
+
+    [Fact]
+    public void Read_ClampsPastAFullWindow()
+    {
+        var reading = ContextMeter.Read(40_000, 16_000);
+        Assert.Equal(new string('█', ContextMeter.BarCells), reading.Filled);
+        Assert.Equal(string.Empty, reading.Empty);
+        Assert.EndsWith("(100%)", reading.Label);
+    }
+
+    [Fact]
+    public void Read_WithoutAKnownWindow_ShowsTheCountOnly()
+    {
+        var reading = ContextMeter.Read(18_000, 0);
+        Assert.Equal(string.Empty, reading.Bar);
+        Assert.Equal("~18k tokens in context", reading.Label);
+    }
+
+    [Fact]
+    public void KnownWindow_IsTheConfiguredLengthForLocalModels_AndUnknownForCloud()
+    {
+        Assert.Equal(32_768, ContextMeter.KnownWindow("qwen2.5-coder:14b", 32_768));
+        Assert.Equal(0, ContextMeter.KnownWindow("deepseek-v4-flash:cloud", 32_768));
+        Assert.Equal(0, ContextMeter.KnownWindow("llama3.1", 0));
+    }
+}
diff --git a/tests/MandoCode.Tests/ReplyPreviewTests.cs b/tests/MandoCode.Tests/ReplyPreviewTests.cs
new file mode 100644
index 0000000..743a444
--- /dev/null
+++ b/tests/MandoCode.Tests/ReplyPreviewTests.cs
@@ -0,0 +1,52 @@
+using MandoCode.Services;
+using Xunit;
+
+namespace MandoCode.Tests;
+
+public class ReplyPreviewTests
+{
+    [Fact]
+    public void Tail_KeepsTheLastLines()
+    {
+        var lines = ReplyPreview.Tail("one\ntwo\nthree\nfour", width: 40, maxLines: 2);
+        Assert.Equal(new[] { "three", "four" }, lines);
+    }
+
+    [Fact]
+    public void Tail_WrapsLongLines_SoNoLineIsWiderThanTheTerminal()
+    {
+        var text = string.Join(' ', Enumerable.Repeat("word", 30));
+        var lines = ReplyPreview.Tail(text, width: 20, maxLines: 50);
+
+        Assert.True(lines.Count > 1);
+        Assert.All(lines, l => Assert.True(ReplyPreview.Cells(l) <= 20, $"'{l}' is wider than 20 cells"));
+    }
+
+    [Fact]
+    public void Tail_SplitsAWordWiderThanTheLine()
+    {
+        var lines = ReplyPreview.Tail(new string('x', 25), width: 10, maxLines: 10);
+        Assert.Equal(new[] { new string('x', 10), new string('x', 10), new string('x', 5) }, lines);
+    }
+
+    [Fact]
+    public void Tail_CountsWideCharactersAsTwoCells()
+    {
+        var lines = ReplyPreview.Tail("日本語日本語", width: 6, maxLines: 10);
+        Assert.Equal(new[] { "日本語", "日本語" }, lines);
+    }
+
+    [Fact]
+    public void Tail_DropsControlCharacters_AndTrimsBlankEnds()
+    {
+        var lines = ReplyPreview.Tail("\n\nhello\u001b[31m\tthere\n\n", width: 40, maxLines: 5);
+        Assert.Equal(new[] { "hello[31m    there" }, lines);
+    }
+
+    [Fact]
+    public void Tail_OfNothing_IsEmpty()
+    {
+        Assert.Empty(ReplyPreview.Tail(null, 40, 5));
+        Assert.Empty(ReplyPreview.Tail("   ", 40, 5));
+    }
+}