fix(acp): restore thinking UI height after session tab switch

Inactive session pages sit on a hidden QStackedWidget, so isVisible()
is false while thoughts and tool cards still stream. Pin height from
the logical collapse flag, force QTextDocument layout, and re-fit on
showEvent so switching back does not clip the body to the header.

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

Author: nullmastermind

src/widgets/AcpMessageWidget.cpp

@@ -31,9 +31,11 @@
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPixmap>
+#include <QPointer>
 #include <QRegularExpression>
 #include <QResizeEvent>
 #include <QScrollBar>
+#include <QShowEvent>
 #include <QStyle>
 #include <QTextBlock>
 #include <QTextBrowser>
@@ -156,6 +158,28 @@ QString ensureHardBreaks(const QString &md)
     return out;
 }
 
+// QTextDocument lays out lazily: after setHtml()/setPlainText() the document
+// reports a stale (often single-line) size until something forces the layout
+// engine to run for the current text width. Measuring height before that pass
+// clips multi-line thought/assistant bodies to ~one line. Touching the layout's
+// documentSize() after pinning the text width forces the full pass, so the
+// subsequent doc->size() read is authoritative. Same helper as AcpToolCallCard.
+qreal layoutDocumentHeight(QTextDocument *doc, int textWidth)
+{
+    if (!doc) return 0.0;
+    doc->setTextWidth(textWidth);
+    QAbstractTextDocumentLayout *layout = doc->documentLayout();
+    if (!layout) return doc->size().height();
+    qreal h = layout->documentSize().height();
+    const QTextBlock last = doc->lastBlock();
+    if (last.isValid()) {
+        const QRectF r = layout->blockBoundingRect(last);
+        if (r.isValid())
+            h = qMax(h, r.bottom());
+    }
+    return qMax(h, doc->size().height());
+}
+
 } // namespace
 
 AcpMessageWidget::AcpMessageWidget(QString role, QWidget *parent)
@@ -203,8 +227,9 @@ AcpMessageWidget::AcpMessageWidget(QString role, QWidget *parent)
         m_layout->addWidget(m_browser);
 
         connect(m_thoughtHeader, &QToolButton::toggled, this, [this](bool checked) {
-            if (m_browser) m_browser->setVisible(checked);
-            refitBrowserHeight();
+            // Header checked = expanded. Keep m_collapsed in lockstep so height
+            // fitting can gate on the logical flag, not QWidget::isVisible().
+            applyCollapsed(!checked);
         });
     } else {
         // assistant + any other roles
@@ -449,6 +474,7 @@ void AcpMessageWidget::rerender()
         normalizeBlockMargins(m_browser->document());
     }
     refitBrowserHeight();
+    scheduleRefit();
 }
 
 void AcpMessageWidget::refitBrowserHeight()
@@ -461,14 +487,6 @@ void AcpMessageWidget::refitBrowserHeight()
     if (m_layout) {
         m_layout->getContentsMargins(&marginL, &marginT, &marginR, &marginB);
     }
-    const int w = width() - marginL - marginR;
-    if (w <= 0) {
-        return;
-    }
-    QTextDocument *doc = m_browser->document();
-    doc->setTextWidth(w);
-    const int browserH = qMax(0, static_cast<int>(std::ceil(doc->size().height())));
-    m_browser->setFixedHeight(browserH);
 
     // Pin the bubble's own height too. setFixedHeight on the inner browser
     // only clamps the browser — QFrame's sizeHint cascades through QBoxLayout
@@ -480,15 +498,49 @@ void AcpMessageWidget::refitBrowserHeight()
         // adds style-derived button margins even with stylesheet padding:0,
         // which adds phantom vertical space inside the bubble.
         bubbleH += m_thoughtHeader->fontMetrics().height();
-        if (m_browser->isVisible()) {
-            bubbleH += m_layout->spacing() + browserH;
+        // Gate on the LOGICAL expand state, not m_browser->isVisible(): a
+        // thought on a hidden QStackedWidget page (inactive session tab) —
+        // or a just-inserted widget not yet painted — reads isVisible()==false
+        // even though the body WILL paint once the tab is shown. That under-
+        // pins the frame to header-only height while the body keeps its
+        // measured height, clipping the thinking text. m_collapsed is
+        // independent of show timing.
+        if (m_collapsed) {
+            setFixedHeight(bubbleH);
+            return;
         }
-    } else {
-        bubbleH += browserH;
+        bubbleH += m_layout->spacing();
     }
+
+    const int w = width() - marginL - marginR;
+    if (w <= 0) {
+        // Width not settled (never-shown stack page). Keep whatever height we
+        // already have unless we just collapsed to header-only above.
+        return;
+    }
+    QTextDocument *doc = m_browser->document();
+    // Force a full layout pass for the current width before measuring —
+    // QTextDocument under-reports height for freshly-set multi-line text
+    // until the layout engine has run, which clips an expanded thought down
+    // to roughly its first line.
+    const int browserH = qMax(0, static_cast<int>(std::ceil(layoutDocumentHeight(doc, w))));
+    m_browser->setFixedHeight(browserH);
+    bubbleH += browserH;
     setFixedHeight(bubbleH);
 }
 
+void AcpMessageWidget::scheduleRefit()
+{
+    if (m_refitScheduled) return;
+    m_refitScheduled = true;
+    QPointer<AcpMessageWidget> guard(this);
+    QTimer::singleShot(0, this, [guard]() {
+        if (!guard) return;
+        guard->m_refitScheduled = false;
+        guard->refitBrowserHeight();
+    });
+}
+
 void AcpMessageWidget::resizeEvent(QResizeEvent *event)
 {
     QFrame::resizeEvent(event);
@@ -501,11 +553,22 @@ void AcpMessageWidget::resizeEvent(QResizeEvent *event)
     }
 }
 
+void AcpMessageWidget::showEvent(QShowEvent *event)
+{
+    QFrame::showEvent(event);
+    // Session-tab switch shows this page without a size change, so resizeEvent
+    // may not run. Re-measure now that we are actually visible and the stacked
+    // layout has given us a real width.
+    refitBrowserHeight();
+    scheduleRefit();
+}
+
 void AcpMessageWidget::changeEvent(QEvent *event)
 {
     QFrame::changeEvent(event);
     if (event->type() == QEvent::FontChange) {
         refitBrowserHeight();
+        scheduleRefit();
     } else if (event->type() == QEvent::PaletteChange
                || event->type() == QEvent::ApplicationPaletteChange) {
         // Re-tint the copy glyph and re-skin code surfaces for the new theme.
@@ -867,6 +930,7 @@ void AcpMessageWidget::setChatFont(const QFont &font)
         rerender();
     } else {
         refitBrowserHeight();
+        scheduleRefit();
     }
 }
 
@@ -886,4 +950,8 @@ void AcpMessageWidget::applyCollapsed(bool collapsed)
         m_browser->setVisible(!collapsed);
     }
     refitBrowserHeight();
+    // Body may have been laid out at a stale width while hidden; re-measure
+    // once the expanded geometry settles so the thought doesn't clip on
+    // first expand / tab show.
+    if (!collapsed) scheduleRefit();
 }

src/widgets/AcpMessageWidget.h

@@ -32,6 +32,7 @@ class QTimer;
 class QToolButton;
 class QLabel;
 class QVBoxLayout;
+class QShowEvent;
 
 // One transcript row representing either a user/assistant/thought/system
 // message. Assistant messages render markdown via QTextDocument::setMarkdown;
@@ -78,6 +79,11 @@ class AcpMessageWidget : public QFrame
 
 protected:
     void resizeEvent(QResizeEvent *event) override;
+    // QStackedWidget (session tabs) hides inactive pages without a size change,
+    // so resizeEvent does not re-run on tab switch. Re-fit on show so a thought
+    // that streamed in the background keeps its body height instead of staying
+    // pinned to the header.
+    void showEvent(QShowEvent *event) override;
     // Bubble height is derived from QTextDocument::size() under the current
     // font metrics; when the parent's font changes (Default Font preference)
     // we need to re-fit, because Qt does not auto-relayout content widgets on
@@ -90,6 +96,7 @@ class AcpMessageWidget : public QFrame
 private:
     void rerender();
     void refitBrowserHeight();
+    void scheduleRefit();
     void applyCollapsed(bool collapsed);
     void scheduleRerender();
     void flushRerender();
@@ -115,6 +122,7 @@ class AcpMessageWidget : public QFrame
     QString m_text;
     bool m_collapsed = false;
     bool m_fromGoalAgent = false;
+    bool m_refitScheduled = false; // coalesced deferred height pass already queued
 
     // Chat (Default Font) typeface, pushed in via setChatFont(). Held so that
     // content created/re-rendered after the initial setFont() (streamed chunks,

src/widgets/AcpToolCallCard.cpp

@@ -29,6 +29,7 @@
 #include <QPointer>
 #include <QRegularExpression>
 #include <QResizeEvent>
+#include <QShowEvent>
 #include <QStringList>
 #include <QTextBlock>
 #include <QTextBrowser>
@@ -1072,7 +1073,9 @@ void AcpToolCallCard::refitBodyHeight()
 
     const int w = width() - marginL - marginR;
     if (w <= 0) {
-        setFixedHeight(cardH);
+        // Width not settled (never-shown stack page). Keep whatever height we
+        // already have — pinning to header-only here clips an expanded body
+        // that streamed on a hidden tab.
         return;
     }
     QTextDocument *doc = m_body->document();
@@ -1128,6 +1131,21 @@ void AcpToolCallCard::resizeEvent(QResizeEvent *event)
     }
 }
 
+void AcpToolCallCard::showEvent(QShowEvent *event)
+{
+    QFrame::showEvent(event);
+    // Session-tab switch shows this page without a size change, so resizeEvent
+    // may not run. Re-measure now that we are actually visible and the stacked
+    // layout has given us a real width.
+    refreshHeader();
+    if (!m_collapsed && m_bodyDirty) {
+        flushBodyRender();
+    } else {
+        refitBodyHeight();
+    }
+    scheduleRefit();
+}
+
 void AcpToolCallCard::setCollapsed(bool collapsed)
 {
     m_collapsed = collapsed;

src/widgets/AcpToolCallCard.h

@@ -31,6 +31,7 @@ class QTextBrowser;
 class QTimer;
 class QToolButton;
 class QVBoxLayout;
+class QShowEvent;
 
 class AcpToolCallCard : public QFrame
 {
@@ -60,6 +61,11 @@ class AcpToolCallCard : public QFrame
 
 protected:
     void resizeEvent(QResizeEvent *event) override;
+    // QStackedWidget (session tabs) hides inactive pages without a size change,
+    // so resizeEvent does not re-run on tab switch. Re-fit on show so an
+    // expanded diff/output body that streamed in the background keeps its
+    // height instead of staying pinned to the header.
+    void showEvent(QShowEvent *event) override;
 
 private:
     void refreshHeader();

tests/test_acp_message_widget_streaming.cpp

@@ -7,6 +7,7 @@
 
 #include <QtTest>
 #include <QTextBrowser>
+#include <QToolButton>
 
 #include "AcpMessageWidget.h"
 
@@ -18,6 +19,8 @@ private slots:
     void assistant_streaming_buffers_chunks();
     void thought_collapse_after_streaming_done();
     void thought_renders_markdown_as_raw_text();
+    void thought_keeps_body_height_while_hidden();
+    void thought_reexpand_while_hidden_restores_body_height();
 };
 
 void TestAcpMessageWidgetStreaming::assistant_streaming_buffers_chunks()
@@ -49,5 +52,51 @@ void TestAcpMessageWidgetStreaming::thought_renders_markdown_as_raw_text()
     QCOMPARE(browser->toPlainText().trimmed(), raw);
 }
 
+void TestAcpMessageWidgetStreaming::thought_keeps_body_height_while_hidden()
+{
+    // Inactive session tabs live on a hidden QStackedWidget page, so
+    // QWidget::isVisible() is false while thought chunks still stream.
+    // Height must follow the logical collapse flag, not isVisible() —
+    // otherwise the bubble pins to header height and clips the body.
+    AcpMessageWidget w(QStringLiteral("thought"));
+    w.resize(420, 40);
+    QVERIFY(!w.isVisible());
+
+    w.setText(QStringLiteral(
+        "line one of the thought\n"
+        "line two of the thought\n"
+        "line three of the thought\n"
+        "line four of the thought"));
+    const int expandedH = w.height();
+
+    w.markStreamingDone();
+    QVERIFY(w.isCollapsed());
+    const int collapsedH = w.height();
+
+    QVERIFY2(expandedH > collapsedH,
+             qPrintable(QStringLiteral("expanded=%1 collapsed=%2")
+                            .arg(expandedH)
+                            .arg(collapsedH)));
+}
+
+void TestAcpMessageWidgetStreaming::thought_reexpand_while_hidden_restores_body_height()
+{
+    AcpMessageWidget w(QStringLiteral("thought"));
+    w.resize(420, 40);
+    w.setText(QStringLiteral("a\nb\nc\nd"));
+    w.markStreamingDone();
+    QVERIFY(w.isCollapsed());
+    const int collapsedH = w.height();
+
+    auto *header = w.findChild<QToolButton *>();
+    QVERIFY(header);
+    header->setChecked(true);
+    QVERIFY(!w.isCollapsed());
+    QVERIFY2(w.height() > collapsedH,
+             qPrintable(QStringLiteral("expanded=%1 collapsed=%2")
+                            .arg(w.height())
+                            .arg(collapsedH)));
+}
+
 QTEST_MAIN(TestAcpMessageWidgetStreaming)
 #include "test_acp_message_widget_streaming.moc"

tests/test_acp_tool_call_card.cpp

@@ -21,6 +21,7 @@ private slots:
     void diff_card_auto_expands_at_terminal_status();
     void running_diff_card_stays_collapsed();
     void collapsed_multiline_title_autosizes_to_two_lines();
+    void expanded_diff_taller_than_collapsed_while_hidden();
 };
 
 namespace {
@@ -198,5 +199,34 @@ void TestAcpToolCallCard::collapsed_multiline_title_autosizes_to_two_lines()
     QCOMPARE(two.height(), beforeToggle);
 }
 
+void TestAcpToolCallCard::expanded_diff_taller_than_collapsed_while_hidden()
+{
+    // Inactive session tabs live on a hidden QStackedWidget page. An
+    // auto-expanded diff must still include the body in its pinned height
+    // even though isVisible() is false — otherwise switching back clips
+    // the diff to the header.
+    AcpProtocol::AcpToolCall tc = baseCall();
+    tc.status = QStringLiteral("completed");
+    tc.content.append(diffBlock());
+
+    AcpToolCallCard expanded(tc);
+    expanded.resize(480, 120);
+    QVERIFY(!expanded.isVisible());
+    QVERIFY(!expanded.isCollapsed());
+    QTRY_VERIFY(bodyFor(expanded)->toPlainText().contains(QStringLiteral("a.cpp")));
+    const int expandedH = expanded.height();
+
+    AcpProtocol::AcpToolCall running = baseCall();
+    AcpToolCallCard collapsed(running);
+    collapsed.resize(480, 120);
+    QVERIFY(collapsed.isCollapsed());
+    const int collapsedH = collapsed.height();
+
+    QVERIFY2(expandedH > collapsedH,
+             qPrintable(QStringLiteral("expanded=%1 collapsed=%2")
+                            .arg(expandedH)
+                            .arg(collapsedH)));
+}
+
 QTEST_MAIN(TestAcpToolCallCard)
 #include "test_acp_tool_call_card.moc"