diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d2d8ed542..8fc3aed6a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -424,12 +424,14 @@ set(mmapper_SRCS
     mapstorage/jsonmapstorage.h
     mapstorage/mapstorage.cpp
     mapstorage/mapstorage.h
-    mpi/mpifilter.cpp
-    mpi/mpifilter.h
     mpi/remoteedit.cpp
     mpi/remoteedit.h
     mpi/remoteeditsession.cpp
     mpi/remoteeditsession.h
+    mpi/RemoteEditDraftStore.cpp
+    mpi/RemoteEditDraftStore.h
+    mpi/RemoteEditPanel.cpp
+    mpi/RemoteEditPanel.h
     mpi/RemoteEditDocumentOps.cpp
     mpi/RemoteEditDocumentOps.h
     mpi/RemoteEditHighlighter.cpp
diff --git a/src/configuration/configuration.cpp b/src/configuration/configuration.cpp
index 4ebe6032d..4cb60ec30 100644
--- a/src/configuration/configuration.cpp
+++ b/src/configuration/configuration.cpp
@@ -67,6 +67,12 @@ NODISCARD const char *getPlatformEditor()
 ConstString SETTINGS_ORGANIZATION = "MUME";
 ConstString OLD_SETTINGS_ORGANIZATION = "Caligor soft";
 ConstString SETTINGS_APPLICATION = "MMapper2";
+
+std::unique_ptr<QSettings> makeAppSettings()
+{
+    return std::make_unique<QSettings>(SETTINGS_ORGANIZATION, SETTINGS_APPLICATION);
+}
+
 ConstString SETTINGS_FIRST_TIME_KEY = "General/Run first time";
 
 class NODISCARD Settings final
@@ -301,6 +307,7 @@ ConstString KEY_TAB_COMPLETION_DICTIONARY_SIZE = "Tab completion dictionary size
 ConstString KEY_THEME = "Theme";
 ConstString KEY_TLS_ENCRYPTION = "TLS encryption";
 ConstString KEY_USE_INTERNAL_EDITOR = "Use internal editor";
+ConstString KEY_EDITOR_DIRECTORY = "Editor directory";
 ConstString KEY_USE_TRILINEAR_FILTERING = "Use trilinear filtering";
 ConstString KEY_WEATHER_ATMOSPHERE_INTENSITY = "weather.atmosphereIntensity";
 ConstString KEY_WEATHER_PRECIPITATION_INTENSITY = "weather.precipitationIntensity";
@@ -599,6 +606,7 @@ void Configuration::reset()
 
 ConstString DEFAULT_MMAPPER_SUBDIR = "/MMapper";
 ConstString DEFAULT_LOGS_SUBDIR = "/Logs";
+ConstString DEFAULT_EDITOR_SUBDIR = "/Editor";
 ConstString DEFAULT_RESOURCES_SUBDIR = "/Resources";
 
 NODISCARD static QString getDefaultDirectory()
@@ -770,6 +778,11 @@ void Configuration::MumeClientProtocolSettings::read(const QSettings &conf)
     internalRemoteEditor = conf.value(KEY_USE_INTERNAL_EDITOR, true).toBool();
     externalRemoteEditorCommand = conf.value(KEY_EXTERNAL_EDITOR_COMMAND, getPlatformEditor())
                                       .toString();
+    editorDirectory = conf.value(KEY_EDITOR_DIRECTORY,
+                                 getDefaultDirectory()
+                                     .append(DEFAULT_MMAPPER_SUBDIR)
+                                     .append(DEFAULT_EDITOR_SUBDIR))
+                          .toString();
 }
 
 void Configuration::MumeNativeSettings::read(const QSettings &conf)
@@ -968,6 +981,7 @@ void Configuration::MumeClientProtocolSettings::write(QSettings &conf) const
 {
     conf.setValue(KEY_USE_INTERNAL_EDITOR, internalRemoteEditor);
     conf.setValue(KEY_EXTERNAL_EDITOR_COMMAND, externalRemoteEditorCommand);
+    conf.setValue(KEY_EDITOR_DIRECTORY, editorDirectory);
 }
 
 void Configuration::PathMachineSettings::write(QSettings &conf) const
diff --git a/src/configuration/configuration.h b/src/configuration/configuration.h
index e2fa18c8a..40b28ec6a 100644
--- a/src/configuration/configuration.h
+++ b/src/configuration/configuration.h
@@ -24,6 +24,7 @@
 #include <QColor>
 #include <QMap>
 #include <QObject>
+#include <QSettings>
 #include <QString>
 #include <QStringList>
 #include <QtCore>
@@ -125,6 +126,7 @@ class NODISCARD Configuration final
     {
         bool internalRemoteEditor = false;
         QString externalRemoteEditorCommand;
+        QString editorDirectory;
 
     private:
         SUBGROUP();
@@ -490,6 +492,9 @@ void setEnteredMain();
 /// Returns a reference to the application configuration object.
 NODISCARD Configuration &setConfig();
 NODISCARD const Configuration &getConfig();
+/// A QSettings in the same organization/application scope as the
+/// configuration itself, for subsystems that persist their own small state.
+NODISCARD std::unique_ptr<QSettings> makeAppSettings();
 
 using SharedCanvasNamedColorOptions
     = std::shared_ptr<const Configuration::ResolvedCanvasNamedColorOptions>;
diff --git a/src/global/AsyncTasks.cpp b/src/global/AsyncTasks.cpp
index 9dc043ddf..86950da9c 100644
--- a/src/global/AsyncTasks.cpp
+++ b/src/global/AsyncTasks.cpp
@@ -37,6 +37,8 @@ std::string get_type_name(const AsyncTaskTypeEnum type)
         return "IO Task";
     case Task:
         return "Task";
+    case RemoteEdit:
+        return "RemoteEdit";
     }
     return "(error)";
 }
diff --git a/src/global/AsyncTasks.h b/src/global/AsyncTasks.h
index 8a2b955e2..165475a69 100644
--- a/src/global/AsyncTasks.h
+++ b/src/global/AsyncTasks.h
@@ -10,7 +10,7 @@
 
 class AnsiOstream;
 
-enum class NODISCARD AsyncTaskTypeEnum : uint8_t { IO, Task };
+enum class NODISCARD AsyncTaskTypeEnum : uint8_t { IO, Task, RemoteEdit };
 
 namespace async_tasks {
 
diff --git a/src/global/random.cpp b/src/global/random.cpp
index d1b9af923..96d34472a 100644
--- a/src/global/random.cpp
+++ b/src/global/random.cpp
@@ -5,6 +5,7 @@
 #include "random.h"
 
 #include <functional>
+#include <string>
 
 NODISCARD static auto expensiveSeed()
 {
@@ -26,3 +27,15 @@ size_t getRandom(const size_t max)
     std::uniform_int_distribution<size_t> dist{0u, max}; // inclusive
     return dist(RandomEngine::getSingleton());
 }
+
+std::string getRandomString(const size_t length)
+{
+    static constexpr const std::string_view chars
+        = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    std::string result;
+    result.reserve(length);
+    for (size_t i = 0; i < length; ++i) {
+        result += chars[getRandom(chars.size() - 1u)];
+    }
+    return result;
+}
diff --git a/src/global/random.h b/src/global/random.h
index ad8d6016c..a30479b91 100644
--- a/src/global/random.h
+++ b/src/global/random.h
@@ -24,6 +24,8 @@ class NODISCARD RandomEngine final : public std::mt19937
 
 // returns a uniformly-distributed random number in [0..max], inclusive
 NODISCARD extern size_t getRandom(size_t max);
+// returns `length` random ASCII alphanumerics
+NODISCARD extern std::string getRandomString(size_t length);
 
 template<typename T>
 NODISCARD decltype(auto) chooseRandomElement(T &&container)
diff --git a/src/mainwindow/TasksPanel.cpp b/src/mainwindow/TasksPanel.cpp
index 7c21bc734..099caa78f 100644
--- a/src/mainwindow/TasksPanel.cpp
+++ b/src/mainwindow/TasksPanel.cpp
@@ -9,6 +9,9 @@
 #include "../global/SendToUser.h"
 #include "../global/thread_utils.h"
 #include "../global/window_utils.h"
+#include "../mpi/remoteedit.h"
+#include "../proxy/connectionlistener.h"
+#include "../proxy/proxy.h"
 #include "AsyncTypes.h"
 #include "mainwindow.h"
 
@@ -73,15 +76,18 @@ struct NODISCARD TasksPanel::ListItem final : public QWidget
         return QScopedPointer<QProgressBar>{progress.release()};
     });
     QScopedPointer<CancelTaskButton> m_cancelButton;
+    QScopedPointer<QPushButton> m_actionButton;
 
 public:
-    explicit ListItem(async_tasks::AsyncTaskHandle moved_task)
+    explicit ListItem(async_tasks::AsyncTaskHandle moved_task, MainWindow &mainWindow)
         : m_task{std::move(moved_task)}
         , m_cancelButton{mmqt::makeQScopedPointer<CancelTaskButton>(m_task)}
+        , m_actionButton{mmqt::makeQScopedPointer<QPushButton>()}
     {
         const auto layout = mmqt::makeQPointer<QVBoxLayout>(this);
         layout->addWidget(m_label.get());
         layout->addWidget(m_progress.get());
+
         layout->addWidget(m_cancelButton.get());
         layout->insertStretch(-1); // must be after all the addWidget() calls
         updateProgress();
@@ -374,7 +380,7 @@ void TasksPanel::add_new_item(const TaskHandle &handle)
 {
     const auto &task = handle.task;
     // NOLINTNEXTLINE (no, this is not leaked; Qt manages it)
-    if (auto *const item = new ListItem(task)) {
+    if (auto *const item = new ListItem(task, m_mainWindow)) {
         getLayout().addWidget(item);
         getKnownTasks().emplace(task.getId(), task);
     }
diff --git a/src/mainwindow/mainwindow-compact.cpp b/src/mainwindow/mainwindow-compact.cpp
index c1c0262fa..109508348 100644
--- a/src/mainwindow/mainwindow-compact.cpp
+++ b/src/mainwindow/mainwindow-compact.cpp
@@ -105,14 +105,15 @@ void MainWindow::buildDefaultCompactLayout()
 
     // One tabbed group so a single panel shows at a time, below the
     // map; hidden docks stay hidden and appear as tabs when shown.
-    const std::array<QDockWidget *, 8> docks{m_dockDialogClient,
+    const std::array<QDockWidget *, 9> docks{m_dockDialogClient,
                                              m_dockDialogGroup,
                                              m_dockDialogRoom,
                                              m_dockDialogDescription,
                                              m_dockDialogLog,
                                              m_dockDialogAdventure,
                                              m_dockDialogTimers,
-                                             m_dockDialogAsync};
+                                             m_dockDialogAsync,
+                                             m_dockDialogRemoteEdits};
     QDockWidget *first = nullptr;
     for (QDockWidget *const dock : docks) {
         dock->setFloating(false);
diff --git a/src/mainwindow/mainwindow.cpp b/src/mainwindow/mainwindow.cpp
index 8647333d4..bce40696a 100644
--- a/src/mainwindow/mainwindow.cpp
+++ b/src/mainwindow/mainwindow.cpp
@@ -28,6 +28,8 @@
 #include "../media/AudioManager.h"
 #include "../media/DescriptionWidget.h"
 #include "../media/MediaLibrary.h"
+#include "../mpi/RemoteEditPanel.h"
+#include "../mpi/remoteedit.h"
 #include "../pathmachine/mmapper2pathmachine.h"
 #include "../preferences/configdialog.h"
 #include "../proxy/connectionlistener.h"
@@ -111,6 +113,7 @@ static void addApplicationFont()
 MainWindow::~MainWindow()
 {
     g_mainWindow = nullptr;
+    remote_edit::setInstance(nullptr);
     mmqt::rdisconnect(this);
     async_tasks::cleanup();
     delete m_listener;
@@ -139,6 +142,9 @@ MainWindow::MainWindow()
 
     m_prespammedPath = new PrespammedPath(this);
 
+    m_remoteEdit = new RemoteEdit(this);
+    remote_edit::setInstance(m_remoteEdit);
+
     m_groupManager = new Mmapper2Group(this);
     m_groupManager->setObjectName("GroupManager");
 
@@ -305,6 +311,27 @@ MainWindow::MainWindow()
         m_dockDialogAsync = dock;
     });
 
+    // Remote edits (MPI editor/viewer tabs)
+    std::invoke([this] {
+        auto *const w = new RemoteEditPanel{deref(m_remoteEdit), this};
+        auto *const dock = new QDockWidget(tr("Remote Edits Panel"), this);
+        dock->setObjectName("DockWidgetRemoteEdits");
+        dock->setAllowedAreas(Qt::AllDockWidgetAreas);
+        dock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable
+                          | QDockWidget::DockWidgetMovable);
+        addDockWidget(Qt::RightDockWidgetArea, dock);
+        dock->setWidget(w);
+        dock->hide();
+
+        connect(w, &RemoteEditPanel::sig_showRequested, dock, [dock]() {
+            dock->show();
+            dock->raise();
+        });
+
+        w->show();
+        m_dockDialogRemoteEdits = dock;
+    });
+
     m_mumeClock = new MumeClock(getConfig().mumeClock.startEpoch, deref(m_gameObserver), this);
     if constexpr (!NO_UPDATER) {
         m_updateDialog = new UpdateDialog(this);
@@ -637,6 +664,25 @@ void MainWindow::wireConnections()
             &FindRoomsDlg::sig_editSelection,
             this,
             &MainWindow::slot_onEditRoomSelection);
+
+    connect(m_listener, &ConnectionListener::sig_proxyCreated, this, [this](QPointer<Proxy> proxy) {
+        if (!proxy)
+            return;
+
+        connect(m_remoteEdit, &RemoteEdit::sig_sendGmcp, proxy.data(), &Proxy::slot_sendGmcp);
+    });
+
+    deref(m_gameObserver).sig2_sentToUserGmcp.connect(m_lifetime, [this](const GmcpMessage &msg) {
+        m_remoteEdit->slot_parseGmcpInput(msg);
+    });
+
+    deref(m_gameObserver).sig2_disconnected.connect(m_lifetime, [this]() {
+        m_remoteEdit->onDisconnected();
+    });
+
+    deref(m_gameObserver).sig2_connected.connect(m_lifetime, [this]() {
+        m_remoteEdit->announcePendingDrafts();
+    });
 }
 
 void MainWindow::slot_log(const QString &mod, const QString &message)
@@ -1366,6 +1412,7 @@ void MainWindow::setupMenuBar()
     sidepanels->addAction(m_dockDialogDescription->toggleViewAction());
     sidepanels->addAction(m_dockDialogTimers->toggleViewAction());
     sidepanels->addAction(m_dockDialogAsync->toggleViewAction());
+    sidepanels->addAction(m_dockDialogRemoteEdits->toggleViewAction());
     windowMenu->addSeparator();
     windowMenu->addAction(showStatusBarAct);
     windowMenu->addAction(showScrollBarsAct);
@@ -1793,6 +1840,10 @@ void MainWindow::closeEvent(QCloseEvent *const event)
     }
 
     asyncIO.setClosedForBusiness();
+    // RemoteEdit sessions aren't registered with async_tasks (see RemoteEdit::shutdown()
+    // for why); tear them down here, synchronously, so no GMCP cancel is sent and every
+    // open edit/draft survives on disk for recovery on next launch.
+    m_remoteEdit->shutdown();
     async_tasks::cancel_all(); /* note: this can only cancel tasks that allow it */
 
     if (asyncIO.isRunningOnBackgroundThread()) {
diff --git a/src/mainwindow/mainwindow.h b/src/mainwindow/mainwindow.h
index cee2e19dd..bbb8ba352 100644
--- a/src/mainwindow/mainwindow.h
+++ b/src/mainwindow/mainwindow.h
@@ -69,6 +69,7 @@ class DescriptionWidget;
 class MediaLibrary;
 class TimerWidget;
 class MapDestination;
+class RemoteEdit;
 
 struct MapLoadData;
 
@@ -91,6 +92,7 @@ class NODISCARD_QOBJECT MainWindow final : public QMainWindow, public ProxyHost
     QDockWidget *m_dockDialogDescription = nullptr;
     QDockWidget *m_dockDialogTimers = nullptr;
     QDockWidget *m_dockDialogAsync = nullptr;
+    QDockWidget *m_dockDialogRemoteEdits = nullptr;
 
     std::unique_ptr<GameObserver> m_gameObserver;
     AutoLogger *m_logger = nullptr;
@@ -122,6 +124,7 @@ class NODISCARD_QOBJECT MainWindow final : public QMainWindow, public ProxyHost
     DescriptionWidget *m_descriptionWidget = nullptr;
     TimerWidget *m_timerWidget = nullptr;
     std::unique_ptr<HotkeyManager> m_hotkeyManager;
+    RemoteEdit *m_remoteEdit = nullptr;
 
     QPointer<QMenu> m_contextMenu;
 
@@ -297,6 +300,7 @@ class NODISCARD_QOBJECT MainWindow final : public QMainWindow, public ProxyHost
 
     NODISCARD HotkeyManager &getHotkeyManager() const { return deref(m_hotkeyManager); }
     NODISCARD CTimers &getTimers() const { return deref(m_timers); }
+    NODISCARD RemoteEdit &getRemoteEdit() const { return deref(m_remoteEdit); }
 
 private:
     // ProxyHost
diff --git a/src/mpi/RemoteEditDraftStore.cpp b/src/mpi/RemoteEditDraftStore.cpp
new file mode 100644
index 000000000..a3137c475
--- /dev/null
+++ b/src/mpi/RemoteEditDraftStore.cpp
@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "RemoteEditDraftStore.h"
+
+#include "../global/TextUtils.h"
+#include "../global/io.h"
+#include "../global/random.h"
+
+#include <utility>
+
+#include <QDateTime>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QMessageLogContext>
+#include <QRegularExpression>
+#include <QSaveFile>
+#include <QSettings>
+#include <QUrl>
+
+namespace {
+
+// MUME reuses small session ids, so the timestamp -- not just the id --
+// keeps concurrent/successive drafts from colliding.
+NODISCARD QString makeKeyStem(const RemoteSessionId sessionId)
+{
+    return QString("%1_%2").arg(sessionId.asInt32()).arg(QDateTime::currentMSecsSinceEpoch());
+}
+
+NODISCARD QString encodeFileName(const RemoteSessionId sessionId, const QString &title)
+{
+    // Keep file names bounded by shortening the title itself, so neither a
+    // %XX escape nor a multi-byte character is ever cut in half.
+    constexpr qsizetype MAX_ENCODED_TITLE = 50;
+    QString shortened = title;
+    QByteArray encoded = QUrl::toPercentEncoding(shortened);
+    while (encoded.size() > MAX_ENCODED_TITLE && !shortened.isEmpty()) {
+        shortened.chop(1);
+        if (!shortened.isEmpty() && shortened.back().isHighSurrogate()) {
+            shortened.chop(1);
+        }
+        encoded = QUrl::toPercentEncoding(shortened);
+    }
+    return QString("draft_%1_%2.txt").arg(makeKeyStem(sessionId), QString::fromLatin1(encoded));
+}
+
+NODISCARD bool decodeFileName(const QString &fileName, RemoteSessionId &sessionId, QString &title)
+{
+    static const QRegularExpression re("^draft_(-?\\d+)_(\\d+)_(.*)\\.txt$");
+    const QRegularExpressionMatch match = re.match(fileName);
+    if (!match.hasMatch()) {
+        return false;
+    }
+    sessionId = RemoteSessionId(match.captured(1).toInt());
+    title = QUrl::fromPercentEncoding(match.captured(3).toUtf8());
+    return true;
+}
+
+constexpr const char *const SETTINGS_GROUP = "RemoteEditDrafts";
+
+} // namespace
+
+RemoteEditDraftStore::~RemoteEditDraftStore() = default;
+
+// ---------------------------------------------------------------------------
+
+RemoteEditFileDraftStore::RemoteEditFileDraftStore(QString directory)
+    : m_directory(std::move(directory))
+{
+    QDir().mkpath(m_directory);
+}
+
+QString RemoteEditFileDraftStore::filePath(const QString &key) const
+{
+    if (key.isEmpty()) {
+        return QString();
+    }
+    return QDir(m_directory).absoluteFilePath(key);
+}
+
+QString RemoteEditFileDraftStore::create(const RemoteSessionId sessionId,
+                                         const QString &title,
+                                         const QString &content)
+{
+    QString fileName = encodeFileName(sessionId, title);
+    if (QFile::exists(filePath(fileName))) {
+        fileName = fileName.chopped(4) + "_" + mmqt::toQStringLatin1(getRandomString(5)) + ".txt";
+    }
+
+    QFile file(filePath(fileName));
+    if (!file.open(QFile::WriteOnly | QFile::Text)) {
+        qWarning() << "Unable to create draft" << file.fileName();
+        return QString();
+    }
+    file.write(mmqt::toQByteArrayLatin1(content)); // MPI is always Latin1
+    file.flush();
+    std::ignore = io::fsyncNoexcept(file);
+    return fileName;
+}
+
+bool RemoteEditFileDraftStore::save(const QString &key, const QString &content)
+{
+    if (key.isEmpty() || !QFile::exists(filePath(key))) {
+        return false;
+    }
+    QSaveFile file(filePath(key));
+    if (!file.open(QFile::WriteOnly | QFile::Text)) {
+        return false;
+    }
+    file.write(mmqt::toQByteArrayLatin1(content));
+    return file.commit();
+}
+
+QString RemoteEditFileDraftStore::read(const QString &key) const
+{
+    if (QFile file(filePath(key)); file.open(QFile::ReadOnly)) {
+        return QString::fromLatin1(file.readAll());
+    }
+    qWarning() << "Unable to read draft" << filePath(key);
+    return QString();
+}
+
+void RemoteEditFileDraftStore::remove(const QString &key)
+{
+    if (key.isEmpty()) {
+        return;
+    }
+    if (!QFile::remove(filePath(key))) {
+        qWarning() << "Unable to remove draft" << filePath(key);
+    }
+}
+
+QList<RemoteEditDraftInfo> RemoteEditFileDraftStore::list() const
+{
+    QList<RemoteEditDraftInfo> drafts;
+    const QDir dir(m_directory);
+    for (const QString &fileName : dir.entryList({"draft_*.txt"}, QDir::Files)) {
+        RemoteSessionId sessionId;
+        QString title;
+        if (decodeFileName(fileName, sessionId, title)) {
+            drafts.append({fileName, title, sessionId, QFileInfo(dir, fileName).lastModified()});
+        }
+    }
+    return drafts;
+}
+
+// ---------------------------------------------------------------------------
+
+RemoteEditSettingsDraftStore::RemoteEditSettingsDraftStore(SettingsFactory makeSettings)
+    : m_makeSettings(std::move(makeSettings))
+{}
+
+QString RemoteEditSettingsDraftStore::create(const RemoteSessionId sessionId,
+                                             const QString &title,
+                                             const QString &content)
+{
+    const QString key = makeKeyStem(sessionId) + "_" + mmqt::toQStringLatin1(getRandomString(5));
+    auto settings = m_makeSettings();
+    settings->beginGroup(SETTINGS_GROUP);
+    settings->beginGroup(key);
+    settings->setValue("sessionId", sessionId.asInt32());
+    settings->setValue("title", title);
+    settings->setValue("content", content);
+    settings->setValue("lastModified", QDateTime::currentDateTime());
+    settings->endGroup();
+    settings->endGroup();
+    settings->sync();
+    return key;
+}
+
+bool RemoteEditSettingsDraftStore::save(const QString &key, const QString &content)
+{
+    auto settings = m_makeSettings();
+    settings->beginGroup(SETTINGS_GROUP);
+    settings->beginGroup(key);
+    if (!settings->contains("title")) {
+        return false;
+    }
+    settings->setValue("content", content);
+    settings->setValue("lastModified", QDateTime::currentDateTime());
+    settings->endGroup();
+    settings->endGroup();
+    settings->sync();
+    return settings->status() == QSettings::NoError;
+}
+
+QString RemoteEditSettingsDraftStore::read(const QString &key) const
+{
+    auto settings = m_makeSettings();
+    return settings->value(QString("%1/%2/content").arg(SETTINGS_GROUP, key)).toString();
+}
+
+void RemoteEditSettingsDraftStore::remove(const QString &key)
+{
+    if (key.isEmpty()) {
+        return;
+    }
+    auto settings = m_makeSettings();
+    settings->beginGroup(SETTINGS_GROUP);
+    settings->remove(key);
+    settings->endGroup();
+    settings->sync();
+}
+
+QList<RemoteEditDraftInfo> RemoteEditSettingsDraftStore::list() const
+{
+    QList<RemoteEditDraftInfo> drafts;
+    auto settings = m_makeSettings();
+    settings->beginGroup(SETTINGS_GROUP);
+    for (const QString &key : settings->childGroups()) {
+        settings->beginGroup(key);
+        drafts.append({key,
+                       settings->value("title").toString(),
+                       RemoteSessionId(settings->value("sessionId").toInt()),
+                       settings->value("lastModified").toDateTime()});
+        settings->endGroup();
+    }
+    settings->endGroup();
+    return drafts;
+}
diff --git a/src/mpi/RemoteEditDraftStore.h b/src/mpi/RemoteEditDraftStore.h
new file mode 100644
index 000000000..d8638896f
--- /dev/null
+++ b/src/mpi/RemoteEditDraftStore.h
@@ -0,0 +1,74 @@
+#pragma once
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "../global/macros.h"
+#include "remoteeditsession.h"
+
+#include <functional>
+#include <memory>
+
+#include <QList>
+#include <QSettings>
+#include <QString>
+
+/// Where unsent drafts live between (and across) sessions. A draft is
+/// addressed by an opaque key handed out by create().
+class NODISCARD RemoteEditDraftStore
+{
+public:
+    virtual ~RemoteEditDraftStore();
+
+    NODISCARD virtual QString create(RemoteSessionId sessionId,
+                                     const QString &title,
+                                     const QString &content)
+        = 0;
+    NODISCARD virtual bool save(const QString &key, const QString &content) = 0;
+    NODISCARD virtual QString read(const QString &key) const = 0;
+    virtual void remove(const QString &key) = 0;
+    NODISCARD virtual QList<RemoteEditDraftInfo> list() const = 0;
+    /// Absolute path of the draft, if this store keeps drafts as files that
+    /// an external editor can open; empty otherwise.
+    NODISCARD virtual QString filePath(const QString & /*key*/) const { return QString(); }
+};
+
+/// One file per draft under `directory`; the key is the file name.
+class NODISCARD RemoteEditFileDraftStore final : public RemoteEditDraftStore
+{
+private:
+    const QString m_directory;
+
+public:
+    explicit RemoteEditFileDraftStore(QString directory);
+
+    NODISCARD QString create(RemoteSessionId sessionId,
+                             const QString &title,
+                             const QString &content) override;
+    NODISCARD bool save(const QString &key, const QString &content) override;
+    NODISCARD QString read(const QString &key) const override;
+    void remove(const QString &key) override;
+    NODISCARD QList<RemoteEditDraftInfo> list() const override;
+    NODISCARD QString filePath(const QString &key) const override;
+};
+
+/// One QSettings group per draft. On WebAssembly Qt persists QSettings to
+/// browser storage, which is what makes drafts survive a page reload there.
+class NODISCARD RemoteEditSettingsDraftStore final : public RemoteEditDraftStore
+{
+public:
+    using SettingsFactory = std::function<std::unique_ptr<QSettings>()>;
+
+private:
+    const SettingsFactory m_makeSettings;
+
+public:
+    explicit RemoteEditSettingsDraftStore(SettingsFactory makeSettings);
+
+    NODISCARD QString create(RemoteSessionId sessionId,
+                             const QString &title,
+                             const QString &content) override;
+    NODISCARD bool save(const QString &key, const QString &content) override;
+    NODISCARD QString read(const QString &key) const override;
+    void remove(const QString &key) override;
+    NODISCARD QList<RemoteEditDraftInfo> list() const override;
+};
diff --git a/src/mpi/RemoteEditPanel.cpp b/src/mpi/RemoteEditPanel.cpp
new file mode 100644
index 000000000..e12c702ea
--- /dev/null
+++ b/src/mpi/RemoteEditPanel.cpp
@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "RemoteEditPanel.h"
+
+#include "../global/utils.h"
+#include "remoteedit.h"
+#include "remoteeditsession.h"
+#include "remoteeditwidget.h"
+
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QPushButton>
+#include <QStackedLayout>
+#include <QTabBar>
+#include <QTabWidget>
+#include <QVBoxLayout>
+
+RemoteEditPanel::RemoteEditPanel(RemoteEdit &remoteEdit, QWidget *const parent)
+    : QWidget(parent)
+    , m_remoteEdit(remoteEdit)
+{
+    auto *const outer = new QVBoxLayout(this);
+    outer->setContentsMargins(0, 0, 0, 0);
+    outer->setSpacing(0);
+
+    m_list = new QWidget(this);
+    m_listLayout = new QVBoxLayout(m_list);
+    m_listLayout->setContentsMargins(8, 4, 8, 4);
+    m_listLayout->setSpacing(2);
+    outer->addWidget(m_list, 0);
+
+    auto *const stackHost = new QWidget(this);
+    outer->addWidget(stackHost, 1);
+    m_stack = new QStackedLayout(stackHost);
+    m_stack->setContentsMargins(0, 0, 0, 0);
+
+    m_placeholder = new QLabel(tr("No remote edits are open.\n"
+                                  "MUME will open pages here when you edit or view text."),
+                               stackHost);
+    m_placeholder->setAlignment(Qt::AlignCenter);
+    m_placeholder->setWordWrap(true);
+    m_placeholder->setEnabled(false);
+    m_stack->addWidget(m_placeholder);
+
+    m_tabs = new QTabWidget(stackHost);
+    m_tabs->setTabsClosable(true);
+    m_tabs->setMovable(true);
+    m_tabs->setDocumentMode(true);
+    m_tabs->setElideMode(Qt::ElideRight);
+    m_tabs->tabBar()->setExpanding(false);
+    m_stack->addWidget(m_tabs);
+
+    connect(m_tabs, &QTabWidget::tabCloseRequested, this, [this](const int index) {
+        checked_dynamic_downcast<RemoteEditWidget *>(m_tabs->widget(index))->requestClose();
+    });
+    // QTabWidget drops a tab on its own when the page widget is destroyed;
+    // this keeps the placeholder in sync with that.
+    connect(m_tabs, &QTabWidget::currentChanged, this, [this]() { updatePlaceholder(); });
+
+    connect(&m_remoteEdit, &RemoteEdit::sig_sessionsChanged, this, &RemoteEditPanel::syncTabs);
+    connect(&m_remoteEdit, &RemoteEdit::sig_draftsChanged, this, &RemoteEditPanel::rebuildList);
+
+    syncTabs();
+}
+
+void RemoteEditPanel::rebuildList()
+{
+    while (QLayoutItem *const item = m_listLayout->takeAt(0)) {
+        delete item->widget();
+        delete item;
+    }
+
+    using Button = std::pair<QString, std::function<void()>>;
+    const auto addRow = [this](const QString &text, const std::vector<Button> &buttons) {
+        auto *const row = new QWidget(m_list);
+        auto *const layout = new QHBoxLayout(row);
+        layout->setContentsMargins(0, 0, 0, 0);
+        auto *const label = new QLabel(text, row);
+        label->setTextFormat(Qt::PlainText);
+        layout->addWidget(label, 1);
+        for (const auto &[caption, onClick] : buttons) {
+            auto *const button = new QPushButton(caption, row);
+            button->setAutoDefault(false);
+            connect(button, &QPushButton::clicked, this, onClick);
+            layout->addWidget(button, 0);
+        }
+        m_listLayout->addWidget(row);
+    };
+
+    for (const auto &[id, session] : m_remoteEdit.getSessions()) {
+        if (session->getWidget() != nullptr) {
+            continue;
+        }
+        const RemoteInternalId internalId = id;
+        addRow(tr("%1 -- open in %2 editor%3")
+                   .arg(session->getTitle(),
+                        QString::fromLatin1(session->getEditorTypeName()).toLower(),
+                        session->isConnected() ? QString() : tr(" (disconnected)")),
+               {{tr("Cancel"), [this, internalId]() {
+                     const auto &sessions = m_remoteEdit.getSessions();
+                     if (const auto it = sessions.find(internalId); it != sessions.end()) {
+                         m_remoteEdit.cancelEdit(it->second.get());
+                     }
+                 }}});
+    }
+
+    for (const auto &draft : m_remoteEdit.pendingDrafts()) {
+        addRow(tr("Unsent draft: %1 (%2)").arg(draft.title, draft.lastModified.toString()),
+               {{tr("View"), [this, draft]() { m_remoteEdit.viewDraft(draft); }},
+                {tr("Discard"), [this, draft]() { m_remoteEdit.discardDraft(draft); }}});
+    }
+
+    m_list->setVisible(m_listLayout->count() > 0);
+}
+
+RemoteEditPanel::~RemoteEditPanel() = default;
+
+QSize RemoteEditPanel::sizeHint() const
+{
+    return QSize{640, 480};
+}
+
+void RemoteEditPanel::syncTabs()
+{
+    for (const auto &[id, session] : m_remoteEdit.getSessions()) {
+        if (auto *const widget = session->getWidget();
+            widget != nullptr && m_tabs->indexOf(widget) < 0) {
+            addPage(widget);
+        }
+    }
+    rebuildList();
+    updatePlaceholder();
+}
+
+void RemoteEditPanel::addPage(RemoteEditWidget *const widget)
+{
+    const int index = m_tabs->addTab(widget, widget->getTitle());
+    m_tabs->setTabToolTip(index,
+                          widget->isDraftView()     ? tr("Recovered draft")
+                          : widget->isEditSession() ? tr("Editing")
+                                                    : tr("Viewing"));
+    updateTabLabel(widget);
+
+    connect(widget, &RemoteEditWidget::sig_focusRequested, this, [this, widget]() {
+        m_tabs->setCurrentWidget(widget);
+        emit sig_showRequested();
+        widget->setFocus(Qt::OtherFocusReason);
+    });
+    connect(widget, &RemoteEditWidget::sig_textModified, this, [this, widget]() {
+        updateTabLabel(widget);
+    });
+
+    m_tabs->setCurrentWidget(widget);
+    emit sig_showRequested();
+    widget->setFocus(Qt::OtherFocusReason);
+}
+
+void RemoteEditPanel::updateTabLabel(RemoteEditWidget *const widget)
+{
+    const int index = m_tabs->indexOf(widget);
+    if (index < 0) {
+        return;
+    }
+    QString label = widget->getTitle();
+    if (widget->isDraftView()) {
+        label = tr("[draft] %1").arg(label);
+    } else if (!widget->isEditSession()) {
+        label = tr("[view] %1").arg(label);
+    } else if (widget->isModified()) {
+        label += "*";
+    }
+    m_tabs->setTabText(index, label);
+}
+
+void RemoteEditPanel::updatePlaceholder()
+{
+    m_stack->setCurrentWidget(m_tabs->count() == 0 ? static_cast<QWidget *>(m_placeholder)
+                                                   : static_cast<QWidget *>(m_tabs));
+}
diff --git a/src/mpi/RemoteEditPanel.h b/src/mpi/RemoteEditPanel.h
new file mode 100644
index 000000000..4952a28ef
--- /dev/null
+++ b/src/mpi/RemoteEditPanel.h
@@ -0,0 +1,49 @@
+#pragma once
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "../global/macros.h"
+
+#include <QWidget>
+
+class QLabel;
+class QStackedLayout;
+class QTabWidget;
+class QVBoxLayout;
+class RemoteEdit;
+class RemoteEditWidget;
+
+/// Hosts every open internal editor/viewer as a tab, and above the tabs
+/// lists what has no page of its own: edits open in an external editor and
+/// unsent drafts on disk. Tabs track RemoteEdit::getSessions(): a session's
+/// page is added when the session appears and vanishes when the session
+/// deletes it.
+class NODISCARD_QOBJECT RemoteEditPanel final : public QWidget
+{
+    Q_OBJECT
+
+private:
+    RemoteEdit &m_remoteEdit;
+    QWidget *m_list = nullptr;
+    QVBoxLayout *m_listLayout = nullptr;
+    QStackedLayout *m_stack = nullptr;
+    QLabel *m_placeholder = nullptr;
+    QTabWidget *m_tabs = nullptr;
+
+public:
+    explicit RemoteEditPanel(RemoteEdit &remoteEdit, QWidget *parent);
+    ~RemoteEditPanel() final;
+
+    NODISCARD QSize sizeHint() const override;
+
+signals:
+    /// A page was added or asked to be focused; the hosting dock should show itself.
+    void sig_showRequested();
+
+private:
+    void syncTabs();
+    void rebuildList();
+    void addPage(RemoteEditWidget *widget);
+    void updateTabLabel(RemoteEditWidget *widget);
+    void updatePlaceholder();
+};
diff --git a/src/mpi/mpifilter.cpp b/src/mpi/mpifilter.cpp
deleted file mode 100644
index f01fbc092..000000000
--- a/src/mpi/mpifilter.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-// Copyright (C) 2019 The MMapper Authors
-// Author: Nils Schimmelmann <nschimme@gmail.com> (Jahara)
-
-#include "mpifilter.h"
-
-#include "../configuration/configuration.h"
-#include "../proxy/GmcpMessage.h"
-#include "../proxy/telnetfilter.h"
-
-#include <QByteArray>
-#include <QMessageLogContext>
-#include <QObject>
-#include <QString>
-
-namespace { // anonymous
-volatile const bool verbose_debugging = false;
-} // namespace
-
-MpiFilterOutputs::~MpiFilterOutputs() = default;
-
-void MpiFilter::receiveMpiView(const QString &title, const QString body)
-{
-    m_outputs.onViewMessage(title, body);
-}
-
-void MpiFilter::receiveMpiEdit(const RemoteSessionId id, const QString &title, const QString body)
-{
-    m_outputs.onEditMessage(id, title, body);
-}
-
-MpiFilterToMud::~MpiFilterToMud() = default;
-
-void MpiFilterToMud::sendRemoteEditMessage(GmcpMessageTypeEnum type,
-                                           const RemoteSessionId id,
-                                           const QString &text = QString())
-{
-    QJsonObject obj;
-    if (!text.isNull()) {
-        // TODO: add + QString("\u0100") to test failure
-        obj["text"] = text;
-    }
-    obj["id"] = id.asInt32();
-    QJsonDocument doc;
-    doc.setObject(obj);
-    GmcpJson json{QString::fromUtf8(doc.toJson())};
-    GmcpMessage msg{type, json};
-    if (verbose_debugging) {
-        qInfo() << msg.toRawBytes();
-    }
-    virt_submitGmcp(msg);
-}
-
-void MpiFilterToMud::cancelRemoteEdit(const RemoteSessionId id)
-{
-    sendRemoteEditMessage(GmcpMessageTypeEnum::MUME_CLIENT_CANCEL_EDIT, id);
-}
-
-void MpiFilterToMud::saveRemoteEdit(const RemoteSessionId id, const Latin1Bytes &content)
-{
-    auto payload = content.getQByteArray();
-    QString text = QString::fromLatin1(payload);
-    sendRemoteEditMessage(GmcpMessageTypeEnum::MUME_CLIENT_WRITE, id, text);
-}
-
-void MpiFilterToMud::submitGmcp(const GmcpMessage &gmcpMessage)
-{
-    virt_submitGmcp(gmcpMessage);
-}
diff --git a/src/mpi/mpifilter.h b/src/mpi/mpifilter.h
deleted file mode 100644
index ee86003ec..000000000
--- a/src/mpi/mpifilter.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-// SPDX-License-Identifier: GPL-2.0-or-later
-// Copyright (C) 2019 The MMapper Authors
-// Author: Nils Schimmelmann <nschimme@gmail.com> (Jahara)
-
-#include "../global/Consts.h"
-#include "../global/Signal2.h"
-#include "../mpi/remoteeditsession.h"
-#include "../proxy/GmcpMessage.h"
-#include "../proxy/telnetfilter.h"
-
-#include <QByteArray>
-#include <QObject>
-#include <QString>
-#include <QtCore>
-
-struct NODISCARD MpiFilterOutputs
-{
-public:
-    virtual ~MpiFilterOutputs();
-
-public:
-    void onParseNewMudInput(const TelnetData &data) { virt_onParseNewMudInput(data); }
-    void onEditMessage(const RemoteSessionId id, const QString &title, const QString &body)
-    {
-        virt_onEditMessage(id, title, body);
-    }
-    void onViewMessage(const QString &title, const QString &body)
-    {
-        virt_onViewMessage(title, body);
-    }
-
-private:
-    virtual void virt_onParseNewMudInput(const TelnetData &) = 0;
-    virtual void virt_onEditMessage(const RemoteSessionId, const QString &, const QString &) = 0;
-    virtual void virt_onViewMessage(const QString &, const QString &) = 0;
-};
-
-// from Mud
-class NODISCARD MpiFilter final
-{
-private:
-    MpiFilterOutputs &m_outputs;
-
-public:
-    explicit MpiFilter(MpiFilterOutputs &outputs)
-        : m_outputs{outputs}
-    {}
-
-private:
-    void parseMessage(char command, const RawBytes &buffer);
-    void parseEditMessage(const RawBytes &buffer);
-    void parseViewMessage(const RawBytes &buffer);
-
-public:
-    void receiveMpiView(const QString &title, const QString body);
-    void receiveMpiEdit(const RemoteSessionId id, const QString &title, const QString body);
-};
-
-// toMud
-class NODISCARD MpiFilterToMud
-{
-public:
-    MpiFilterToMud() = default;
-    virtual ~MpiFilterToMud();
-
-public:
-    void cancelRemoteEdit(const RemoteSessionId id);
-    void saveRemoteEdit(const RemoteSessionId id, const Latin1Bytes &content);
-
-private:
-    void sendRemoteEditMessage(GmcpMessageTypeEnum type,
-                               const RemoteSessionId id,
-                               const QString &text);
-    void submitGmcp(const GmcpMessage &gmcpMessage);
-    virtual void virt_submitGmcp(const GmcpMessage &gmcpMessage) = 0;
-};
diff --git a/src/mpi/remoteedit.cpp b/src/mpi/remoteedit.cpp
index 2c7b5e85c..3469c1ef1 100644
--- a/src/mpi/remoteedit.cpp
+++ b/src/mpi/remoteedit.cpp
@@ -5,27 +5,86 @@
 #include "remoteedit.h"
 
 #include "../configuration/configuration.h"
-#include "../global/Consts.h"
+#include "../global/AnsiOstream.h"
+#include "../global/AnsiTextUtils.h"
+#include "../global/SendToUser.h"
 #include "../global/window_utils.h"
+#include "../proxy/TaggedBytes.h"
 #include "remoteeditsession.h"
 
 #include <cassert>
 #include <memory>
 #include <utility>
 
-#include <QClipboard>
-#include <QFileDialog>
+#include <QDateTime>
 #include <QGuiApplication>
 #include <QMessageBox>
 #include <QMessageLogContext>
+#include <QPushButton>
 #include <QString>
 
-using char_consts::C_NEWLINE;
+namespace { // anonymous
+
+const volatile bool g_prefixMessagesToUser = true;
+constexpr const auto whiteOnCyan = getRawAnsi(AnsiColor16Enum::white, AnsiColor16Enum::cyan);
+void notifyUserOfNewSession(const std::string_view article,
+                            const std::string_view what,
+                            const QString &title)
+{
+    global::sendToUser([&article, &what, &title](AnsiOstream &aos) {
+        const auto color = whiteOnCyan;
+        if (g_prefixMessagesToUser) {
+            aos.writeWithColor(color.withBold(), "Info");
+            aos.writeWithColor(color, ": ");
+        }
+        aos.writeWithColor(color, "MMapper is opening ");
+        aos.writeWithColor(color, article);
+        aos.writeWithColor(color, " ");
+        aos.writeWithColor(color.withBold(), what);
+        aos.writeWithColor(color, " window with title \"");
+        aos.writeWithColor(color.withBold(), mmqt::toStdStringUtf8(title));
+        aos.writeWithColor(color, "\"");
+        aos.write("\n");
+    });
+}
+
+void notifyUserOfSubmissionFailure(const QString &title, const QString &errorMsg)
+{
+    global::sendToUser([&title, &errorMsg](AnsiOstream &aos) {
+        const auto color = whiteOnCyan;
+        if (g_prefixMessagesToUser) {
+            aos.writeWithColor(color.withBold(), "Info");
+            aos.writeWithColor(color, ": ");
+        }
+        aos.writeWithColor(color, "Submission of \"");
+        aos.writeWithColor(color.withBold(), mmqt::toStdStringUtf8(title));
+        aos.writeWithColor(color, "\" to MUME failed: ");
+        aos.writeWithColor(color.withBold(), mmqt::toStdStringUtf8(errorMsg));
+        aos.writeWithColor(color,
+                           ". It was kept as an unsent draft (Sidepanels > Remote Edits Panel).");
+        aos.write("\n");
+    });
+}
+
+NODISCARD std::unique_ptr<RemoteEditDraftStore> makeDraftStore()
+{
+#ifdef Q_OS_WASM
+    return std::make_unique<RemoteEditSettingsDraftStore>(&makeAppSettings);
+#else
+    return std::make_unique<RemoteEditFileDraftStore>(
+        getConfig().mumeClientProtocol.editorDirectory);
+#endif
+}
+
+} // namespace
 
 RemoteEdit::RemoteEdit(QObject *const parent)
     : QObject(parent)
+    , m_store(makeDraftStore())
 {}
 
+RemoteEdit::~RemoteEdit() = default;
+
 void RemoteEdit::slot_remoteView(const QString &title, const QString &body)
 {
     addSession(REMOTE_VIEW_SESSION_ID, title, body);
@@ -41,15 +100,70 @@ void RemoteEdit::slot_remoteEdit(const RemoteSessionId sessionId,
 void RemoteEdit::addSession(const RemoteSessionId sessionId,
                             const QString &title,
                             const QString &body)
+{
+    const bool isEdit = (sessionId != REMOTE_VIEW_SESSION_ID);
+    if (isEdit) {
+        notifyUserOfNewSession("an", "Editor", title);
+    } else {
+        notifyUserOfNewSession("a", "Viewer", title);
+    }
+
+    const auto offeredDraft = isEdit ? findPendingDraft(title) : std::nullopt;
+
+#ifndef Q_OS_WASM
+    if (offeredDraft && !getConfig().mumeClientProtocol.internalRemoteEditor) {
+        // An external editor can't show a restore banner, so ask before
+        // launching it, and seed its file with whichever text was chosen.
+        auto *const dlg = new QMessageBox(
+            QMessageBox::Question,
+            tr("Recovered draft"),
+            tr("An unsent draft of \"%1\" from %2 was recovered.\n\n"
+               "Start the editor from the recovered draft, or from the text MUME just sent?")
+                .arg(title, offeredDraft->lastModified.toString()),
+            QMessageBox::NoButton,
+            nullptr);
+        dlg->setAttribute(Qt::WA_DeleteOnClose);
+        QPushButton *const useDraft = dlg->addButton(tr("Recovered draft"), QMessageBox::AcceptRole);
+        dlg->addButton(tr("Text from MUME"), QMessageBox::RejectRole);
+        dlg->setDefaultButton(useDraft);
+        const DraftInfo draft = *offeredDraft;
+        connect(dlg,
+                &QMessageBox::finished,
+                this,
+                [this, dlg, useDraft, sessionId, title, body, draft]() {
+                    if (dlg->clickedButton() == static_cast<QAbstractButton *>(useDraft)) {
+                        createSession(sessionId, title, readDraft(draft.key), std::nullopt);
+                        deleteDraft(draft.key);
+                    } else {
+                        createSession(sessionId, title, body, std::nullopt);
+                    }
+                });
+        dlg->open();
+        return;
+    }
+#endif
+
+    createSession(sessionId, title, body, offeredDraft);
+}
+
+void RemoteEdit::createSession(const RemoteSessionId sessionId,
+                               const QString &title,
+                               const QString &body,
+                               const std::optional<DraftInfo> &offeredDraft)
 {
     const auto internalId = RemoteInternalId{getInternalIdCount()};
+    const bool isEdit = (sessionId != REMOTE_VIEW_SESSION_ID);
     std::unique_ptr<RemoteEditSession> session;
 
+    const QString draftKey = isEdit ? deref(m_store).create(sessionId, title, body) : QString();
+
     if (getConfig().mumeClientProtocol.internalRemoteEditor) {
         session = std::make_unique<RemoteEditInternalSession>(internalId,
                                                               sessionId,
                                                               title,
                                                               body,
+                                                              draftKey,
+                                                              /*draftView=*/false,
                                                               this);
     } else {
 #ifndef Q_OS_WASM
@@ -57,6 +171,7 @@ void RemoteEdit::addSession(const RemoteSessionId sessionId,
                                                               sessionId,
                                                               title,
                                                               body,
+                                                              draftKey,
                                                               this);
 #else
         mmqt::showInformation(nullptr,
@@ -65,9 +180,18 @@ void RemoteEdit::addSession(const RemoteSessionId sessionId,
         return;
 #endif
     }
+
+    if (offeredDraft) {
+        session->offerDraft(*offeredDraft);
+    }
+
     m_sessions.insert(std::make_pair(internalId, std::move(session)));
 
     m_greatestUsedId = internalId.asUint32(); // Increment internalId counter
+    emit sig_sessionsChanged();
+    if (isEdit) {
+        emit sig_draftsChanged();
+    }
 }
 
 void RemoteEdit::removeSession(const RemoteEditSession &session)
@@ -77,29 +201,57 @@ void RemoteEdit::removeSession(const RemoteEditSession &session)
     if (search != m_sessions.end()) {
         qDebug() << "Destroying RemoteEditSession" << internalId.asUint32();
         m_sessions.erase(search);
-
+        emit sig_sessionsChanged();
     } else {
         qWarning() << "Unable to find" << internalId.asUint32() << "session to erase";
     }
 }
 
-void RemoteEdit::cancel(const RemoteEditSession *const pSession)
+void RemoteEdit::cancelEdit(RemoteEditSession *const pSession)
 {
     auto &session = deref(pSession);
 
-    if (session.isEditSession() && session.isConnected()) {
+    // Only a connected live edit is truly abandoned here (MUME is told to
+    // cancel, so the draft is deleted). A disconnected edit or a recovery
+    // window closed the same way keeps its draft on disk for later recovery.
+    if (session.isEditSession() && session.isConnected() && !session.isDraftView()) {
         qDebug() << "Cancelling session" << session.getSessionId().asInt32();
-        emit sig_remoteEditCancel(session.getSessionId());
+
+        QJsonObject obj;
+        obj["id"] = session.getSessionId().asInt32();
+        QJsonDocument doc;
+        doc.setObject(obj);
+        GmcpJson json{QString::fromUtf8(doc.toJson())};
+        GmcpMessage msg{GmcpMessageTypeEnum::MUME_CLIENT_CANCEL_EDIT, json};
+        emit sig_sendGmcp(msg);
+        deleteDraft(session.getDraftKey());
+    } else {
+        session.flushDraft();
     }
+    removeSession(session);
+}
 
+void RemoteEdit::discardDraft(const RemoteEditSession *const pSession)
+{
+    auto &session = deref(pSession);
+    deleteDraft(session.getDraftKey());
     removeSession(session);
 }
 
+void RemoteEdit::discardDraft(const DraftInfo &draft)
+{
+    deleteDraft(draft.key);
+}
+
 void RemoteEdit::save(const RemoteEditSession *const pSession)
 {
     auto &session = deref(pSession);
     trySave(session);
-    removeSession(session);
+    // If connected, the session lives on (with no window backing it) until
+    // the MUME.Client.Write ack arrives; see slot_parseGmcpInput().
+    if (!session.isConnected()) {
+        removeSession(session);
+    }
 }
 
 void RemoteEdit::trySave(const RemoteEditSession &session)
@@ -130,33 +282,40 @@ void RemoteEdit::sendToMume(const RemoteEditSession &session)
     // (e.g. unicode transliteration, etc).
     auto latin1 = Latin1Bytes{
         mmqt::toQByteArrayLatin1(session.getContent())}; // MPI is always Latin1
-    emit sig_remoteEditSave(session.getSessionId(), latin1);
+
+    QJsonObject obj;
+    obj["text"] = QString::fromLatin1(latin1.getQByteArray());
+    obj["id"] = session.getSessionId().asInt32();
+    QJsonDocument doc;
+    doc.setObject(obj);
+    GmcpJson json{QString::fromUtf8(doc.toJson())};
+    GmcpMessage msg{GmcpMessageTypeEnum::MUME_CLIENT_WRITE, json};
+
+    emit sig_sendGmcp(msg);
+
+    // FR-4.4: Upon confirmed delivery success, delete local temporary file and unregister task.
+    // Deletion is now handled in slot_parseGmcpInput for MUME_CLIENT_WRITE.
 }
 
 void RemoteEdit::trySaveLocally(const RemoteEditSession &session)
 {
-    if (!session.isEditSession()) {
-        assert(false);
-    }
-
-    auto *dlg = new QMessageBox(
-        QMessageBox::Critical,
-        "MUME Disconnected",
-        "The connection to MUME was lost. Your unsaved changes will be lost unless you save the file locally now.",
-        QMessageBox::StandardButtons{QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel},
-        nullptr);
-    dlg->setAttribute(Qt::WA_DeleteOnClose);
-    const auto id = session.getInternalId().asUint32();
-    const auto body = session.getContent().toUtf8();
-    connect(dlg, &QMessageBox::finished, this, [id, body](int result) {
-        if (result == QMessageBox::Save) {
-            qDebug() << "Session" << id << "was saved";
-            QFileDialog::saveFileContent(body, QString("MMapper-Edit-%1.txt").arg(id));
+    // The draft on disk already holds the latest content (auto-save for the
+    // internal editor; the editor's own save for an external one).
+    qWarning() << "Session" << session.getInternalId().asUint32()
+               << "submitted while disconnected - draft preserved";
+    global::sendToUser([&session](AnsiOstream &aos) {
+        const auto color = whiteOnCyan;
+        if (g_prefixMessagesToUser) {
+            aos.writeWithColor(color.withBold(), "Info");
+            aos.writeWithColor(color, ": ");
         }
+        aos.writeWithColor(color, "Not connected to MUME; \"");
+        aos.writeWithColor(color.withBold(), mmqt::toStdStringUtf8(session.getTitle()));
+        aos.writeWithColor(color,
+                           "\" was kept as an unsent draft. Re-run the edit command once "
+                           "reconnected to restore it.");
+        aos.write("\n");
     });
-    dlg->open();
-    QGuiApplication::clipboard()->setText(body);
-    qWarning() << "Session" << id << "was copied to the clipboard";
 }
 
 void RemoteEdit::onDisconnected()
@@ -164,9 +323,317 @@ void RemoteEdit::onDisconnected()
     for (const auto &pair : m_sessions) {
         const auto &id = pair.first;
         const auto &session = pair.second;
-        if (session->isEditSession()) {
+        if (session->isEditSession() && session->isConnected()) {
             qWarning() << "Session" << id.asUint32() << "marked as disconnected";
             session->setDisconnected();
         }
     }
 }
+
+void RemoteEdit::slot_parseGmcpInput(const GmcpMessage &msg)
+{
+    if (msg.isMumeClientEdit()) {
+        auto doc = msg.getJsonDocument();
+        if (!doc)
+            return;
+        auto optObj = doc->getObject();
+        if (!optObj)
+            return;
+        auto &obj = *optObj;
+        auto optId = obj.getInt("id");
+        auto optTitle = obj.getString("title");
+        auto optBody = obj.getString("text");
+        if (optId && optTitle && optBody) {
+            slot_remoteEdit(RemoteSessionId(*optId), *optTitle, *optBody);
+        }
+    } else if (msg.isMumeClientView()) {
+        auto doc = msg.getJsonDocument();
+        if (!doc)
+            return;
+        auto optObj = doc->getObject();
+        if (!optObj)
+            return;
+        auto &obj = *optObj;
+        auto optTitle = obj.getString("title");
+        auto optBody = obj.getString("text");
+        if (optTitle && optBody) {
+            slot_remoteView(*optTitle, *optBody);
+        }
+    } else if (msg.isMumeClientWrite()) {
+        auto doc = msg.getJsonDocument();
+        if (!doc)
+            return;
+        auto optObj = doc->getObject();
+        if (!optObj)
+            return;
+        auto &obj = *optObj;
+        auto optId = obj.getInt("id");
+        auto optResult = obj.getBool("result");
+        auto optResultMsg = obj.getString("result");
+        if (optId) {
+            const auto sessionId = RemoteSessionId(*optId);
+            for (auto it = m_sessions.begin(); it != m_sessions.end(); ++it) {
+                // A recovered draft's session id belongs to a dead MUME session and
+                // can never legitimately receive this ack.
+                if (it->second->isDraftView() || it->second->getSessionId() != sessionId) {
+                    continue;
+                }
+                if (optResult && *optResult) {
+                    qDebug() << "MUME.Client.Write success for session" << optId.value();
+                    deleteDraft(it->second->getDraftKey());
+                } else {
+                    const QString errorMsg = optResultMsg.value_or("unknown error");
+                    qWarning() << "MUME.Client.Write failed for session" << optId.value() << ":"
+                               << errorMsg;
+                    notifyUserOfSubmissionFailure(it->second->getTitle(), errorMsg);
+                    // Draft is kept so it can be restored by re-running the edit command.
+                }
+                removeSession(*(it->second));
+                break;
+            }
+        }
+    } else if (msg.isMumeClientCancelEdit()) {
+        auto doc = msg.getJsonDocument();
+        if (!doc)
+            return;
+        auto optObj = doc->getObject();
+        if (!optObj)
+            return;
+        auto &obj = *optObj;
+        auto optId = obj.getInt("id");
+        auto optResult = obj.getBool("result");
+        if (optId) {
+            // The session is already gone by the time this ack arrives -- cancelEdit()
+            // removes it (and deletes its draft) synchronously when the user cancels.
+            // This is purely informational logging.
+            if (optResult && *optResult) {
+                qDebug() << "MUME.Client.CancelEdit success for session" << optId.value();
+            } else {
+                qWarning() << "MUME.Client.CancelEdit failed for session" << optId.value();
+            }
+        }
+    }
+}
+
+QList<RemoteEdit::DraftInfo> RemoteEdit::pendingDrafts() const
+{
+    QList<DraftInfo> pending;
+    for (const auto &draft : deref(m_store).list()) {
+        bool active = false;
+        for (const auto &pair : m_sessions) {
+            if (pair.second->getDraftKey() == draft.key) {
+                active = true;
+                break;
+            }
+        }
+        if (!active) {
+            pending.append(draft);
+        }
+    }
+    return pending;
+}
+
+std::optional<RemoteEdit::DraftInfo> RemoteEdit::findPendingDraft(const QString &title) const
+{
+    std::optional<DraftInfo> best;
+    for (const auto &draft : pendingDrafts()) {
+        if (draft.title == title && (!best || draft.lastModified > best->lastModified)) {
+            best = draft;
+        }
+    }
+    return best;
+}
+
+void RemoteEdit::announcePendingDrafts() const
+{
+    const auto drafts = pendingDrafts();
+    if (drafts.isEmpty()) {
+        return;
+    }
+    global::sendToUser([&drafts](AnsiOstream &aos) {
+        const auto color = whiteOnCyan;
+        if (g_prefixMessagesToUser) {
+            aos.writeWithColor(color.withBold(), "Info");
+            aos.writeWithColor(color, ": ");
+        }
+        aos.writeWithColor(color, "MMapper has ");
+        aos.writeWithColor(color.withBold(), std::to_string(drafts.size()));
+        aos.writeWithColor(color, drafts.size() == 1 ? " unsent draft" : " unsent drafts");
+        aos.writeWithColor(color,
+                           " from a previous session (Sidepanels > Remote Edits Panel, or _edits).");
+        aos.write("\n");
+    });
+}
+
+void RemoteEdit::viewDraft(const DraftInfo &draft)
+{
+    for (const auto &pair : m_sessions) {
+        if (pair.second->getDraftKey() == draft.key) {
+            pair.second->focus();
+            return;
+        }
+    }
+
+    const auto internalId = RemoteInternalId{getInternalIdCount()};
+    auto session = std::make_unique<RemoteEditInternalSession>(internalId,
+                                                               REMOTE_VIEW_SESSION_ID,
+                                                               draft.title,
+                                                               readDraft(draft.key),
+                                                               draft.key,
+                                                               /*draftView=*/true,
+                                                               this);
+    session->setDisconnected();
+
+    m_sessions.insert(std::make_pair(internalId, std::move(session)));
+    m_greatestUsedId = internalId.asUint32();
+    emit sig_sessionsChanged();
+}
+
+void RemoteEdit::shutdown()
+{
+    // Destroying each session synchronously closes its widget and (for a
+    // live external session) terminates the child process -- see
+    // ~RemoteEditExternalSession. No GMCP message is sent and no draft is
+    // deleted, so every open edit remains recoverable on next launch.
+    m_sessions.clear();
+}
+
+void RemoteEdit::reportStatus(AnsiOstream &aos) const
+{
+    aos.write("Remote edits:\n");
+    for (const auto &pair : m_sessions) {
+        std::ignore = reportStatus(aos, pair.first);
+    }
+    const auto pending = pendingDrafts();
+    for (const auto &draft : pending) {
+        aos.write("  (pending) ");
+        aos.write(mmqt::toStdStringUtf8(draft.title));
+        aos.write(" -- unsent draft, last modified ");
+        aos.write(mmqt::toStdStringUtf8(draft.lastModified.toString()));
+        aos.write("\n");
+    }
+    aos.write("Total: ");
+    aos.write(m_sessions.size());
+    aos.write(" open, ");
+    aos.write(static_cast<size_t>(pending.size()));
+    aos.write(" unsent draft(s).\n");
+}
+
+bool RemoteEdit::reportStatus(AnsiOstream &aos, const RemoteInternalId id) const
+{
+    const auto it = m_sessions.find(id);
+    if (it == m_sessions.end()) {
+        return false;
+    }
+    const auto &session = *it->second;
+
+    aos.write("  #");
+    aos.write(id.asUint32());
+    aos.write(" \"");
+    aos.write(mmqt::toStdStringUtf8(session.getTitle()));
+    aos.write("\" -- ");
+    if (session.isDraftView()) {
+        aos.write("viewing unsent draft (read-only)");
+    } else if (!session.isEditSession()) {
+        aos.write("viewing");
+    } else if (session.isConnected()) {
+        aos.write("editing (connected)");
+    } else {
+        aos.write("editing (disconnected -- draft preserved)");
+    }
+    aos.write("\n");
+    return true;
+}
+
+void RemoteEdit::deleteDraft(const QString &key)
+{
+    if (key.isEmpty()) {
+        return;
+    }
+    qInfo() << "Deleting draft" << key;
+    deref(m_store).remove(key);
+    emit sig_draftsChanged();
+}
+
+namespace remote_edit {
+
+namespace {
+RemoteEdit *g_instance = nullptr;
+} // namespace
+
+void setInstance(RemoteEdit *const instance)
+{
+    g_instance = instance;
+}
+
+void report_status(AnsiOstream &aos)
+{
+    if (g_instance == nullptr) {
+        aos.write("Error: RemoteEdit is not available.\n");
+        return;
+    }
+    g_instance->reportStatus(aos);
+}
+
+bool report_status(AnsiOstream &aos, const uint32_t id)
+{
+    if (g_instance == nullptr) {
+        aos.write("Error: RemoteEdit is not available.\n");
+        return false;
+    }
+    if (!g_instance->reportStatus(aos, RemoteInternalId{id})) {
+        aos.write("Error: Invalid remote edit id.\n");
+        return false;
+    }
+    return true;
+}
+
+bool cancel(const uint32_t id)
+{
+    if (g_instance == nullptr) {
+        return false;
+    }
+    const auto &sessions = g_instance->getSessions();
+    const auto it = sessions.find(RemoteInternalId{id});
+    if (it == sessions.end()) {
+        return false;
+    }
+    g_instance->cancelEdit(it->second.get());
+    return true;
+}
+
+bool discard(const uint32_t id)
+{
+    if (g_instance == nullptr) {
+        return false;
+    }
+    const auto &sessions = g_instance->getSessions();
+    const auto it = sessions.find(RemoteInternalId{id});
+    if (it == sessions.end()) {
+        return false;
+    }
+    // A live edit has no draft-only state to discard; route it through cancelEdit()
+    // (which also sends the GMCP cancel and deletes the draft) instead.
+    if (it->second->isDraftView()) {
+        g_instance->discardDraft(it->second.get());
+    } else {
+        g_instance->cancelEdit(it->second.get());
+    }
+    return true;
+}
+
+void simulate_edit(const QString &title)
+{
+    if (g_instance == nullptr) {
+        return;
+    }
+    // Large ids keep the fake session clear of anything MUME hands out.
+    static int32_t nextFakeId = 1000000;
+    g_instance->slot_remoteEdit(RemoteSessionId{nextFakeId++},
+                                title,
+                                QString(
+                                    "Simulated edit \"%1\".\nType here; nothing is sent to MUME.\n")
+                                    .arg(title));
+}
+
+} // namespace remote_edit
diff --git a/src/mpi/remoteedit.h b/src/mpi/remoteedit.h
index c0cceaa91..f8d12d835 100644
--- a/src/mpi/remoteedit.h
+++ b/src/mpi/remoteedit.h
@@ -4,12 +4,15 @@
 // Author: Nils Schimmelmann <nschimme@gmail.com> (Jahara)
 
 #include "../global/macros.h"
-#include "../proxy/TaggedBytes.h"
+#include "../global/utils.h"
+#include "../proxy/GmcpMessage.h"
+#include "RemoteEditDraftStore.h"
 #include "remoteeditsession.h"
 
 #include <climits>
 #include <map>
 #include <memory>
+#include <optional>
 
 #include <QByteArray>
 #include <QObject>
@@ -18,6 +21,7 @@
 #include <QtGlobal>
 
 class RemoteEditSession;
+class AnsiOstream;
 
 class NODISCARD_QOBJECT RemoteEdit final : public QObject
 {
@@ -26,19 +30,67 @@ class NODISCARD_QOBJECT RemoteEdit final : public QObject
 private:
     friend class RemoteEditSession;
 
+public:
+    using DraftInfo = RemoteEditDraftInfo;
+
 private:
+    std::unique_ptr<RemoteEditDraftStore> m_store;
     std::map<RemoteInternalId, std::unique_ptr<RemoteEditSession>> m_sessions;
     uint32_t m_greatestUsedId = 0;
 
 public:
     explicit RemoteEdit(QObject *parent);
-    ~RemoteEdit() final = default;
+    ~RemoteEdit() final;
 
 public:
     void onDisconnected();
+    /// One line in the game output if unsent drafts exist; called when a
+    /// connection comes up, since nothing can hear it before then.
+    void announcePendingDrafts() const;
+    void slot_parseGmcpInput(const GmcpMessage &msg);
+
+    NODISCARD RemoteEditDraftStore &getDraftStore() { return deref(m_store); }
+    NODISCARD QString readDraft(const QString &key) const { return deref(m_store).read(key); }
+    /// Removes the draft and tells listeners.
+    void deleteDraft(const QString &key);
+
+public:
+    /// Abort a session: sends a GMCP cancel if it's a live connected edit,
+    /// then removes the in-memory session. Deletes the draft file for a
+    /// live edit being cancelled (the user is explicitly abandoning it);
+    /// a draft-recovery window's draft is left on disk so it can be
+    /// recovered again later.
+    void cancelEdit(RemoteEditSession *session);
+    /// Explicit, user-requested, irreversible deletion of a draft's file,
+    /// plus removal of the in-memory session if one exists.
+    void discardDraft(const RemoteEditSession *session);
+    /// Same, for a pending draft with no in-memory session backing it.
+    void discardDraft(const DraftInfo &draft);
+    /// Opens a pending draft as a read-only page (always internal, whatever
+    /// the internalRemoteEditor setting). MUME no longer has the edit open,
+    /// so the only way to send it is to re-run the edit command and accept
+    /// the restore offer that a matching title then triggers.
+    void viewDraft(const DraftInfo &draft);
+    /// Called once from MainWindow::closeEvent(): synchronously tears down
+    /// every session (this is what actually stops any live external editor
+    /// process and closes any open widget) without sending any GMCP message
+    /// or deleting any draft file, so every open edit survives as a
+    /// recoverable draft across a restart.
+    void shutdown();
+
+    /// Drafts on disk not backed by an active session.
+    NODISCARD QList<DraftInfo> pendingDrafts() const;
+    /// Most recently modified pending draft with this title, if any.
+    NODISCARD std::optional<DraftInfo> findPendingDraft(const QString &title) const;
+    NODISCARD const std::map<RemoteInternalId, std::unique_ptr<RemoteEditSession>> &getSessions() const
+    {
+        return m_sessions;
+    }
+
+    void reportStatus(AnsiOstream &aos) const;
+    NODISCARD bool reportStatus(AnsiOstream &aos, RemoteInternalId id) const;
 
 protected:
-    void cancel(const RemoteEditSession *);
     void save(const RemoteEditSession *);
 
 private:
@@ -47,6 +99,10 @@ class NODISCARD_QOBJECT RemoteEdit final : public QObject
         return m_greatestUsedId == UINT_MAX ? 0 : m_greatestUsedId + 1;
     }
     void addSession(const RemoteSessionId, const QString &, const QString &);
+    void createSession(RemoteSessionId sessionId,
+                       const QString &title,
+                       const QString &body,
+                       const std::optional<DraftInfo> &offeredDraft);
     void removeSession(const RemoteEditSession &session);
 
 private:
@@ -55,10 +111,27 @@ class NODISCARD_QOBJECT RemoteEdit final : public QObject
     void trySaveLocally(const RemoteEditSession &session);
 
 signals:
-    void sig_remoteEditCancel(const RemoteSessionId sessionId);
-    void sig_remoteEditSave(const RemoteSessionId sessionId, const Latin1Bytes &content);
+    void sig_sendGmcp(const GmcpMessage &msg);
+    /// Emitted whenever a session is added or removed.
+    void sig_sessionsChanged();
+    /// Emitted whenever a draft file is created or deleted.
+    void sig_draftsChanged();
 
 public slots:
     void slot_remoteView(const QString &, const QString &);
     void slot_remoteEdit(const RemoteSessionId, const QString &, const QString &);
 };
+
+/// Non-owning access to the single MainWindow-owned RemoteEdit instance, for
+/// callers (like the `_edits` in-game command in AbstractParser) that have
+/// no direct reference to it. Mirrors the async_tasks:: free-function
+/// registry pattern (see AsyncTasks.h) used for the same reason.
+namespace remote_edit {
+void setInstance(RemoteEdit *instance);
+extern void report_status(AnsiOstream &aos);
+NODISCARD extern bool report_status(AnsiOstream &aos, uint32_t id);
+NODISCARD extern bool cancel(uint32_t id);
+NODISCARD extern bool discard(uint32_t id);
+/// Testing aid: behaves exactly as if MUME had sent MUME.Client.Edit.
+extern void simulate_edit(const QString &title);
+} // namespace remote_edit
diff --git a/src/mpi/remoteeditprocess.cpp b/src/mpi/remoteeditprocess.cpp
index b2daf09fb..296882cf9 100644
--- a/src/mpi/remoteeditprocess.cpp
+++ b/src/mpi/remoteeditprocess.cpp
@@ -21,27 +21,16 @@
 #include <QString>
 #include <QStringList>
 
-static constexpr const std::string_view VALID
-    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-static constexpr const auto VALID_LEN = VALID.length();
-
-NODISCARD static std::string randomString(int length)
-{
-    std::ostringstream os;
-    for (int i = 0; i < length; ++i) {
-        os << VALID[getRandom(VALID_LEN)];
-    }
-    return os.str();
-}
-
 RemoteEditProcess::RemoteEditProcess(const bool editSession,
                                      const QString &title,
                                      const QString &body,
+                                     const QString &fullPath,
                                      QObject *const parent)
     : QObject(parent)
     , m_title(title)
     , m_body(body)
     , m_editSession(editSession)
+    , m_fullPath(fullPath)
 {
     m_process.setProcessChannelMode(QProcess::MergedChannels);
 
@@ -52,30 +41,28 @@ RemoteEditProcess::RemoteEditProcess(const bool editSession,
             &RemoteEditProcess::slot_onFinished);
     connect(&m_process, &QProcess::errorOccurred, this, &RemoteEditProcess::slot_onError);
 
-    // Set the file template
-    QString fileTemplate = QString("%1MMapper.%2.pid%3.%4")
-                               .arg(QDir::tempPath() + QDir::separator())    // %1
-                               .arg(m_editSession ? "edit" : "view")         // %2
-                               .arg(QCoreApplication::applicationPid())      // %3
-                               .arg(mmqt::toQStringLatin1(randomString(6))); // %4 // ASCII
-    QFile file(fileTemplate);
-
-    // Try opening up the temporary file
-    if (!file.open(QFile::WriteOnly | QFile::Text)) {
-        qCritical() << "View session was unable to create a temporary file";
-        throw std::runtime_error("failed to start");
+    if (m_fullPath.isEmpty()) {
+        // Fallback for view mode if no draft was provisioned (though normally it is now)
+        m_fullPath = QDir::tempPath() + QDir::separator()
+                     + QString("MMapper.view.%1.%2")
+                           .arg(QCoreApplication::applicationPid())
+                           .arg(mmqt::toQStringLatin1(getRandomString(6)));
     }
 
-    m_fileName = file.fileName();
-    qDebug() << "View session file template" << m_fileName;
-    file.write(mmqt::toQByteArrayLatin1(m_body)); // MPI is always Latin1
-    file.flush();
+    QFile file(m_fullPath);
+    if (!file.exists()) {
+        if (!file.open(QFile::WriteOnly | QFile::Text)) {
+            qCritical() << "View session was unable to create a temporary file" << m_fullPath;
+            throw std::runtime_error("failed to start");
+        }
+        file.write(mmqt::toQByteArrayLatin1(m_body)); // MPI is always Latin1
+        file.flush();
+        std::ignore = io::fsyncNoexcept(file);
+        file.close();
+    }
 
-    // REVISIT: check return value?
-    std::ignore = io::fsyncNoexcept(file);
-    file.close();
-    m_previousTime = QFileInfo{m_fileName}.lastModified();
-    qDebug() << "File written with last modified timestamp" << m_previousTime;
+    m_previousTime = QFileInfo{m_fullPath}.lastModified();
+    qDebug() << "External editor using file" << m_fullPath << "with timestamp" << m_previousTime;
 
     // Set the TITLE environmental variable
     QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
@@ -87,7 +74,7 @@ RemoteEditProcess::RemoteEditProcess(const bool editSession,
 
     // Start the process!
     QStringList args = splitCommandLine(getConfig().mumeClientProtocol.externalRemoteEditorCommand);
-    args << m_fileName;
+    args << m_fullPath;
     const QString &program = args.takeFirst();
     qDebug() << program << args;
     m_process.start(program, args);
@@ -98,8 +85,26 @@ RemoteEditProcess::RemoteEditProcess(const bool editSession,
 RemoteEditProcess::~RemoteEditProcess()
 {
     qInfo() << "Destroyed RemoteEditProcess";
-    QFile file(m_fileName);
-    file.remove();
+    terminateSynchronously();
+    // We don't remove the file here anymore for edit sessions,
+    // as it is managed by the session/manager and must persist
+    // until success confirmation.
+    if (!m_editSession) {
+        QFile file(m_fullPath);
+        file.remove();
+    }
+}
+
+void RemoteEditProcess::terminateSynchronously()
+{
+    disconnect(&m_process, nullptr, this, nullptr);
+    if (m_process.state() != QProcess::NotRunning) {
+        m_process.terminate();
+        if (!m_process.waitForFinished(200)) {
+            m_process.kill();
+            m_process.waitForFinished(200);
+        }
+    }
 }
 
 void RemoteEditProcess::virt_onFinished(int exitCode, QProcess::ExitStatus status)
@@ -117,9 +122,9 @@ void RemoteEditProcess::virt_onFinished(int exitCode, QProcess::ExitStatus statu
         return;
     }
 
-    QFile file(m_fileName);
+    QFile file(m_fullPath);
     if (!file.open(QFile::ReadOnly)) {
-        qWarning() << "Edit session unable to read file!";
+        qWarning() << "Edit session unable to read file!" << m_fullPath;
         emit sig_cancel();
         return;
     }
diff --git a/src/mpi/remoteeditprocess.h b/src/mpi/remoteeditprocess.h
index 0d00d4c8c..c2b74e78a 100644
--- a/src/mpi/remoteeditprocess.h
+++ b/src/mpi/remoteeditprocess.h
@@ -28,16 +28,24 @@ class NODISCARD_QOBJECT RemoteEditProcess final : public QObject
     const bool m_editSession;
 
     QProcess m_process;
-    QString m_fileName;
+    QString m_fullPath;
     QDateTime m_previousTime;
 
 public:
     explicit RemoteEditProcess(bool editSession,
                                const QString &title,
                                const QString &body,
+                               const QString &fullPath,
                                QObject *parent);
     ~RemoteEditProcess() final;
 
+    NODISCARD bool isRunning() const { return m_process.state() == QProcess::Running; }
+
+    /// Synchronously stops the child process (terminate(), then kill() if it
+    /// doesn't exit promptly) and disconnects its signals first, so tearing
+    /// down mid-edit never emits a stray sig_cancel()/sig_save().
+    void terminateSynchronously();
+
 private:
     virtual void virt_onError(QProcess::ProcessError);
     virtual void virt_onFinished(int, QProcess::ExitStatus);
diff --git a/src/mpi/remoteeditsession.cpp b/src/mpi/remoteeditsession.cpp
index 3ac4362b5..afb584a39 100644
--- a/src/mpi/remoteeditsession.cpp
+++ b/src/mpi/remoteeditsession.cpp
@@ -21,11 +21,17 @@
 
 RemoteEditSession::RemoteEditSession(const RemoteInternalId internalId,
                                      const RemoteSessionId sessionId,
+                                     QString title,
+                                     QString draftKey,
+                                     const bool draftView,
                                      RemoteEdit *const remoteEdit)
     : QObject(remoteEdit)
     , m_manager(remoteEdit)
+    , m_title(std::move(title))
     , m_internalId(internalId)
     , m_sessionId(sessionId)
+    , m_draftView(draftView)
+    , m_draftKey(std::move(draftKey))
 {
     assert(m_manager != nullptr);
 }
@@ -37,25 +43,53 @@ void RemoteEditSession::save()
 
 void RemoteEditSession::cancel()
 {
-    m_manager->cancel(this);
+    m_manager->cancelEdit(this);
+}
+
+void RemoteEditSession::discard()
+{
+    m_manager->discardDraft(this);
+}
+
+QString RemoteEditSession::getFullDraftPath() const
+{
+    return m_manager->getDraftStore().filePath(m_draftKey);
 }
 
 RemoteEditInternalSession::RemoteEditInternalSession(const RemoteInternalId internalId,
                                                      const RemoteSessionId sessionId,
                                                      const QString &title,
                                                      const QString &body,
+                                                     const QString &draftKey,
+                                                     const bool draftView,
                                                      RemoteEdit *const parent)
-    : RemoteEditSession(internalId, sessionId, parent)
-    , m_widget(
-          new RemoteEditWidget(isEditSession(),
-                               title,
-                               body,
-                               checked_dynamic_downcast<QWidget *>(parent->parent()) // MainWindow
-                               ))
+    : RemoteEditSession(internalId, sessionId, title, draftKey, draftView, parent)
+    , m_widget(new RemoteEditWidget(isEditSession(), draftView, title, body, nullptr))
 {
     const auto widget = m_widget.data();
     connect(widget, &RemoteEditWidget::sig_save, this, &RemoteEditSession::slot_onSave);
     connect(widget, &RemoteEditWidget::sig_cancel, this, &RemoteEditSession::slot_onCancel);
+    connect(widget, &RemoteEditWidget::sig_discard, this, &RemoteEditSession::slot_onDiscard);
+    connect(widget,
+            &RemoteEditWidget::sig_textModified,
+            this,
+            &RemoteEditInternalSession::slot_onTextModified);
+
+    if (isEditSession()) {
+        m_debounceTimer = new QTimer(this);
+        m_debounceTimer->setSingleShot(true);
+        connect(m_debounceTimer,
+                &QTimer::timeout,
+                this,
+                &RemoteEditInternalSession::slot_performAutoSave);
+
+        m_throttleTimer = new QTimer(this);
+        m_throttleTimer->setSingleShot(true);
+        connect(m_throttleTimer,
+                &QTimer::timeout,
+                this,
+                &RemoteEditInternalSession::slot_performAutoSave);
+    }
 }
 
 RemoteEditInternalSession::~RemoteEditInternalSession()
@@ -63,7 +97,80 @@ RemoteEditInternalSession::~RemoteEditInternalSession()
     qDebug() << "Destructed RemoteEditInternalSession" << getInternalId().asUint32()
              << getSessionId().asInt32();
     if (auto *const p = m_widget.get()) {
-        p->close();
+        p->closeSilently();
+    }
+}
+
+RemoteEditWidget *RemoteEditInternalSession::virt_getWidget() const
+{
+    return m_widget.data();
+}
+
+void RemoteEditInternalSession::virt_focus()
+{
+    if (auto *const p = m_widget.get()) {
+        p->focus();
+    }
+}
+
+void RemoteEditInternalSession::virt_offerDraft(const RemoteEditDraftInfo &draft)
+{
+    auto *const p = m_widget.get();
+    if (p == nullptr) {
+        return;
+    }
+    const QString key = draft.key;
+    p->offerRecoveredDraft(
+        draft.lastModified,
+        [this, key]() {
+            if (auto *const w = m_widget.get()) {
+                w->replaceText(m_manager->readDraft(key));
+            }
+            m_manager->deleteDraft(key);
+        },
+        [this, key]() { m_manager->deleteDraft(key); });
+}
+
+void RemoteEditInternalSession::virt_onDisconnected()
+{
+    if (auto *const p = m_widget.get()) {
+        p->showDisconnected();
+    }
+}
+
+void RemoteEditInternalSession::virt_flushDraft()
+{
+    if ((m_debounceTimer != nullptr && m_debounceTimer->isActive())
+        || (m_throttleTimer != nullptr && m_throttleTimer->isActive())) {
+        slot_performAutoSave();
+    }
+}
+
+void RemoteEditInternalSession::slot_onTextModified(const QString &content)
+{
+    m_content = content;
+
+    // FR-3.2: 2000ms debounce
+    m_debounceTimer->start(2000);
+
+    // FR-3.3: 15000ms max throttle
+    if (!m_throttleTimer->isActive()) {
+        m_throttleTimer->start(15000);
+    }
+}
+
+void RemoteEditInternalSession::slot_performAutoSave()
+{
+    if (m_draftKey.isEmpty()) {
+        return;
+    }
+
+    if (m_manager->getDraftStore().save(m_draftKey, m_content)) {
+        qDebug() << "Auto-save successful for" << m_draftKey;
+        m_debounceTimer->stop();
+        m_throttleTimer->stop();
+    } else {
+        qWarning() << "Auto-save failed for" << m_draftKey;
     }
 }
 
@@ -72,10 +179,11 @@ RemoteEditExternalSession::RemoteEditExternalSession(const RemoteInternalId inte
                                                      const RemoteSessionId sessionId,
                                                      const QString &title,
                                                      const QString &body,
+                                                     const QString &draftKey,
                                                      RemoteEdit *const parent)
-    : RemoteEditSession(internalId, sessionId, parent)
-    , m_process(new RemoteEditProcess(isEditSession(), title, body, this))
+    : RemoteEditSession(internalId, sessionId, title, draftKey, /*draftView=*/false, parent)
 {
+    m_process = new RemoteEditProcess(isEditSession(), title, body, getFullDraftPath(), this);
     const auto proc = m_process.data();
     connect(proc, &RemoteEditProcess::sig_save, this, &RemoteEditExternalSession::slot_onSave);
     connect(proc, &RemoteEditProcess::sig_cancel, this, &RemoteEditExternalSession::slot_onCancel);
@@ -85,8 +193,12 @@ RemoteEditExternalSession::~RemoteEditExternalSession()
 {
     qDebug() << "Destructed RemoteEditExternalSession" << getInternalId().asUint32()
              << getSessionId().asInt32();
-    if (auto *const p = m_process.get()) {
-        p->deleteLater();
-    }
+    // m_process is a QObject child of `this`, so QObject's own destructor
+    // deletes it synchronously right after this body runs -- which in turn
+    // synchronously terminates the child process (RemoteEditProcess::~RemoteEditProcess()
+    // calls terminateSynchronously()). Deliberately not deleteLater(): that
+    // defers to the event loop, which never runs again if this destructor
+    // fires after QApplication::exec() has already returned (see
+    // RemoteEdit::shutdown()).
 }
 #endif
diff --git a/src/mpi/remoteeditsession.h b/src/mpi/remoteeditsession.h
index 7f0d9e2ed..66bbc0764 100644
--- a/src/mpi/remoteeditsession.h
+++ b/src/mpi/remoteeditsession.h
@@ -9,10 +9,9 @@
 #endif
 
 #include "../global/TaggedInt.h"
-#include "../global/TaggedString.h"
 #include "../global/macros.h"
-#include "../proxy/TaggedBytes.h"
 
+#include <QDateTime>
 #include <QObject>
 #include <QPointer>
 #include <QString>
@@ -58,16 +57,27 @@ struct NODISCARD RemoteSessionId final
 // Internally shared across all view sessions
 static inline const RemoteSessionId REMOTE_VIEW_SESSION_ID = RemoteSessionId(-1);
 
+struct NODISCARD RemoteEditDraftInfo final
+{
+    QString key;
+    QString title;
+    RemoteSessionId sessionId;
+    QDateTime lastModified;
+};
+
 class NODISCARD_QOBJECT RemoteEditSession : public QObject
 {
     Q_OBJECT
 
-private:
+protected:
     RemoteEdit *m_manager = nullptr;
     QString m_content;
+    QString m_title;
     const RemoteInternalId m_internalId{};
     const RemoteSessionId m_sessionId = REMOTE_VIEW_SESSION_ID;
+    const bool m_draftView = false;
     bool m_connected = true;
+    QString m_draftKey;
 
 private:
 #ifndef Q_OS_WASM
@@ -78,23 +88,56 @@ class NODISCARD_QOBJECT RemoteEditSession : public QObject
 public:
     explicit RemoteEditSession(RemoteInternalId internalId,
                                RemoteSessionId sessionId,
+                               QString title,
+                               QString draftKey,
+                               bool draftView,
                                RemoteEdit *remoteEdit);
 
 public:
     NODISCARD auto getInternalId() const { return m_internalId; }
     NODISCARD auto getSessionId() const { return m_sessionId; }
     NODISCARD bool isEditSession() const { return m_sessionId != REMOTE_VIEW_SESSION_ID; }
+    /// True for a read-only page showing an unsent draft, as opposed to a
+    /// live session originating from a MUME GMCP edit/view request.
+    NODISCARD bool isDraftView() const { return m_draftView; }
     NODISCARD const QString &getContent() const { return m_content; }
+    NODISCARD const QString &getTitle() const { return m_title; }
     void setContent(QString content) { m_content = std::move(content); }
     void cancel();
     void save();
+    void discard();
+    /// Brings this session's editor page to the front, if it has one (no-op otherwise).
+    void focus() { virt_focus(); }
+    /// A pending draft with this session's title exists; let the user restore it.
+    void offerDraft(const RemoteEditDraftInfo &draft) { virt_offerDraft(draft); }
+    /// The editor page hosted by RemoteEditPanel, or nullptr for sessions without one.
+    NODISCARD RemoteEditWidget *getWidget() const { return virt_getWidget(); }
+    /// Flushes any pending debounced auto-save immediately.
+    void flushDraft() { virt_flushDraft(); }
+    /// Short label for UI, e.g. "Internal" / "External".
+    NODISCARD const char *getEditorTypeName() const { return virt_getEditorTypeName(); }
 
 public:
     NODISCARD bool isConnected() const { return m_connected; }
-    void setDisconnected() { m_connected = false; }
+    void setDisconnected()
+    {
+        m_connected = false;
+        virt_onDisconnected();
+    }
+    NODISCARD const QString &getDraftKey() const { return m_draftKey; }
+    NODISCARD QString getFullDraftPath() const;
+
+private:
+    virtual void virt_focus() {}
+    virtual void virt_offerDraft(const RemoteEditDraftInfo & /*draft*/) {}
+    virtual void virt_flushDraft() {}
+    NODISCARD virtual const char *virt_getEditorTypeName() const { return "Internal"; }
+    NODISCARD virtual RemoteEditWidget *virt_getWidget() const { return nullptr; }
+    virtual void virt_onDisconnected() {}
 
 protected slots:
     void slot_onCancel() { cancel(); }
+    void slot_onDiscard() { discard(); }
     void slot_onSave(const QString &content)
     {
         setContent(content);
@@ -108,14 +151,29 @@ class NODISCARD_QOBJECT RemoteEditInternalSession final : public RemoteEditSessi
 
 private:
     QPointer<RemoteEditWidget> m_widget;
+    QTimer *m_debounceTimer = nullptr;
+    QTimer *m_throttleTimer = nullptr;
 
 public:
     explicit RemoteEditInternalSession(RemoteInternalId internalId,
                                        RemoteSessionId sessionId,
                                        const QString &title,
                                        const QString &body,
+                                       const QString &draftKey,
+                                       bool draftView,
                                        RemoteEdit *remoteEdit);
     ~RemoteEditInternalSession() final;
+
+private:
+    void virt_focus() override;
+    void virt_offerDraft(const RemoteEditDraftInfo &draft) override;
+    void virt_flushDraft() override;
+    NODISCARD RemoteEditWidget *virt_getWidget() const override;
+    void virt_onDisconnected() override;
+
+private slots:
+    void slot_onTextModified(const QString &content);
+    void slot_performAutoSave();
 };
 
 #ifndef Q_OS_WASM
@@ -131,7 +189,11 @@ class NODISCARD_QOBJECT RemoteEditExternalSession final : public RemoteEditSessi
                                        RemoteSessionId sessionId,
                                        const QString &title,
                                        const QString &body,
+                                       const QString &draftKey,
                                        RemoteEdit *remoteEdit);
     ~RemoteEditExternalSession() final;
+
+private:
+    NODISCARD const char *virt_getEditorTypeName() const override { return "External"; }
 };
 #endif
diff --git a/src/mpi/remoteeditwidget.cpp b/src/mpi/remoteeditwidget.cpp
index 77147806f..0e4499da9 100644
--- a/src/mpi/remoteeditwidget.cpp
+++ b/src/mpi/remoteeditwidget.cpp
@@ -10,7 +10,6 @@
 #include "../global/Consts.h"
 #include "../global/TabUtils.h"
 #include "../global/TextUtils.h"
-#include "../global/window_utils.h"
 #include "../viewers/AnsiViewWindow.h"
 #include "RemoteEditDocumentOps.h"
 #include "RemoteEditHighlighter.h"
@@ -26,10 +25,13 @@
 using namespace char_consts;
 
 #include <QAction>
+#include <QFrame>
+#include <QLabel>
 #include <QMenu>
 #include <QMessageBox>
 #include <QMessageLogContext>
 #include <QPlainTextEdit>
+#include <QPushButton>
 #include <QScopedPointer>
 #include <QSize>
 #include <QString>
@@ -204,20 +206,17 @@ void RemoteTextEdit::toggleWhitespace()
 }
 
 RemoteEditWidget::RemoteEditWidget(const bool editSession,
+                                   const bool draftView,
                                    QString title,
                                    QString body,
                                    QWidget *const parent)
-    : QDialog(parent)
+    : QWidget(parent)
     , m_editSession(editSession)
+    , m_draftView(draftView)
     , m_title(std::move(title))
     , m_body(std::move(body))
+    , m_lastNotifiedText(m_body)
 {
-    setWindowFlags(Qt::Window | Qt::WindowSystemMenuHint | Qt::WindowMinimizeButtonHint
-                   | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint);
-    mmqt::setWindowTitle2(*this,
-                          QString("MMapper %1").arg(m_editSession ? "Editor" : "Viewer"),
-                          m_title);
-
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setContentsMargins(0, 0, 0, 0);
     mainLayout->setSpacing(0);
@@ -233,26 +232,84 @@ RemoteEditWidget::RemoteEditWidget(const bool editSession,
     m_findReplaceWidget.reset(createFindReplaceWidget());
     mainLayout->addWidget(m_findReplaceWidget.get(), 0);
 
+    m_banner = new QFrame(this);
+    m_banner->setFrameShape(QFrame::StyledPanel);
+    m_banner->setAutoFillBackground(true);
+    m_banner->setBackgroundRole(QPalette::ToolTipBase);
+    m_banner->setForegroundRole(QPalette::ToolTipText);
+    auto *const bannerLayout = new QHBoxLayout(m_banner);
+    bannerLayout->setContentsMargins(8, 4, 8, 4);
+    m_bannerLabel = new QLabel(m_banner);
+    m_bannerLabel->setWordWrap(true);
+    bannerLayout->addWidget(m_bannerLabel, 1);
+    m_banner->hide();
+    mainLayout->addWidget(m_banner, 0);
+
     m_textEdit.reset(createTextEdit());
     mainLayout->addWidget(m_textEdit.get(), 1);
+    setFocusProxy(m_textEdit.get());
 
     m_statusBar = new QStatusBar(this);
-    setAttribute(Qt::WA_DeleteOnClose);
+    m_statusBar->setSizeGripEnabled(false);
     mainLayout->addWidget(m_statusBar);
 
     addStatusBar(m_textEdit.get());
     addFileMenu(m_textEdit.get());
 
-    // REVISIT: Restore geometry from config?
-    setGeometry(QStyle::alignedRect(Qt::LeftToRight,
-                                    Qt::AlignCenter,
-                                    size(),
-                                    qApp->primaryScreen()->availableGeometry()));
+    if (m_draftView) {
+        showBanner(tr("Unsent draft (read-only). MUME no longer has this edit open: re-run the "
+                      "edit command in MUME and choose \"Restore\" to continue it, or copy the "
+                      "text out."),
+                   {{tr("Discard draft"), [this]() { slot_discardDraft(); }}});
+    }
+
+    // This page shares a top-level window with MainWindow (and with every
+    // other page), whose actions use overlapping keys (Ctrl+S, Ctrl+Q,
+    // Ctrl+Z, ...). Qt fires nothing for an ambiguous QAction shortcut, so:
+    // scope this page's actions to itself, and claim their keys ahead of the
+    // shortcut map (see eventFilter) while focus is inside the page.
+    for (QAction *const action : findChildren<QAction *>()) {
+        action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
+    }
+    for (QWidget *const child : findChildren<QWidget *>()) {
+        child->installEventFilter(this);
+    }
+}
 
-    show();
-    raise();
-    activateWindow();
-    m_textEdit->setFocus(); // REVISIT: can this be done in the creation function?
+QAction *RemoteEditWidget::findActionForKey(const QKeyEvent &key) const
+{
+    const QKeySequence seq(key.keyCombination());
+    if (seq.isEmpty() || key.modifiers() == Qt::NoModifier) {
+        return nullptr;
+    }
+    for (QAction *const action : findChildren<QAction *>()) {
+        if (action->isEnabled() && action->shortcuts().contains(seq)) {
+            return action;
+        }
+    }
+    return nullptr;
+}
+
+bool RemoteEditWidget::eventFilter(QObject *const obj, QEvent *const event)
+{
+    switch (event->type()) {
+    case QEvent::ShortcutOverride:
+        if (findActionForKey(*checked_dynamic_downcast<QKeyEvent *>(event)) != nullptr) {
+            event->accept();
+            return false;
+        }
+        break;
+    case QEvent::KeyPress:
+        if (QAction *const action = findActionForKey(
+                *checked_dynamic_downcast<QKeyEvent *>(event))) {
+            action->trigger();
+            return true;
+        }
+        break;
+    default:
+        break;
+    }
+    return QWidget::eventFilter(obj, event);
 }
 
 auto RemoteEditWidget::createTextEdit() -> Editor *
@@ -260,14 +317,10 @@ auto RemoteEditWidget::createTextEdit() -> Editor *
     QFont font;
     font.fromString(getConfig().integratedClient.font);
     const QFontMetrics fm(font);
-    const int x = fm.averageCharWidth() * (80 + 1);
-    const int y = fm.lineSpacing() * (24 + 1);
 
     const auto pTextEdit = new Editor(m_body, this);
     pTextEdit->setFont(font);
     pTextEdit->setReadOnly(!m_editSession);
-    pTextEdit->setMinimumSize(QSize(x + contentsMargins().left() + contentsMargins().right(),
-                                    y + contentsMargins().top() + contentsMargins().bottom()));
     pTextEdit->setLineWrapMode(Editor::LineWrapMode::NoWrap);
     pTextEdit->setSizeIncrement(fm.averageCharWidth(), fm.lineSpacing());
     pTextEdit->setTabStopDistance(fm.horizontalAdvance(" ") * 8); // A tab is 8 spaces wide
@@ -333,7 +386,7 @@ auto RemoteEditWidget::createFindReplaceWidget() -> FindReplaceWidget *
 void RemoteEditWidget::addFileMenu(const Editor *const pTextEdit)
 {
     QMenu *const fileMenu = m_menuBar->addMenu(tr("&File"));
-    if (m_editSession) {
+    if (m_editSession && !m_draftView) {
         addSave(fileMenu);
     }
     addExit(fileMenu);
@@ -530,6 +583,7 @@ void RemoteEditWidget::addSave(QMenu *const fileMenu)
     saveAction->setStatusTip(tr("Submit changes to MUME"));
     fileMenu->addAction(saveAction);
     connect(saveAction, &QAction::triggered, this, &RemoteEditWidget::slot_finishEdit);
+    m_saveAction = saveAction;
 }
 
 void RemoteEditWidget::addExit(QMenu *const fileMenu)
@@ -546,7 +600,8 @@ void RemoteEditWidget::addExit(QMenu *const fileMenu)
                                             tr("E&xit"),
                                             this);
     quitAction->setShortcut(tr("Ctrl+Q"));
-    quitAction->setStatusTip(tr("Cancel and do not submit changes to MUME"));
+    quitAction->setStatusTip(m_draftView ? tr("Close this page (the draft is kept)")
+                                         : tr("Cancel and do not submit changes to MUME"));
     fileMenu->addAction(quitAction);
     connect(quitAction, &QAction::triggered, this, &RemoteEditWidget::slot_cancelEdit);
 }
@@ -601,6 +656,13 @@ void RemoteEditWidget::addStatusBar(const Editor *const pTextEdit)
             this,
             &RemoteEditWidget::slot_updateStatusBar);
     connect(pTextEdit, &QPlainTextEdit::textChanged, this, &RemoteEditWidget::slot_updateStatusBar);
+    connect(pTextEdit, &QPlainTextEdit::textChanged, this, [this, pTextEdit]() {
+        // textChanged also fires for highlighter passes, so only report real changes.
+        if (QString text = pTextEdit->toPlainText(); m_editSession && text != m_lastNotifiedText) {
+            m_lastNotifiedText = std::move(text);
+            emit sig_textModified(m_lastNotifiedText);
+        }
+    });
 }
 
 void RemoteEditWidget::slot_updateStatus(const QString &message_param)
@@ -811,25 +873,83 @@ QSize RemoteEditWidget::minimumSizeHint() const
 
 QSize RemoteEditWidget::sizeHint() const
 {
-    return QSize{640, 480};
+    const QFontMetrics fm(m_textEdit->font());
+    return QSize{fm.averageCharWidth() * (80 + 1), fm.lineSpacing() * (24 + 1)};
 }
 
-void RemoteEditWidget::closeEvent(QCloseEvent *event)
+void RemoteEditWidget::requestClose()
 {
     if (m_submitted) {
-        event->accept();
         return;
     }
 
-    if (m_editSession && slot_contentsChanged()) {
-        // Ask first; if the user discards, slot_cancelEdit() closes again.
-        event->ignore();
+    // Only a connected live edit loses anything on close; a disconnected one
+    // is auto-saved as a draft, and a draft page is read-only.
+    if (m_editSession && m_connected && isModified()) {
         promptDiscardChanges();
         return;
     }
 
     slot_cancelEdit();
-    event->accept();
+}
+
+void RemoteEditWidget::showBanner(
+    const QString &text, const std::vector<std::pair<QString, std::function<void()>>> &buttons)
+{
+    for (QPushButton *const old : m_banner->findChildren<QPushButton *>()) {
+        delete old;
+    }
+    m_bannerLabel->setText(text);
+    auto *const layout = checked_dynamic_downcast<QHBoxLayout *>(m_banner->layout());
+    for (const auto &[label, fn] : buttons) {
+        auto *const button = new QPushButton(label, m_banner);
+        button->setAutoDefault(false);
+        connect(button, &QPushButton::clicked, this, fn);
+        layout->addWidget(button, 0);
+    }
+    m_banner->show();
+}
+
+void RemoteEditWidget::hideBanner()
+{
+    m_banner->hide();
+}
+
+void RemoteEditWidget::offerRecoveredDraft(const QDateTime &lastModified,
+                                           std::function<void()> restore,
+                                           std::function<void()> discard)
+{
+    showBanner(tr("An unsent draft of this text from %1 was recovered.").arg(lastModified.toString()),
+               {{tr("Restore draft"),
+                 [this, doRestore = std::move(restore)]() {
+                     doRestore();
+                     hideBanner();
+                 }},
+                {tr("Discard draft"),
+                 [this, doDiscard = std::move(discard)]() {
+                     doDiscard();
+                     hideBanner();
+                 }},
+                {tr("Keep for later"), [this]() { hideBanner(); }}});
+}
+
+void RemoteEditWidget::showDisconnected()
+{
+    m_connected = false;
+    if (m_saveAction != nullptr) {
+        m_saveAction->setEnabled(false);
+    }
+    if (!m_editSession) {
+        return;
+    }
+    showBanner(tr("Connection to MUME lost. Your changes are being saved as a draft; re-run the "
+                  "edit command once reconnected to restore them."),
+               {});
+}
+
+void RemoteEditWidget::replaceText(const QString &text)
+{
+    m_textEdit->replaceAll(text);
 }
 
 void RemoteEditWidget::promptDiscardChanges()
@@ -855,11 +975,11 @@ void RemoteEditWidget::promptDiscardChanges()
 /* Qt virtual */
 void RemoteEditWidget::showEvent(QShowEvent *event)
 {
-    QDialog::showEvent(event);
+    QWidget::showEvent(event);
     slot_updateStatusBar();
 }
 
-bool RemoteEditWidget::slot_contentsChanged() const
+bool RemoteEditWidget::isModified() const
 {
     const QString text = m_textEdit->toPlainText();
     return QString::compare(text, m_body, Qt::CaseSensitive) != 0;
@@ -869,12 +989,29 @@ void RemoteEditWidget::slot_cancelEdit()
 {
     m_submitted = true;
     emit sig_cancel();
-    close();
+    closeSilently();
 }
 
 void RemoteEditWidget::slot_finishEdit()
 {
     m_submitted = true;
     emit sig_save(m_textEdit->toPlainText());
-    close();
+    closeSilently();
+}
+
+void RemoteEditWidget::slot_discardDraft()
+{
+    m_submitted = true;
+    emit sig_discard();
+    closeSilently();
+}
+
+void RemoteEditWidget::closeSilently()
+{
+    // deleteLater() rather than delete: this is frequently reached from
+    // inside one of this widget's own slots (via the session the signal
+    // reached), so a synchronous delete would destroy the emitter mid-signal.
+    m_submitted = true;
+    hide();
+    deleteLater();
 }
diff --git a/src/mpi/remoteeditwidget.h b/src/mpi/remoteeditwidget.h
index 76e0e7088..ee2d8ba34 100644
--- a/src/mpi/remoteeditwidget.h
+++ b/src/mpi/remoteeditwidget.h
@@ -6,9 +6,13 @@
 #include "../global/macros.h"
 #include "remoteeditsession.h"
 
+#include <functional>
 #include <memory>
+#include <utility>
+#include <vector>
 
 #include <QAction>
+#include <QDateTime>
 #include <QDialog>
 #include <QPlainTextEdit>
 #include <QScopedPointer>
@@ -19,7 +23,9 @@
 struct EditViewCommand;
 struct EditCommand2;
 
-class QCloseEvent;
+class QFrame;
+class QKeyEvent;
+class QLabel;
 class QMenu;
 class QMenuBar;
 class QObject;
@@ -130,23 +136,32 @@ class NODISCARD_QOBJECT RemoteTextEdit final : public QPlainTextEdit
     void handle_toolTip(QEvent *event) const;
 };
 
-class NODISCARD_QOBJECT RemoteEditWidget : public QDialog
+/// One editor/viewer page; hosted as a tab by RemoteEditPanel. Its lifetime
+/// belongs to the owning RemoteEditInternalSession, which deletes it (via
+/// closeSilently()) when the session ends, and the hosting tab disappears with it.
+class NODISCARD_QOBJECT RemoteEditWidget : public QWidget
 {
     Q_OBJECT
 
 private:
-    QMenuBar *m_menuBar;
-    QStatusBar *m_statusBar;
+    QMenuBar *m_menuBar = nullptr;
+    QStatusBar *m_statusBar = nullptr;
+    QFrame *m_banner = nullptr;
+    QLabel *m_bannerLabel = nullptr;
+    QAction *m_saveAction = nullptr;
 
 public:
     using Editor = RemoteTextEdit;
 
 private:
     const bool m_editSession;
+    const bool m_draftView;
     const QString m_title;
     const QString m_body;
+    QString m_lastNotifiedText;
 
     bool m_submitted = false;
+    bool m_connected = true;
     QScopedPointer<Editor> m_textEdit;
     QScopedPointer<GotoWidget> m_gotoWidget;
     QScopedPointer<FindReplaceWidget> m_findReplaceWidget;
@@ -155,16 +170,40 @@ class NODISCARD_QOBJECT RemoteEditWidget : public QDialog
     std::unique_ptr<QDialog> m_preview;
 
 public:
-    explicit RemoteEditWidget(bool editSession, QString title, QString body, QWidget *parent);
+    explicit RemoteEditWidget(
+        bool editSession, bool draftView, QString title, QString body, QWidget *parent);
     ~RemoteEditWidget() override;
 
 public:
     NODISCARD QSize minimumSizeHint() const override;
     NODISCARD QSize sizeHint() const override;
-    void closeEvent(QCloseEvent *event) override;
+    NODISCARD const QString &getTitle() const { return m_title; }
+    NODISCARD bool isEditSession() const { return m_editSession; }
+    NODISCARD bool isDraftView() const { return m_draftView; }
+    NODISCARD bool isModified() const;
+    /// What the tab's close button does: prompts if there are unsaved edits,
+    /// otherwise cancels the session.
+    void requestClose();
+    /// Asks the hosting panel to bring this page to the front.
+    void focus() { emit sig_focusRequested(); }
+    /// Offers to replace the text with an unsent draft of the same title.
+    void offerRecoveredDraft(const QDateTime &lastModified,
+                             std::function<void()> restore,
+                             std::function<void()> discard);
+    /// MUME went away: Submit is disabled and the page explains where the text goes.
+    void showDisconnected();
+    void replaceText(const QString &text);
+    /// Schedules deletion without the "discard changes?" prompt; used when the
+    /// manager is tearing down the session for reasons other than the user
+    /// choosing Submit/Exit/Discard in this widget.
+    void closeSilently();
 
 protected:
     void showEvent(QShowEvent *event) override;
+    bool eventFilter(QObject *obj, QEvent *event) override;
+
+private:
+    NODISCARD QAction *findActionForKey(const QKeyEvent &key) const;
 
 private:
     NODISCARD Editor *createTextEdit();
@@ -180,15 +219,21 @@ class NODISCARD_QOBJECT RemoteEditWidget : public QDialog
     void addExit(QMenu *fileMenu);
     void addStatusBar(const Editor *pTextEdit);
     void promptDiscardChanges();
+    void showBanner(const QString &text,
+                    const std::vector<std::pair<QString, std::function<void()>>> &buttons);
+    void hideBanner();
 
 signals:
     void sig_cancel();
     void sig_save(const QString &);
+    void sig_textModified(const QString &);
+    void sig_discard();
+    void sig_focusRequested();
 
 protected slots:
     void slot_cancelEdit();
     void slot_finishEdit();
-    NODISCARD bool slot_contentsChanged() const;
+    void slot_discardDraft();
     void slot_updateStatusBar();
     void slot_updateStatus(const QString &message);
     void slot_handleFindRequested(const QString &term, QTextDocument::FindFlags flags);
diff --git a/src/observer/gameobserver.cpp b/src/observer/gameobserver.cpp
index 88a17b368..ea0121d5e 100644
--- a/src/observer/gameobserver.cpp
+++ b/src/observer/gameobserver.cpp
@@ -11,6 +11,11 @@ void GameObserver::observeConnected()
     sig2_connected.invoke();
 }
 
+void GameObserver::observeDisconnected()
+{
+    sig2_disconnected.invoke();
+}
+
 void GameObserver::observeSentToMud(const QString &input)
 {
     auto str = input;
diff --git a/src/observer/gameobserver.h b/src/observer/gameobserver.h
index eec57e187..46917aa1f 100644
--- a/src/observer/gameobserver.h
+++ b/src/observer/gameobserver.h
@@ -12,6 +12,7 @@ class NODISCARD GameObserver final
 {
 public:
     Signal2<> sig2_connected;
+    Signal2<> sig2_disconnected;
 
     Signal2<QString> sig2_sentToMudString;  // removes ANSI
     Signal2<QString> sig2_sentToUserString; // removes ANSI
@@ -39,6 +40,7 @@ class NODISCARD GameObserver final
 
 public:
     void observeConnected();
+    void observeDisconnected();
     void observeSentToMud(const QString &ba);
     void observeSentToUser(const QString &ba);
     void observeSentToUserGmcp(const GmcpMessage &m);
diff --git a/src/parser/AbstractParser-Commands.cpp b/src/parser/AbstractParser-Commands.cpp
index d5418a4e3..c51d5c8b3 100644
--- a/src/parser/AbstractParser-Commands.cpp
+++ b/src/parser/AbstractParser-Commands.cpp
@@ -20,6 +20,7 @@
 #include "../map/enums.h"
 #include "../map/infomark.h"
 #include "../mapdata/mapdata.h"
+#include "../mpi/remoteedit.h"
 #include "../observer/gameobserver.h"
 #include "../syntax/Sublist.h"
 #include "../syntax/SyntaxArgs.h"
@@ -199,6 +200,7 @@ const Abbrev cmdConfig{"config", 4};
 const Abbrev cmdConnect{"connect", 4};
 const Abbrev cmdDirections{"dirs", 3};
 const Abbrev cmdDisconnect{"disconnect", 4};
+const Abbrev cmdEdits{"edits", 3};
 // TODO: move this to a sub-command of _map
 const Abbrev cmdGenerateBaseMap{"generate-base-map"};
 const Abbrev cmdGroup{"group", 2};
@@ -1171,6 +1173,14 @@ void AbstractParser::initSpecialCommandMap()
         },
         makeSimpleHelp("List or manage background tasks."));
 
+    add(
+        cmdEdits,
+        [this](const View<StringView> /*s*/, StringView rest) -> bool {
+            this->doEditsCommand(rest);
+            return true;
+        },
+        makeSimpleHelp("List or manage remote (MPI) edit/view sessions."));
+
     add(
         cmdBack,
         [this](const View<StringView> /*s*/, StringView rest) {
@@ -1471,3 +1481,93 @@ void AbstractParser::doTasksCommand(StringView rest)
 
     eval("async", taskSyntax, rest);
 }
+
+void AbstractParser::doEditsCommand(StringView rest)
+{
+    const auto argInt = syntax::TokenMatcher::alloc<syntax::ArgInt>();
+
+    const auto doEditList = syntax::Accept(
+        [](User &user, const Pair * /*args*/) {
+            AnsiOstream &aos = user.getOstream();
+            remote_edit::report_status(aos);
+        },
+        "list remote edit/view sessions and recovered drafts");
+
+    const auto doEditStatus = syntax::Accept(
+        [](User &user, const Pair *args) {
+            AnsiOstream &aos = user.getOstream();
+            const auto argv = getAnyVectorReversed(args);
+            assert(argv.size() == 2);
+            assert(argv[1].getString() == "status");
+
+            const auto id = argv[0].getInt();
+            if (id < 0) {
+                aos << "Error: cannot show status for invalid remote edit id: "
+                    << ColoredValue{red, id} << ".\n";
+                return;
+            }
+            std::ignore = remote_edit::report_status(aos, static_cast<uint32_t>(id));
+        },
+        "show status for a remote edit session");
+
+    const auto doEditCancel = syntax::Accept(
+        [](User &user, const Pair *args) {
+            AnsiOstream &aos = user.getOstream();
+            const auto argv = getAnyVectorReversed(args);
+            assert(argv.size() == 2);
+            assert(argv[1].getString() == "cancel");
+
+            const auto id = argv[0].getInt();
+            if (id < 0 || !remote_edit::cancel(static_cast<uint32_t>(id))) {
+                aos << "Error: cannot cancel invalid remote edit id: " << ColoredValue{red, id}
+                    << ".\n";
+                return;
+            }
+            aos << "Cancelled remote edit " << id << ".\n";
+        },
+        "cancel a remote edit session (draft is preserved)");
+
+    const auto doEditDiscard = syntax::Accept(
+        [](User &user, const Pair *args) {
+            AnsiOstream &aos = user.getOstream();
+            const auto argv = getAnyVectorReversed(args);
+            assert(argv.size() == 2);
+            assert(argv[1].getString() == "discard");
+
+            const auto id = argv[0].getInt();
+            if (id < 0 || !remote_edit::discard(static_cast<uint32_t>(id))) {
+                aos << "Error: cannot discard invalid remote edit id: " << ColoredValue{red, id}
+                    << ".\n";
+                return;
+            }
+            aos << "Discarded draft for remote edit " << id << ".\n";
+        },
+        "permanently delete a recovered draft's file, or cancel a live edit and discard its "
+        "draft");
+
+    const auto doEditSimulate = syntax::Accept(
+        [](User &user, const Pair *args) {
+            AnsiOstream &aos = user.getOstream();
+            const auto v = getAnyVectorReversed(args);
+            assert(v.size() == 2);
+            assert(v[0].getString() == "simulate");
+            const std::string title = concatenate_unquoted(v[1].getVector());
+            if (title.empty()) {
+                aos << "Error: a title is required.\n";
+                return;
+            }
+            remote_edit::simulate_edit(mmqt::toQStringUtf8(title));
+        },
+        "(testing) open an editor as if MUME had requested an edit with this title");
+
+    const auto editSyntax = syn(syn("list", doEditList),
+                                syn("simulate",
+                                    syntax::TokenMatcher::alloc<syntax::ArgRest>(),
+                                    doEditSimulate),
+                                syn(argInt, //
+                                    syn("status", doEditStatus),
+                                    syn("cancel", doEditCancel),
+                                    syn("discard", doEditDiscard)));
+
+    eval("edits", editSyntax, rest);
+}
diff --git a/src/parser/AbstractParser-Config.cpp b/src/parser/AbstractParser-Config.cpp
index 3fe671464..40fb59552 100644
--- a/src/parser/AbstractParser-Config.cpp
+++ b/src/parser/AbstractParser-Config.cpp
@@ -401,6 +401,7 @@ void AbstractParser::doConfig(const StringView cmd)
                         };
 
                         auto *editor = new RemoteEditWidget(true,
+                                                            false,
                                                             "MMapper Client Configuration",
                                                             content,
                                                             nullptr);
diff --git a/src/parser/abstractparser.h b/src/parser/abstractparser.h
index ac7d8235f..779979fdc 100644
--- a/src/parser/abstractparser.h
+++ b/src/parser/abstractparser.h
@@ -414,6 +414,7 @@ class NODISCARD_QOBJECT AbstractParser final : public ParserCommon
     void doBackCommand();
     void doConfig(StringView view);
     void doTasksCommand(StringView args);
+    void doEditsCommand(StringView args);
 
     NODISCARD bool isConnected();
     void doConnectToHost();
diff --git a/src/proxy/MudTelnet.cpp b/src/proxy/MudTelnet.cpp
index d0a4c68ea..97dd40f5d 100644
--- a/src/proxy/MudTelnet.cpp
+++ b/src/proxy/MudTelnet.cpp
@@ -7,7 +7,6 @@
 #include "../clock/mumeclock.h"
 #include "../global/Consts.h"
 #include "../global/LineUtils.h"
-#include "../global/SendToUser.h"
 #include "../global/TextUtils.h"
 #include "../global/Version.h"
 #include "../global/emojis.h"
@@ -451,58 +450,6 @@ void MudTelnet::virt_receiveGmcpMessage(const GmcpMessage &msg)
         return;
     }
 
-    if (msg.isMumeClientView() || msg.isMumeClientEdit()) {
-        if (!msg.getJsonDocument()) {
-            return;
-        }
-        auto optObj = msg.getJsonDocument()->getObject();
-        if (!optObj) {
-            return;
-        }
-        auto &obj = optObj.value();
-
-        const auto optTitle = obj.getString("title");
-        const auto optText = obj.getString("text");
-
-        if (msg.isMumeClientView()) {
-            m_outputs.onMumeClientView(optTitle.value_or("View text..."), optText.value_or(""));
-        } else if (msg.isMumeClientEdit()) {
-            if (auto optId = obj.getInt("id")) {
-                m_outputs.onMumeClientEdit(RemoteSessionId{optId.value()},
-                                           optTitle.value_or("Edit text..."),
-                                           optText.value_or(""));
-            }
-        }
-        return;
-    }
-
-    if (msg.isMumeClientWrite() || msg.isMumeClientCancelEdit()) {
-        if (!msg.getJsonDocument()) {
-            return;
-        }
-        auto optObj = msg.getJsonDocument()->getObject();
-        if (!optObj) {
-            return;
-        }
-        auto &obj = optObj.value();
-
-        const auto id = obj.getInt("id").value_or(REMOTE_VIEW_SESSION_ID.asInt32());
-        const auto optBool = obj.getBool("result");
-        const auto optString = obj.getString("result");
-
-        if (optBool && optBool.value()) {
-            qDebug() << "[success] Successfully" << (msg.isMumeClientWrite() ? "sent" : "cancelled")
-                     << "remote edit" << id;
-        } else {
-            const auto action = (msg.isMumeClientWrite() ? "sending" : "canceling");
-            const auto result = optString.value_or("missing text");
-            qDebug() << "Failure" << action << "remote message" << id << result;
-            // Mume doesn't send anything, so we have to make our own message.
-            global::sendToUser(QString("Failure %1 remote message: %2\n").arg(action, result));
-        }
-        return;
-    }
-
     m_outputs.onRelayGmcpFromMudToUser(msg);
 }
 
diff --git a/src/proxy/MudTelnet.h b/src/proxy/MudTelnet.h
index f54df5dd9..e7a281c22 100644
--- a/src/proxy/MudTelnet.h
+++ b/src/proxy/MudTelnet.h
@@ -4,7 +4,6 @@
 // Author: Nils Schimmelmann <nschimme@gmail.com> (Jahara)
 
 #include "../global/Signal2.h"
-#include "../mpi/remoteeditsession.h"
 #include "AbstractTelnet.h"
 
 #include <QByteArray>
@@ -33,14 +32,6 @@ struct NODISCARD MudTelnetOutputs
     void onSendMSSPToUser(const TelnetMsspBytes &bytes) { virt_onSendMSSPToUser(bytes); }
     void onSendGameTimeToClock(const MsspTime &time) { virt_onSendGameTimeToClock(time); }
     void onTryCharLogin() { virt_onTryCharLogin(); }
-    void onMumeClientView(const QString &title, const QString &body)
-    {
-        virt_onMumeClientView(title, body);
-    }
-    void onMumeClientEdit(const RemoteSessionId id, const QString &title, const QString &body)
-    {
-        virt_onMumeClientEdit(id, title, body);
-    }
     void onMumeClientError(const QString &errmsg) { virt_onMumeClientError(errmsg); }
 
 private:
@@ -51,11 +42,6 @@ struct NODISCARD MudTelnetOutputs
     virtual void virt_onSendMSSPToUser(const TelnetMsspBytes &) = 0;
     virtual void virt_onSendGameTimeToClock(const MsspTime &) = 0;
     virtual void virt_onTryCharLogin() = 0;
-    virtual void virt_onMumeClientView(const QString &title, const QString &body) = 0;
-    virtual void virt_onMumeClientEdit(const RemoteSessionId id,
-                                       const QString &title,
-                                       const QString &body)
-        = 0;
     virtual void virt_onMumeClientError(const QString &errmsg) = 0;
 };
 
diff --git a/src/proxy/connectionlistener.cpp b/src/proxy/connectionlistener.cpp
index 8a6f704f2..e5b499ccd 100644
--- a/src/proxy/connectionlistener.cpp
+++ b/src/proxy/connectionlistener.cpp
@@ -11,6 +11,7 @@
 #include "../global/Charset.h"
 #include "../global/MakeQPointer.h"
 #include "../global/TextUtils.h"
+#include "../mpi/remoteedit.h"
 #include "TcpSocket.h"
 #include "proxy.h"
 
@@ -128,6 +129,7 @@ void ConnectionListener::startClient(std::unique_ptr<AbstractSocket> socket)
                                    m_gameOberver,
                                    std::move(socket),
                                    *this);
+        emit sig_proxyCreated(m_proxy);
     } else {
         log("New connection: rejected.");
         const auto msg = std::invoke([]() -> QByteArray {
diff --git a/src/proxy/connectionlistener.h b/src/proxy/connectionlistener.h
index 7c838f832..4875c474c 100644
--- a/src/proxy/connectionlistener.h
+++ b/src/proxy/connectionlistener.h
@@ -25,7 +25,7 @@ class Mmapper2PathMachine;
 class MumeClock;
 class CTimers;
 class PrespammedPath;
-class Proxy;
+#include "proxy.h"
 class QObject;
 class RoomManager;
 
@@ -80,6 +80,7 @@ class NODISCARD_QOBJECT ConnectionListener final : public QObject
 
 public:
     void listen();
+    NODISCARD Proxy *getProxy() const { return m_proxy.data(); }
 
 private:
     void log(const QString &msg) { emit sig_log("Listener", msg); }
@@ -87,6 +88,7 @@ class NODISCARD_QOBJECT ConnectionListener final : public QObject
 signals:
     void sig_log(const QString &, const QString &);
     void sig_clientSuccessfullyConnected();
+    void sig_proxyCreated(QPointer<Proxy> proxy);
 
 protected slots:
     void slot_onIncomingConnection(qintptr socketDescriptor);
diff --git a/src/proxy/proxy.cpp b/src/proxy/proxy.cpp
index 90ef5dfd4..0a39904ec 100644
--- a/src/proxy/proxy.cpp
+++ b/src/proxy/proxy.cpp
@@ -19,9 +19,6 @@
 #include "../global/io.h"
 #include "../group/mmapper2group.h"
 #include "../map/parseevent.h"
-#include "../mpi/mpifilter.h"
-#include "../mpi/remoteedit.h"
-#include "../mpi/remoteeditwidget.h"
 #include "../observer/gameobserver.h"
 #include "../parser/abstractparser.h"
 #include "../parser/mumexmlparser.h"
@@ -205,12 +202,7 @@ Proxy::~Proxy()
         getUserSocket().disconnectFromHost();
     }
 
-    {
-        auto &remoteEdit = deref(m_remoteEdit);
-        remoteEdit.onDisconnected();
-        remoteEdit.disconnect(); // disconnect all signals
-        remoteEdit.deleteLater();
-    }
+    getGameObserver().observeDisconnected();
 
     destroyPipelineObjects();
 }
@@ -234,11 +226,7 @@ void Proxy::allocPipelineObjects()
 
     // Two main paths:
     // UserSocket -> UserTelnet -> UserTelnetFilter -> (User)Parser
-    // MudSocket -> MudTelnet -> MudTelnetFilter -> MpiFilter -> { RemoteEdit or (Mud)Parser }
-    //
-    // Technically MudTelnetFilter 100% required for MpiFilter, because its protocol
-    // is based on newlines, and it's sensitive to the difference between "\n" and "\r\n",
-    // but UserTelnetFilter is just a buffer for Parser.
+    // MudSocket -> MudTelnet -> MudTelnetFilter -> (Mud)Parser
     //
     // TODO: refactor the Parser into UserParser and MudParser.
     // The distinction is already partly in place for AbstractParser (User)
@@ -250,9 +238,6 @@ void Proxy::allocPipelineObjects()
     allocUserTelnet();
     allocMudTelnet();
 
-    allocMpiFilter();
-    allocRemoteEdit();
-
     allocParser();
 
     auto &lifetime = getPipeline().apis.sendToUserLifetime.emplace();
@@ -314,7 +299,6 @@ void Proxy::allocMudSocket()
         NODISCARD Proxy &getProxy() { return m_proxy; }
         NODISCARD MudTelnet &getMudTelnet() { return getProxy().getMudTelnet(); }
         NODISCARD MumeXmlParser &getMudParser() { return getProxy().getMudParser(); }
-        NODISCARD RemoteEdit &getRemoteEdit() { return getProxy().getRemoteEdit(); }
         NODISCARD UserTelnet &getUserTelnet() { return getProxy().getUserTelnet(); }
         NODISCARD Mmapper2Group &getGroupManager() { return getProxy().getGroupManager(); }
         NODISCARD ProxyHost &getHost() { return getProxy().getHost(); }
@@ -344,7 +328,7 @@ void Proxy::allocMudSocket()
 
         void virt_onSocketStatus(const QString &msg) final
         {
-            getProxy().sendStatusToUser(msg.toUtf8().toStdString());
+            getProxy().sendStatusToUser(mmqt::toStdStringUtf8(msg));
         }
 
         void virt_onDisconnected() final
@@ -354,7 +338,6 @@ void Proxy::allocMudSocket()
             getMudParser().onReset();
             getGroupManager().onReset();
             getProxy().mudTerminatedConnection();
-            getRemoteEdit().onDisconnected();
         }
 
         void virt_onProcessMudStream(const TelnetIacBytes &bytes) final
@@ -493,15 +476,14 @@ void Proxy::allocMudTelnet()
 
         void virt_onRelayGmcpFromMudToUser(const GmcpMessage &msg) final
         {
-            if (msg.isMumeClientView() || msg.isMumeClientEdit() || msg.isMumeClientCancelEdit()
-                || msg.isMumeClientError() || msg.isMumeClientWrite() || msg.isMumeClientXml()) {
-                // this is a private message between MUME and mmapper.
-                qWarning() << "MUME.Client message was almost sent to the user.";
-                return;
-            }
+            const bool isMumeClient = msg.isMumeClientView() || msg.isMumeClientEdit()
+                                      || msg.isMumeClientCancelEdit() || msg.isMumeClientError()
+                                      || msg.isMumeClientWrite() || msg.isMumeClientXml();
 
-            // forwarded (to user)
-            getUserTelnet().onGmcpToUser(msg);
+            if (!isMumeClient) {
+                // forwarded (to user)
+                getUserTelnet().onGmcpToUser(msg);
+            }
 
             // REVISIT: should parser be first?
             getGroupManager().slot_parseGmcpInput(msg);
@@ -530,16 +512,6 @@ void Proxy::allocMudTelnet()
             }
         }
 
-        void virt_onMumeClientView(const QString &title, const QString &body) final
-        {
-            getProxy().getMpiFilterFromMud().receiveMpiView(title, body);
-        }
-        void virt_onMumeClientEdit(const RemoteSessionId id,
-                                   const QString &title,
-                                   const QString &body) final
-        {
-            getProxy().getMpiFilterFromMud().receiveMpiEdit(id, title, body);
-        }
         void virt_onMumeClientError(const QString &errmsg) final
         {
             qInfo() << errmsg;
@@ -769,107 +741,6 @@ void Proxy::allocParser()
                      });
 }
 
-void Proxy::allocMpiFilter()
-{
-    struct NODISCARD LocalMpiFilterOutputs final : public MpiFilterOutputs
-    {
-    private:
-        Proxy &m_proxy;
-
-    public:
-        explicit LocalMpiFilterOutputs(Proxy &proxy)
-            : m_proxy{proxy}
-        {}
-
-    private:
-        NODISCARD Proxy &getProxy() { return m_proxy; }
-        NODISCARD MumeXmlParser &getMudParser() { return getProxy().getMudParser(); }
-        NODISCARD RemoteEdit &getRemoteEdit() { return getProxy().getRemoteEdit(); }
-
-    private:
-        void notifyUser(const std::string_view article,
-                        const std::string_view what,
-                        const QString &title)
-        {
-            const auto color = whiteOnCyan;
-            auto aos = getProxy().getSendToUserAnsiOstream();
-            if (g_prefixMessagesToUser) {
-                aos.writeWithColor(color.withBold(), "Info");
-                aos.writeWithColor(color, ": ");
-            }
-            aos.writeWithColor(color, "MMapper is opening ");
-            aos.writeWithColor(color, article);
-            aos.writeWithColor(color, " ");
-            aos.writeWithColor(color.withBold(), what);
-            aos.writeWithColor(color, " window with title \"");
-            aos.writeWithColor(color.withBold(), mmqt::toStdStringUtf8(title));
-            aos.writeWithColor(color, "\"");
-            aos.write("\n");
-        }
-
-    private:
-        void virt_onEditMessage(const RemoteSessionId id,
-                                const QString &title,
-                                const QString &body) final
-        {
-            notifyUser("an", "Editor", title);
-            getRemoteEdit().slot_remoteEdit(id, title, body);
-        }
-        void virt_onViewMessage(const QString &title, const QString &body) final
-        {
-            notifyUser("a", "Viewer", title);
-            getRemoteEdit().slot_remoteView(title, body);
-        }
-        void virt_onParseNewMudInput(const TelnetData &data) final
-        {
-            getMudParser().slot_parseNewMudInput(data);
-        }
-    };
-
-    auto &pipe = getPipeline();
-    auto &out = pipe.outputs.mud.mpiFilterOutputs = std::make_unique<LocalMpiFilterOutputs>(*this);
-    pipe.mud.mpiFilterFromMud = std::make_unique<MpiFilter>(deref(out));
-}
-
-void Proxy::allocRemoteEdit()
-{
-    // Caution: RemoteEdit outlives the proxy, since it manages windows.
-    m_remoteEdit = mmqt::makeQPointer<RemoteEdit>(&m_host.asQObject());
-
-    struct NODISCARD LocalMpiFilterToMud final : public MpiFilterToMud
-    {
-    private:
-        Proxy &m_proxy;
-
-    public:
-        explicit LocalMpiFilterToMud(Proxy &proxy)
-            : m_proxy{proxy}
-        {}
-
-    private:
-        void virt_submitGmcp(const GmcpMessage &gmcpMessage) final
-        {
-            m_proxy.getMudTelnet().onSubmitGmcpMumeClient(gmcpMessage);
-        }
-    };
-
-    auto &pipe = getPipeline();
-    pipe.mud.mpiFilterToMud = std::make_unique<LocalMpiFilterToMud>(*this);
-
-    auto &remoteEdit = deref(m_remoteEdit);
-    QObject::connect(&remoteEdit,
-                     &RemoteEdit::sig_remoteEditCancel,
-                     this,
-                     [this](const RemoteSessionId id) { getMpiFilterToMud().cancelRemoteEdit(id); });
-
-    QObject::connect(&remoteEdit,
-                     &RemoteEdit::sig_remoteEditSave,
-                     this,
-                     [this](const RemoteSessionId id, const Latin1Bytes &content) {
-                         getMpiFilterToMud().saveRemoteEdit(id, content);
-                     });
-}
-
 void Proxy::init()
 {
     auto initMisc = [this]() {
@@ -965,6 +836,7 @@ void Proxy::mudTerminatedConnection()
     getUserTelnet().onRelayEchoMode(true);
 
     log("Mud terminated connection ...");
+    getGameObserver().observeDisconnected();
 
     sendNewlineToUser();
     sendStatusToUser("MUME closed the connection.");
@@ -1197,7 +1069,7 @@ void Proxy::log(const QString &msg)
     getHost().log("Proxy", msg);
 }
 
-RemoteEdit &Proxy::getRemoteEdit()
+void Proxy::slot_sendGmcp(const GmcpMessage &msg)
 {
-    return deref(m_remoteEdit);
+    getMudTelnet().onSubmitGmcpMumeClient(msg);
 }
diff --git a/src/proxy/proxy.h b/src/proxy/proxy.h
index 605febd6a..11390fe01 100644
--- a/src/proxy/proxy.h
+++ b/src/proxy/proxy.h
@@ -35,8 +35,6 @@ class MapCanvas;
 class MapData;
 class Mmapper2Group;
 class Mmapper2PathMachine;
-class MpiFilter;
-class MpiFilterToMud;
 class MudTelnet;
 class MumeClock;
 class MumeFallbackSocket;
@@ -55,7 +53,6 @@ class AbstractSocket;
 struct AbstractParserOutputs;
 struct AnsiWarningMessage;
 struct GameTime;
-struct MpiFilterOutputs;
 struct MudTelnetOutputs;
 struct MumeSocketOutputs;
 struct ParserCommonData;
@@ -97,7 +94,6 @@ class NODISCARD_QOBJECT Proxy final : public QObject
             {
                 std::unique_ptr<MumeSocketOutputs> mudSocketOutputs;
                 std::unique_ptr<MudTelnetOutputs> mudTelnetOutputs;
-                std::unique_ptr<MpiFilterOutputs> mpiFilterOutputs;
             };
             std::unique_ptr<AbstractParserOutputs> parserXmlOutputs;
             User user;
@@ -134,8 +130,6 @@ class NODISCARD_QOBJECT Proxy final : public QObject
             std::unique_ptr<MumeFallbackSocket> mudSocket;
             std::unique_ptr<MudTelnet> mudTelnet;
             std::unique_ptr<TelnetLineFilter> mudTelnetFilter;
-            std::unique_ptr<MpiFilter> mpiFilterFromMud;
-            std::unique_ptr<MpiFilterToMud> mpiFilterToMud;
             std::unique_ptr<MumeXmlParser> mudParser;
             std::unique_ptr<PasswordConfig> passwordConfig;
         };
@@ -150,10 +144,6 @@ class NODISCARD_QOBJECT Proxy final : public QObject
     // because it's intended for sendXXX within the lifetime of this object.
     Signal2Lifetime m_lifetime;
 
-    // Technically we create this, but we don't "own" it;
-    // it outlives this object when the connection closes.
-    QPointer<RemoteEdit> m_remoteEdit;
-
     enum class NODISCARD ServerStateEnum {
         Initialized,
         Offline,
@@ -204,8 +194,6 @@ class NODISCARD_QOBJECT Proxy final : public QObject
     void allocUserTelnet();
     void allocMudTelnet();
     void allocParser();
-    void allocMpiFilter();
-    void allocRemoteEdit();
 
 private:
     void processUserStream();
@@ -299,19 +287,12 @@ class NODISCARD_QOBJECT Proxy final : public QObject
     {
         return deref(getPipeline().mud.mudTelnetFilter);
     }
-    NODISCARD MpiFilter &getMpiFilterFromMud() { return deref(getPipeline().mud.mpiFilterFromMud); }
-    NODISCARD MpiFilterToMud &getMpiFilterToMud()
-    {
-        return deref(getPipeline().mud.mpiFilterToMud);
-    }
-
     NODISCARD UserSocket &getUserSocket() { return deref(getPipeline().user.userSocket); }
     NODISCARD UserTelnet &getUserTelnet() { return deref(getPipeline().user.userTelnet); }
     NODISCARD TelnetLineFilter &getUserTelnetFilter()
     {
         return deref(getPipeline().user.userTelnetFilter);
     }
-    NODISCARD RemoteEdit &getRemoteEdit();
     NODISCARD MumeXmlParser &getMudParser() { return deref(getPipeline().mud.mudParser); }
     NODISCARD AbstractParser &getUserParser() { return deref(getPipeline().user.userParser); }
     NODISCARD PasswordConfig &getPasswordConfig()
@@ -326,4 +307,7 @@ class NODISCARD_QOBJECT Proxy final : public QObject
     {
         return deref(getPipeline().user.userTelnet);
     }
+
+public slots:
+    void slot_sendGmcp(const GmcpMessage &msg);
 };
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index a69ed3e8c..c772c340c 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -301,6 +301,24 @@ set_target_properties(
 )
 add_test(NAME TestTimer COMMAND TestTimer)
 
+# Remote edit draft store
+set(remote_edit_draft_store
+        ../src/mpi/RemoteEditDraftStore.cpp
+        ../src/mpi/RemoteEditDraftStore.h
+)
+set(TestRemoteEditDraftStore TestRemoteEditDraftStore.cpp)
+add_executable(TestRemoteEditDraftStore ${remote_edit_draft_store} ${TestRemoteEditDraftStore})
+add_dependencies(TestRemoteEditDraftStore mm_global)
+target_link_libraries(TestRemoteEditDraftStore mm_global Qt6::Test coverage_config)
+set_target_properties(
+        TestRemoteEditDraftStore PROPERTIES
+        CXX_STANDARD 20
+        CXX_STANDARD_REQUIRED ON
+        CXX_EXTENSIONS OFF
+        COMPILE_FLAGS "${WARNING_FLAGS}"
+)
+add_test(NAME TestRemoteEditDraftStore COMMAND TestRemoteEditDraftStore)
+
 # Room panel mob
 set(room_mob
         ../src/roompanel/RoomMob.h
diff --git a/tests/TestRemoteEditDraftStore.cpp b/tests/TestRemoteEditDraftStore.cpp
new file mode 100644
index 000000000..563efc98e
--- /dev/null
+++ b/tests/TestRemoteEditDraftStore.cpp
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "TestRemoteEditDraftStore.h"
+
+#include "../src/mpi/RemoteEditDraftStore.h"
+
+#include <memory>
+
+#include <QDir>
+#include <QSettings>
+#include <QTemporaryDir>
+#include <QtTest/QtTest>
+
+namespace {
+
+enum class NODISCARD StoreKind { File, Settings };
+
+struct NODISCARD Fixture final
+{
+    QTemporaryDir dir;
+    std::unique_ptr<RemoteEditDraftStore> store;
+
+    explicit Fixture(const StoreKind kind)
+    {
+        switch (kind) {
+        case StoreKind::File:
+            store = std::make_unique<RemoteEditFileDraftStore>(dir.filePath("drafts"));
+            break;
+        case StoreKind::Settings: {
+            const QString ini = dir.filePath("drafts.ini");
+            store = std::make_unique<RemoteEditSettingsDraftStore>(
+                [ini]() { return std::make_unique<QSettings>(ini, QSettings::IniFormat); });
+            break;
+        }
+        }
+    }
+};
+
+void addStoreKinds()
+{
+    QTest::addColumn<int>("kind");
+    QTest::newRow("file") << static_cast<int>(StoreKind::File);
+    QTest::newRow("settings") << static_cast<int>(StoreKind::Settings);
+}
+
+NODISCARD StoreKind fetchKind()
+{
+    QFETCH(int, kind);
+    return static_cast<StoreKind>(kind);
+}
+
+} // namespace
+
+TestRemoteEditDraftStore::TestRemoteEditDraftStore() = default;
+TestRemoteEditDraftStore::~TestRemoteEditDraftStore() = default;
+
+void TestRemoteEditDraftStore::testRoundTrip_data()
+{
+    addStoreKinds();
+}
+
+void TestRemoteEditDraftStore::testRoundTrip()
+{
+    Fixture f(fetchKind());
+    auto &store = *f.store;
+
+    QVERIFY(store.list().isEmpty());
+
+    const QString key = store.create(RemoteSessionId{42}, "Board post", "first\n");
+    QVERIFY(!key.isEmpty());
+    QCOMPARE(store.read(key), QString("first\n"));
+
+    const auto listed = store.list();
+    QCOMPARE(listed.size(), 1);
+    QCOMPARE(listed.front().key, key);
+    QCOMPARE(listed.front().title, QString("Board post"));
+    QCOMPARE(listed.front().sessionId, RemoteSessionId{42});
+    QVERIFY(listed.front().lastModified.isValid());
+
+    QVERIFY(store.save(key, "second\n"));
+    QCOMPARE(store.read(key), QString("second\n"));
+
+    store.remove(key);
+    QVERIFY(store.list().isEmpty());
+    QVERIFY(store.read(key).isEmpty());
+}
+
+void TestRemoteEditDraftStore::testCollidingSessionIds_data()
+{
+    addStoreKinds();
+}
+
+void TestRemoteEditDraftStore::testCollidingSessionIds()
+{
+    // MUME reuses session ids, so two edits with the same id and title must
+    // never share a draft.
+    Fixture f(fetchKind());
+    auto &store = *f.store;
+
+    const QString a = store.create(RemoteSessionId{7}, "Same", "A");
+    const QString b = store.create(RemoteSessionId{7}, "Same", "B");
+    QVERIFY(a != b);
+    QCOMPARE(store.read(a), QString("A"));
+    QCOMPARE(store.read(b), QString("B"));
+    QCOMPARE(store.list().size(), 2);
+}
+
+void TestRemoteEditDraftStore::testRemoveUnknownKeyIsHarmless_data()
+{
+    addStoreKinds();
+}
+
+void TestRemoteEditDraftStore::testRemoveUnknownKeyIsHarmless()
+{
+    Fixture f(fetchKind());
+    auto &store = *f.store;
+    const QString key = store.create(RemoteSessionId{1}, "Keep", "x");
+    store.remove("");
+    store.remove("does-not-exist");
+    QCOMPARE(store.list().size(), 1);
+    QVERIFY(!store.save("does-not-exist", "y"));
+    QCOMPARE(store.read(key), QString("x"));
+}
+
+void TestRemoteEditDraftStore::testFileStoreKeepsTitleWithAwkwardCharacters()
+{
+    Fixture f(StoreKind::File);
+    auto &store = *f.store;
+
+    // Slashes, spaces, and a title long enough that the 50-byte cap lands
+    // inside a percent-escape; the file name must stay valid and the title
+    // must decode to a prefix of the original rather than garbage.
+    const QString title = QString("a/b c%d ") + QString(30, QChar(0xE9)) + "tail";
+    const QString key = store.create(RemoteSessionId{3}, title, "body");
+    QVERIFY(!key.isEmpty());
+    QVERIFY(!key.contains('/'));
+    QVERIFY(QFile::exists(store.filePath(key)));
+
+    const auto listed = store.list();
+    QCOMPARE(listed.size(), 1);
+    QVERIFY(title.startsWith(listed.front().title));
+    QVERIFY(listed.front().title.startsWith("a/b c%d "));
+}
+
+void TestRemoteEditDraftStore::testFileStoreIgnoresForeignFiles()
+{
+    Fixture f(StoreKind::File);
+    auto &store = *f.store;
+    std::ignore = store.create(RemoteSessionId{1}, "Real", "x");
+
+    const QDir dir(f.dir.filePath("drafts"));
+    for (const char *const name : {"notes.txt", "draft_bogus.txt", "draft_1_x_y.txt"}) {
+        QFile file(dir.absoluteFilePath(name));
+        QVERIFY(file.open(QFile::WriteOnly));
+        file.write("junk");
+    }
+
+    const auto listed = store.list();
+    QCOMPARE(listed.size(), 1);
+    QCOMPARE(listed.front().title, QString("Real"));
+}
+
+void TestRemoteEditDraftStore::testFileStoreExposesPath()
+{
+    Fixture f(StoreKind::File);
+    const QString key = f.store->create(RemoteSessionId{1}, "T", "x");
+    QVERIFY(f.store->filePath(key).startsWith(f.dir.path()));
+    QVERIFY(f.store->filePath("").isEmpty());
+}
+
+void TestRemoteEditDraftStore::testSettingsStoreHasNoPath()
+{
+    Fixture f(StoreKind::Settings);
+    const QString key = f.store->create(RemoteSessionId{1}, "T", "x");
+    QVERIFY(f.store->filePath(key).isEmpty());
+
+    // A fresh store over the same settings sees the draft: this is the
+    // "survives a reload" property the WebAssembly build relies on.
+    const QString ini = f.dir.filePath("drafts.ini");
+    RemoteEditSettingsDraftStore reopened(
+        [ini]() { return std::make_unique<QSettings>(ini, QSettings::IniFormat); });
+    QCOMPARE(reopened.list().size(), 1);
+    QCOMPARE(reopened.read(key), QString("x"));
+}
+
+QTEST_MAIN(TestRemoteEditDraftStore)
diff --git a/tests/TestRemoteEditDraftStore.h b/tests/TestRemoteEditDraftStore.h
new file mode 100644
index 000000000..467f17319
--- /dev/null
+++ b/tests/TestRemoteEditDraftStore.h
@@ -0,0 +1,28 @@
+#pragma once
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2026 The MMapper Authors
+
+#include "../src/global/macros.h"
+
+#include <QObject>
+
+class NODISCARD_QOBJECT TestRemoteEditDraftStore final : public QObject
+{
+    Q_OBJECT
+
+public:
+    TestRemoteEditDraftStore();
+    ~TestRemoteEditDraftStore() final;
+
+private Q_SLOTS:
+    void testRoundTrip_data();
+    void testRoundTrip();
+    void testCollidingSessionIds_data();
+    void testCollidingSessionIds();
+    void testRemoveUnknownKeyIsHarmless_data();
+    void testRemoveUnknownKeyIsHarmless();
+    void testFileStoreKeepsTitleWithAwkwardCharacters();
+    void testFileStoreIgnoresForeignFiles();
+    void testFileStoreExposesPath();
+    void testSettingsStoreHasNoPath();
+};