feat(queries): edit, pin and delete a saved query from the UI

Item 82. Saving a query worked and nothing else did: changing one field meant
retyping the whole query under the same name, and deleting one meant editing
the file by hand. An action that creates something the UI cannot then change or
remove is incomplete, and the user hit it within minutes of the first hand test.

Right-clicking a saved query, on its button or its menu entry, now offers Edit,
Move to menu / Show as a button, and Delete. Every path funnels through one
replaceSavedQuery(), which matches on the name the dialog was OPENED with rather
than the one it returns, so a rename replaces the entry instead of leaving the
original behind beside a new one, and which merges the stored entry's unknown
fields in a single place rather than in three. Delete confirms first: the rule
against confirmation dialogs covers tag mutations, which the undo stack can take
back, and this writes user config that it cannot.

Two cases the item did not anticipate. A generated entry has no query to edit,
so the dialog shows its composed query read-only rather than offering a field
that changes nothing, and carries `generated` and `flat` through an edit rather
than letting it decay into a plain entry holding a snapshot of what it resolved
to today. And the overwrite notice had to learn to ignore the entry being
edited, since warning that "Inbox" already exists while editing Inbox is noise.

This also fixes a defect that predated it and was already reachable from the
save path. rebuildSavedQueryRow() called deleteLater() on the old row, which
defers destruction to the event loop, so the stale row went on answering
findChild() and every lookup after a rebuild reported the state from before the
edit. Nothing looked wrong on screen, which is why it surfaced only as three
tests failing against a row that had in fact been rebuilt correctly.

Five tests, three mutations. Matching on the returned name fails two, never
writing the file fails three, and dropping the unknown-field merge fails one.
That last one initially proved nothing: it drove UNPIN, which copies the stored
entry and so carries `unknown` along by itself, and passed with the merge
deleted. It now goes through the edit path with a replacement that has none,
which is what the dialog actually returns.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

8 files changed, 455 insertions, 8 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b384eda..5b14938 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,6 +28,12 @@ point at which they are stable.
   it can now be reordered, renamed, unpinned or deleted like any other entry
   rather than being a fixed button you did not own.
 
+- **Right-click a saved query** to edit, pin, unpin or delete it. A saved query
+  could previously be created and never changed: the only route to adjusting one
+  field was to retype the whole query under the same name, and there was no way
+  to delete one at all short of editing the file (item 82). Deleting asks first,
+  since it writes your config and is not undoable.
+
 ### Changed
 
 - Saved queries have a **row of their own** beneath the query bar rather than
diff --git a/README.md b/README.md
index 749d89d..9148923 100644
--- a/README.md
+++ b/README.md
@@ -244,6 +244,12 @@ sent folder, rather than offering a button that finds nothing.
 The name is what the button says, so `Important` and `Flagged` can run the same
 query and differ only in the label.
 
+**Right-click a saved query** (a button, or its entry in the menu) to edit it,
+move it between the row and the menu, or delete it. Deleting asks first: it
+rewrites this file and there is no undo for it. Editing a generated entry shows
+its composed query read-only, since that one is built from your accounts rather
+than stored.
+
 **Upgrading from 0.17.0 or earlier.** Saved queries used to live in a
 `[queries]` section of `qtmaildir.conf`. The first launch after upgrading reads
 that section, writes `queries.json` from it, and marks every entry pinned so
diff --git a/docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md b/docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md
index 9d19e4d..5e97337 100644
--- a/docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md
+++ b/docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md
@@ -146,7 +146,7 @@ taking that too literally.
 | 80 | A rule with many conditions squeezes the rule list to one visible row | defect | XS | **done** 2026-08-13 on `rule-builder`, unreleased. Follows item 76 |
 | 79 | Opening the rules dialog and saving destroys the first rule | defect | XS | **fixed on `rule-builder`** 2026-08-13, unreleased. Shipped in 0.16.0; damaged one real rule, repaired by hand |
 | 81 | No way to turn a saved query into a tagging rule | workflow | S | open; depends on 23, which builds the dialog, and is excluded from its spec on purpose. Writes to the shared rules file, so it spans this repo and `mailctl` |
-| 82 | A saved query cannot be edited, unpinned or deleted from the UI | defect | S | open; found by hand-testing item 23 on 2026-08-13. Saving works, unsaving does not |
+| 82 | A saved query cannot be edited, unpinned or deleted from the UI | defect | S | **done** 2026-08-13 on `saved-queries`, unreleased. Right-click offers Edit, Pin/Unpin and Delete |
 
 Sizes are rough: XS under an hour, S a sitting, M a session.
 
@@ -618,6 +618,30 @@ queries** entry, offering Edit, Unpin (or Pin) and Delete.
 
 **Size: S**, and it should land before the saved-query work is called done.
 
+**Done 2026-08-13.** A context menu on each button and each menu entry, with
+Edit, Move to menu / Show as a button, and Delete. Every path goes through one
+`replaceSavedQuery()`, matched on the name the dialog was OPENED with, so a
+rename replaces rather than duplicating, and merging the stored entry's unknown
+fields in one place rather than three.
+
+Two things the approach above did not anticipate. A GENERATED entry has no
+query to edit, so the dialog shows its composed query read-only rather than
+offering a field that changes nothing, and carries `generated` and `flat`
+through an edit rather than letting it decay into a plain entry holding a
+snapshot. And the overwrite notice had to learn to ignore the entry being
+edited: warning that "Inbox" already exists while editing Inbox is noise.
+
+It also exposed a defect that predated it. `rebuildSavedQueryRow()` called
+`deleteLater()` on the old row, which defers destruction to the event loop, so
+the stale row went on answering `findChild()` and every lookup after a rebuild
+saw the state from before the edit. It was already reachable from the save path.
+Fixed by reparenting the row out immediately.
+
+The unknown-fields test initially passed against the merge being deleted: it
+drove UNPIN, which copies the stored entry and therefore carries `unknown`
+along by itself. It now goes through the edit path with a replacement that has
+none, which is what the dialog actually returns.
+
 ## Deferred, unsized, or split out
 
 Items noted while triaging but not part of the original list. Same numbering
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 62f4751..14e4202 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1698,6 +1698,7 @@ void MainWindow::buildSavedQueryRow(QWidget *parent, QVBoxLayout *layout)
             button->setObjectName(QStringLiteral("sentButton"));
         connect(button, &QPushButton::clicked, this,
                 [this, saved]() { runSavedQuery(saved); });
+        addSavedQueryActions(button, saved);
         box->addWidget(button);
     }
 
@@ -1718,6 +1719,12 @@ void MainWindow::buildSavedQueryRow(QWidget *parent, QVBoxLayout *layout)
             QAction *action = menu->addAction(saved.name);
             connect(action, &QAction::triggered, this,
                     [this, saved]() { runSavedQuery(saved); });
+            // A menu entry has no context menu of its own, so its own submenu
+            // carries the same three actions; an unpinned query would
+            // otherwise be the one thing that cannot be edited or deleted.
+            auto *entryMenu = new QMenu(menu);
+            addSavedQueryActions(entryMenu, saved);
+            action->setMenu(entryMenu);
         }
         menuButton->setMenu(menu);
         box->addWidget(menuButton);
@@ -1733,6 +1740,105 @@ void MainWindow::buildSavedQueryRow(QWidget *parent, QVBoxLayout *layout)
         row->hide();
 }
 
+void MainWindow::addSavedQueryActions(QWidget *target, const SavedQuery &saved)
+{
+    target->setContextMenuPolicy(Qt::ActionsContextMenu);
+
+    auto *edit = new QAction(tr("Edit..."), target);
+    edit->setObjectName(QStringLiteral("editQuery"));
+    connect(edit, &QAction::triggered, this,
+            [this, saved]() { editSavedQuery(saved); });
+    target->addAction(edit);
+
+    auto *pin = new QAction(saved.pinned ? tr("Move to menu")
+                                         : tr("Show as a button"),
+                            target);
+    pin->setObjectName(QStringLiteral("pinQuery"));
+    connect(pin, &QAction::triggered, this, [this, saved]() {
+        SavedQuery toggled = saved;
+        toggled.pinned = !saved.pinned;
+        replaceSavedQuery(saved.name, toggled);
+    });
+    target->addAction(pin);
+
+    auto *separator = new QAction(target);
+    separator->setSeparator(true);
+    target->addAction(separator);
+
+    auto *remove = new QAction(tr("Delete"), target);
+    remove->setObjectName(QStringLiteral("deleteQuery"));
+    connect(remove, &QAction::triggered, this,
+            [this, saved]() { deleteSavedQuery(saved); });
+    target->addAction(remove);
+}
+
+void MainWindow::editSavedQuery(const SavedQuery &saved)
+{
+    SaveQueryDialog dialog(m_config, saved, this);
+    if (dialog.exec() != QDialog::Accepted)
+        return;
+
+    // Matched on the name the dialog OPENED with. Using the returned name would
+    // leave the original entry in place and add a second one under the new
+    // name, which is a duplicate rather than a rename.
+    replaceSavedQuery(saved.name, dialog.savedQuery());
+}
+
+void MainWindow::deleteSavedQuery(const SavedQuery &saved)
+{
+    // One of the few places in this application that confirms. The rule against
+    // confirmation dialogs covers tag mutations, which are undoable through the
+    // undo stack; this writes user config, is not on that stack, and cannot be
+    // taken back.
+    if (m_confirmDelete) {
+        const auto answer = QMessageBox::question(
+            this, tr("Delete saved query"),
+            tr("Delete the saved query '%1'?").arg(saved.name),
+            QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
+        if (answer != QMessageBox::Yes)
+            return;
+    }
+
+    replaceSavedQuery(saved.name, SavedQuery());
+}
+
+void MainWindow::replaceSavedQuery(const QString &originalName,
+                                   const SavedQuery &replacement)
+{
+    QList<SavedQuery> queries = m_config.savedQueries();
+    const bool removing = replacement.name.isEmpty();
+
+    for (int i = 0; i < queries.size(); ++i) {
+        if (queries.at(i).name.compare(originalName, Qt::CaseInsensitive) != 0)
+            continue;
+
+        if (removing) {
+            queries.removeAt(i);
+        } else {
+            // The unknown fields belong to the STORED entry: a field written by
+            // a later build survives an edit made here rather than being
+            // dropped on the next save.
+            SavedQuery merged = replacement;
+            merged.unknown = queries.at(i).unknown;
+            queries[i] = merged;
+        }
+        break;
+    }
+
+    m_config.setSavedQueries(queries);
+    if (!m_config.saveSavedQueries()) {
+        QMessageBox::warning(this, tr("Saved queries"),
+                             tr("Could not write the saved queries file."));
+        return;
+    }
+
+    rebuildSavedQueryRow();
+    statusBar()->showMessage(
+        removing ? tr("Deleted saved query '%1'.").arg(originalName)
+                 : tr("Updated saved query '%1'.").arg(replacement.name),
+        kStatusMessageMs);
+}
+
 void MainWindow::runSavedQuery(const SavedQuery &saved)
 {
     // Through the dropdown, never by pre-scoping the text: runQuery() applies
@@ -1817,6 +1923,13 @@ void MainWindow::rebuildSavedQueryRow()
 
     const int index = layout->indexOf(old);
     layout->removeWidget(old);
+    // Reparented out NOW, not merely scheduled for deletion. deleteLater()
+    // defers destruction to the event loop, so the old row goes on answering
+    // findChild() until it runs, and findChild returns the FIRST match: every
+    // lookup after a rebuild found the stale row and reported the state from
+    // before the edit. Nothing visible was wrong, which is why this only
+    // showed up as three tests failing on a row that had in fact been rebuilt.
+    old->setParent(nullptr);
     old->deleteLater();
 
     buildSavedQueryRow(centralWidget(), layout);
diff --git a/src/mainwindow.h b/src/mainwindow.h
index e6ee322..6e8501a 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -125,6 +125,25 @@ public:
     static void setLocksPathForTesting(const QString &path);
     static QString locksPath();
 
+    /// Suppresses the delete confirmation.
+    ///
+    /// A test seam. Deleting a saved query is destructive and not on the undo
+    /// stack, so it asks first; a test cannot answer a modal dialog without
+    /// hanging, and driving one through QTest would assert the dialog rather
+    /// than the deletion.
+    void setConfirmDeleteForTesting(bool confirm) { m_confirmDelete = confirm; }
+
+    /// Renames or replaces a stored query, as the edit dialog would on accept.
+    ///
+    /// A test seam for the rename path specifically: the dialog is modal, and
+    /// the property worth asserting is that a rename REPLACES rather than
+    /// duplicating, which is decided after the dialog returns.
+    void replaceSavedQueryForTesting(const QString &originalName,
+                                     const SavedQuery &replacement)
+    {
+        replaceSavedQuery(originalName, replacement);
+    }
+
     /// How many commands are on the undo stack.
     ///
     /// A test seam. The undo QAction is always enabled and checks canUndo()
@@ -253,6 +272,21 @@ private:
     /// Rebuilds the saved-query row in place after the stored list changed.
     void rebuildSavedQueryRow();
 
+    /// Hangs Edit, Pin/Unpin and Delete on a saved query's button or menu
+    /// entry. The only route to changing a stored query from the UI.
+    void addSavedQueryActions(QWidget *target, const SavedQuery &saved);
+
+    /// Replaces the entry named `originalName`, writes the file and rebuilds
+    /// the row. An empty `replacement.name` deletes it instead.
+    ///
+    /// Matched on the ORIGINAL name, not the replacement's: a rename otherwise
+    /// leaves the old entry in place and adds a second one.
+    void replaceSavedQuery(const QString &originalName,
+                           const SavedQuery &replacement);
+
+    void editSavedQuery(const SavedQuery &saved);
+    void deleteSavedQuery(const SavedQuery &saved);
+
 private slots:
     void runCurrentQuery() { runQuery(FlatResult::No); }
 
@@ -628,6 +662,8 @@ private:
     QLineEdit *m_queryEdit = nullptr;
     /// Save query, beside the field. Driven by the save_query action.
     QToolButton *m_saveQueryButton = nullptr;
+    /// Whether deleting a saved query asks first. Always true outside tests.
+    bool m_confirmDelete = true;
     QueryCompleter *m_queryCompleter = nullptr;
     /// Its own type, not the QTreeView base. The strip painting and the
     /// expander column are ThreadListView's, and holding the base here only
diff --git a/src/savequerydialog.cpp b/src/savequerydialog.cpp
index 1ea97c2..2d09986 100644
--- a/src/savequerydialog.cpp
+++ b/src/savequerydialog.cpp
@@ -42,19 +42,51 @@ SaveQueryDialog::SaveQueryDialog(const Config &config, const QString &query,
     : QDialog(parent)
     , m_config(config)
 {
+    SavedQuery initial;
+    initial.query = query;
+    initial.account = accountKey;
+    initial.pinned = true;
     setWindowTitle(tr("Save query"));
+    build(initial);
+}
 
+SaveQueryDialog::SaveQueryDialog(const Config &config,
+                                 const SavedQuery &existing, QWidget *parent)
+    : QDialog(parent)
+    , m_config(config)
+    , m_originalName(existing.name)
+    , m_generated(existing.generated)
+    , m_flat(existing.flat)
+{
+    setWindowTitle(tr("Edit saved query"));
+    build(existing);
+}
+
+void SaveQueryDialog::build(const SavedQuery &initial)
+{
     auto *layout = new QVBoxLayout(this);
     auto *form = new QFormLayout;
 
-    m_name = new QLineEdit(this);
+    m_name = new QLineEdit(initial.name, this);
     m_name->setObjectName(QStringLiteral("saveQueryName"));
     m_name->setPlaceholderText(tr("A name for this query"));
     form->addRow(tr("Name"), m_name);
 
-    m_query = new QLineEdit(query, this);
+    m_query = new QLineEdit(initial.query, this);
     m_query->setObjectName(QStringLiteral("saveQueryQuery"));
-    form->addRow(tr("Query"), m_query);
+    if (initial.isGenerated()) {
+        // A generated entry has no stored query: it is composed from the
+        // accounts every time it runs. Shown, so the user can see what it will
+        // do, but read-only, since editing it would change nothing.
+        m_query->setText(m_config.resolvedQuery(initial));
+        m_query->setReadOnly(true);
+        m_query->setToolTip(tr("Built from your accounts and not editable. "
+                               "It follows the sent folder each account "
+                               "configures."));
+        form->addRow(tr("Query"), m_query);
+    } else {
+        form->addRow(tr("Query"), m_query);
+    }
 
     // The scope is stored as an account KEY, so the entries carry the key as
     // data exactly as the main window's dropdown does. "All accounts" is the
@@ -63,15 +95,15 @@ SaveQueryDialog::SaveQueryDialog(const Config &config, const QString &query,
     m_account = new QComboBox(this);
     m_account->setObjectName(QStringLiteral("saveQueryAccount"));
     m_account->addItem(tr("All accounts"), QString());
-    for (const Account &account : config.accounts())
+    for (const Account &account : m_config.accounts())
         m_account->addItem(account.key, account.key);
-    const int index = m_account->findData(accountKey);
+    const int index = m_account->findData(initial.account);
     m_account->setCurrentIndex(index >= 0 ? index : 0);
     form->addRow(tr("Account"), m_account);
 
     m_pinned = new QCheckBox(tr("Show as a button"), this);
     m_pinned->setObjectName(QStringLiteral("saveQueryPinned"));
-    m_pinned->setChecked(true);
+    m_pinned->setChecked(initial.pinned);
     form->addRow(QString(), m_pinned);
 
     layout->addLayout(form);
@@ -108,7 +140,14 @@ void SaveQueryDialog::updateOkState()
     const bool usable = !name.isEmpty() && !m_query->text().trimmed().isEmpty();
     m_ok->setEnabled(usable);
 
-    if (!name.isEmpty() && namesAnExistingQuery(m_config, name)) {
+    // Ignores the entry being edited: warning that "Inbox" already exists
+    // while editing Inbox is noise, and the real case worth catching is a
+    // rename onto a name something else already holds.
+    const bool isItsOwnName =
+        !m_originalName.isEmpty()
+        && name.compare(m_originalName, Qt::CaseInsensitive) == 0;
+    if (!name.isEmpty() && !isItsOwnName
+        && namesAnExistingQuery(m_config, name)) {
         m_notice->setText(
             tr("A saved query named '%1' already exists and will be "
                "replaced.").arg(name));
@@ -124,5 +163,12 @@ SavedQuery SaveQueryDialog::savedQuery() const
     saved.query = m_query->text().trimmed();
     saved.account = m_account->currentData().toString();
     saved.pinned = m_pinned->isChecked();
+    // Carried through rather than re-derived: an edit must not turn a
+    // generated entry into a plain one holding a snapshot of what it happened
+    // to resolve to today.
+    saved.generated = m_generated;
+    saved.flat = m_flat;
+    if (saved.isGenerated())
+        saved.query.clear();
     return saved;
 }
diff --git a/src/savequerydialog.h b/src/savequerydialog.h
index be5a2af..d859254 100644
--- a/src/savequerydialog.h
+++ b/src/savequerydialog.h
@@ -42,6 +42,11 @@ public:
     SaveQueryDialog(const Config &config, const QString &query,
                     const QString &accountKey, QWidget *parent = nullptr);
 
+    /// Edits an entry that already exists, prefilled from it rather than from
+    /// the query bar.
+    SaveQueryDialog(const Config &config, const SavedQuery &existing,
+                    QWidget *parent = nullptr);
+
     /// The query as edited. Only meaningful after exec() returned Accepted.
     SavedQuery savedQuery() const;
 
@@ -51,8 +56,19 @@ public:
     static bool namesAnExistingQuery(const Config &config, const QString &name);
 
 private:
+    void build(const SavedQuery &initial);
     void updateOkState();
 
+    /// The name the dialog was opened on, empty when creating. The caller
+    /// matches on this rather than on the returned name, so a rename replaces
+    /// the entry instead of adding a second one beside it.
+    QString m_originalName;
+
+    /// Set for a generated entry, whose query is composed from the accounts
+    /// and cannot be edited here.
+    QString m_generated;
+    bool m_flat = false;
+
     const Config &m_config;
     QLineEdit *m_name = nullptr;
     QLineEdit *m_query = nullptr;
diff --git a/tests/test_mainwindow.cpp b/tests/test_mainwindow.cpp
index 883e9a7..d090016 100644
--- a/tests/test_mainwindow.cpp
+++ b/tests/test_mainwindow.cpp
@@ -203,6 +203,11 @@ private slots:
     void aStoredGeneratedQueryRunsFlatAndComposed();
     void aRenamedSentEntryKeepsWorking();
     void aGeneratedQueryWithNothingToShowIsSkipped();
+    void aSavedQueryButtonOffersEditUnpinAndDelete();
+    void unpinningMovesAQueryToTheMenu();
+    void deletingRemovesTheQueryFromTheFile();
+    void anEditedQueryKeepsItsUnknownFields();
+    void renamingReplacesRatherThanDuplicating();
 
 private:
     /// Owns the throwaway lock table init() points every test at. A pointer
@@ -5775,4 +5780,199 @@ void TestMainWindow::aGeneratedQueryWithNothingToShowIsSkipped()
              "a generated query with nothing to show must not get a button");
 }
 
+/// Reads queries.json back from disk, which is what "it was saved" means.
+static QJsonArray storedQueries(const QTemporaryDir &dir)
+{
+    QFile f(dir.filePath(QStringLiteral("qtmaildir/queries.json")));
+    if (!f.open(QIODevice::ReadOnly))
+        return {};
+    const QJsonObject root = QJsonDocument::fromJson(f.readAll()).object();
+    return root.value(QStringLiteral("queries")).toArray();
+}
+
+static QAction *contextActionNamed(MainWindow &window, QWidget *target,
+                                   const QString &objectName)
+{
+    const QList<QAction *> actions = target->actions();
+    for (QAction *action : actions) {
+        if (action->objectName() == objectName)
+            return action;
+    }
+    Q_UNUSED(window);
+    return nullptr;
+}
+
+void TestMainWindow::aSavedQueryButtonOffersEditUnpinAndDelete()
+{
+    QTemporaryDir dir;
+    QVERIFY(dir.isValid());
+    Config config;
+    loadWithQueries(config, dir, QStringLiteral(R"({
+        "version": 1,
+        "queries": [
+            { "name": "Inbox", "query": "tag:inbox", "pinned": true }
+        ]
+    })"));
+
+    MainWindow window(config);
+    auto *row = window.findChild<QWidget *>(QStringLiteral("savedQueryRow"));
+    QVERIFY(row);
+    auto *button = row->findChild<QPushButton *>();
+    QVERIFY(button);
+
+    // A context menu, so the actions live on the widget itself.
+    QCOMPARE(button->contextMenuPolicy(), Qt::ActionsContextMenu);
+    QVERIFY(contextActionNamed(window, button, QStringLiteral("editQuery")));
+    QVERIFY(contextActionNamed(window, button, QStringLiteral("pinQuery")));
+    QVERIFY(contextActionNamed(window, button, QStringLiteral("deleteQuery")));
+}
+
+void TestMainWindow::unpinningMovesAQueryToTheMenu()
+{
+    QTemporaryDir dir;
+    QVERIFY(dir.isValid());
+    Config config;
+    loadWithQueries(config, dir, QStringLiteral(R"({
+        "version": 1,
+        "queries": [
+            { "name": "Inbox", "query": "tag:inbox", "pinned": true },
+            { "name": "Other", "query": "tag:other", "pinned": true }
+        ]
+    })"));
+
+    MainWindow window(config);
+    auto *row = window.findChild<QWidget *>(QStringLiteral("savedQueryRow"));
+    QVERIFY(row);
+    QCOMPARE(savedQueryButtonLabels(window).size(), 2);
+    QVERIFY(!window.findChild<QPushButton *>(
+        QStringLiteral("savedQueryMenuButton")));
+
+    auto *button = row->findChild<QPushButton *>();
+    QVERIFY(button);
+    QAction *pin = contextActionNamed(window, button, QStringLiteral("pinQuery"));
+    QVERIFY(pin);
+    pin->trigger();
+
+    // Off the row, into the menu, and written to the file: an unpin that only
+    // redrew would come back pinned on the next launch.
+    QCOMPARE(savedQueryButtonLabels(window), QStringList{ QStringLiteral("Other") });
+    auto *menuButton =
+        window.findChild<QPushButton *>(QStringLiteral("savedQueryMenuButton"));
+    QVERIFY(menuButton);
+    QCOMPARE(menuButton->menu()->actions().size(), 1);
+
+    const QJsonArray stored = storedQueries(dir);
+    QCOMPARE(stored.size(), 2);
+    QCOMPARE(stored.at(0).toObject().value(QStringLiteral("name")).toString(),
+             QStringLiteral("Inbox"));
+    QVERIFY2(!stored.at(0).toObject().contains(QStringLiteral("pinned")),
+             "the unpin did not reach the file");
+}
+
+void TestMainWindow::deletingRemovesTheQueryFromTheFile()
+{
+    QTemporaryDir dir;
+    QVERIFY(dir.isValid());
+    Config config;
+    loadWithQueries(config, dir, QStringLiteral(R"({
+        "version": 1,
+        "queries": [
+            { "name": "Doomed", "query": "tag:doomed", "pinned": true },
+            { "name": "Keeper", "query": "tag:keeper", "pinned": true }
+        ]
+    })"));
+
+    MainWindow window(config);
+    auto *row = window.findChild<QWidget *>(QStringLiteral("savedQueryRow"));
+    QVERIFY(row);
+    auto *button = row->findChild<QPushButton *>();
+    QVERIFY(button);
+    QCOMPARE(button->text(), QStringLiteral("Doomed"));
+
+    QAction *del =
+        contextActionNamed(window, button, QStringLiteral("deleteQuery"));
+    QVERIFY(del);
+    // Destructive and not on the undo stack, so it confirms. Suppressed here
+    // rather than driven through the modal dialog, which would hang the test.
+    window.setConfirmDeleteForTesting(false);
+    del->trigger();
+
+    QCOMPARE(savedQueryButtonLabels(window),
+             QStringList{ QStringLiteral("Keeper") });
+
+    const QJsonArray stored = storedQueries(dir);
+    QCOMPARE(stored.size(), 1);
+    QCOMPARE(stored.at(0).toObject().value(QStringLiteral("name")).toString(),
+             QStringLiteral("Keeper"));
+}
+
+/// A field a later build wrote must survive an edit here, or upgrading and
+/// downgrading silently strips config the user set.
+void TestMainWindow::anEditedQueryKeepsItsUnknownFields()
+{
+    QTemporaryDir dir;
+    QVERIFY(dir.isValid());
+    Config config;
+    loadWithQueries(config, dir, QStringLiteral(R"({
+        "version": 1,
+        "queries": [
+            { "name": "Inbox", "query": "tag:inbox", "pinned": true,
+              "icon": "mail-inbox" }
+        ]
+    })"));
+
+    MainWindow window(config);
+
+    // Through the EDIT path, with a replacement carrying no unknown fields of
+    // its own, which is exactly what SaveQueryDialog returns. Driving this
+    // through unpin instead proved nothing: unpin copies the stored entry, so
+    // it carries `unknown` along by itself and the merge is never exercised.
+    // That version passed with the merge deleted.
+    SavedQuery edited;
+    edited.name = QStringLiteral("Inbox");
+    edited.query = QStringLiteral("tag:inbox and not tag:muted");
+    edited.pinned = true;
+    QVERIFY(edited.unknown.isEmpty());
+    window.replaceSavedQueryForTesting(QStringLiteral("Inbox"), edited);
+
+    const QJsonArray stored = storedQueries(dir);
+    QCOMPARE(stored.size(), 1);
+    const QJsonObject entry = stored.at(0).toObject();
+    // The edit landed...
+    QCOMPARE(entry.value(QStringLiteral("query")).toString(),
+             QStringLiteral("tag:inbox and not tag:muted"));
+    // ...and did not take the unknown field down with it.
+    QCOMPARE(entry.value(QStringLiteral("icon")).toString(),
+             QStringLiteral("mail-inbox"));
+}
+
+/// Renaming must match on the name the dialog OPENED with. Matching on the
+/// returned name leaves the original in place and adds a second entry.
+void TestMainWindow::renamingReplacesRatherThanDuplicating()
+{
+    QTemporaryDir dir;
+    QVERIFY(dir.isValid());
+    Config config;
+    loadWithQueries(config, dir, QStringLiteral(R"({
+        "version": 1,
+        "queries": [
+            { "name": "Old", "query": "tag:old", "pinned": true }
+        ]
+    })"));
+
+    MainWindow window(config);
+
+    SavedQuery renamed;
+    renamed.name = QStringLiteral("New");
+    renamed.query = QStringLiteral("tag:old");
+    renamed.pinned = true;
+    window.replaceSavedQueryForTesting(QStringLiteral("Old"), renamed);
+
+    const QJsonArray stored = storedQueries(dir);
+    QCOMPARE(stored.size(), 1);
+    QCOMPARE(stored.at(0).toObject().value(QStringLiteral("name")).toString(),
+             QStringLiteral("New"));
+    QCOMPARE(savedQueryButtonLabels(window), QStringList{ QStringLiteral("New") });
+}
+
 #include "test_mainwindow.moc"