feat(ai-chat): apply chat font to messages and fix goal status

Push the configured chat (Default Font) typeface down into message
bubbles, tool-call cards, and their inner text browsers — styled widgets
don't inherit setFont(), so the font is applied per-widget and threaded
into the rendered HTML, with code spans re-familied on the document model
and the hinting preference honored. Also fix the goal-status row and
busy-placeholder clock so a goal reaching a terminal state mid-rebind no
longer leaves the input stuck on "Agent is working…".

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

Author: nullmastermind

src/docks/AiAgentDock.cpp

@@ -330,29 +330,34 @@ bool AiAgentDock::attachGoalAgent(GoalAgent *goal)
         emit goalDebugLogAppended(entry);
     });
     connect(m_goalAgent, &GoalAgent::statusChanged, this, [this](GoalAgent::Status s) {
-        if (!m_model) return;
+        // The view's goal-status update drives both the on-screen status row
+        // AND the input's busy-placeholder clock (m_goalRunning), so it MUST
+        // run on every transition independent of m_model — otherwise a goal
+        // that reaches a terminal status while the model is detached (mid
+        // rebind) would leave the placeholder stuck at "Agent is working…".
+        // Only the appendSystemMessage transcript notes are gated on m_model.
         switch (s) {
         case GoalAgent::Active:
-            m_model->appendSystemMessage(tr("⟡ Goal started"));
             if (m_view && m_goalAgent) {
                 m_view->setGoalActive(
                     m_goalAgent->currentCriterionIndex() + 1,
                     m_goalAgent->criteria().size(),
                     0, m_goalAgent->maxIterations());
             }
+            if (m_model) m_model->appendSystemMessage(tr("⟡ Goal started"));
             break;
         case GoalAgent::Achieved:
-            m_model->appendSystemMessage(tr("✓ Goal achieved: %1").arg(
-                m_goalAgent ? m_goalAgent->lastActionText().left(200) : QString()));
             if (m_view) m_view->setGoalTerminal(tr("Goal achieved"));
+            if (m_model) m_model->appendSystemMessage(tr("✓ Goal achieved: %1").arg(
+                m_goalAgent ? m_goalAgent->lastActionText() : QString()));
             break;
         case GoalAgent::Cancelled:
-            m_model->appendSystemMessage(tr("⊘ Goal cancelled"));
             if (m_view) m_view->setGoalTerminal(tr("Goal stopped"));
+            if (m_model) m_model->appendSystemMessage(tr("⊘ Goal cancelled"));
             break;
         case GoalAgent::Failed:
-            m_model->appendSystemMessage(tr("✗ Goal failed"));
             if (m_view) m_view->setGoalTerminal(tr("Goal failed"));
+            if (m_model) m_model->appendSystemMessage(tr("✗ Goal failed"));
             break;
         default:
             break;

src/widgets/AcpMessageWidget.cpp

@@ -19,6 +19,7 @@
 #ifndef ACP_MESSAGE_WIDGET_H
 #define ACP_MESSAGE_WIDGET_H
 
+#include <QFont>
 #include <QFrame>
 #include <QPixmap>
 #include <QString>
@@ -63,6 +64,14 @@ class AcpMessageWidget : public QFrame
     void setFromGoalAgent(bool goal);
     bool isFromGoalAgent() const { return m_fromGoalAgent; }
 
+    // Apply the chat (Default Font) typeface explicitly. Required because this
+    // bubble and its inner QTextBrowser both carry a stylesheet, and styled
+    // widgets do NOT inherit a parent's setFont() — Qt re-resolves their font
+    // from the application default. So the transcript host's font never reaches
+    // the bubble body; we must push it down per-widget (QTextDocument default
+    // font + user QLabels) here.
+    void setChatFont(const QFont &font);
+
     bool isCollapsed() const { return m_collapsed; }
     QString role() const { return m_role; }
     QString plainText() const { return m_text; }
@@ -74,6 +83,9 @@ class AcpMessageWidget : public QFrame
     // we need to re-fit, because Qt does not auto-relayout content widgets on
     // font inheritance alone.
     void changeEvent(QEvent *event) override;
+    // Watches the assistant browser's viewport to reveal/position the per-code-
+    // block copy button on hover and hide it on leave.
+    bool eventFilter(QObject *watched, QEvent *event) override;
 
 private:
     void rerender();
@@ -82,14 +94,47 @@ class AcpMessageWidget : public QFrame
     void scheduleRerender();
     void flushRerender();
 
+    // Assistant code-block affordances. Code (fenced `<pre>`) blocks get a
+    // distinct inset surface; a single reusable hover button copies the block
+    // under the cursor. Built lazily on first assistant render.
+    void ensureCopyButton();
+    void rebuildCopyIcon();
+    void scanCodeRegions();       // map fenced-code doc ranges + raw text
+    void updateCopyButtonForPos(const QPoint &viewportPos);
+    QString codeStyleSheet() const; // pre/code CSS with chat font + palette
+    // Post-process the assistant document's code fragments: rewrite the
+    // monospace family Qt bakes during setMarkdown to the chat family, loosen
+    // line spacing inside code blocks, and add top/bottom block margins around
+    // each fenced region so it separates from adjacent prose. Runs on the
+    // document model (reliable) where QTextDocument's CSS subset is not.
+    void styleCodeInDocument();
+    // One fenced code region: document character range + its raw text.
+    struct CodeRegion { int start; int end; QString text; };
+
     QString m_role;
     QString m_text;
     bool m_collapsed = false;
     bool m_fromGoalAgent = false;
 
+    // Chat (Default Font) typeface, pushed in via setChatFont(). Held so that
+    // content created/re-rendered after the initial setFont() (streamed chunks,
+    // lazily-built user text blocks) is stamped with the same font. Default-
+    // constructed until the first setChatFont() call.
+    QFont m_chatFont;
+    bool m_chatFontSet = false;
+
     QTextBrowser *m_browser = nullptr;     // assistant + non-thought rendered widgets
     QToolButton *m_thoughtHeader = nullptr; // thought role
     QVBoxLayout *m_layout = nullptr;
+
+    // Hover copy button for fenced code blocks (assistant role only). One
+    // reusable button parented to the browser viewport, repositioned to the
+    // top-right of the code region under the cursor. m_codeRegions is rebuilt
+    // on every assistant render; m_hoverCodeIndex tracks which region the
+    // button currently serves (-1 = hidden).
+    QToolButton *m_copyCodeBtn = nullptr;
+    QVector<CodeRegion> m_codeRegions;
+    int m_hoverCodeIndex = -1;
     // Debounce timer for assistant markdown re-renders. setMarkdown on a long
     // table-bearing payload is O(N) per call; without debouncing, every
     // streamed chunk re-parses the whole document and the UI thread stalls.

src/widgets/AcpMessageWidget.h

@@ -38,6 +38,7 @@
 #include <QClipboard>
 #include <QComboBox>
 #include <QDialog>
+#include <QElapsedTimer>
 #include <QEvent>
 #include <QFileDialog>
 #include <QFont>
@@ -566,6 +567,15 @@ void AcpSessionView::buildUi()
         }
     });
 
+    // Input-placeholder busy clock — repaints the elapsed-time placeholder once
+    // a second while any agent is working. The underlying span is measured by
+    // the monotonic m_busyClock; this timer only triggers the text refresh, so
+    // a missed tick (event-loop stall) self-corrects on the next fire.
+    m_busyPlaceholderTimer = new QTimer(this);
+    m_busyPlaceholderTimer->setInterval(1000);
+    connect(m_busyPlaceholderTimer, &QTimer::timeout,
+            this, &AcpSessionView::updateBusyPlaceholderText);
+
     btnRow->addWidget(m_cancelBtn);
     btnRow->addWidget(m_sendBtn);
 
@@ -625,6 +635,8 @@ void AcpSessionView::buildUi()
                 this, &AcpSessionView::applyChatFont);
         connect(settings, &ApplicationSettings::fontSizeChanged,
                 this, &AcpSessionView::applyChatFont);
+        connect(settings, &ApplicationSettings::fontHintingChanged,
+                this, &AcpSessionView::applyChatFont);
     }
     applyChatFont();
 
@@ -722,6 +734,7 @@ void AcpSessionView::hydrateFromModel()
             && entry.messageIndex < messages.size()) {
             const AcpMessage &msg = messages.at(entry.messageIndex);
             auto *w = new AcpMessageWidget(msg.role, m_transcriptHost);
+            w->setChatFont(chatFont()); // styled widget: must set font explicitly
             if (msg.fromGoalAgent) {
                 w->setFromGoalAgent(true);
             }
@@ -732,6 +745,7 @@ void AcpSessionView::hydrateFromModel()
             auto it = toolCalls.find(entry.toolCallId);
             if (it != toolCalls.end()) {
                 auto *card = new AcpToolCallCard(it.value(), m_transcriptHost);
+                card->setChatFont(chatFont()); // styled widget: must set font explicitly
                 insertTimelineWidget(card);
                 m_toolCallCards.insert(entry.toolCallId, card);
             }
@@ -925,6 +939,7 @@ void AcpSessionView::appendMessageWidget(int idx)
     const AcpMessage &msg = m_model->messages().at(idx);
 
     auto *w = new AcpMessageWidget(msg.role, m_transcriptHost);
+    w->setChatFont(chatFont()); // styled widget: must set font explicitly
     if (msg.fromGoalAgent) {
         w->setFromGoalAgent(true);
     }
@@ -1018,6 +1033,7 @@ void AcpSessionView::onToolCallAddedOrUpdated(const QString &toolCallId)
     auto *card = m_toolCallCards.value(toolCallId, nullptr);
     if (!card) {
         card = new AcpToolCallCard(tc, m_transcriptHost);
+        card->setChatFont(chatFont()); // styled widget: must set font explicitly
         insertTimelineWidget(card);
         m_toolCallCards.insert(toolCallId, card);
         m_currentGroupCards.append(card);
@@ -1197,6 +1213,10 @@ void AcpSessionView::onIsProcessingChanged(bool processing)
         }
     }
     if (m_planWidget) m_planWidget->setAgentIdle(!processing);
+
+    // Recompute the input busy-placeholder against the new ACP state (it also
+    // depends on m_goalRunning, so the union is resolved inside).
+    refreshBusyPlaceholder();
 }
 
 void AcpSessionView::onTurnEnded(int groupId)
@@ -1308,6 +1328,8 @@ QStringList AcpSessionView::goalDebugLog() const
 void AcpSessionView::setGoalActive(int criterionIndex, int totalCriteria, int iteration, int maxIterations)
 {
     if (!m_goalStatusRow) return;
+    m_goalRunning = true;
+    refreshBusyPlaceholder();
     QString text;
     if (totalCriteria > 1) {
         text = tr("Goal %1/%2 · iter %3/%4")
@@ -1342,6 +1364,8 @@ void AcpSessionView::setGoalActive(int criterionIndex, int totalCriteria, int it
 void AcpSessionView::setGoalTerminal(const QString &statusText)
 {
     if (!m_goalStatusRow) return;
+    m_goalRunning = false;
+    refreshBusyPlaceholder();
     m_goalStatusLabel->setText(statusText);
     m_goalStopBtn->hide();
     m_goalStatusRow->show();
@@ -1360,6 +1384,8 @@ void AcpSessionView::setGoalTerminal(const QString &statusText)
 void AcpSessionView::clearGoalStatus()
 {
     if (!m_goalStatusRow) return;
+    m_goalRunning = false;
+    refreshBusyPlaceholder();
     m_goalStatusRow->hide();
     if (m_goalElapsedTimer) m_goalElapsedTimer->stop();
     if (m_goalElapsedLabel) m_goalElapsedLabel->hide();
@@ -1553,6 +1579,63 @@ void AcpSessionView::onElapsedTick()
     }
 }
 
+void AcpSessionView::refreshBusyPlaceholder()
+{
+    if (!m_input) return;
+
+    // Union of every running-agent surface. Either an in-flight ACP turn or an
+    // active goal keeps the input "busy"; the placeholder reflects that union,
+    // not whichever finished last.
+    const bool acpBusy = m_model && m_model->isProcessing();
+    const bool busy = acpBusy || m_goalRunning;
+
+    if (busy == m_busyPlaceholderActive) {
+        // No edge — the other surface was already keeping us busy. Leave the
+        // monotonic clock untouched so the elapsed span keeps accumulating.
+        return;
+    }
+    m_busyPlaceholderActive = busy;
+
+    if (busy) {
+        m_busyClock.start();                 // idle→busy edge: anchor the clock once
+        updateBusyPlaceholderText();         // paint 0m 0s immediately, don't wait 1 s
+        m_busyPlaceholderTimer->start();
+    } else {
+        m_busyPlaceholderTimer->stop();
+        // Busy→idle edge. setInputPlaceholder() handles the viewport
+        // invalidation so the input reverts to the idle text immediately
+        // instead of staying frozen on the last "Agent is working… (Xm Ys)".
+        setInputPlaceholder(tr("Send a message"));
+    }
+}
+
+void AcpSessionView::updateBusyPlaceholderText()
+{
+    if (!m_input || !m_busyPlaceholderActive) return;
+    const qint64 elapsedSec = m_busyClock.elapsed() / 1000;
+    const qint64 minutes = elapsedSec / 60;
+    const qint64 seconds = elapsedSec % 60;
+    setInputPlaceholder(tr("Agent is working… (%1m %2s)").arg(minutes).arg(seconds));
+}
+
+void AcpSessionView::setInputPlaceholder(const QString &text)
+{
+    if (!m_input) return;
+    m_input->setPlaceholderText(text);
+    // QPlainTextEdit::setPlaceholderText() does not reliably invalidate the
+    // viewport on a pure text change (its internal repaint is conditional and
+    // varies across Qt 6.5↔6.10), so without this poke a placeholder transition
+    // stays frozen on whatever was last painted by an unrelated relayout. The
+    // placeholder is drawn in the viewport's paintEvent — invalidate it
+    // directly, but only when it's actually on screen (empty document); when
+    // the user has typed text the placeholder is hidden and Qt repaints the
+    // content edit itself. Routed through one helper so no transition can skip
+    // the poke. At most one repaint per second while busy — negligible cost.
+    if (m_input->document()->isEmpty()) {
+        m_input->viewport()->update();
+    }
+}
+
 void AcpSessionView::onShowDebugLogClicked()
 {
     // Find the owning AiAgentDock so we can scope the dialog title and goal
@@ -1787,14 +1870,41 @@ void AcpSessionView::rebuildAttachIcon()
                                     palette().color(QPalette::WindowText)));
 }
 
-void AcpSessionView::applyChatFont()
+QFont AcpSessionView::chatFont() const
 {
     auto *settings = appSettings();
-    if (!settings) return;
+    QFont f = settings ? QFont(settings->fontName(), settings->fontSize())
+                       : QFont();
+    // Mirror the editor's glyph-hinting policy: these are plain Qt widgets, so
+    // Scintilla's platform-layer flag doesn't reach them — set it on the QFont
+    // directly. Without it, thin fonts (e.g. Lilex) look blurry here while the
+    // Scintilla editor looks sharp. See EditorManager / PlatQt for the editor side.
+    f.setHintingPreference(settings && !settings->fontHinting()
+        ? QFont::PreferNoHinting
+        : QFont::PreferFullHinting);
+    return f;
+}
+
+void AcpSessionView::applyChatFont()
+{
+    if (!appSettings()) return;
 
-    QFont f(settings->fontName(), settings->fontSize());
+    const QFont f = chatFont();
+    // The transcript host carries no stylesheet, so its setFont() is a cheap,
+    // harmless default for any unstyled descendants. But the message bubbles
+    // (AcpMessageWidget) AND their inner QTextBrowsers are stylesheet'd, and Qt
+    // does NOT propagate an inherited font into a styled widget — so we must
+    // push the font into each bubble explicitly via setChatFont().
     if (m_transcriptHost) m_transcriptHost->setFont(f);
     if (m_input) m_input->setFont(f);
+
+    for (AcpMessageWidget *w : m_messageWidgets) {
+        if (w) w->setChatFont(f);
+    }
+    if (m_activeThought) m_activeThought->setChatFont(f);
+    for (AcpToolCallCard *c : m_toolCallCards) {
+        if (c) c->setChatFont(f);
+    }
 }
 
 bool AcpSessionView::inputKeyEventIsSubmit(QKeyEvent *ke) const

src/widgets/AcpSessionView.cpp

@@ -19,6 +19,8 @@
 #ifndef ACP_SESSION_VIEW_H
 #define ACP_SESSION_VIEW_H
 
+#include <QElapsedTimer>
+#include <QFont>
 #include <QHash>
 #include <QPointer>
 #include <QString>
@@ -172,13 +174,36 @@ private slots:
     void resetElapsed();
     void onElapsedTick();
 
+    // Input-placeholder busy clock. Distinct from the transcript-tail
+    // heartbeats above: those reset on every structural event, whereas this
+    // measures the *whole* wall span during which any agent is working. The
+    // union of "the ACP turn is processing" OR "a goal is active" drives it —
+    // the clock starts on the idle→busy edge and only stops (restoring the
+    // resting "Send a message" placeholder) once BOTH are idle again, so a
+    // second agent starting, or one finishing mid-run, never restarts it.
+    void refreshBusyPlaceholder();
+    void updateBusyPlaceholderText();
+
+    // Single chokepoint for every chat-input placeholder change. Sets the text
+    // AND invalidates the viewport when the placeholder is on screen (empty
+    // document) — QPlainTextEdit::setPlaceholderText() does not reliably
+    // repaint on a pure text change, so routing all transitions through here
+    // makes it impossible for a future placeholder change to silently freeze.
+    void setInputPlaceholder(const QString &text);
+
     // Push the user's saved per-agent preferences (model/mode/effort) into
     // the running session. Called once per session after metadata first
     // populates the available catalogs.
     void applySavedPreferences();
 
     void applyChatFont();
 
+    // Build the chat (Default Font) QFont from settings, with the hinting
+    // policy applied. Used to stamp every bubble explicitly (styled widgets
+    // don't inherit setFont) and the input. Returns a sensible fallback when
+    // settings are unavailable (test harness).
+    QFont chatFont() const;
+
     // Slash-command completion popup.
     void showCommandPopup();
     void hideCommandPopup();
@@ -246,6 +271,16 @@ private slots:
     int m_goalElapsedMs = 0;
     int m_goalTerminalGeneration = 0;
 
+    // Input-placeholder busy clock (see refreshBusyPlaceholder). m_busyClock is
+    // monotonic and only re-started on the idle→busy edge; the 1 s timer repaints
+    // the placeholder. m_goalRunning mirrors the attached goal's active state
+    // (the view has no direct GoalAgent pointer, so the dock-driven
+    // setGoalActive/setGoalTerminal/clearGoalStatus calls toggle it).
+    QTimer *m_busyPlaceholderTimer = nullptr;
+    QElapsedTimer m_busyClock;
+    bool m_busyPlaceholderActive = false;
+    bool m_goalRunning = false;
+
     // Tracking
     QHash<int, AcpMessageWidget *> m_messageWidgets;
     QHash<QString, AcpToolCallCard *> m_toolCallCards;