@@ -873,6 +873,7 @@ void AcpSessionView::hydrateFromModel()
                                          &m_foldedMask);
     recordTruncation(plan);
 
+    const QFont font = chatFont();
     int pendingHidden = 0;
     for (int i = 0; i < timeline.size(); ++i) {
         const auto fold = foldAt.constFind(i);
@@ -893,7 +894,7 @@ void AcpSessionView::hydrateFromModel()
             insertTimelineWidget(makeTruncationPlaceholder(pendingHidden), false);
             pendingHidden = 0;
         }
-        if (QWidget *w = createEntryWidget(timeline.at(i)))
+        if (QWidget *w = createEntryWidget(timeline.at(i), font))
             insertTimelineWidget(w, false);
     }
     if (pendingHidden > 0) {
@@ -997,6 +998,8 @@ void AcpSessionView::rebind(AcpSessionModel *model, AcpConnection *connection)
     m_truncatedToolCallIds.clear();
     m_reportMessages.clear();
     m_foldedTurns.clear();
+    m_expandQueue.clear();
+    if (m_expandPump) m_expandPump->stop();
     m_foldedMask.clear();
     m_foldedCount = 0;
     m_liveRow.clear(); // already queued for deletion with the rest of the layout
@@ -1118,7 +1121,7 @@ void AcpSessionView::removeTranscriptWidget(QWidget *w)
 
 // Builds (and registers) the widget for one timeline entry; the caller places
 // it. Null when the entry renders nothing (empty bubble, unknown tool call).
-QWidget *AcpSessionView::createEntryWidget(const AcpTimelineEntry &entry)
+QWidget *AcpSessionView::createEntryWidget(const AcpTimelineEntry &entry, const QFont &font)
 {
     if (!m_model) return nullptr;
     if (entry.kind == AcpTimelineEntry::Kind::Message) {
@@ -1129,7 +1132,7 @@ QWidget *AcpSessionView::createEntryWidget(const AcpTimelineEntry &entry)
         if (!messageHasVisibleContent(msg))
             return nullptr;
         auto *w = new AcpMessageWidget(msg.role, m_transcriptHost);
-        w->setChatFont(chatFont()); // styled widget: must set font explicitly
+        w->setChatFont(font); // styled widget: must set font explicitly
         if (msg.fromGoalAgent
             || msg.marker == QLatin1String(kAcpMarkerGoalAchieved)) {
             w->setFromGoalAgent(true);
@@ -1145,7 +1148,7 @@ QWidget *AcpSessionView::createEntryWidget(const AcpTimelineEntry &entry)
     if (it == m_model->toolCalls().constEnd())
         return nullptr;
     auto *card = new AcpToolCallCard(it.value(), m_transcriptHost);
-    card->setChatFont(chatFont()); // styled widget: must set font explicitly
+    card->setChatFont(font); // styled widget: must set font explicitly
     if (isGoalJudgeToolId(it.key()))
         card->setGoalTint(true);
     m_toolCallCards.insert(entry.toolCallId, card);
@@ -1206,24 +1209,32 @@ void AcpSessionView::setFoldedMask(const QVector<int> &entries, bool folded)
     const auto &timeline = m_model->timeline();
     if (m_foldedMask.size() < timeline.size())
         m_foldedMask.resize(timeline.size());
-    for (int i : entries) {
-        if (i < 0 || i >= timeline.size())
-            continue;
-        const std::uint8_t want = folded ? 1 : 0;
-        if (m_foldedMask.at(i) == want)
-            continue;
-        m_foldedMask[i] = want;
-        m_foldedCount += folded ? 1 : -1;
-        // Updates for a folded entry must not resurrect its widget: reuse the
-        // truncation suppression sets that every update path already consults.
-        const AcpTimelineEntry &e = timeline.at(i);
-        if (e.kind == AcpTimelineEntry::Kind::Message) {
-            if (folded) m_truncatedMessageIndices.insert(e.messageIndex);
-            else m_truncatedMessageIndices.remove(e.messageIndex);
-        } else {
-            if (folded) m_truncatedToolCallIds.insert(e.toolCallId);
-            else m_truncatedToolCallIds.remove(e.toolCallId);
-        }
+    for (int i : entries)
+        setEntryFolded(i, folded);
+}
+
+void AcpSessionView::setEntryFolded(int i, bool folded)
+{
+    if (!m_model) return;
+    const auto &timeline = m_model->timeline();
+    if (i < 0 || i >= timeline.size())
+        return;
+    if (m_foldedMask.size() < timeline.size())
+        m_foldedMask.resize(timeline.size());
+    const std::uint8_t want = folded ? 1 : 0;
+    if (m_foldedMask.at(i) == want)
+        return;
+    m_foldedMask[i] = want;
+    m_foldedCount += folded ? 1 : -1;
+    // Updates for a folded entry must not resurrect its widget: reuse the
+    // truncation suppression sets that every update path already consults.
+    const AcpTimelineEntry &e = timeline.at(i);
+    if (e.kind == AcpTimelineEntry::Kind::Message) {
+        if (folded) m_truncatedMessageIndices.insert(e.messageIndex);
+        else m_truncatedMessageIndices.remove(e.messageIndex);
+    } else {
+        if (folded) m_truncatedToolCallIds.insert(e.toolCallId);
+        else m_truncatedToolCallIds.remove(e.toolCallId);
     }
 }
 
@@ -1374,22 +1385,29 @@ void AcpSessionView::setTurnExpanded(int turnBegin, bool expanded)
     ft.expanded = expanded;
     if (ft.row) ft.row->setExpanded(expanded);
 
-    const auto &timeline = m_model->timeline();
     if (expanded) {
-        setFoldedMask(ft.entries, false);
-        int at = ft.row ? m_transcriptLayout->indexOf(ft.row) + 1 : -1;
-        for (int i : ft.entries) {
-            if (i < 0 || i >= timeline.size())
-                continue;
-            QWidget *w = createEntryWidget(timeline.at(i));
-            if (!w)
-                continue;
-            if (at >= 0)
-                m_transcriptLayout->insertWidget(at++, w);
-            else
-                insertTimelineWidget(w, false);
+        // A turn can hold hundreds of tool calls and bubbles; building them all
+        // in this click handler froze the UI for seconds. The first slice runs
+        // now (the rows right under the fold row), the rest one slice per
+        // event-loop pass so paint and input keep flowing. Every entry is built.
+        ft.nextEntry = 0;
+        if (!materializeTurnSlice(turnBegin, chatFont())) {
+            if (!m_expandQueue.contains(turnBegin))
+                m_expandQueue.append(turnBegin);
+            if (!m_expandPump) {
+                m_expandPump = new QTimer(this);
+                m_expandPump->setSingleShot(true);
+                m_expandPump->setInterval(0);
+                connect(m_expandPump, &QTimer::timeout, this, &AcpSessionView::pumpExpandQueue);
+            }
+            m_expandPump->start();
         }
     } else {
+        // Collapsing mid-expansion drops the pending slices; entries never
+        // built have no widget and are still folded.
+        ft.nextEntry = -1;
+        m_expandQueue.removeOne(turnBegin);
+        const auto &timeline = m_model->timeline();
         for (int i : ft.entries) {
             if (i >= 0 && i < timeline.size())
                 removeEntryWidget(timeline.at(i));
@@ -1399,6 +1417,74 @@ void AcpSessionView::setTurnExpanded(int turnBegin, bool expanded)
     syncTranscriptHostWidth();
 }
 
+bool AcpSessionView::materializeTurnSlice(int turnBegin, const QFont &font)
+{
+    // ~1/3 of a 60 Hz frame: leaves the rest for the layout pass and paint the
+    // new widgets trigger. Always builds at least one entry so a slice that
+    // overruns (a large diff card) still makes progress.
+    constexpr qint64 kSliceBudgetNs = 6'000'000;
+    auto it = m_foldedTurns.find(turnBegin);
+    if (it == m_foldedTurns.end() || !m_model || !m_transcriptLayout)
+        return true;
+    FoldedTurn &ft = it.value();
+    if (!ft.expanded || ft.nextEntry < 0)
+        return true;
+
+    const auto &timeline = m_model->timeline();
+    const int count = ft.entries.size();
+    // Insert after the last built entry still on screen (truncation may have
+    // dropped some between slices), else right under the fold row.
+    QWidget *anchor = nullptr;
+    for (int k = qMin(ft.nextEntry, count) - 1; k >= 0 && !anchor; --k) {
+        const int i = ft.entries.at(k);
+        if (i >= 0 && i < timeline.size())
+            anchor = widgetForTimelineEntry(timeline.at(i));
+    }
+    if (!anchor)
+        anchor = ft.row;
+    const int anchorIdx = anchor ? m_transcriptLayout->indexOf(anchor) : -1;
+    int at = anchorIdx >= 0 ? anchorIdx + 1 : -1; // -1: append at the tail
+
+    QElapsedTimer clock;
+    clock.start();
+    while (ft.nextEntry < count) {
+        const int i = ft.entries.at(ft.nextEntry++);
+        if (i < 0 || i >= timeline.size())
+            continue;
+        setEntryFolded(i, false);
+        const AcpTimelineEntry &entry = timeline.at(i);
+        if (QWidget *existing = widgetForTimelineEntry(entry)) {
+            // Rare: an update re-created it already. Keep order after it.
+            const int idx = m_transcriptLayout->indexOf(existing);
+            if (idx >= 0)
+                at = idx + 1;
+        } else if (QWidget *w = createEntryWidget(entry, font)) {
+            if (at >= 0)
+                m_transcriptLayout->insertWidget(at++, w);
+            else
+                insertTimelineWidget(w, false);
+        }
+        if (clock.nsecsElapsed() >= kSliceBudgetNs)
+            break;
+    }
+    if (ft.nextEntry < count)
+        return false;
+    ft.nextEntry = -1;
+    return true;
+}
+
+void AcpSessionView::pumpExpandQueue()
+{
+    if (m_expandQueue.isEmpty())
+        return;
+    const int turnBegin = m_expandQueue.first();
+    if (materializeTurnSlice(turnBegin, chatFont()))
+        m_expandQueue.removeFirst();
+    syncTranscriptHostWidth();
+    if (!m_expandQueue.isEmpty())
+        m_expandPump->start();
+}
+
 // A goal-judge turn is removed from the tail of the timeline; a fold recorded
 // for entries that no longer exist must go with it.
 void AcpSessionView::pruneStaleFoldedTurns()
 
@@ -202,14 +202,21 @@ private slots:
     void ensureLiveTurnRow();
     void dropLiveTurnRow();
     void setTurnExpanded(int turnBegin, bool expanded);
+    // Materializes one time-boxed slice of an expanding turn; true when nothing
+    // is left (done, collapsed, or the turn is gone).
+    bool materializeTurnSlice(int turnBegin, const QFont &font);
+    void pumpExpandQueue();
     void removeEntryWidget(const AcpTimelineEntry &entry);
     // Copy buttons under each finished turn's final report.
     // includeNewest: the newest turn has ended.
     void refreshResponseActions(bool includeNewest);
     void attachResponseActions(int messageIndex, AcpMessageWidget *w);
-    QWidget *createEntryWidget(const AcpTimelineEntry &entry);
+    // font: the chat typeface, resolved once by batch callers (chatFont() walks
+    // qApp's children and reads settings).
+    QWidget *createEntryWidget(const AcpTimelineEntry &entry, const QFont &font);
     AcpTurnFoldRow *makeFoldRow(const AcpTurnFolding::Turn &turn, AcpTurnFoldRow *adopt = nullptr);
     void setFoldedMask(const QVector<int> &entries, bool folded);
+    void setEntryFolded(int timelineIndex, bool folded);
     void pruneStaleFoldedTurns();
     void syncTranscriptHostWidth();
     void scrollToBottomDeferred();
@@ -386,8 +393,13 @@ private slots:
         QPointer<AcpTurnFoldRow> row;
         QVector<int> entries; // timeline indices hidden while collapsed
         bool expanded = false;
+        // Expanding builds widgets in time-boxed slices: next `entries` position
+        // to materialize, -1 when nothing is pending.
+        int nextEntry = -1;
     };
     QHash<int, FoldedTurn> m_foldedTurns; // key: first timeline index of the turn
+    QVector<int> m_expandQueue;           // turn begins with slices still pending, FIFO
+    QTimer *m_expandPump = nullptr;       // zero-interval: one slice per event-loop pass
     QVector<std::uint8_t> m_foldedMask;   // per timeline index; 1 = currently folded (no widget)
     int m_foldedCount = 0;
     QPointer<AcpTurnFoldRow> m_liveRow; // heads the running turn; ticks once per second
 
@@ -928,28 +928,15 @@ AcpToolCallCard::AcpToolCallCard(const AcpProtocol::AcpToolCall &initial, QWidge
 
     outer->addLayout(header);
 
-    m_body = new QTextBrowser(this);
-    m_body->setStyleSheet(QStringLiteral("QTextBrowser { background: transparent; border: none; }"));
-    m_body->setOpenExternalLinks(true);
-    // Cards size to content. Internal scroll on a card produces a nested
-    // scrollbar inside the transcript's own scroll area — bad UX. The expand
-    // button collapses verbose output instead.
-    m_body->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-    m_body->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
-    m_body->setFrameShape(QFrame::NoFrame);
-    m_body->document()->setDocumentMargin(0);
-    outer->addWidget(m_body);
+    // The body (QTextBrowser: scroll area, viewport, two scrollbars, document)
+    // and its render timer are built on first expand — ensureBody(). Most cards
+    // stay collapsed, and an expanded "Worked for" turn instantiates hundreds.
 
     connect(m_expandBtn, &QToolButton::toggled, this, [this](bool checked) {
         m_userToggled = true;
         setCollapsed(!checked);
     });
 
-    m_renderTimer = new QTimer(this);
-    m_renderTimer->setSingleShot(true);
-    m_renderTimer->setInterval(kBodyRenderDebounceMs);
-    connect(m_renderTimer, &QTimer::timeout, this, &AcpToolCallCard::flushBodyRender);
-
     refreshHeader();
     // Cards land collapsed by default — the title alone is enough to scan a
     // turn. Body rendering is intentionally lazy: tool output can be huge, and
@@ -961,6 +948,28 @@ AcpToolCallCard::AcpToolCallCard(const AcpProtocol::AcpToolCall &initial, QWidge
     maybeAutoExpandForDiff();
 }
 
+void AcpToolCallCard::ensureBody()
+{
+    if (m_body) return;
+    m_body = new QTextBrowser(this);
+    m_body->setStyleSheet(QStringLiteral("QTextBrowser { background: transparent; border: none; }"));
+    m_body->setOpenExternalLinks(true);
+    // Cards size to content. Internal scroll on a card produces a nested
+    // scrollbar inside the transcript's own scroll area — bad UX. The expand
+    // button collapses verbose output instead.
+    m_body->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    m_body->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    m_body->setFrameShape(QFrame::NoFrame);
+    m_body->document()->setDocumentMargin(0);
+    if (m_chatFontSet) m_body->document()->setDefaultFont(m_chatFont);
+    m_outer->addWidget(m_body);
+
+    m_renderTimer = new QTimer(this);
+    m_renderTimer->setSingleShot(true);
+    m_renderTimer->setInterval(kBodyRenderDebounceMs);
+    connect(m_renderTimer, &QTimer::timeout, this, &AcpToolCallCard::flushBodyRender);
+}
+
 void AcpToolCallCard::setGoalTint(bool on)
 {
     if (m_fromGoalAgent == on)
@@ -1628,6 +1637,7 @@ void AcpToolCallCard::showEvent(QShowEvent *event)
 void AcpToolCallCard::setCollapsed(bool collapsed)
 {
     m_collapsed = collapsed;
+    if (!collapsed) ensureBody();
     if (m_body) m_body->setVisible(!collapsed);
     if (collapsed && m_renderTimer && m_renderTimer->isActive()) {
         m_renderTimer->stop();
 
@@ -73,6 +73,7 @@ class AcpToolCallCard : public QFrame
     void showEvent(QShowEvent *event) override;
 
 private:
+    void ensureBody();
     void refreshHeader();
     void scheduleBodyRender();
     void flushBodyRender();
@@ -110,13 +111,13 @@ class AcpToolCallCard : public QFrame
     bool m_autoExpandedForDiff = false;  // we've already auto-expanded once for a completed diff
     bool m_bodyDirty = true;             // body document is stale vs m_content/rawInput/rawOutput
     bool m_refitScheduled = false;       // a deferred refit is already queued
-    QTimer *m_renderTimer = nullptr;     // coalesces expensive QTextDocument body renders
+    QTimer *m_renderTimer = nullptr;     // coalesces expensive QTextDocument body renders; built with m_body
 
     QLabel *m_statusIcon = nullptr;
     QLabel *m_titleLabel = nullptr;
     QLabel *m_durationLabel = nullptr;
     QToolButton *m_expandBtn = nullptr;
-    QTextBrowser *m_body = nullptr;
+    QTextBrowser *m_body = nullptr;      // null until first expand (ensureBody)
     QVBoxLayout *m_outer = nullptr;
 };