diff --git a/README.md b/README.md
index af3e20a..56ad7cf 100644
--- a/README.md
+++ b/README.md
@@ -129,6 +129,84 @@ reusable, self-contained Avalonia terminal control package (it bundles
 Avalonia applications. See the "NuGet package" section of
 [docs/release.md](docs/release.md) for packaging and consumption details.
 
+## Per-tab asciicast recording
+
+Recording actions operate on the active terminal pane. `startRecording` captures
+future PTY output, `stopRecording` retains the completed recording,
+`saveRecording` opens a native Save As dialog and exports an asciicast `.cast`
+file, and `replayRecording` replays the active pane's latest capture in a
+separate read-only tab with its original timing. The recorder writes v2 by
+default and the core API can also export v3 with
+`recording.ToJson(AsciicastFormat.V3)`. `openRecording` detects and replays both
+v2 and v3 files, even when the current pane has no recording. Pickers start in
+the `recordings` directory beside `settings.json`.
+
+All path-taking actions also accept an explicit `path` for keybindings,
+command-line activation, and automation. A path on `startRecording` enables an
+auto-save workflow: stopping the recording writes directly to that path.
+Exported v2 files are compatible with v2 players such as `asciinema play`;
+imported v3 files retain their relative event timing during replay.
+
+To stream the active tab, open the command palette and choose **Start
+streaming...**, paste the producer `ws://` or `wss://` URL, and choose
+**Asciinema v3** (recommended), **Asciinema v2**, or **DVLS v2**. The recording
+bar changes to **Live** while connected. Choose **Stop streaming** from the
+palette (or use the bar's **Stop** button) to flush and close the stream. DT
+remembers the URL only for the current process because producer URLs may
+contain access tokens.
+
+NuGet consumers can also stream an active recording to an asciicast-compatible
+WebSocket push endpoint:
+
+```csharp
+await terminal.StartRecordingAsync(
+    new Uri("wss://gateway.example/jet/jrec/push/session?token=signed-token"));
+// Use the terminal normally.
+await terminal.StopRecordingAsync();
+```
+
+The control preserves authentication query parameters, adds
+`fileType=asciicast`, and sends the visible starting screen plus subsequent
+output as asciicast v2 JSONL text messages. Endpoint discovery and token
+acquisition stay in the embedding application.
+
+Official asciinema servers are also supported. Create a live stream through the
+server API, then pass its `ws_producer_url` and select v2 or v3:
+
+```csharp
+await terminal.StartRecordingAsync(
+    new Uri(streamResponse.WsProducerUrl),
+    AsciicastFormat.V3);
+```
+
+This negotiates the matching `v2.asciicast` or `v3.asciicast` WebSocket
+subprotocol. V3 output uses relative event deltas; the legacy URI-only overload
+remains compatible with DVLS push URLs and server-side first-message detection.
+
+While a recording is active, its tab shows a red recording indicator and the
+active pane displays elapsed time, format, destination, and Stop/Save controls.
+Stopped captures remain available from the same bar for saving or replay. A
+yellow tab indicator marks an unsaved capture, and closing its pane, tab, or
+window asks for confirmation even when normal close confirmations are disabled.
+
+Replay tabs include pause/resume, restart, progress, and 0.5x-2x playback speed
+controls. Replay remains read-only and can be closed without affecting the
+original terminal session or recording.
+
+The actions can be invoked from the command palette or assigned in
+`settings.json`; for example:
+
+```json
+{
+  "command": {
+    "action": "startRecording",
+    "path": "%USERPROFILE%\\Desktop\\demo.cast",
+    "format": "v3"
+  },
+  "keys": "ctrl+shift+r"
+}
+```
+
 ## Compatibility inventory
 
 ### Safety and compatibility settings
diff --git a/src/Devolutions.Terminal.App/Actions/ActionScopeCatalog.cs b/src/Devolutions.Terminal.App/Actions/ActionScopeCatalog.cs
index 0d9ac83..9c88a43 100644
--- a/src/Devolutions.Terminal.App/Actions/ActionScopeCatalog.cs
+++ b/src/Devolutions.Terminal.App/Actions/ActionScopeCatalog.cs
@@ -17,6 +17,7 @@ public static class ActionScopeCatalog
         "identifyWindow" or
         "newWindow" or
         "openAbout" or
+        "openRecording" or
         "openNewTabDropdown" or
         "openSettings" or
         "openSystemMenu" or
diff --git a/src/Devolutions.Terminal.App/Actions/CloseConfirmationPolicy.cs b/src/Devolutions.Terminal.App/Actions/CloseConfirmationPolicy.cs
index a900d7f..3c9ccc5 100644
--- a/src/Devolutions.Terminal.App/Actions/CloseConfirmationPolicy.cs
+++ b/src/Devolutions.Terminal.App/Actions/CloseConfirmationPolicy.cs
@@ -4,11 +4,16 @@ namespace Devolutions.Terminal.App.Actions;
 
 public static class CloseConfirmationPolicy
 {
-    public static bool RequiresConfirmation(ConfirmOnClose policy, int runningSessions, bool automaticExit = false) =>
-        !automaticExit && policy switch
+    public static bool RequiresConfirmation(
+        ConfirmOnClose policy,
+        int runningSessions,
+        int unsavedRecordings = 0,
+        bool automaticExit = false) =>
+        unsavedRecordings > 0 ||
+        (!automaticExit && policy switch
         {
             ConfirmOnClose.Always => runningSessions > 0,
             ConfirmOnClose.Automatic => runningSessions > 1,
             _ => false,
-        };
+        });
 }
diff --git a/src/Devolutions.Terminal.App/Views/MainWindow.Lifecycle.cs b/src/Devolutions.Terminal.App/Views/MainWindow.Lifecycle.cs
index f86fee2..a60eb9a 100644
--- a/src/Devolutions.Terminal.App/Views/MainWindow.Lifecycle.cs
+++ b/src/Devolutions.Terminal.App/Views/MainWindow.Lifecycle.cs
@@ -34,13 +34,27 @@ private async Task<bool> ConfirmCloseAsync(IEnumerable<TerminalPane> panes, bool
         var snapshot = panes.ToArray();
         var sessions = snapshot.Select(pane => pane.Control.ProcessMetadata).ToArray();
         var running = snapshot.Count(pane => pane.Control.IsRunning);
-        if (!CloseConfirmationPolicy.RequiresConfirmation(_settings.ConfirmOnClose, running, automaticExit))
+        var unsavedRecordings = snapshot.Count(pane => pane.Control.HasUnsavedRecording);
+        if (!CloseConfirmationPolicy.RequiresConfirmation(
+                _settings.ConfirmOnClose,
+                running,
+                unsavedRecordings,
+                automaticExit))
         {
             return true;
         }
 
+        var message = (running, unsavedRecordings) switch
+        {
+            (> 0, > 0) =>
+                $"Close {running} running terminal session(s)? " +
+                $"{unsavedRecordings} unsaved recording(s) will be discarded.",
+            (_, > 0) =>
+                $"Close terminal sessions? {unsavedRecordings} unsaved recording(s) will be discarded.",
+            _ => $"Close {running} running terminal session(s)? Unsaved work may be lost.",
+        };
         return await _confirmationDialog.ShowAsync(this, "Close terminal sessions",
-                   $"Close {running} running terminal session(s)? Unsaved work may be lost.", "Close sessions").ConfigureAwait(true) &&
+                   message, "Close sessions").ConfigureAwait(true) &&
                panes.SequenceEqual(snapshot) &&
                snapshot.Select(pane => pane.Control.ProcessMetadata).SequenceEqual(sessions);
     }
@@ -74,9 +88,11 @@ protected override void OnClosing(WindowClosingEventArgs e)
         }
 
         base.OnClosing(e);
+        var panes = _tabs.SelectMany(tab => tab.Panes.Leaves()).ToArray();
         if (!e.Cancel && !_closeApproved &&
             CloseConfirmationPolicy.RequiresConfirmation(_settings.ConfirmOnClose,
-                _tabs.SelectMany(tab => tab.Panes.Leaves()).Count(pane => pane.Control.IsRunning)))
+                panes.Count(pane => pane.Control.IsRunning),
+                panes.Count(pane => pane.Control.HasUnsavedRecording)))
         {
             e.Cancel = true;
             if (!_closeConfirmationPending)
@@ -89,6 +105,7 @@ protected override void OnClosing(WindowClosingEventArgs e)
     protected override async void OnClosed(EventArgs e)
     {
         _isClosed = true;
+        _recordingUiTimer.Stop();
         if (!_layoutPersisted && _tabs.Count > 0)
         {
             TryPersistCurrentLayout(CaptureLayout());
diff --git a/src/Devolutions.Terminal.App/Views/MainWindow.axaml b/src/Devolutions.Terminal.App/Views/MainWindow.axaml
index 33a74d9..8c555a6 100644
--- a/src/Devolutions.Terminal.App/Views/MainWindow.axaml
+++ b/src/Devolutions.Terminal.App/Views/MainWindow.axaml
@@ -99,6 +99,64 @@
     </Border>
     <Grid>
       <Panel x:Name="TerminalHost" Background="#0C0C0C" />
+      <Border x:Name="RecordingStateBar"
+              IsVisible="False"
+              HorizontalAlignment="Center"
+              VerticalAlignment="Bottom"
+              Margin="12"
+              Padding="10,6"
+              CornerRadius="6"
+              Background="#F02B2B2B">
+        <StackPanel Orientation="Horizontal"
+                    Spacing="8"
+                    VerticalAlignment="Center">
+          <TextBlock x:Name="RecordingStatusText"
+                     VerticalAlignment="Center"
+                     FontWeight="SemiBold" />
+          <TextBlock x:Name="RecordingElapsedText"
+                     VerticalAlignment="Center" />
+          <ProgressBar x:Name="ReplayProgress"
+                       IsVisible="False"
+                       Width="120"
+                       Height="4"
+                       Minimum="0"
+                       VerticalAlignment="Center" />
+          <TextBlock x:Name="RecordingDestinationText"
+                     MaxWidth="260"
+                     TextTrimming="CharacterEllipsis"
+                     VerticalAlignment="Center"
+                     Foreground="#B8B8B8" />
+          <Button x:Name="RecordingStopButton"
+                  IsVisible="False"
+                  Content="Stop"
+                  Click="RecordingStop_OnClick" />
+          <Button x:Name="RecordingSaveButton"
+                  IsVisible="False"
+                  Content="Save as..."
+                  Click="RecordingSave_OnClick" />
+          <Button x:Name="RecordingReplayButton"
+                  IsVisible="False"
+                  Content="Replay"
+                  Click="RecordingReplay_OnClick" />
+          <Button x:Name="ReplayPauseButton"
+                  IsVisible="False"
+                  Content="Pause"
+                  Click="ReplayPause_OnClick" />
+          <Button x:Name="ReplayRestartButton"
+                  IsVisible="False"
+                  Content="Restart"
+                  Click="ReplayRestart_OnClick" />
+          <ComboBox x:Name="ReplaySpeedComboBox"
+                    IsVisible="False"
+                    Width="72"
+                    SelectionChanged="ReplaySpeed_OnSelectionChanged">
+            <ComboBoxItem Content="0.5x" Tag="0.5" />
+            <ComboBoxItem Content="1x" Tag="1" />
+            <ComboBoxItem Content="1.5x" Tag="1.5" />
+            <ComboBoxItem Content="2x" Tag="2" />
+          </ComboBox>
+        </StackPanel>
+      </Border>
       <Border x:Name="FindBar"
               IsVisible="False"
               HorizontalAlignment="Right"
diff --git a/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs b/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
index f82f59f..2a0aab9 100644
--- a/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
+++ b/src/Devolutions.Terminal.App/Views/MainWindow.axaml.cs
@@ -1,3 +1,5 @@
+using System.Text;
+using System.Net.WebSockets;
 using Avalonia;
 using Avalonia.Automation;
 using Avalonia.Automation.Peers;
@@ -11,6 +13,7 @@
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Platform;
+using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using Devolutions.Terminal.Connection;
 using Devolutions.Terminal;
@@ -80,9 +83,12 @@ public partial class MainWindow :
     private readonly TaskCompletionSource<TerminalWindowActivationResult> _initialActivationCompletion =
         new(TaskCreationOptions.RunContinuationsAsynchronously);
     private readonly DispatcherTimer _notificationTimer;
+    private readonly DispatcherTimer _recordingUiTimer;
     private PixelPoint? _normalPosition;
     private WindowSizeState _normalSize = new();
     private KeyModifiers _newTabButtonModifiers;
+    private string _lastStreamingUri = string.Empty;
+    private int _lastStreamingMode;
 
     public MainWindow() : this(0, string.Empty, null)
     {
@@ -131,6 +137,10 @@ public MainWindow(
             _notificationTimer.Stop();
             NotificationToast.IsVisible = false;
         };
+        _recordingUiTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(250) };
+        _recordingUiTimer.Tick += (_, _) => UpdateRecordingStateBar();
+        ReplaySpeedComboBox.SelectedIndex = 1;
+        _recordingUiTimer.Start();
         _connectionFactory = new TerminalConnectionFactory(
             new AzureCloudShellAuthenticationCallbacks
             {
@@ -185,12 +195,12 @@ public MainWindow(
             NativeMenu.SetMenu(
                 this,
                 MacOsNativeMenu.CreateWindowMenu(action =>
-                    _actionDispatcher.DispatchAsync(new ActionAndArgs(action))));
+                    DispatchActionAsync(new ActionAndArgs(action))));
         }
     }
 
     public void DispatchMenuAction(ShortcutAction action) =>
-        _ = _actionDispatcher.DispatchAsync(new ActionAndArgs(action));
+        _ = DispatchActionAsync(new ActionAndArgs(action));
 
     private MainWindow(ProfileSettings initialProfile) : this()
     {
@@ -636,6 +646,323 @@ private async Task CreateTabAsync(ProfileSettings profile)
         }
     }
 
+    private async Task CreateReplayTabAsync(AsciicastRecording recording)
+    {
+        var title = string.IsNullOrWhiteSpace(recording.Title)
+            ? "Asciicast replay"
+            : $"{recording.Title} (replay)";
+        var profile = new ProfileSettings
+        {
+            Name = title,
+            TabTitle = title,
+            SuppressApplicationTitle = true,
+        };
+        var pane = CreatePane(
+            profile,
+            presentation: new PanePresentationState
+            {
+                Title = title,
+                IsReadOnly = true,
+            });
+        var tab = new TerminalTab(pane);
+        _tabCollection.Add(tab);
+        ActivateTab(tab);
+        RebuildTabs();
+
+        try
+        {
+            await pane.Control.ReplayRecordingAsync(recording).ConfigureAwait(true);
+            ShowNotification(new TerminalNotification(
+                "Recording replay complete",
+                title));
+        }
+        catch (OperationCanceledException)
+        {
+            // Closing the replay tab cancels its playback.
+        }
+    }
+
+    private void OnRecordingStateChanged(object? sender, EventArgs e)
+    {
+        if (!Dispatcher.UIThread.CheckAccess())
+        {
+            Dispatcher.UIThread.Post(() => OnRecordingStateChanged(sender, e));
+            return;
+        }
+
+        RebuildTabs();
+        UpdateRecordingStateBar();
+    }
+
+    private void OnReplayStateChanged(object? sender, EventArgs e)
+    {
+        if (!Dispatcher.UIThread.CheckAccess())
+        {
+            Dispatcher.UIThread.Post(UpdateRecordingStateBar);
+            return;
+        }
+
+        UpdateRecordingStateBar();
+    }
+
+    private void UpdateRecordingStateBar()
+    {
+        var control = ActiveControl;
+        if (control is null || (!control.HasRecording && !control.HasReplay))
+        {
+            RecordingStateBar.IsVisible = false;
+            return;
+        }
+
+        RecordingStateBar.IsVisible = true;
+        var replay = control.HasReplay;
+        RecordingStopButton.IsVisible = !replay && control.IsRecording;
+        RecordingSaveButton.IsVisible = !replay && control.HasRecording;
+        RecordingReplayButton.IsVisible = !replay && control.HasRecording && !control.IsRecording;
+        ReplayPauseButton.IsVisible = replay;
+        ReplayRestartButton.IsVisible = replay;
+        ReplaySpeedComboBox.IsVisible = replay;
+        ReplayProgress.IsVisible = replay;
+
+        if (replay)
+        {
+            RecordingStatusText.Foreground = Brushes.White;
+            RecordingStatusText.Text = control.IsReplayPaused
+                ? "Replay paused"
+                : control.IsReplaying
+                    ? "Replaying"
+                    : "Replay complete";
+            RecordingElapsedText.Text =
+                $"{FormatMediaTime(control.ReplayPosition)} / {FormatMediaTime(control.ReplayDuration)}";
+            RecordingDestinationText.Text = string.Empty;
+            ToolTip.SetTip(RecordingDestinationText, null);
+            ReplayPauseButton.Content = control.IsReplayPaused ? "Resume" : "Pause";
+            ReplayPauseButton.IsEnabled = control.IsReplaying;
+            ReplayRestartButton.IsEnabled = control.HasReplay;
+            ReplayProgress.Maximum = Math.Max(1d, control.ReplayDuration.TotalSeconds);
+            ReplayProgress.Value = Math.Min(
+                ReplayProgress.Maximum,
+                control.ReplayPosition.TotalSeconds);
+            var speedIndex = control.ReplaySpeed switch
+            {
+                <= 0.5 => 0,
+                <= 1 => 1,
+                <= 1.5 => 2,
+                _ => 3,
+            };
+            if (ReplaySpeedComboBox.SelectedIndex != speedIndex)
+            {
+                ReplaySpeedComboBox.SelectedIndex = speedIndex;
+            }
+
+            return;
+        }
+
+        var format = control.RecordingFormat?.ToString().ToLowerInvariant() ?? "v2";
+        var streaming = control.IsStreamingRecording;
+        RecordingStatusText.Text = control.IsRecording
+            ? streaming
+                ? $"● Live {format}"
+                : $"● Recording {format}"
+            : control.HasUnsavedRecording
+                ? $"Recording ready ({format})"
+                : $"Recording saved ({format})";
+        RecordingStatusText.Foreground = control.IsRecording
+            ? new SolidColorBrush(Color.Parse("#FF7B7F"))
+            : Brushes.White;
+        RecordingElapsedText.Text = FormatMediaTime(control.RecordingElapsed);
+        var recordingPath = control.RecordingPath;
+        RecordingDestinationText.Text = streaming
+            ? recordingPath is null ? "Streaming live • not saved" : $"Streaming live • {Path.GetFileName(recordingPath)}"
+            : recordingPath is null
+            ? control.HasUnsavedRecording ? "Not saved" : string.Empty
+            : control.IsRecording
+                ? $"Auto-save: {Path.GetFileName(recordingPath)}"
+                : Path.GetFileName(recordingPath);
+        ToolTip.SetTip(RecordingDestinationText, recordingPath);
+    }
+
+    private static string FormatMediaTime(TimeSpan value) =>
+        value.TotalHours >= 1
+            ? value.ToString(@"h\:mm\:ss", CultureInfo.InvariantCulture)
+            : value.ToString(@"mm\:ss", CultureInfo.InvariantCulture);
+
+    private async void RecordingStop_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var control = ActiveControl;
+        if (control is null)
+        {
+            return;
+        }
+
+        var streaming = control.IsStreamingRecording;
+        try
+        {
+            var savedPath = await control.StopRecordingAsync().ConfigureAwait(true);
+            ShowNotification(new TerminalNotification(
+                streaming ? "Live stream stopped" : "Recording stopped",
+                savedPath is null ? "Use Save as... to export the recording." : $"Saved to {savedPath}"));
+        }
+        catch (Exception ex) when (ex is WebSocketException or IOException or OperationCanceledException)
+        {
+            ShowNotification(new TerminalNotification("Unable to stop live stream cleanly", ex.Message));
+        }
+        finally
+        {
+            UpdateRecordingStateBar();
+        }
+    }
+
+    private async Task StartStreamingAsync(TermControl control)
+    {
+        var request = await PromptForStreamingTargetAsync().ConfigureAwait(true);
+        if (request is null)
+        {
+            return;
+        }
+
+        _lastStreamingUri = request.Uri.AbsoluteUri;
+        _lastStreamingMode = request.Mode;
+        try
+        {
+            if (request.Mode == 2)
+            {
+                await control.StartRecordingAsync(request.Uri).ConfigureAwait(true);
+            }
+            else
+            {
+                var format = request.Mode == 1 ? AsciicastFormat.V2 : AsciicastFormat.V3;
+                await control.StartRecordingAsync(request.Uri, format).ConfigureAwait(true);
+            }
+
+            ShowNotification(new TerminalNotification(
+                "Live stream started",
+                request.Mode == 2
+                    ? "Streaming the active terminal using DVLS asciicast v2."
+                    : $"Streaming the active terminal using asciicast {(request.Mode == 1 ? "v2" : "v3")}."));
+        }
+        catch (Exception ex) when (
+            ex is ArgumentException or
+                InvalidOperationException or
+                WebSocketException or
+                HttpRequestException or
+                OperationCanceledException)
+        {
+            ShowNotification(new TerminalNotification("Unable to start live stream", ex.Message));
+        }
+        finally
+        {
+            UpdateRecordingStateBar();
+        }
+    }
+
+    private async Task StopStreamingAsync(TermControl control)
+    {
+        try
+        {
+            var savedPath = await control.StopRecordingAsync().ConfigureAwait(true);
+            ShowNotification(new TerminalNotification(
+                "Live stream stopped",
+                savedPath is null ? "Use Save as... to export the recording." : $"Saved to {savedPath}"));
+        }
+        catch (Exception ex) when (ex is WebSocketException or IOException or OperationCanceledException)
+        {
+            ShowNotification(new TerminalNotification("Unable to stop live stream cleanly", ex.Message));
+        }
+        finally
+        {
+            UpdateRecordingStateBar();
+        }
+    }
+
+    private async void RecordingSave_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var control = ActiveControl;
+        if (control is null)
+        {
+            return;
+        }
+
+        try
+        {
+            var destination = await SaveRecordingAsync(
+                control,
+                requestedPath: null,
+                control.RecordingFormat ?? AsciicastFormat.V2).ConfigureAwait(true);
+            if (destination is not null)
+            {
+                ShowNotification(new TerminalNotification("Recording saved", destination));
+            }
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidOperationException)
+        {
+            ShowNotification(new TerminalNotification("Recording save failed", ex.Message));
+        }
+    }
+
+    private async void RecordingReplay_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var control = ActiveControl;
+        if (control is null)
+        {
+            return;
+        }
+
+        await CreateReplayTabAsync(control.GetRecording()).ConfigureAwait(true);
+    }
+
+    private void ReplayPause_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var control = ActiveControl;
+        if (control is null)
+        {
+            return;
+        }
+
+        if (control.IsReplayPaused)
+        {
+            control.ResumeReplay();
+        }
+        else
+        {
+            control.PauseReplay();
+        }
+    }
+
+    private async void ReplayRestart_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var control = ActiveControl;
+        if (control is null)
+        {
+            return;
+        }
+
+        try
+        {
+            await control.RestartReplayAsync().ConfigureAwait(true);
+            ShowNotification(new TerminalNotification(
+                "Recording replay complete",
+                _activeTab?.Title ?? "Asciicast replay"));
+        }
+        catch (OperationCanceledException)
+        {
+            // Another restart or closing the replay tab cancels this run.
+        }
+    }
+
+    private void ReplaySpeed_OnSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (ActiveControl is not { HasReplay: true } control ||
+            ReplaySpeedComboBox.SelectedItem is not ComboBoxItem { Tag: string speedText } ||
+            !double.TryParse(speedText, NumberStyles.Float, CultureInfo.InvariantCulture, out var speed) ||
+            Math.Abs(control.ReplaySpeed - speed) < 0.001)
+        {
+            return;
+        }
+
+        control.SetReplaySpeed(speed);
+    }
+
     private TerminalPane CreatePane(
         ProfileSettings profile,
         TerminalSessionDescriptor? session = null,
@@ -660,6 +987,8 @@ private TerminalPane CreatePane(
             profile,
             control,
             presentation);
+        control.RecordingStateChanged += OnRecordingStateChanged;
+        control.ReplayStateChanged += OnReplayStateChanged;
         pane.Presentation.IsAdministrator = OperatingSystem.IsWindows() && profile.Elevate;
         control.TitleChanged += (_, title) =>
         {
@@ -832,11 +1161,13 @@ private void ActivateTab(TerminalTab tab)
         RebuildTerminalHost();
         if (tab.IsSettingsTab)
         {
+            UpdateRecordingStateBar();
             tab.CustomContent?.Focus();
             return;
         }
 
         tab.Panes.ActiveContent?.Control.Focus();
+        UpdateRecordingStateBar();
     }
 
     private void ActivatePane(TerminalTab tab, TerminalPane pane)
@@ -849,6 +1180,7 @@ private void ActivatePane(TerminalTab tab, TerminalPane pane)
         SynchronizeTitle(tab);
         RebuildTerminalHost();
         pane.Control.Focus();
+        UpdateRecordingStateBar();
     }
 
     private async Task ClosePaneAsync(TerminalTab tab, TerminalPane pane, bool automaticExit = false)
@@ -1118,6 +1450,27 @@ private void RebuildTabs()
             content.Children.Add(title);
 
             var status = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 4 };
+            var recordingControl = tab.Panes.Leaves()
+                .Select(static pane => pane.Control)
+                .FirstOrDefault(static control => control.IsRecording || control.HasUnsavedRecording);
+            if (recordingControl is not null)
+            {
+                var recordingIndicator = new TextBlock
+                {
+                    Text = "●",
+                    Foreground = recordingControl.IsRecording
+                        ? new SolidColorBrush(Color.Parse("#FF5A5F"))
+                        : new SolidColorBrush(Color.Parse("#F4C95D")),
+                    VerticalAlignment = VerticalAlignment.Center,
+                };
+                var indicatorText = recordingControl.IsRecording
+                    ? $"Recording {recordingControl.RecordingFormat?.ToString().ToLowerInvariant()}"
+                    : "Unsaved recording";
+                AutomationProperties.SetName(recordingIndicator, indicatorText);
+                ToolTip.SetTip(recordingIndicator, indicatorText);
+                status.Children.Add(recordingIndicator);
+            }
+
             if (compact)
             {
                 if (presentation.ProgressState != TerminalProgressState.None)
@@ -1914,6 +2267,85 @@ action.Args is SwapPaneArgs args &&
             ShowNotification(new TerminalNotification("Buffer exported", path));
             return Task.CompletedTask;
         });
+        Register(
+            ShortcutAction.StartRecording,
+            ActionScope.Control,
+            _ => ActiveControl is { IsRecording: false, IsStreamingRecording: false },
+            action =>
+            {
+                var args = action.Args as StartRecordingArgs;
+                ActiveControl!.StartRecording(args?.Path, args?.Format ?? AsciicastFormat.V2);
+                ShowNotification(new TerminalNotification(
+                    "Recording started",
+                    "Output from the active terminal is now being recorded."));
+                return Task.CompletedTask;
+            });
+        Register(
+            ShortcutAction.StopRecording,
+            ActionScope.Control,
+            _ => ActiveControl is { IsRecording: true, IsStreamingRecording: false },
+            _ =>
+        {
+            var savedPath = ActiveControl!.StopRecording();
+            ShowNotification(new TerminalNotification(
+                "Recording stopped",
+                savedPath is null
+                    ? "The recording is ready to save or replay. Choose a .cast destination when you're ready."
+                    : $"Saved to {savedPath}. The recording is still available for replay."));
+            return Task.CompletedTask;
+        });
+        Register(
+            ShortcutAction.StartStreaming,
+            ActionScope.Control,
+            _ => ActiveControl is
+            {
+                IsRecording: false,
+                IsStreamingRecording: false,
+                HasReplay: false,
+            },
+            _ => StartStreamingAsync(ActiveControl!));
+        Register(
+            ShortcutAction.StopStreaming,
+            ActionScope.Control,
+            _ => ActiveControl?.IsStreamingRecording == true,
+            _ => StopStreamingAsync(ActiveControl!));
+        Register(ShortcutAction.SaveRecording, ActionScope.Control, _ => ActiveControl?.HasRecording == true, async action =>
+        {
+            var control = ActiveControl!;
+            var args = action.Args as SaveRecordingArgs;
+            var savedDestination = await SaveRecordingAsync(
+                control,
+                args?.Path,
+                args?.Format ?? AsciicastFormat.V2).ConfigureAwait(true);
+            if (savedDestination is null)
+            {
+                return;
+            }
+
+            ShowNotification(new TerminalNotification("Recording saved", savedDestination));
+        });
+        Register(ShortcutAction.ReplayRecording, ActionScope.Control, action =>
+            ActiveControl?.HasRecording == true ||
+            !string.IsNullOrWhiteSpace((action.Args as ReplayRecordingArgs)?.Path), async action =>
+        {
+            var control = ActiveControl!;
+            var requestedPath = (action.Args as ReplayRecordingArgs)?.Path;
+            var recording = string.IsNullOrWhiteSpace(requestedPath)
+                ? control.GetRecording()
+                : LoadRecording(requestedPath);
+            await CreateReplayTabAsync(recording).ConfigureAwait(true);
+        });
+        Register(ShortcutAction.OpenRecording, ActionScope.Window, _ => true, async action =>
+        {
+            var requestedPath = (action.Args as OpenRecordingArgs)?.Path;
+            var recording = await OpenRecordingAsync(requestedPath).ConfigureAwait(true);
+            if (recording is null)
+            {
+                return;
+            }
+
+            await CreateReplayTabAsync(recording).ConfigureAwait(true);
+        });
         Register(ShortcutAction.SelectCommand, ActionScope.Control, _ => ActiveControl is not null, action =>
         {
             ActiveControl!.SelectCommand(
@@ -2400,6 +2832,16 @@ private void PopulateCommandPalette()
     private async Task<ActionDispatchResult> DispatchActionAsync(ActionAndArgs action)
     {
         _lastDispatchResult = await _actionDispatcher.DispatchAsync(action).ConfigureAwait(true);
+        if (_lastDispatchResult.Status is ActionDispatchStatus.Failed or
+            ActionDispatchStatus.Disabled)
+        {
+            ShowNotification(new TerminalNotification(
+                _lastDispatchResult.Status == ActionDispatchStatus.Failed
+                    ? "Action failed"
+                    : "Action unavailable",
+                _lastDispatchResult.Message ?? action.ActionName));
+        }
+
         return _lastDispatchResult;
     }
 
@@ -2839,6 +3281,15 @@ private bool TryRenameWindow(string name)
         string title,
         string prompt,
         string initialValue)
+    {
+        return await PromptForTextAsync(title, prompt, initialValue, saveButtonText: "Save").ConfigureAwait(true);
+    }
+
+    private async Task<string?> PromptForTextAsync(
+        string title,
+        string prompt,
+        string initialValue,
+        string saveButtonText)
     {
         var textBox = new TextBox
         {
@@ -2847,7 +3298,7 @@ private bool TryRenameWindow(string name)
         };
         var accept = new Button
         {
-            Content = "Save",
+            Content = saveButtonText,
             IsDefault = true,
             MinWidth = 80,
         };
@@ -2892,6 +3343,267 @@ private bool TryRenameWindow(string name)
         return await dialog.ShowDialog<string?>(this).ConfigureAwait(true);
     }
 
+    private async Task<StreamingRecordingRequest?> PromptForStreamingTargetAsync()
+    {
+        var urlBox = new TextBox
+        {
+            Text = _lastStreamingUri,
+            MinWidth = 460,
+            PlaceholderText = "wss://server.example/ws/S/producer-token",
+        };
+        var modeBox = new ComboBox
+        {
+            MinWidth = 220,
+            ItemsSource = new[]
+            {
+                "Asciinema v3 (recommended)",
+                "Asciinema v2",
+                "DVLS v2",
+            },
+            SelectedIndex = _lastStreamingMode,
+        };
+        var validation = new TextBlock
+        {
+            Foreground = new SolidColorBrush(Color.Parse("#FF9B9B")),
+            TextWrapping = TextWrapping.Wrap,
+        };
+        var accept = new Button
+        {
+            Content = "Start streaming",
+            IsDefault = true,
+            IsEnabled = false,
+            MinWidth = 110,
+        };
+        var cancel = new Button
+        {
+            Content = "Cancel",
+            IsCancel = true,
+            MinWidth = 80,
+        };
+        var buttons = new StackPanel
+        {
+            Orientation = Orientation.Horizontal,
+            HorizontalAlignment = HorizontalAlignment.Right,
+            Spacing = 8,
+            Children = { cancel, accept },
+        };
+        var dialog = new Window
+        {
+            Title = "Stream live",
+            CanResize = false,
+            SizeToContent = SizeToContent.WidthAndHeight,
+            WindowStartupLocation = WindowStartupLocation.CenterOwner,
+            Content = new StackPanel
+            {
+                Margin = new Thickness(20),
+                Spacing = 10,
+                Children =
+                {
+                    new TextBlock
+                    {
+                        Text = "Paste the producer WebSocket URL supplied by your asciinema server or DVLS.",
+                        TextWrapping = TextWrapping.Wrap,
+                        MaxWidth = 520,
+                    },
+                    new TextBlock { Text = "Producer URL", FontWeight = FontWeight.SemiBold },
+                    urlBox,
+                    new TextBlock { Text = "Protocol", FontWeight = FontWeight.SemiBold },
+                    modeBox,
+                    validation,
+                    new TextBlock
+                    {
+                        Text = "The URL is remembered only until this DT process exits because it may contain an access token.",
+                        Foreground = new SolidColorBrush(Color.Parse("#B8B8B8")),
+                        FontSize = 12,
+                        TextWrapping = TextWrapping.Wrap,
+                        MaxWidth = 520,
+                    },
+                    buttons,
+                },
+            },
+        };
+
+        Uri? parsedUri = null;
+        void Validate()
+        {
+            var text = urlBox.Text?.Trim();
+            var valid = Uri.TryCreate(text, UriKind.Absolute, out parsedUri) &&
+                        parsedUri.Scheme is "ws" or "wss";
+            accept.IsEnabled = valid;
+            validation.Text = valid || string.IsNullOrWhiteSpace(text)
+                ? string.Empty
+                : "Enter an absolute ws:// or wss:// producer URL.";
+        }
+
+        urlBox.TextChanged += (_, _) => Validate();
+        accept.Click += (_, _) =>
+        {
+            Validate();
+            if (parsedUri is not null)
+            {
+                dialog.Close(new StreamingRecordingRequest(parsedUri, modeBox.SelectedIndex));
+            }
+        };
+        cancel.Click += (_, _) => dialog.Close(null);
+        dialog.Opened += (_, _) =>
+        {
+            Validate();
+            urlBox.Focus();
+            urlBox.SelectAll();
+        };
+        return await dialog.ShowDialog<StreamingRecordingRequest?>(this).ConfigureAwait(true);
+    }
+
+    private sealed record StreamingRecordingRequest(Uri Uri, int Mode);
+
+    private async Task<string?> SaveRecordingAsync(
+        TermControl control,
+        string? requestedPath,
+        AsciicastFormat format)
+    {
+        if (!string.IsNullOrWhiteSpace(requestedPath))
+        {
+            return control.SaveRecording(requestedPath, format);
+        }
+
+        var defaultRecordingPath = GetDefaultRecordingPath();
+        var storage = this.StorageProvider;
+        if (storage is not null && storage.CanSave)
+        {
+            var startLocation = await storage.TryGetFolderFromPathAsync(
+                new Uri(GetRecordingFolderPath())).ConfigureAwait(true);
+            var suggestedFile = await storage.SaveFilePickerAsync(new FilePickerSaveOptions
+            {
+                Title = "Save terminal recording",
+                SuggestedFileName = Path.GetFileName(defaultRecordingPath),
+                SuggestedStartLocation = startLocation,
+                DefaultExtension = "cast",
+                FileTypeChoices =
+                [
+                    new FilePickerFileType("Asciicast recording")
+                    {
+                        Patterns = ["*.cast"],
+                    },
+                ],
+            }).ConfigureAwait(true);
+
+            if (suggestedFile is null)
+            {
+                return null;
+            }
+
+            var localPath = suggestedFile.TryGetLocalPath();
+            if (!string.IsNullOrWhiteSpace(localPath))
+            {
+                return control.SaveRecording(localPath, format);
+            }
+
+            var recording = control.GetRecording();
+            var bytes = Encoding.UTF8.GetBytes(recording.ToJson(format));
+            await using var stream = await suggestedFile.OpenWriteAsync().ConfigureAwait(true);
+            if (stream.CanSeek)
+            {
+                stream.SetLength(0);
+            }
+
+            await stream.WriteAsync(bytes).ConfigureAwait(true);
+            await stream.FlushAsync().ConfigureAwait(true);
+            return suggestedFile.Name;
+        }
+
+        var path = await PromptForTextAsync(
+            "Save recording",
+            "Path for the .cast file",
+            defaultRecordingPath,
+            saveButtonText: "Save").ConfigureAwait(true);
+        return string.IsNullOrWhiteSpace(path) ? null : control.SaveRecording(path, format);
+    }
+
+    private async Task<AsciicastRecording?> OpenRecordingAsync(string? requestedPath)
+    {
+        if (!string.IsNullOrWhiteSpace(requestedPath))
+        {
+            return LoadRecording(requestedPath);
+        }
+
+        var storage = this.StorageProvider;
+        if (storage is not null && storage.CanOpen)
+        {
+            var startLocation = await storage.TryGetFolderFromPathAsync(
+                new Uri(GetRecordingFolderPath())).ConfigureAwait(true);
+            var files = await storage.OpenFilePickerAsync(new FilePickerOpenOptions
+            {
+                Title = "Open terminal recording",
+                AllowMultiple = false,
+                SuggestedStartLocation = startLocation,
+                FileTypeFilter =
+                [
+                    new FilePickerFileType("Asciicast recordings")
+                    {
+                        Patterns = ["*.cast"],
+                    },
+                    FilePickerFileTypes.All,
+                ],
+            }).ConfigureAwait(true);
+
+            if (files is { Count: > 0 })
+            {
+                var selectedFile = files[0];
+                var localPath = selectedFile.TryGetLocalPath();
+                if (!string.IsNullOrWhiteSpace(localPath))
+                {
+                    return LoadRecording(localPath);
+                }
+
+                await using var stream = await selectedFile.OpenReadAsync().ConfigureAwait(true);
+                using var reader = new StreamReader(stream, Encoding.UTF8);
+                return AsciicastRecording.FromJson(
+                    await reader.ReadToEndAsync().ConfigureAwait(true));
+            }
+
+            return null;
+        }
+
+        var defaultRecordingPath = GetDefaultRecordingPath();
+        var path = await PromptForTextAsync(
+            "Open recording",
+            "Path to the .cast file",
+            defaultRecordingPath,
+            saveButtonText: "Open").ConfigureAwait(true);
+        return string.IsNullOrWhiteSpace(path) ? null : LoadRecording(path);
+    }
+
+    private static AsciicastRecording LoadRecording(string path)
+    {
+        var expanded = Environment.ExpandEnvironmentVariables(path);
+        if (!File.Exists(expanded))
+        {
+            throw new FileNotFoundException("The recording file does not exist.", expanded);
+        }
+
+        return AsciicastRecording.FromJson(File.ReadAllText(expanded));
+    }
+
+    private static string GetRecordingFolderPath()
+    {
+        var directory = Path.Combine(
+            Path.GetDirectoryName(Path.GetFullPath(SettingsService.SettingsPath))!,
+            "recordings");
+        Directory.CreateDirectory(directory);
+        return directory;
+    }
+
+    private string GetDefaultRecordingPath()
+    {
+        var directory = Path.Combine(
+            Path.GetDirectoryName(Path.GetFullPath(SettingsService.SettingsPath))!,
+            "recordings");
+        Directory.CreateDirectory(directory);
+        return Path.Combine(
+            directory,
+            $"terminal-recording-{DateTime.Now:yyyyMMdd-HHmmss-fff}.cast");
+    }
+
     private bool CanPaste() =>
         _activeTab is { IsSettingsTab: false } &&
         _activeTab.Panes.ActiveContent is { } activePane &&
diff --git a/src/Devolutions.Terminal.Control/PACKAGE.md b/src/Devolutions.Terminal.Control/PACKAGE.md
index a9fda0c..123429e 100644
--- a/src/Devolutions.Terminal.Control/PACKAGE.md
+++ b/src/Devolutions.Terminal.Control/PACKAGE.md
@@ -36,6 +36,49 @@ Subsequent layout passes resize both to fit the available space. You can use
 for the profile and display; pending layout changes made while the connection
 starts are applied once it is ready.
 
+## Stream an asciicast recording
+
+The control can stream a recording to a caller-supplied WebSocket push URI while
+retaining the recording locally for save or replay:
+
+```csharp
+// The application owns endpoint discovery and authentication. For a DVLS
+// recording push URL, the signed token is already present in the query string.
+var recordingUri = new Uri(
+    "wss://gateway.example/jet/jrec/push/session-id?token=signed-token");
+
+await terminal.StartRecordingAsync(recordingUri);
+// Terminal output is now sent as asciicast v2 JSONL text frames.
+await terminal.StopRecordingAsync();
+```
+
+`StartRecordingAsync` preserves existing query parameters and adds
+`fileType=asciicast`. It opens a plain WebSocket without a subprotocol, sends
+the v2 header first, then streams output events with elapsed timestamps and
+CRLF-normalized text. The terminal's visible screen is included as the initial
+frame. Pass the optional `path` argument to save the same recording to disk
+when it stops.
+
+For an official asciinema server, create a live stream through its HTTP API and
+pass the returned `ws_producer_url` with the desired format:
+
+```csharp
+var producerUri = new Uri(streamResponse.WsProducerUrl);
+await terminal.StartRecordingAsync(producerUri, AsciicastFormat.V3);
+// Terminal output is sent using the v3.asciicast WebSocket subprotocol.
+await terminal.StopRecordingAsync();
+```
+
+This overload supports both `AsciicastFormat.V2` and `AsciicastFormat.V3`,
+negotiates the corresponding `v2.asciicast` or `v3.asciicast` subprotocol, and
+leaves the producer URI unchanged. V2 streams use elapsed timestamps; v3
+streams use per-event time deltas as required by the asciicast v3 format.
+
+Endpoint construction, token acquisition, and authentication remain the host
+application's responsibility. `RecordingStreamCompletion` can be awaited to
+confirm that queued frames were flushed, and `RecordingStreamError` exposes the
+last transport failure.
+
 See the [`samples/Devolutions.Terminal.Control.Sample`](https://github.com/Devolutions/devolutions-terminal/tree/main/samples/Devolutions.Terminal.Control.Sample)
 project in the [Devolutions Terminal repository](https://github.com/Devolutions/devolutions-terminal)
 for a full working app, plus the full source and documentation.
diff --git a/src/Devolutions.Terminal.Control/TermControl.cs b/src/Devolutions.Terminal.Control/TermControl.cs
index 233bdf4..461e108 100644
--- a/src/Devolutions.Terminal.Control/TermControl.cs
+++ b/src/Devolutions.Terminal.Control/TermControl.cs
@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.Diagnostics;
 using System.Globalization;
 using System.Runtime.Versioning;
@@ -80,12 +81,31 @@ public sealed class TermControl : Avalonia.Controls.Control
     private TerminalInteractionOptions _interactionOptions = new();
     private Thickness _padding = new(8);
     private readonly DispatcherTimer _ptyResizeTimer;
+    private readonly Stopwatch _recordingStopwatch = new();
     private int _pendingPtyColumns;
     private int _pendingPtyRows;
     private int _pendingPtyPixelWidth;
     private int _pendingPtyPixelHeight;
     private bool _hasPendingPtyResize;
     private bool _connectionStarting;
+    private AsciicastRecording? _activeRecording;
+    private AsciicastRecording? _lastRecording;
+    private string? _recordingPath;
+    private long _recordingVersion;
+    private long _savedRecordingVersion;
+    private Decoder _recordingDecoder = Encoding.UTF8.GetDecoder();
+    private AsciicastWebSocketStreamer? _recordingStreamer;
+    private Task? _recordingStreamCompletion;
+    private Exception? _recordingStreamError;
+    private bool _recordingStartPending;
+    private readonly object _replayLock = new();
+    private CancellationTokenSource? _replayCancellationTokenSource;
+    private AsciicastRecording? _replayRecording;
+    private TaskCompletionSource<bool>? _replayResumeSource;
+    private bool _isReplayPaused;
+    private double _replaySpeed = 1d;
+    private double _replayPositionSeconds;
+    private double _replayDurationSeconds;
 
     // Throughput-harness diagnostics (Devolutions.Terminal.Bench): posts requested by
     // the engine-invalidated handler vs UI drains actually executed.
@@ -428,8 +448,27 @@ public async Task RestartAsync(CancellationToken cancellationToken = default)
 
     public async Task CloseAsync()
     {
+        _replayCancellationTokenSource?.Cancel();
         _blinkTimer.Stop();
         ClearPendingPtyResize();
+        if (IsRecording)
+        {
+            StopRecording();
+        }
+
+        var recordingStreamCompletion = RecordingStreamCompletion;
+        if (recordingStreamCompletion is not null)
+        {
+            try
+            {
+                await recordingStreamCompletion.ConfigureAwait(false);
+            }
+            catch (Exception exception)
+            {
+                ReportInteractionError("Asciicast WebSocket streaming", exception);
+            }
+        }
+
         if (_connection is not null)
         {
             var connection = _connection;
@@ -1002,6 +1041,735 @@ public void ResetTerminal()
         InvalidateVisual();
     }
 
+    public bool IsRecording
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _activeRecording is not null;
+            }
+        }
+    }
+
+    public bool HasRecording
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _activeRecording is not null || _lastRecording is not null;
+            }
+        }
+    }
+
+    public bool HasUnsavedRecording
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return (_activeRecording is not null || _lastRecording is not null) &&
+                       _recordingVersion != _savedRecordingVersion;
+            }
+        }
+    }
+
+    public TimeSpan RecordingElapsed
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                var seconds = _activeRecording is not null
+                    ? _recordingStopwatch.Elapsed.TotalSeconds
+                    : _lastRecording?.Frames.LastOrDefault()?.Timestamp ?? 0d;
+                return TimeSpan.FromSeconds(seconds);
+            }
+        }
+    }
+
+    public AsciicastFormat? RecordingFormat
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return (_activeRecording ?? _lastRecording)?.Format;
+            }
+        }
+    }
+
+    public string? RecordingPath
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _recordingPath;
+            }
+        }
+    }
+
+    public bool IsStreamingRecording
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _recordingStartPending || _recordingStreamer is not null;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets the active or most recently completed WebSocket streaming operation.
+    /// Await this task to observe transport errors and confirm all frames were flushed.
+    /// </summary>
+    public Task? RecordingStreamCompletion
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _recordingStreamCompletion;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets the last WebSocket recording transport error.
+    /// </summary>
+    public Exception? RecordingStreamError
+    {
+        get
+        {
+            lock (_outputLock)
+            {
+                return _recordingStreamError;
+            }
+        }
+    }
+
+    public bool HasReplay
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return _replayRecording is not null;
+            }
+        }
+    }
+
+    public bool IsReplaying
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return _replayCancellationTokenSource is not null;
+            }
+        }
+    }
+
+    public bool IsReplayPaused
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return _isReplayPaused;
+            }
+        }
+    }
+
+    public double ReplaySpeed
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return _replaySpeed;
+            }
+        }
+    }
+
+    public TimeSpan ReplayPosition
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return TimeSpan.FromSeconds(_replayPositionSeconds);
+            }
+        }
+    }
+
+    public TimeSpan ReplayDuration
+    {
+        get
+        {
+            lock (_replayLock)
+            {
+                return TimeSpan.FromSeconds(_replayDurationSeconds);
+            }
+        }
+    }
+
+    public event EventHandler? RecordingStateChanged;
+    public event EventHandler? ReplayStateChanged;
+
+    public void StartRecording(
+        string? path = null,
+        AsciicastFormat format = AsciicastFormat.V2)
+    {
+        lock (_outputLock)
+        {
+            if (_activeRecording is not null || _recordingStartPending)
+            {
+                throw new InvalidOperationException("This terminal is already being recorded.");
+            }
+
+            BeginRecording(path, format, streamer: null);
+        }
+
+        RecordingStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    /// <summary>
+    /// Starts recording and streams asciicast v2 JSONL to a caller-supplied
+    /// WebSocket push URI. The URI may already contain authentication query
+    /// parameters; <c>fileType=asciicast</c> is added automatically.
+    /// </summary>
+    public async Task StartRecordingAsync(
+        Uri streamingUri,
+        string? path = null,
+        CancellationToken cancellationToken = default)
+    {
+        await StartRecordingAsyncCore(
+            streamingUri,
+            AsciicastFormat.V2,
+            useAsciinemaSubProtocol: false,
+            path,
+            cancellationToken).ConfigureAwait(true);
+    }
+
+    /// <summary>
+    /// Starts recording and streams asciicast v2 or v3 JSONL to an official
+    /// asciinema server producer URI using the matching WebSocket subprotocol.
+    /// </summary>
+    public async Task StartRecordingAsync(
+        Uri streamingUri,
+        AsciicastFormat format,
+        string? path = null,
+        CancellationToken cancellationToken = default)
+    {
+        await StartRecordingAsyncCore(
+            streamingUri,
+            format,
+            useAsciinemaSubProtocol: true,
+            path,
+            cancellationToken).ConfigureAwait(true);
+    }
+
+    private async Task StartRecordingAsyncCore(
+        Uri streamingUri,
+        AsciicastFormat format,
+        bool useAsciinemaSubProtocol,
+        string? path,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(streamingUri);
+        AsciicastRecording header;
+        lock (_outputLock)
+        {
+            if (_activeRecording is not null || _recordingStartPending)
+            {
+                throw new InvalidOperationException("This terminal is already being recorded.");
+            }
+
+            _recordingStartPending = true;
+            _recordingStreamCompletion = null;
+            _recordingStreamError = null;
+            header = new AsciicastRecording(
+                Engine.Columns,
+                Engine.Rows,
+                Engine.Title,
+                format)
+            {
+                Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
+            };
+        }
+
+        AsciicastWebSocketStreamer? streamer = null;
+        try
+        {
+            streamer = useAsciinemaSubProtocol
+                ? AsciicastWebSocketStreamer.CreateForAsciinema(streamingUri, format)
+                : new AsciicastWebSocketStreamer(streamingUri);
+            await streamer.StartAsync(header, cancellationToken).ConfigureAwait(true);
+            lock (_outputLock)
+            {
+                BeginRecording(path, format, streamer, header.Timestamp);
+                _recordingStreamCompletion = streamer.Completion;
+                _recordingStartPending = false;
+            }
+        }
+        catch
+        {
+            lock (_outputLock)
+            {
+                _recordingStartPending = false;
+            }
+
+            if (streamer is not null)
+            {
+                await streamer.DisposeAsync().ConfigureAwait(false);
+            }
+
+            throw;
+        }
+
+        RecordingStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    public string? StopRecording()
+    {
+        AsciicastRecording recording;
+        string? destinationPath;
+        AsciicastWebSocketStreamer? streamer;
+        lock (_outputLock)
+        {
+            if (_activeRecording is null)
+            {
+                return null;
+            }
+
+            FlushRecordingDecoder(_activeRecording);
+            _recordingStopwatch.Stop();
+            recording = _activeRecording.Copy();
+            _lastRecording = recording;
+            _activeRecording = null;
+            destinationPath = _recordingPath;
+            streamer = _recordingStreamer;
+            _recordingStreamer = null;
+            if (streamer is not null)
+            {
+                _recordingStreamCompletion = CompleteRecordingStreamAsync(streamer);
+            }
+        }
+
+        if (destinationPath is not null)
+        {
+            WriteRecording(recording, destinationPath);
+            lock (_outputLock)
+            {
+                _savedRecordingVersion = _recordingVersion;
+            }
+        }
+
+        RecordingStateChanged?.Invoke(this, EventArgs.Empty);
+        return destinationPath;
+    }
+
+    /// <summary>
+    /// Stops recording, saves any configured file destination, and waits until
+    /// the WebSocket stream has flushed and closed.
+    /// </summary>
+    public async Task<string?> StopRecordingAsync(CancellationToken cancellationToken = default)
+    {
+        var path = StopRecording();
+        var completion = RecordingStreamCompletion;
+        if (completion is not null)
+        {
+            await completion.WaitAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        return path;
+    }
+
+    public string SaveRecording(string? path = null, AsciicastFormat? format = null)
+    {
+        AsciicastRecording recording;
+        string resolvedPath;
+        long recordingVersion;
+        lock (_outputLock)
+        {
+            var sourceRecording = _activeRecording ?? _lastRecording;
+            recording = sourceRecording?.Copy(format)
+                ?? throw new InvalidOperationException("This terminal does not have a recording to save.");
+            resolvedPath = ResolveRecordingPath(path ?? _recordingPath, createDefault: true)!;
+            _recordingPath = resolvedPath;
+            recordingVersion = _recordingVersion;
+        }
+
+        WriteRecording(recording, resolvedPath);
+        lock (_outputLock)
+        {
+            _savedRecordingVersion = Math.Max(_savedRecordingVersion, recordingVersion);
+        }
+
+        RecordingStateChanged?.Invoke(this, EventArgs.Empty);
+        return resolvedPath;
+    }
+
+    public AsciicastRecording GetRecording(string? path = null)
+    {
+        if (!string.IsNullOrWhiteSpace(path))
+        {
+            var resolvedPath = ResolveRecordingPath(path, createDefault: false)!;
+            return AsciicastRecording.FromJson(File.ReadAllText(resolvedPath));
+        }
+
+        lock (_outputLock)
+        {
+            return (_activeRecording ?? _lastRecording)?.Copy()
+                ?? throw new InvalidOperationException("This terminal does not have a recording to replay.");
+        }
+    }
+
+    public async Task ReplayRecordingAsync(
+        AsciicastRecording recording,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(recording);
+
+        CancellationTokenSource? previousReplay;
+        var replayCancellationTokenSource =
+            CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        lock (_replayLock)
+        {
+            previousReplay = _replayCancellationTokenSource;
+            _replayCancellationTokenSource = replayCancellationTokenSource;
+            _replayRecording = recording.Copy();
+            _replayResumeSource?.TrySetResult(true);
+            _replayResumeSource = null;
+            _isReplayPaused = false;
+            _replayPositionSeconds = 0d;
+            _replayDurationSeconds = recording.Frames.LastOrDefault()?.Timestamp ?? 0d;
+        }
+
+        previousReplay?.Cancel();
+        ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+        var replayToken = replayCancellationTokenSource.Token;
+        var completed = false;
+
+        try
+        {
+            Engine.Resize(recording.Width, recording.Height);
+            ResetTerminal();
+            var previousTimestamp = 0d;
+            foreach (var frame in recording.Frames)
+            {
+                var delay = Math.Max(0d, frame.Timestamp - previousTimestamp);
+                await DelayReplayAsync(delay, replayCancellationTokenSource).ConfigureAwait(true);
+
+                replayToken.ThrowIfCancellationRequested();
+                Engine.Feed(frame.Data);
+                previousTimestamp = frame.Timestamp;
+                lock (_replayLock)
+                {
+                    if (ReferenceEquals(_replayCancellationTokenSource, replayCancellationTokenSource))
+                    {
+                        _replayPositionSeconds = frame.Timestamp;
+                    }
+                }
+
+                ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+            }
+
+            InvalidateVisual();
+            completed = true;
+        }
+        finally
+        {
+            lock (_replayLock)
+            {
+                if (ReferenceEquals(_replayCancellationTokenSource, replayCancellationTokenSource))
+                {
+                    _replayCancellationTokenSource = null;
+                    _replayResumeSource?.TrySetResult(true);
+                    _replayResumeSource = null;
+                    _isReplayPaused = false;
+                    if (completed)
+                    {
+                        _replayPositionSeconds = _replayDurationSeconds;
+                    }
+                }
+            }
+
+            replayCancellationTokenSource.Dispose();
+            ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    public void PauseReplay()
+    {
+        lock (_replayLock)
+        {
+            if (_replayCancellationTokenSource is null || _isReplayPaused)
+            {
+                return;
+            }
+
+            _isReplayPaused = true;
+            _replayResumeSource = new TaskCompletionSource<bool>(
+                TaskCreationOptions.RunContinuationsAsynchronously);
+        }
+
+        ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    public void ResumeReplay()
+    {
+        TaskCompletionSource<bool>? resumeSource;
+        lock (_replayLock)
+        {
+            if (!_isReplayPaused)
+            {
+                return;
+            }
+
+            _isReplayPaused = false;
+            resumeSource = _replayResumeSource;
+            _replayResumeSource = null;
+        }
+
+        resumeSource?.TrySetResult(true);
+        ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    public void SetReplaySpeed(double speed)
+    {
+        if (!double.IsFinite(speed) || speed is < 0.25 or > 4)
+        {
+            throw new ArgumentOutOfRangeException(nameof(speed), speed, "Replay speed must be between 0.25x and 4x.");
+        }
+
+        lock (_replayLock)
+        {
+            _replaySpeed = speed;
+        }
+
+        ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    public Task RestartReplayAsync(CancellationToken cancellationToken = default)
+    {
+        AsciicastRecording recording;
+        lock (_replayLock)
+        {
+            recording = _replayRecording?.Copy()
+                ?? throw new InvalidOperationException("This terminal does not have a recording to replay.");
+        }
+
+        return ReplayRecordingAsync(recording, cancellationToken);
+    }
+
+    private async Task DelayReplayAsync(
+        double sourceSeconds,
+        CancellationTokenSource replayCancellationTokenSource)
+    {
+        var remaining = sourceSeconds;
+        var replayToken = replayCancellationTokenSource.Token;
+        while (remaining > 0)
+        {
+            Task? resumeTask = null;
+            double speed;
+            lock (_replayLock)
+            {
+                if (!ReferenceEquals(_replayCancellationTokenSource, replayCancellationTokenSource))
+                {
+                    replayToken.ThrowIfCancellationRequested();
+                }
+
+                if (_isReplayPaused)
+                {
+                    resumeTask = _replayResumeSource?.Task;
+                }
+
+                speed = _replaySpeed;
+            }
+
+            if (resumeTask is not null)
+            {
+                await resumeTask.WaitAsync(replayToken).ConfigureAwait(true);
+                continue;
+            }
+
+            var sourceSlice = Math.Min(remaining, speed * 0.05);
+            await Task.Delay(TimeSpan.FromSeconds(sourceSlice / speed), replayToken).ConfigureAwait(true);
+            remaining -= sourceSlice;
+            lock (_replayLock)
+            {
+                if (ReferenceEquals(_replayCancellationTokenSource, replayCancellationTokenSource))
+                {
+                    _replayPositionSeconds = Math.Min(
+                        _replayDurationSeconds,
+                        _replayPositionSeconds + sourceSlice);
+                }
+            }
+
+            ReplayStateChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    private void AppendRecordingOutput(ReadOnlySpan<byte> data)
+    {
+        if (_activeRecording is null || data.IsEmpty)
+        {
+            return;
+        }
+
+        var rented = ArrayPool<char>.Shared.Rent(Encoding.UTF8.GetMaxCharCount(data.Length));
+        try
+        {
+            _recordingDecoder.Convert(
+                data,
+                rented,
+                flush: false,
+                out _,
+                out var charsUsed,
+                out _);
+            if (charsUsed > 0)
+            {
+                _activeRecording.AppendFrame(
+                    _recordingStopwatch.Elapsed.TotalSeconds,
+                    new string(rented, 0, charsUsed));
+                WriteRecordingStreamFrame(_activeRecording.Frames[^1]);
+                _recordingVersion++;
+            }
+        }
+        finally
+        {
+            ArrayPool<char>.Shared.Return(rented);
+        }
+    }
+
+    private void FlushRecordingDecoder(AsciicastRecording recording)
+    {
+        Span<char> remaining = stackalloc char[2];
+        _recordingDecoder.Convert(
+            [],
+            remaining,
+            flush: true,
+            out _,
+            out var charsUsed,
+            out _);
+        if (charsUsed > 0)
+        {
+            recording.AppendFrame(
+                _recordingStopwatch.Elapsed.TotalSeconds,
+                new string(remaining[..charsUsed]));
+            WriteRecordingStreamFrame(recording.Frames[^1]);
+            _recordingVersion++;
+        }
+    }
+
+    private void BeginRecording(
+        string? path,
+        AsciicastFormat format,
+        AsciicastWebSocketStreamer? streamer,
+        long? timestamp = null)
+    {
+        _recordingPath = ResolveRecordingPath(path, createDefault: false);
+        _activeRecording = new AsciicastRecording(Engine.Columns, Engine.Rows, Engine.Title, format)
+        {
+            Timestamp = timestamp ?? DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
+        };
+        _recordingStreamer = streamer;
+        _recordingStreamCompletion = streamer?.Completion;
+        _recordingStreamError = null;
+        _recordingDecoder = Encoding.UTF8.GetDecoder();
+        _recordingStopwatch.Restart();
+        var initialSnapshot = TerminalBufferExport.ToPlainText(
+            Engine.CreateSnapshot().Buffer,
+            trimTrailingWhitespace: true);
+        if (!string.IsNullOrWhiteSpace(initialSnapshot))
+        {
+            _activeRecording.AppendFrame(0d, initialSnapshot);
+            WriteRecordingStreamFrame(_activeRecording.Frames[^1]);
+        }
+
+        _recordingVersion++;
+    }
+
+    private void WriteRecordingStreamFrame(AsciicastFrame frame)
+    {
+        if (_recordingStreamer is null)
+        {
+            return;
+        }
+
+        try
+        {
+            _recordingStreamer.Write(frame);
+        }
+        catch (Exception exception)
+        {
+            _recordingStreamError = exception;
+            _recordingStreamCompletion = Task.FromException(exception);
+            _recordingStreamer = null;
+            Dispatcher.UIThread.Post(
+                () => ReportInteractionError("Asciicast WebSocket streaming", exception));
+        }
+    }
+
+    private async Task CompleteRecordingStreamAsync(AsciicastWebSocketStreamer streamer)
+    {
+        try
+        {
+            await streamer.DisposeAsync().ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            lock (_outputLock)
+            {
+                _recordingStreamError = exception;
+            }
+
+            Dispatcher.UIThread.Post(
+                () => ReportInteractionError("Asciicast WebSocket streaming", exception));
+            throw;
+        }
+        finally
+        {
+            Dispatcher.UIThread.Post(
+                () => RecordingStateChanged?.Invoke(this, EventArgs.Empty));
+        }
+    }
+
+    private static void WriteRecording(AsciicastRecording recording, string path)
+    {
+        Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path))!);
+        File.WriteAllText(path, recording.ToJson(), new UTF8Encoding(false));
+    }
+
+    private static string? ResolveRecordingPath(string? path, bool createDefault)
+    {
+        var requested = string.IsNullOrWhiteSpace(path)
+            ? null
+            : Environment.ExpandEnvironmentVariables(path);
+
+        if (!string.IsNullOrWhiteSpace(requested))
+        {
+            return requested;
+        }
+
+        if (!createDefault)
+        {
+            return null;
+        }
+
+        var directory = Path.Combine(
+            Path.GetDirectoryName(Path.GetFullPath(SettingsService.SettingsPath))!,
+            "recordings");
+        return Path.Combine(
+            directory,
+            $"terminal-recording-{DateTime.Now:yyyyMMdd-HHmmss-fff}.cast");
+    }
+
     public void ShowHide(bool show)
     {
         IsVisible = show;
@@ -1586,6 +2354,7 @@ private void OnOutput(object? sender, ReadOnlyMemory<byte> data)
                 // Feed on the PTY thread so cursor-position reports (CSI 6n) go
                 // back to zsh before PROMPT_SP prints a spurious '%'.
                 Engine.Feed(data.Span);
+                AppendRecordingOutput(data.Span);
             }
             catch (Exception exception)
             {
diff --git a/src/Devolutions.Terminal.Core/AsciicastRecording.cs b/src/Devolutions.Terminal.Core/AsciicastRecording.cs
new file mode 100644
index 0000000..5ffa2c0
--- /dev/null
+++ b/src/Devolutions.Terminal.Core/AsciicastRecording.cs
@@ -0,0 +1,299 @@
+using System.Text;
+using System.Text.Json;
+
+namespace Devolutions.Terminal.Core;
+
+public sealed record AsciicastFrame(double Timestamp, string Data);
+
+public enum AsciicastFormat
+{
+    V2 = 2,
+    V3 = 3,
+}
+
+public sealed class AsciicastRecording
+{
+    private readonly Dictionary<string, string> _env;
+
+    public AsciicastRecording(
+        int width,
+        int height,
+        string? title = null,
+        AsciicastFormat format = AsciicastFormat.V2)
+    {
+        Width = Math.Max(1, width);
+        Height = Math.Max(1, height);
+        Title = title;
+        Format = format;
+        _env = new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["TERM"] = "xterm-256color",
+        };
+    }
+
+    public int Version => (int)Format;
+    public AsciicastFormat Format { get; }
+    public int Width { get; }
+    public int Height { get; }
+    public long Timestamp { get; set; }
+    public string? Title { get; set; }
+    public IReadOnlyDictionary<string, string> Env => _env;
+    public List<AsciicastFrame> Frames { get; } = [];
+
+    public void AppendFrame(double timestamp, string data)
+    {
+        if (!double.IsFinite(timestamp) ||
+            timestamp < 0 ||
+            timestamp > TimeSpan.MaxValue.TotalSeconds)
+        {
+            throw new ArgumentOutOfRangeException(
+                nameof(timestamp),
+                timestamp,
+                "An asciicast event timestamp must be a finite, non-negative number of seconds.");
+        }
+
+        ArgumentNullException.ThrowIfNull(data);
+        Frames.Add(new AsciicastFrame(timestamp, data));
+    }
+
+    public AsciicastRecording Copy(AsciicastFormat? format = null)
+    {
+        var copy = new AsciicastRecording(Width, Height, Title, format ?? Format)
+        {
+            Timestamp = Timestamp,
+        };
+        copy._env.Clear();
+        foreach (var pair in _env)
+        {
+            copy._env[pair.Key] = pair.Value;
+        }
+
+        copy.Frames.AddRange(Frames);
+        return copy;
+    }
+
+    public static AsciicastRecording FromJson(string json)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(json);
+
+        using var reader = new StringReader(json);
+        var headerLine = reader.ReadLine();
+        if (string.IsNullOrWhiteSpace(headerLine))
+        {
+            throw InvalidRecording();
+        }
+
+        using var headerDocument = JsonDocument.Parse(headerLine);
+        var header = headerDocument.RootElement;
+        if (header.ValueKind != JsonValueKind.Object ||
+            !header.TryGetProperty("version", out var versionElement) ||
+            !versionElement.TryGetInt32(out var version) ||
+            version is not (2 or 3))
+        {
+            throw InvalidRecording();
+        }
+
+        var format = (AsciicastFormat)version;
+        var width = format == AsciicastFormat.V3
+            ? ReadPositiveInt(header, "term", "cols", 80)
+            : ReadPositiveInt(header, "width", 80);
+        var height = format == AsciicastFormat.V3
+            ? ReadPositiveInt(header, "term", "rows", 24)
+            : ReadPositiveInt(header, "height", 24);
+        var title = header.TryGetProperty("title", out var titleElement) &&
+                    titleElement.ValueKind == JsonValueKind.String
+            ? titleElement.GetString()
+            : null;
+
+        var recording = new AsciicastRecording(width, height, title, format);
+        if (header.TryGetProperty("timestamp", out var timestampElement) &&
+            timestampElement.TryGetInt64(out var timestamp))
+        {
+            recording.Timestamp = timestamp;
+        }
+
+        if (header.TryGetProperty("env", out var envElement) &&
+            envElement.ValueKind == JsonValueKind.Object)
+        {
+            recording._env.Clear();
+            foreach (var property in envElement.EnumerateObject())
+            {
+                recording._env[property.Name] = property.Value.ValueKind == JsonValueKind.String
+                    ? property.Value.GetString() ?? string.Empty
+                    : property.Value.ToString();
+            }
+        }
+
+        if (format == AsciicastFormat.V3 &&
+            header.TryGetProperty("term", out var termElement) &&
+            termElement.ValueKind == JsonValueKind.Object &&
+            termElement.TryGetProperty("type", out var typeElement) &&
+            typeElement.ValueKind == JsonValueKind.String &&
+            (!header.TryGetProperty("env", out var headerEnv) ||
+             headerEnv.ValueKind != JsonValueKind.Object ||
+             !headerEnv.TryGetProperty("TERM", out _)))
+        {
+            recording._env["TERM"] = typeElement.GetString() ?? string.Empty;
+        }
+
+        var timestampOffset = 0d;
+        while (reader.ReadLine() is { } eventLine)
+        {
+            if (eventLine.StartsWith('#') || string.IsNullOrWhiteSpace(eventLine))
+            {
+                continue;
+            }
+
+            using var eventDocument = JsonDocument.Parse(eventLine);
+            var entry = eventDocument.RootElement;
+            if (entry.ValueKind != JsonValueKind.Array ||
+                entry.GetArrayLength() != 3 ||
+                entry[0].ValueKind != JsonValueKind.Number ||
+                entry[1].ValueKind != JsonValueKind.String ||
+                entry[2].ValueKind != JsonValueKind.String)
+            {
+                throw InvalidRecording();
+            }
+
+            var eventTime = entry[0].GetDouble();
+            if (format == AsciicastFormat.V3)
+            {
+                if (!double.IsFinite(eventTime) || eventTime < 0)
+                {
+                    throw InvalidRecording();
+                }
+
+                timestampOffset += eventTime;
+                eventTime = timestampOffset;
+            }
+
+            var eventType = entry[1].GetString();
+            if (eventType == "o")
+            {
+                recording.AppendFrame(eventTime, entry[2].GetString() ?? string.Empty);
+            }
+        }
+
+        return recording;
+    }
+
+    public string ToJson() => ToJson(Format);
+
+    public string ToJson(AsciicastFormat format)
+    {
+        using var stream = new MemoryStream();
+        WriteHeader(stream, format);
+        var previousTimestamp = 0d;
+        foreach (var frame in Frames)
+        {
+            var timestamp = format == AsciicastFormat.V3
+                ? Math.Max(0, frame.Timestamp - previousTimestamp)
+                : frame.Timestamp;
+            WriteEvent(stream, timestamp, frame.Data);
+            previousTimestamp = frame.Timestamp;
+        }
+
+        return Encoding.UTF8.GetString(stream.ToArray());
+    }
+
+    internal byte[] CreateHeaderLine(AsciicastFormat format)
+    {
+        using var stream = new MemoryStream();
+        WriteHeader(stream, format);
+        return stream.ToArray();
+    }
+
+    internal static byte[] CreateEventLine(double timestamp, string data, AsciicastFormat format = AsciicastFormat.V2)
+    {
+        using var stream = new MemoryStream();
+        WriteEvent(stream, timestamp, data, format);
+        return stream.ToArray();
+    }
+
+    private void WriteHeader(Stream stream, AsciicastFormat format)
+    {
+        using (var writer = new Utf8JsonWriter(stream))
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("version", (int)format);
+            if (format == AsciicastFormat.V3)
+            {
+                writer.WritePropertyName("term");
+                writer.WriteStartObject();
+                writer.WriteNumber("cols", Width);
+                writer.WriteNumber("rows", Height);
+                if (Env.TryGetValue("TERM", out var terminalType))
+                {
+                    writer.WriteString("type", terminalType);
+                }
+
+                writer.WriteEndObject();
+            }
+            else
+            {
+                writer.WriteNumber("width", Width);
+                writer.WriteNumber("height", Height);
+            }
+
+            writer.WriteNumber("timestamp", Timestamp);
+            if (Title is not null)
+            {
+                writer.WriteString("title", Title);
+            }
+
+            writer.WritePropertyName("env");
+            writer.WriteStartObject();
+            foreach (var pair in Env)
+            {
+                writer.WriteString(pair.Key, pair.Value);
+            }
+
+            writer.WriteEndObject();
+            writer.WriteEndObject();
+        }
+
+        stream.WriteByte((byte)'\n');
+    }
+
+    private static void WriteEvent(Stream stream, double timestamp, string data, AsciicastFormat format = AsciicastFormat.V2)
+    {
+        using (var writer = new Utf8JsonWriter(stream))
+        {
+            writer.WriteStartArray();
+            writer.WriteNumberValue(timestamp);
+            writer.WriteStringValue("o");
+            writer.WriteStringValue(data);
+            writer.WriteEndArray();
+        }
+
+        if (format == AsciicastFormat.V3)
+        {
+            stream.WriteByte((byte)'\n');
+            return;
+        }
+
+        stream.WriteByte((byte)'\n');
+    }
+
+    private static int ReadPositiveInt(JsonElement element, string name, int fallback) =>
+        element.TryGetProperty(name, out var property) &&
+        property.TryGetInt32(out var value) &&
+        value > 0
+            ? value
+            : fallback;
+
+    private static int ReadPositiveInt(
+        JsonElement element,
+        string parentName,
+        string name,
+        int fallback)
+    {
+        return element.TryGetProperty(parentName, out var parent) &&
+               parent.ValueKind == JsonValueKind.Object
+            ? ReadPositiveInt(parent, name, fallback)
+            : fallback;
+    }
+
+    private static InvalidOperationException InvalidRecording() =>
+        new("The selected file is not a valid asciicast v2 or v3 recording.");
+}
diff --git a/src/Devolutions.Terminal.Core/AsciicastWebSocketStreamer.cs b/src/Devolutions.Terminal.Core/AsciicastWebSocketStreamer.cs
new file mode 100644
index 0000000..2cdf16b
--- /dev/null
+++ b/src/Devolutions.Terminal.Core/AsciicastWebSocketStreamer.cs
@@ -0,0 +1,262 @@
+using System.Net.WebSockets;
+using System.Threading.Channels;
+
+namespace Devolutions.Terminal.Core;
+
+/// <summary>
+/// Streams an asciicast recording to a WebSocket push endpoint, optionally
+/// negotiating an asciinema subprotocol such as <c>v2.asciicast</c> or
+/// <c>v3.asciicast</c>.
+/// </summary>
+public sealed class AsciicastWebSocketStreamer : IAsyncDisposable
+{
+    private readonly ClientWebSocket _socket = new();
+    private readonly Channel<AsciicastFrame> _frames = Channel.CreateUnbounded<AsciicastFrame>(
+        new UnboundedChannelOptions
+        {
+            SingleReader = true,
+            SingleWriter = false,
+            AllowSynchronousContinuations = false,
+        });
+    private readonly CancellationTokenSource _lifetime = new();
+    private readonly string? _requestedSubProtocol;
+    private Task? _sendTask;
+    private bool _started;
+    private bool _stopped;
+    private double _previousTimestamp;
+
+    public AsciicastWebSocketStreamer(
+        Uri streamingUri,
+        string? subProtocol = null,
+        bool appendAsciicastFileType = true)
+    {
+        ArgumentNullException.ThrowIfNull(streamingUri);
+        if (!streamingUri.IsAbsoluteUri || streamingUri.Scheme is not ("ws" or "wss"))
+        {
+            throw new ArgumentException(
+                "The asciicast streaming URI must be an absolute ws:// or wss:// URI.",
+                nameof(streamingUri));
+        }
+
+        if (!string.IsNullOrWhiteSpace(subProtocol) &&
+            !IsSupportedAsciinemaSubProtocol(subProtocol))
+        {
+            throw new ArgumentException(
+                "The WebSocket sub-protocol must be a supported asciinema value such as 'v2.asciicast' or 'v3.asciicast'.",
+                nameof(subProtocol));
+        }
+
+        _requestedSubProtocol = string.IsNullOrWhiteSpace(subProtocol)
+            ? null
+            : ToSubProtocol(FromSubProtocol(subProtocol));
+        StreamingUri = appendAsciicastFileType ? AddAsciicastFileType(streamingUri) : streamingUri;
+    }
+
+    public static AsciicastWebSocketStreamer CreateForAsciinema(
+        Uri streamingUri,
+        AsciicastFormat format,
+        bool appendAsciicastFileType = false)
+    {
+        ArgumentNullException.ThrowIfNull(streamingUri);
+        var subProtocol = ToSubProtocol(format);
+        var uri = appendAsciicastFileType ? AddAsciicastFileType(streamingUri) : streamingUri;
+        return new AsciicastWebSocketStreamer(uri, subProtocol, appendAsciicastFileType: false);
+    }
+
+    public string? RequestedSubProtocol => _requestedSubProtocol;
+
+    /// <summary>
+    /// Gets the effective WebSocket URI. DVLS-compatible construction adds
+    /// <c>fileType=asciicast</c> while preserving caller-provided authentication
+    /// parameters; official asciinema construction leaves the URI unchanged.
+    /// </summary>
+    public Uri StreamingUri { get; }
+
+    /// <summary>
+    /// Gets the background send operation after <see cref="StartAsync"/>.
+    /// </summary>
+    public Task Completion => _sendTask ?? Task.CompletedTask;
+
+    /// <summary>
+    /// Connects and sends the asciicast JSONL header as the first text message.
+    /// </summary>
+    public async Task StartAsync(
+        AsciicastRecording recording,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(recording);
+        ObjectDisposedException.ThrowIf(_lifetime.IsCancellationRequested, this);
+        if (_started)
+        {
+            throw new InvalidOperationException("This asciicast WebSocket stream has already been started.");
+        }
+
+        var format = ResolveFormat(recording.Format);
+        if (_requestedSubProtocol is not null &&
+            format != FromSubProtocol(_requestedSubProtocol))
+        {
+            throw new ArgumentException(
+                $"The {_requestedSubProtocol} WebSocket subprotocol requires an asciicast {FromSubProtocol(_requestedSubProtocol)} recording.",
+                nameof(recording));
+        }
+
+        _started = true;
+        try
+        {
+            if (_requestedSubProtocol is not null)
+            {
+                _socket.Options.AddSubProtocol(_requestedSubProtocol);
+            }
+
+            await _socket.ConnectAsync(StreamingUri, cancellationToken).ConfigureAwait(false);
+            var header = recording.CreateHeaderLine(format);
+            await _socket.SendAsync(
+                header,
+                WebSocketMessageType.Text,
+                endOfMessage: true,
+                cancellationToken).ConfigureAwait(false);
+            _previousTimestamp = 0d;
+            _sendTask = SendLoopAsync(_lifetime.Token, format);
+        }
+        catch
+        {
+            _started = false;
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Queues one output event without blocking the terminal output thread.
+    /// </summary>
+    public void Write(AsciicastFrame frame)
+    {
+        ArgumentNullException.ThrowIfNull(frame);
+        if (!_started || _stopped)
+        {
+            throw new InvalidOperationException("The asciicast WebSocket stream is not accepting output.");
+        }
+
+        if (_sendTask is { IsCompleted: true })
+        {
+            _sendTask.GetAwaiter().GetResult();
+            throw new InvalidOperationException("The asciicast WebSocket stream has completed.");
+        }
+
+        if (!_frames.Writer.TryWrite(frame))
+        {
+            throw new InvalidOperationException("The asciicast WebSocket stream is no longer accepting output.");
+        }
+    }
+
+    /// <summary>
+    /// Flushes queued events and closes the WebSocket normally.
+    /// </summary>
+    public async Task StopAsync(CancellationToken cancellationToken = default)
+    {
+        if (!_started || _stopped)
+        {
+            return;
+        }
+
+        _stopped = true;
+        _frames.Writer.TryComplete();
+        if (_sendTask is not null)
+        {
+            await _sendTask.WaitAsync(cancellationToken).ConfigureAwait(false);
+        }
+
+        if (_socket.State is WebSocketState.Open or WebSocketState.CloseReceived)
+        {
+            await _socket.CloseOutputAsync(
+                WebSocketCloseStatus.NormalClosure,
+                "Recording stopped",
+                cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        try
+        {
+            await StopAsync().ConfigureAwait(false);
+        }
+        finally
+        {
+            await _lifetime.CancelAsync().ConfigureAwait(false);
+            _socket.Dispose();
+            _lifetime.Dispose();
+        }
+    }
+
+    private async Task SendLoopAsync(CancellationToken cancellationToken, AsciicastFormat format)
+    {
+        try
+        {
+            await foreach (var frame in _frames.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))
+            {
+                var data = NormalizeLineEndings(frame.Data);
+                var timestamp = format == AsciicastFormat.V3
+                    ? Math.Max(0d, frame.Timestamp - _previousTimestamp)
+                    : frame.Timestamp;
+                await _socket.SendAsync(
+                    AsciicastRecording.CreateEventLine(timestamp, data, format),
+                    WebSocketMessageType.Text,
+                    endOfMessage: true,
+                    cancellationToken).ConfigureAwait(false);
+                _previousTimestamp = frame.Timestamp;
+            }
+        }
+        finally
+        {
+            _frames.Writer.TryComplete();
+        }
+    }
+
+    private static string NormalizeLineEndings(string data) =>
+        data.Replace("\r\n", "\n", StringComparison.Ordinal)
+            .Replace("\n", "\r\n", StringComparison.Ordinal);
+
+    private static AsciicastFormat ResolveFormat(AsciicastFormat requested)
+    {
+        if (requested is AsciicastFormat.V2 or AsciicastFormat.V3)
+        {
+            return requested;
+        }
+
+        throw new ArgumentOutOfRangeException(nameof(requested), requested, "Only asciicast v2 and v3 are supported.");
+    }
+
+    private static string ToSubProtocol(AsciicastFormat format) => format switch
+    {
+        AsciicastFormat.V2 => "v2.asciicast",
+        AsciicastFormat.V3 => "v3.asciicast",
+        _ => throw new ArgumentOutOfRangeException(nameof(format), format, "Only asciicast v2 and v3 are supported."),
+    };
+
+    private static AsciicastFormat FromSubProtocol(string subProtocol) =>
+        subProtocol.Equals("v2.asciicast", StringComparison.OrdinalIgnoreCase)
+            ? AsciicastFormat.V2
+            : subProtocol.Equals("v3.asciicast", StringComparison.OrdinalIgnoreCase)
+                ? AsciicastFormat.V3
+                : throw new ArgumentOutOfRangeException(
+                    nameof(subProtocol),
+                    subProtocol,
+                    "Only the v2.asciicast and v3.asciicast WebSocket subprotocols are supported.");
+
+    private static bool IsSupportedAsciinemaSubProtocol(string subProtocol) =>
+        subProtocol.Equals("v2.asciicast", StringComparison.OrdinalIgnoreCase) ||
+        subProtocol.Equals("v3.asciicast", StringComparison.OrdinalIgnoreCase);
+
+    private static Uri AddAsciicastFileType(Uri uri)
+    {
+        var query = uri.Query.TrimStart('?')
+            .Split('&', StringSplitOptions.RemoveEmptyEntries)
+            .Where(static part => !part.StartsWith("fileType=", StringComparison.OrdinalIgnoreCase))
+            .Append("fileType=asciicast");
+        return new UriBuilder(uri)
+        {
+            Query = string.Join('&', query),
+            Fragment = string.Empty,
+        }.Uri;
+    }
+}
diff --git a/src/Devolutions.Terminal.Settings/ActionJson.cs b/src/Devolutions.Terminal.Settings/ActionJson.cs
index f483ca3..eaa73f5 100644
--- a/src/Devolutions.Terminal.Settings/ActionJson.cs
+++ b/src/Devolutions.Terminal.Settings/ActionJson.cs
@@ -3,6 +3,7 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
+using Devolutions.Terminal.Core;
 
 namespace Devolutions.Terminal.Settings;
 
@@ -254,6 +255,17 @@ internal static void Write(Utf8JsonWriter writer, ActionAndArgs value)
         ShortcutAction.ClearBuffer => new ClearBufferArgs(
             Enum(json, "clear", ClearBufferType.All,
                 ("screen", ClearBufferType.Screen), ("scrollback", ClearBufferType.Scrollback), ("all", ClearBufferType.All))),
+        ShortcutAction.StartRecording => new StartRecordingArgs(
+            String(json, "path") ?? "",
+            Enum(json, "format", AsciicastFormat.V2,
+                ("v2", AsciicastFormat.V2), ("v3", AsciicastFormat.V3))),
+        ShortcutAction.StopRecording => new StopRecordingArgs(),
+        ShortcutAction.SaveRecording => new SaveRecordingArgs(
+            String(json, "path") ?? "",
+            Enum(json, "format", AsciicastFormat.V2,
+                ("v2", AsciicastFormat.V2), ("v3", AsciicastFormat.V3))),
+        ShortcutAction.ReplayRecording => new ReplayRecordingArgs(String(json, "path") ?? ""),
+        ShortcutAction.OpenRecording => new OpenRecordingArgs(String(json, "path") ?? ""),
         ShortcutAction.MultipleActions => new MultipleActionsArgs(Actions(json)),
         ShortcutAction.AdjustOpacity => new AdjustOpacityArgs(Int(json, "opacity"), Bool(json, "relative", true)),
         ShortcutAction.Suggestions => new SuggestionsArgs(Suggestions(json, "source"), Bool(json, "useCommandline")),
@@ -324,6 +336,17 @@ private static void WriteArgs(Utf8JsonWriter writer, IActionArgs args)
             case FocusPaneArgs value: writer.WriteNumber("id", value.Id); break;
             case ExportBufferArgs value: writer.WriteString("path", value.Path); break;
             case ClearBufferArgs value: writer.WriteString("clear", Lower(value.Clear)); break;
+            case StartRecordingArgs value:
+                writer.WriteString("path", value.Path);
+                if (value.Format != AsciicastFormat.V2) writer.WriteString("format", Lower(value.Format));
+                break;
+            case StopRecordingArgs: break;
+            case SaveRecordingArgs value:
+                writer.WriteString("path", value.Path);
+                if (value.Format != AsciicastFormat.V2) writer.WriteString("format", Lower(value.Format));
+                break;
+            case ReplayRecordingArgs value: writer.WriteString("path", value.Path); break;
+            case OpenRecordingArgs value: writer.WriteString("path", value.Path); break;
             case MultipleActionsArgs value:
                 writer.WritePropertyName("actions");
                 writer.WriteStartArray();
@@ -666,6 +689,12 @@ public override void Write(Utf8JsonWriter writer, ActionAndArgs value, JsonSeria
 [JsonSerializable(typeof(FocusPaneArgs))]
 [JsonSerializable(typeof(ExportBufferArgs))]
 [JsonSerializable(typeof(ClearBufferArgs))]
+[JsonSerializable(typeof(AsciicastFormat))]
+[JsonSerializable(typeof(StartRecordingArgs))]
+[JsonSerializable(typeof(StopRecordingArgs))]
+[JsonSerializable(typeof(SaveRecordingArgs))]
+[JsonSerializable(typeof(ReplayRecordingArgs))]
+[JsonSerializable(typeof(OpenRecordingArgs))]
 [JsonSerializable(typeof(MultipleActionsArgs))]
 [JsonSerializable(typeof(AdjustOpacityArgs))]
 [JsonSerializable(typeof(SuggestionsArgs))]
diff --git a/src/Devolutions.Terminal.Settings/ActionTypes.cs b/src/Devolutions.Terminal.Settings/ActionTypes.cs
index 4850033..3cb0d4d 100644
--- a/src/Devolutions.Terminal.Settings/ActionTypes.cs
+++ b/src/Devolutions.Terminal.Settings/ActionTypes.cs
@@ -1,5 +1,6 @@
 using System.Collections.ObjectModel;
 using System.Text.Json.Serialization;
+using Devolutions.Terminal.Core;
 
 namespace Devolutions.Terminal.Settings;
 
@@ -75,6 +76,13 @@ public enum ShortcutAction
     OpenSystemMenu,
     ExportBuffer,
     ClearBuffer,
+    StartRecording,
+    StopRecording,
+    StartStreaming,
+    StopStreaming,
+    SaveRecording,
+    ReplayRecording,
+    OpenRecording,
     MultipleActions,
     Quit,
     AdjustOpacity,
@@ -175,6 +183,13 @@ public static class ActionCatalog
         new(ShortcutAction.OpenSystemMenu, "openSystemMenu", false),
         new(ShortcutAction.ExportBuffer, "exportBuffer", true),
         new(ShortcutAction.ClearBuffer, "clearBuffer", true),
+        new(ShortcutAction.StartRecording, "startRecording", true),
+        new(ShortcutAction.StopRecording, "stopRecording", false),
+        new(ShortcutAction.StartStreaming, "startStreaming", false),
+        new(ShortcutAction.StopStreaming, "stopStreaming", false),
+        new(ShortcutAction.SaveRecording, "saveRecording", true),
+        new(ShortcutAction.ReplayRecording, "replayRecording", true),
+        new(ShortcutAction.OpenRecording, "openRecording", true),
         new(ShortcutAction.MultipleActions, "multipleActions", true),
         new(ShortcutAction.Quit, "quit", false),
         new(ShortcutAction.AdjustOpacity, "adjustOpacity", true),
@@ -332,6 +347,15 @@ public sealed record ToggleCommandPaletteArgs(CommandPaletteLaunchMode LaunchMod
 public sealed record FocusPaneArgs(uint Id = 0) : IActionArgs;
 public sealed record ExportBufferArgs(string Path = "") : IActionArgs;
 public sealed record ClearBufferArgs(ClearBufferType Clear = ClearBufferType.All) : IActionArgs;
+public sealed record StartRecordingArgs(
+    string Path = "",
+    AsciicastFormat Format = AsciicastFormat.V2) : IActionArgs;
+public sealed record StopRecordingArgs : IActionArgs;
+public sealed record SaveRecordingArgs(
+    string Path = "",
+    AsciicastFormat Format = AsciicastFormat.V2) : IActionArgs;
+public sealed record ReplayRecordingArgs(string Path = "") : IActionArgs;
+public sealed record OpenRecordingArgs(string Path = "") : IActionArgs;
 public sealed record MultipleActionsArgs(IReadOnlyList<ActionAndArgs> Actions) : IActionArgs
 {
     public MultipleActionsArgs() : this([]) { }
diff --git a/src/Devolutions.Terminal.Settings/Defaults/defaults.json b/src/Devolutions.Terminal.Settings/Defaults/defaults.json
index 2c16a5e..53a65b6 100644
--- a/src/Devolutions.Terminal.Settings/Defaults/defaults.json
+++ b/src/Devolutions.Terminal.Settings/Defaults/defaults.json
@@ -543,6 +543,13 @@
         { "command": { "action": "showSuggestions", "source": "all"}, "id": "Terminal.Suggestions" },
         { "command": "openCWD", "id": "Terminal.OpenCWD" },
         { "command": "workspaces", "id": "Terminal.Workspaces" },
+        { "command": { "action": "startRecording" }, "id": "Terminal.StartRecording", "name": "Start terminal recording" },
+        { "command": "stopRecording", "id": "Terminal.StopRecording", "name": "Stop terminal recording" },
+        { "command": "startStreaming", "id": "Terminal.StartStreaming", "name": "Start streaming..." },
+        { "command": "stopStreaming", "id": "Terminal.StopStreaming", "name": "Stop streaming" },
+        { "command": { "action": "saveRecording" }, "id": "Terminal.SaveRecording", "name": "Save terminal recording as..." },
+        { "command": { "action": "replayRecording" }, "id": "Terminal.ReplayRecording", "name": "Replay current terminal recording" },
+        { "command": { "action": "openRecording" }, "id": "Terminal.OpenRecording", "name": "Open terminal recording..." },
 
         // Tab Management
         // "command": "closeTab" is unbound by default.
diff --git a/tests/Devolutions.Terminal.App.Tests/ActionDispatcherTests.cs b/tests/Devolutions.Terminal.App.Tests/ActionDispatcherTests.cs
index ad5b0f2..60dbf3a 100644
--- a/tests/Devolutions.Terminal.App.Tests/ActionDispatcherTests.cs
+++ b/tests/Devolutions.Terminal.App.Tests/ActionDispatcherTests.cs
@@ -129,6 +129,11 @@ public void AvaloniaKeysUseActionMapNames(Key key, string expected) =>
     [InlineData(ShortcutAction.TogglePaneReadOnly, ActionScope.Pane)]
     [InlineData(ShortcutAction.ToggleBroadcastInput, ActionScope.Pane)]
     [InlineData(ShortcutAction.TabSearch, ActionScope.Window)]
+    [InlineData(ShortcutAction.OpenRecording, ActionScope.Window)]
+    [InlineData(ShortcutAction.StartStreaming, ActionScope.Control)]
+    [InlineData(ShortcutAction.StopStreaming, ActionScope.Control)]
+    [InlineData(ShortcutAction.SaveRecording, ActionScope.Control)]
+    [InlineData(ShortcutAction.ReplayRecording, ActionScope.Control)]
     public void PracticalActionsHaveExpectedScope(ShortcutAction action, ActionScope expected) =>
         Assert.Equal(expected, ActionScopeCatalog.GetScope(ActionCatalog.GetJsonName(action)));
 }
diff --git a/tests/Devolutions.Terminal.App.Tests/CloseConfirmationPolicyTests.cs b/tests/Devolutions.Terminal.App.Tests/CloseConfirmationPolicyTests.cs
index 14cbfff..227d99f 100644
--- a/tests/Devolutions.Terminal.App.Tests/CloseConfirmationPolicyTests.cs
+++ b/tests/Devolutions.Terminal.App.Tests/CloseConfirmationPolicyTests.cs
@@ -16,10 +16,31 @@ public sealed class CloseConfirmationPolicyTests
     public void PolicyCountsOnlyRunningSessions(ConfirmOnClose policy, int running, bool expected) =>
         Assert.Equal(expected, CloseConfirmationPolicy.RequiresConfirmation(policy, running));
 
+    [Theory]
+    [InlineData(ConfirmOnClose.Never, 0, false, false)]
+    [InlineData(ConfirmOnClose.Never, 1, false, true)]
+    [InlineData(ConfirmOnClose.Automatic, 1, true, true)]
+    [InlineData(ConfirmOnClose.Always, 1, true, true)]
+    public void UnsavedRecordingAlwaysRequiresConfirmation(
+        ConfirmOnClose policy,
+        int unsavedRecordings,
+        bool automaticExit,
+        bool expected) =>
+        Assert.Equal(
+            expected,
+            CloseConfirmationPolicy.RequiresConfirmation(
+                policy,
+                runningSessions: 0,
+                unsavedRecordings,
+                automaticExit));
+
     [Theory]
     [InlineData(ConfirmOnClose.Never)]
     [InlineData(ConfirmOnClose.Automatic)]
     [InlineData(ConfirmOnClose.Always)]
     public void AutomaticProcessExitNeverPrompts(ConfirmOnClose policy) =>
-        Assert.False(CloseConfirmationPolicy.RequiresConfirmation(policy, 3, automaticExit: true));
+        Assert.False(CloseConfirmationPolicy.RequiresConfirmation(
+            policy,
+            3,
+            automaticExit: true));
 }
diff --git a/tests/Devolutions.Terminal.Control.Tests/TermControlOutputPumpTests.cs b/tests/Devolutions.Terminal.Control.Tests/TermControlOutputPumpTests.cs
index f694336..6709cd6 100644
--- a/tests/Devolutions.Terminal.Control.Tests/TermControlOutputPumpTests.cs
+++ b/tests/Devolutions.Terminal.Control.Tests/TermControlOutputPumpTests.cs
@@ -1,7 +1,11 @@
+using System.Net;
+using System.Net.WebSockets;
 using System.Text;
+using System.Text.Json;
 using Avalonia.Headless.XUnit;
 using Avalonia.Threading;
 using Devolutions.Terminal.Connection;
+using Devolutions.Terminal.Core;
 using Devolutions.Terminal.Settings;
 using Xunit;
 
@@ -82,6 +86,229 @@ public async Task OutputBurstCoalescesIntoFewUiDrains()
         }
     }
 
+    [AvaloniaFact]
+    public async Task RecordingCapturesOutputAndRetainsItAfterStop()
+    {
+        var connection = new FakePtyConnection();
+        var control = new TermControl();
+        control.ConnectionFactory = _ => connection;
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 80, 24);
+            control.StartRecording();
+            var output = Encoding.UTF8.GetBytes("hello 🙂");
+            connection.Emit(output.AsMemory(0, 8));
+            connection.Emit(output.AsMemory(8));
+
+            Assert.True(control.IsRecording);
+            Assert.Null(control.StopRecording());
+            Assert.False(control.IsRecording);
+            Assert.True(control.HasUnsavedRecording);
+
+            var recording = control.GetRecording();
+            Assert.Equal("hello 🙂", string.Concat(recording.Frames.Select(static frame => frame.Data)));
+        }
+        finally
+        {
+            await control.CloseAsync();
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task RecordingIncludesVisiblePromptAtStart()
+    {
+        var connection = new FakePtyConnection();
+        var control = new TermControl();
+        control.ConnectionFactory = _ => connection;
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 80, 24);
+            connection.Emit("PowerShell 7.6.6\r\nPS C:\\Users\\mamoreau> ");
+            control.StartRecording();
+            connection.Emit("echo hi\r\n");
+
+            var recording = control.GetRecording();
+            Assert.Equal(2, recording.Frames.Count);
+            Assert.Contains("PowerShell 7.6.6", recording.Frames[0].Data, StringComparison.Ordinal);
+            Assert.Contains("echo hi", recording.Frames[1].Data, StringComparison.Ordinal);
+        }
+        finally
+        {
+            await control.CloseAsync();
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task RecordingCanBeSavedAfterItStops()
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.cast");
+        var connection = new FakePtyConnection();
+        var control = new TermControl();
+        control.ConnectionFactory = _ => connection;
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 80, 24);
+            control.StartRecording();
+            connection.Emit("saved output");
+            control.StopRecording();
+
+            Assert.Equal(path, control.SaveRecording(path));
+            Assert.False(control.HasUnsavedRecording);
+            var saved = Devolutions.Terminal.Core.AsciicastRecording.FromJson(
+                await File.ReadAllTextAsync(path));
+            Assert.Equal("saved output", Assert.Single(saved.Frames).Data);
+        }
+        finally
+        {
+            await control.CloseAsync();
+            File.Delete(path);
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task RecordingBecomesUnsavedWhenOutputArrivesAfterSave()
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.cast");
+        var connection = new FakePtyConnection();
+        var control = new TermControl();
+        control.ConnectionFactory = _ => connection;
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 80, 24);
+            control.StartRecording();
+            connection.Emit("first");
+            control.SaveRecording(path);
+
+            Assert.False(control.HasUnsavedRecording);
+
+            connection.Emit(" second");
+
+            Assert.True(control.HasUnsavedRecording);
+            Assert.Equal(path, control.StopRecording());
+            Assert.False(control.HasUnsavedRecording);
+        }
+        finally
+        {
+            await control.CloseAsync();
+            File.Delete(path);
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task StreamingRecordingSendsInitialScreenAndLiveOutput()
+    {
+        await using var server = RecordingWebSocketServer.Start();
+        var connection = new FakePtyConnection();
+        var control = new TermControl();
+        control.ConnectionFactory = _ => connection;
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 80, 24);
+            connection.Emit("PowerShell 7.6.6\r\nPS C:\\Users\\mamoreau> ");
+
+            await control.StartRecordingAsync(
+                new Uri($"{server.WebSocketBase}jet/jrec/push/session?token=abc"));
+            Assert.True(control.IsStreamingRecording);
+            connection.Emit("echo hi\n");
+            await control.StopRecordingAsync();
+            Assert.False(control.IsStreamingRecording);
+
+            var messages = await server.Messages;
+            Assert.Equal(3, messages.Count);
+            using var initial = JsonDocument.Parse(messages[1]);
+            using var output = JsonDocument.Parse(messages[2]);
+            Assert.Contains(
+                "PowerShell 7.6.6",
+                initial.RootElement[2].GetString(),
+                StringComparison.Ordinal);
+            Assert.Equal("echo hi\r\n", output.RootElement[2].GetString());
+            Assert.Null(control.RecordingStreamError);
+        }
+        finally
+        {
+            await control.CloseAsync();
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task AsciinemaV3StreamingNegotiatesSubprotocolAndUsesV3Header()
+    {
+        await using var server = RecordingWebSocketServer.Start("v3.asciicast");
+        var connection = new FakePtyConnection();
+        var control = new TermControl
+        {
+            ConnectionFactory = _ => connection,
+        };
+
+        try
+        {
+            await control.StartAsync(new ProfileSettings { Commandline = "cmd.exe" }, 100, 30);
+
+            await control.StartRecordingAsync(server.WebSocketBase, AsciicastFormat.V3);
+            connection.Emit("echo streamed\n");
+            await control.StopRecordingAsync();
+
+            var messages = await server.Messages;
+            Assert.True(messages.Count >= 2);
+            using var header = JsonDocument.Parse(messages[0]);
+            Assert.Equal(3, header.RootElement.GetProperty("version").GetInt32());
+            Assert.Equal(100, header.RootElement.GetProperty("term").GetProperty("cols").GetInt32());
+            Assert.Equal(30, header.RootElement.GetProperty("term").GetProperty("rows").GetInt32());
+            Assert.Null(control.RecordingStreamError);
+        }
+        finally
+        {
+            await control.CloseAsync();
+        }
+    }
+
+    [AvaloniaFact]
+    public async Task InvalidStreamingUriDoesNotLeaveRecordingStartPending()
+    {
+        var control = new TermControl();
+
+        await Assert.ThrowsAsync<ArgumentException>(
+            () => control.StartRecordingAsync(new Uri("https://gateway.example/record")));
+
+        control.StartRecording();
+        Assert.True(control.IsRecording);
+        control.StopRecording();
+        await control.CloseAsync();
+    }
+
+    [AvaloniaFact]
+    public async Task ReplayExposesPauseSpeedAndProgressState()
+    {
+        var control = new TermControl();
+        var recording = new Devolutions.Terminal.Core.AsciicastRecording(80, 24);
+        recording.AppendFrame(5, "later");
+        using var cancellation = new CancellationTokenSource();
+
+        var replay = control.ReplayRecordingAsync(recording, cancellation.Token);
+        control.PauseReplay();
+        control.SetReplaySpeed(2);
+
+        Assert.True(control.HasReplay);
+        Assert.True(control.IsReplaying);
+        Assert.True(control.IsReplayPaused);
+        Assert.Equal(2, control.ReplaySpeed);
+        Assert.Equal(TimeSpan.FromSeconds(5), control.ReplayDuration);
+
+        control.ResumeReplay();
+        cancellation.Cancel();
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => replay);
+
+        Assert.False(control.IsReplaying);
+        Assert.False(control.IsReplayPaused);
+        Assert.True(control.HasReplay);
+        await control.CloseAsync();
+    }
+
     private sealed class FakePtyConnection : IRestartableTerminalConnection
     {
         public event EventHandler<ReadOnlyMemory<byte>>? OutputReceived;
@@ -161,5 +388,92 @@ public Task CloseAsync(CancellationToken cancellationToken = default)
 
         public void Emit(string text) =>
             OutputReceived?.Invoke(this, Encoding.UTF8.GetBytes(text));
+
+        public void Emit(ReadOnlyMemory<byte> data) =>
+            OutputReceived?.Invoke(this, data);
+    }
+
+    private sealed class RecordingWebSocketServer : IAsyncDisposable
+    {
+        private readonly HttpListener _listener;
+        private readonly Task<IReadOnlyList<string>> _messages;
+
+        private RecordingWebSocketServer(
+            HttpListener listener,
+            Uri webSocketBase,
+            string? acceptedSubProtocol)
+        {
+            _listener = listener;
+            WebSocketBase = webSocketBase;
+            _messages = AcceptAsync(acceptedSubProtocol);
+        }
+
+        public Uri WebSocketBase { get; }
+        public Task<IReadOnlyList<string>> Messages => _messages;
+
+        public static RecordingWebSocketServer Start(string? acceptedSubProtocol = null)
+        {
+            var tcp = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0);
+            tcp.Start();
+            var port = ((IPEndPoint)tcp.LocalEndpoint).Port;
+            tcp.Stop();
+
+            var listener = new HttpListener();
+            listener.Prefixes.Add($"http://127.0.0.1:{port}/");
+            listener.Start();
+            return new RecordingWebSocketServer(
+                listener,
+                new Uri($"ws://127.0.0.1:{port}/"),
+                acceptedSubProtocol);
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            _listener.Close();
+            try
+            {
+                await _messages.WaitAsync(TimeSpan.FromSeconds(5));
+            }
+            catch (Exception) when (!_messages.IsCompletedSuccessfully)
+            {
+            }
+        }
+
+        private async Task<IReadOnlyList<string>> AcceptAsync(string? acceptedSubProtocol)
+        {
+            var context = await _listener.GetContextAsync();
+            var messages = new List<string>();
+            var socket = (await context.AcceptWebSocketAsync(acceptedSubProtocol)).WebSocket;
+            try
+            {
+                var buffer = new byte[16 * 1024];
+                while (true)
+                {
+                    var message = new MemoryStream();
+                    WebSocketReceiveResult result;
+                    do
+                    {
+                        result = await socket.ReceiveAsync(buffer, CancellationToken.None);
+                        if (result.MessageType == WebSocketMessageType.Close)
+                        {
+                            await socket.CloseAsync(
+                                WebSocketCloseStatus.NormalClosure,
+                                "Recording received",
+                                CancellationToken.None);
+                            return messages;
+                        }
+
+                        message.Write(buffer, 0, result.Count);
+                    }
+                    while (!result.EndOfMessage);
+
+                    messages.Add(Encoding.UTF8.GetString(message.ToArray()));
+                }
+            }
+            finally
+            {
+                socket.Dispose();
+            }
+        }
     }
 }
diff --git a/tests/Devolutions.Terminal.Core.Tests/AsciicastRecordingTests.cs b/tests/Devolutions.Terminal.Core.Tests/AsciicastRecordingTests.cs
new file mode 100644
index 0000000..4a2778c
--- /dev/null
+++ b/tests/Devolutions.Terminal.Core.Tests/AsciicastRecordingTests.cs
@@ -0,0 +1,119 @@
+using System.Text.Json;
+using Devolutions.Terminal.Core;
+using Xunit;
+
+namespace Devolutions.Terminal.Core.Tests;
+
+public sealed class AsciicastRecordingTests
+{
+    [Fact]
+    public void ToJsonWritesAsciicastV2Ndjson()
+    {
+        var recording = new AsciicastRecording(120, 40, "demo")
+        {
+            Timestamp = 1_700_000_000,
+        };
+        recording.AppendFrame(0.25, "hello\r\n");
+
+        var lines = recording.ToJson().Split('\n', StringSplitOptions.RemoveEmptyEntries);
+
+        Assert.Equal(2, lines.Length);
+        using var header = JsonDocument.Parse(lines[0]);
+        Assert.Equal(2, header.RootElement.GetProperty("version").GetInt32());
+        Assert.Equal(120, header.RootElement.GetProperty("width").GetInt32());
+        Assert.Equal(40, header.RootElement.GetProperty("height").GetInt32());
+        Assert.Equal("demo", header.RootElement.GetProperty("title").GetString());
+        Assert.Equal("xterm-256color", header.RootElement.GetProperty("env").GetProperty("TERM").GetString());
+
+        using var outputEvent = JsonDocument.Parse(lines[1]);
+        Assert.Equal(0.25, outputEvent.RootElement[0].GetDouble());
+        Assert.Equal("o", outputEvent.RootElement[1].GetString());
+        Assert.Equal("hello\r\n", outputEvent.RootElement[2].GetString());
+    }
+
+    [Fact]
+    public void FromJsonReadsOutputEventsAndIgnoresInputEvents()
+    {
+        const string json = """
+            {"version":2,"width":90,"height":30,"timestamp":1700000000,"title":"shell","env":{"TERM":"screen","SHELL":"/bin/sh"}}
+            [0.1,"o","prompt"]
+            [0.2,"i","secret"]
+            [0.3,"o","\r\nresult"]
+            """;
+
+        var recording = AsciicastRecording.FromJson(json);
+
+        Assert.Equal(90, recording.Width);
+        Assert.Equal(30, recording.Height);
+        Assert.Equal(1_700_000_000, recording.Timestamp);
+        Assert.Equal("shell", recording.Title);
+        Assert.Equal("screen", recording.Env["TERM"]);
+        Assert.Equal("/bin/sh", recording.Env["SHELL"]);
+        Assert.Collection(
+            recording.Frames,
+            frame =>
+            {
+                Assert.Equal(0.1, frame.Timestamp);
+                Assert.Equal("prompt", frame.Data);
+            },
+            frame =>
+            {
+                Assert.Equal(0.3, frame.Timestamp);
+                Assert.Equal("\r\nresult", frame.Data);
+            });
+    }
+
+    [Fact]
+    public void FromJsonRejectsUnsupportedHeader()
+    {
+        var exception = Assert.Throws<InvalidOperationException>(
+            () => AsciicastRecording.FromJson("""{"version":1,"width":80,"height":24}"""));
+
+        Assert.Contains("asciicast v2 or v3", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ToJsonWritesAsciicastV3WithRelativeEventIntervals()
+    {
+        var recording = new AsciicastRecording(120, 40, "demo", AsciicastFormat.V3)
+        {
+            Timestamp = 1_700_000_000,
+        };
+        recording.AppendFrame(0.25, "hello");
+        recording.AppendFrame(1.0, " world");
+
+        var lines = recording.ToJson().Split('\n', StringSplitOptions.RemoveEmptyEntries);
+
+        using var header = JsonDocument.Parse(lines[0]);
+        Assert.Equal(3, header.RootElement.GetProperty("version").GetInt32());
+        Assert.Equal(120, header.RootElement.GetProperty("term").GetProperty("cols").GetInt32());
+        Assert.Equal(40, header.RootElement.GetProperty("term").GetProperty("rows").GetInt32());
+        Assert.Equal("xterm-256color", header.RootElement.GetProperty("term").GetProperty("type").GetString());
+
+        using var secondEvent = JsonDocument.Parse(lines[2]);
+        Assert.Equal(0.75, secondEvent.RootElement[0].GetDouble(), precision: 10);
+    }
+
+    [Fact]
+    public void FromJsonReadsV3IntervalsAsReplayTimestamps()
+    {
+        const string json = """
+            {"version":3,"term":{"cols":90,"rows":30,"type":"screen"},"timestamp":1700000000,"title":"shell","env":{"SHELL":"/bin/sh"}}
+            [0.1,"o","prompt"]
+            [0.2,"i","secret"]
+            [0.3,"o","\r\nresult"]
+            # a comment
+            """;
+
+        var recording = AsciicastRecording.FromJson(json);
+
+        Assert.Equal(AsciicastFormat.V3, recording.Format);
+        Assert.Equal(90, recording.Width);
+        Assert.Equal(30, recording.Height);
+        Assert.Equal("screen", recording.Env["TERM"]);
+        Assert.Collection(
+            recording.Frames,
+            frame => Assert.Equal(0.1, frame.Timestamp, precision: 10),
+            frame => Assert.Equal(0.6, frame.Timestamp, precision: 10));
+    }
+}
diff --git a/tests/Devolutions.Terminal.Core.Tests/AsciicastWebSocketStreamerTests.cs b/tests/Devolutions.Terminal.Core.Tests/AsciicastWebSocketStreamerTests.cs
new file mode 100644
index 0000000..9ac4698
--- /dev/null
+++ b/tests/Devolutions.Terminal.Core.Tests/AsciicastWebSocketStreamerTests.cs
@@ -0,0 +1,212 @@
+using System.Net;
+using System.Net.WebSockets;
+using System.Text;
+using System.Text.Json;
+using Devolutions.Terminal.Core;
+using Xunit;
+
+namespace Devolutions.Terminal.Core.Tests;
+
+public sealed class AsciicastWebSocketStreamerTests
+{
+    [Fact]
+    public async Task StreamsDvlsCompatibleV2JsonlAndPreservesAuthenticationQuery()
+    {
+        await using var server = RecordingWebSocketServer.Start();
+        var recording = new AsciicastRecording(120, 40, format: AsciicastFormat.V2)
+        {
+            Timestamp = 1234567890,
+        };
+        await using var streamer = new AsciicastWebSocketStreamer(
+            new Uri($"{server.WebSocketBase}jet/jrec/push/session?token=signed-token&fileType=raw"));
+
+        await streamer.StartAsync(recording);
+        streamer.Write(new AsciicastFrame(0.25, "one\nTwo\r\nThree\rFour"));
+        await streamer.StopAsync();
+
+        var request = await server.Request;
+        Assert.Null(streamer.RequestedSubProtocol);
+        Assert.Null(request.SubProtocol);
+        Assert.Equal("signed-token", request.Query["token"]);
+        Assert.Equal("asciicast", request.Query["fileType"]);
+        Assert.DoesNotContain("fileType=raw", request.RawQuery, StringComparison.OrdinalIgnoreCase);
+        Assert.Equal(2, request.Messages.Count);
+
+        using var header = JsonDocument.Parse(request.Messages[0]);
+        Assert.Equal(2, header.RootElement.GetProperty("version").GetInt32());
+        Assert.Equal(1234567890, header.RootElement.GetProperty("timestamp").GetInt64());
+        Assert.Equal(120, header.RootElement.GetProperty("width").GetInt32());
+        Assert.Equal(40, header.RootElement.GetProperty("height").GetInt32());
+        Assert.EndsWith("\n", request.Messages[0], StringComparison.Ordinal);
+
+        using var output = JsonDocument.Parse(request.Messages[1]);
+        Assert.Equal(0.25, output.RootElement[0].GetDouble());
+        Assert.Equal("o", output.RootElement[1].GetString());
+        Assert.Equal("one\r\nTwo\r\nThree\rFour", output.RootElement[2].GetString());
+        Assert.EndsWith("\n", request.Messages[1], StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public async Task SupportsAsciinemaV2SubprotocolWhenExplicitlyRequested()
+    {
+        await using var server = RecordingWebSocketServer.Start("v2.asciicast");
+        await using var streamer = AsciicastWebSocketStreamer.CreateForAsciinema(
+            server.WebSocketBase,
+            AsciicastFormat.V2,
+            appendAsciicastFileType: false);
+        var recording = new AsciicastRecording(80, 24, format: AsciicastFormat.V2);
+
+        await streamer.StartAsync(recording);
+        await streamer.StopAsync();
+
+        var request = await server.Request;
+        Assert.Equal("v2.asciicast", streamer.RequestedSubProtocol);
+        Assert.Equal("v2.asciicast", request.SubProtocol);
+        Assert.Empty(request.RawQuery);
+        Assert.Single(request.Messages);
+        using var header = JsonDocument.Parse(request.Messages[0]);
+        Assert.Equal(2, header.RootElement.GetProperty("version").GetInt32());
+    }
+
+    [Fact]
+    public async Task SupportsAsciinemaV3SubprotocolWithRelativeEventTimestamps()
+    {
+        await using var server = RecordingWebSocketServer.Start("v3.asciicast");
+        await using var streamer = AsciicastWebSocketStreamer.CreateForAsciinema(
+            server.WebSocketBase,
+            AsciicastFormat.V3);
+        var recording = new AsciicastRecording(80, 24, format: AsciicastFormat.V3);
+
+        await streamer.StartAsync(recording);
+        streamer.Write(new AsciicastFrame(0.25, "one"));
+        streamer.Write(new AsciicastFrame(0.75, "two"));
+        await streamer.StopAsync();
+
+        var request = await server.Request;
+        Assert.Equal("v3.asciicast", request.SubProtocol);
+        Assert.Empty(request.RawQuery);
+        Assert.Equal(3, request.Messages.Count);
+
+        using var header = JsonDocument.Parse(request.Messages[0]);
+        Assert.Equal(3, header.RootElement.GetProperty("version").GetInt32());
+        Assert.Equal(80, header.RootElement.GetProperty("term").GetProperty("cols").GetInt32());
+        Assert.Equal(24, header.RootElement.GetProperty("term").GetProperty("rows").GetInt32());
+
+        using var firstOutput = JsonDocument.Parse(request.Messages[1]);
+        Assert.Equal(0.25, firstOutput.RootElement[0].GetDouble());
+        Assert.Equal("one", firstOutput.RootElement[2].GetString());
+
+        using var secondOutput = JsonDocument.Parse(request.Messages[2]);
+        Assert.Equal(0.5, secondOutput.RootElement[0].GetDouble());
+        Assert.Equal("two", secondOutput.RootElement[2].GetString());
+    }
+
+    [Fact]
+    public async Task RejectsRecordingThatDoesNotMatchRequestedSubprotocol()
+    {
+        await using var streamer = AsciicastWebSocketStreamer.CreateForAsciinema(
+            new Uri("ws://127.0.0.1:1/"),
+            AsciicastFormat.V3);
+        var recording = new AsciicastRecording(80, 24, format: AsciicastFormat.V2);
+
+        var exception = await Assert.ThrowsAsync<ArgumentException>(
+            () => streamer.StartAsync(recording));
+
+        Assert.Contains("v3.asciicast", exception.Message, StringComparison.Ordinal);
+    }
+
+    private sealed class RecordingWebSocketServer : IAsyncDisposable
+    {
+        private readonly HttpListener _listener;
+        private readonly Task<RecordingRequest> _request;
+
+        private RecordingWebSocketServer(
+            HttpListener listener,
+            Uri webSocketBase,
+            string? acceptedSubProtocol)
+        {
+            _listener = listener;
+            WebSocketBase = webSocketBase;
+            _request = AcceptAsync(acceptedSubProtocol);
+        }
+
+        public Uri WebSocketBase { get; }
+        public Task<RecordingRequest> Request => _request;
+
+        public static RecordingWebSocketServer Start(string? acceptedSubProtocol = null)
+        {
+            var tcp = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0);
+            tcp.Start();
+            var port = ((IPEndPoint)tcp.LocalEndpoint).Port;
+            tcp.Stop();
+
+            var listener = new HttpListener();
+            listener.Prefixes.Add($"http://127.0.0.1:{port}/");
+            listener.Start();
+            return new RecordingWebSocketServer(
+                listener,
+                new Uri($"ws://127.0.0.1:{port}/"),
+                acceptedSubProtocol);
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            _listener.Close();
+            try
+            {
+                await _request.WaitAsync(TimeSpan.FromSeconds(5));
+            }
+            catch (Exception) when (!_request.IsCompletedSuccessfully)
+            {
+            }
+        }
+
+        private async Task<RecordingRequest> AcceptAsync(string? acceptedSubProtocol)
+        {
+            var context = await _listener.GetContextAsync();
+            var messages = new List<string>();
+            var socket = (await context.AcceptWebSocketAsync(acceptedSubProtocol)).WebSocket;
+            try
+            {
+                var buffer = new byte[16 * 1024];
+                while (true)
+                {
+                    var message = new MemoryStream();
+                    WebSocketReceiveResult result;
+                    do
+                    {
+                        result = await socket.ReceiveAsync(buffer, CancellationToken.None);
+                        if (result.MessageType == WebSocketMessageType.Close)
+                        {
+                            await socket.CloseAsync(
+                                WebSocketCloseStatus.NormalClosure,
+                                "Recording received",
+                                CancellationToken.None);
+                            return new RecordingRequest(
+                                context.Request.QueryString,
+                                context.Request.Url?.Query ?? string.Empty,
+                                socket.SubProtocol,
+                                messages);
+                        }
+
+                        message.Write(buffer, 0, result.Count);
+                    }
+                    while (!result.EndOfMessage);
+
+                    Assert.Equal(WebSocketMessageType.Text, result.MessageType);
+                    messages.Add(Encoding.UTF8.GetString(message.ToArray()));
+                }
+            }
+            finally
+            {
+                socket.Dispose();
+            }
+        }
+    }
+
+    private sealed record RecordingRequest(
+        System.Collections.Specialized.NameValueCollection Query,
+        string RawQuery,
+        string? SubProtocol,
+        IReadOnlyList<string> Messages);
+}
diff --git a/tests/Devolutions.Terminal.Settings.Tests/ActionMapTests.cs b/tests/Devolutions.Terminal.Settings.Tests/ActionMapTests.cs
index ab11d1d..8b0b354 100644
--- a/tests/Devolutions.Terminal.Settings.Tests/ActionMapTests.cs
+++ b/tests/Devolutions.Terminal.Settings.Tests/ActionMapTests.cs
@@ -23,6 +23,8 @@ public sealed class ActionMapTests
         "disableReadOnlyMode", "findMatch", "newWindow", "identifyWindow", "identifyWindows",
         "renameWindow", "openWindowRenamer", "debugTerminalCwd", "searchWeb", "globalSummon",
         "quakeMode", "focusPane", "openSystemMenu", "exportBuffer", "clearBuffer",
+        "startRecording", "stopRecording", "startStreaming", "stopStreaming",
+        "saveRecording", "replayRecording", "openRecording",
         "multipleActions", "quit", "adjustOpacity", "restoreLastClosed", "selectAll",
         "selectCommand", "selectOutput", "markMode", "toggleBlockSelection",
         "switchSelectionEndpoint", "showSuggestions", "experimental.colorSelection",
@@ -32,12 +34,12 @@ public sealed class ActionMapTests
     ];
 
     [Fact]
-    public void PublicActionInventoryExactlyMatchesNativeList()
+    public void PublicActionInventoryExactlyMatchesSupportedList()
     {
-        Assert.Equal(92, ActionCatalog.All.Count);
+        Assert.Equal(99, ActionCatalog.All.Count);
         Assert.Equal(ExpectedActionNames, ActionCatalog.All.Select(action => action.JsonName));
-        Assert.Equal(92, ActionCatalog.All.Select(action => action.Action).Distinct().Count());
-        Assert.Equal(93, Enum.GetValues<ShortcutAction>().Length); // Invalid + 92 public actions.
+        Assert.Equal(99, ActionCatalog.All.Select(action => action.Action).Distinct().Count());
+        Assert.Equal(100, Enum.GetValues<ShortcutAction>().Length); // Invalid + 99 public actions.
     }
 
     [Fact]
@@ -96,6 +98,10 @@ public void EveryWithArgsActionCreatesItsConcreteArgumentRecord()
             [ShortcutAction.FocusPane] = typeof(FocusPaneArgs),
             [ShortcutAction.ExportBuffer] = typeof(ExportBufferArgs),
             [ShortcutAction.ClearBuffer] = typeof(ClearBufferArgs),
+            [ShortcutAction.StartRecording] = typeof(StartRecordingArgs),
+            [ShortcutAction.SaveRecording] = typeof(SaveRecordingArgs),
+            [ShortcutAction.ReplayRecording] = typeof(ReplayRecordingArgs),
+            [ShortcutAction.OpenRecording] = typeof(OpenRecordingArgs),
             [ShortcutAction.MultipleActions] = typeof(MultipleActionsArgs),
             [ShortcutAction.AdjustOpacity] = typeof(AdjustOpacityArgs),
             [ShortcutAction.Suggestions] = typeof(SuggestionsArgs),
@@ -105,7 +111,7 @@ public void EveryWithArgsActionCreatesItsConcreteArgumentRecord()
             [ShortcutAction.OpenWorkspace] = typeof(OpenWorkspaceArgs),
         };
 
-        Assert.Equal(44, expected.Count);
+        Assert.Equal(48, expected.Count);
         foreach (var definition in ActionCatalog.All.Where(action => action.HasArguments))
         {
             var parsed = ActionJson.Parse(JsonValue.Create(definition.JsonName));
@@ -180,6 +186,29 @@ public void EmbeddedActionsAndUserDefaultBindingsResolve()
             binding => Assert.NotNull(settings.ActionMap.GetActionByID(binding.Value)));
     }
 
+    [Fact]
+    public void EmbeddedRecordingCommandsExposeDistinctWorkflows()
+    {
+        var settings = SettingsService.CreateDefault();
+        (string Id, string Name, ShortcutAction Action)[] commands =
+        [
+            ("Terminal.StartRecording", "Start terminal recording", ShortcutAction.StartRecording),
+            ("Terminal.StopRecording", "Stop terminal recording", ShortcutAction.StopRecording),
+            ("Terminal.StartStreaming", "Start streaming...", ShortcutAction.StartStreaming),
+            ("Terminal.StopStreaming", "Stop streaming", ShortcutAction.StopStreaming),
+            ("Terminal.SaveRecording", "Save terminal recording as...", ShortcutAction.SaveRecording),
+            ("Terminal.ReplayRecording", "Replay current terminal recording", ShortcutAction.ReplayRecording),
+            ("Terminal.OpenRecording", "Open terminal recording...", ShortcutAction.OpenRecording),
+        ];
+
+        foreach (var expected in commands)
+        {
+            var command = Assert.IsType<Command>(settings.ActionMap.GetActionByID(expected.Id));
+            Assert.Equal(expected.Name, command.Name);
+            Assert.Equal(expected.Action, command.ActionAndArgs?.Action);
+        }
+    }
+
     [Fact]
     public void EmbeddedDefaultsUsePlatformKeyBindings()
     {