pilotswarm 0.5.61 → 0.5.63

package/ui/core/src/controller.js

@@ -11,6 +11,7 @@ import {
     DEFAULT_HISTORY_EVENT_LIMIT,
     dedupeChatMessages,
     getNextHistoryEventLimit,
+    parseAskedAndAnsweredExchange,
 } from "./history.js";
 import { applySessionUsageEvent, cloneContextUsageSnapshot } from "./context-usage.js";
 import { validateCanvasAction, formatCanvasActionPrompt, createCanvasActionLimiter } from "./canvas-actions.js";
@@ -5490,6 +5491,7 @@ export class PilotSwarmUiController {
     /**
      * Reconcile outbox state against a single CMS event. Removes outbox items
      * whose `clientMessageIds` were observed as a durable `user.message`
+     * (or a legacy merged `system.message` carrying those exact identities)
      * (acknowledged → drop the local optimistic item) or as a
      * `pending_messages.cancelled` (cancel confirmed → drop the cancelling
      * item). Pure side-effect helper that is safe to call repeatedly.
@@ -5501,16 +5503,20 @@ export class PilotSwarmUiController {
      */
     reconcileOutboxAgainstEvent(sessionId, event) {
         if (!sessionId || !event) return;
-        if (event.eventType === "user.message") {
+        if (event.eventType === "user.message" || event.eventType === "system.message") {
             const content = event?.data?.content;
             const clientMessageIds = Array.isArray(event?.data?.clientMessageIds)
                 ? event.data.clientMessageIds.filter((id) => typeof id === "string")
                 : (typeof event?.data?.clientMessageId === "string" ? [event.data.clientMessageId] : []);
             if (clientMessageIds.length > 0) {
                 for (const id of clientMessageIds) {
-                    this.acknowledgeOutboxPrompt(sessionId, content, id);
+                    // Older workers classified a merged internal + user turn
+                    // from its leading protocol marker. The preserved IDs are
+                    // still an exact receipt. Never text-match a system event:
+                    // its content can quote unrelated pending user input.
+                    this.acknowledgeOutboxPrompt(sessionId, event.eventType === "user.message" ? content : undefined, id);
                 }
-            } else if (typeof content === "string" && content.trim()) {
+            } else if (event.eventType === "user.message" && typeof content === "string" && content.trim()) {
                 // Fallback: text-match acknowledgement until clientMessageId is
                 // plumbed through every layer.
                 this.acknowledgeOutboxPrompt(sessionId, content);
@@ -5832,10 +5838,11 @@ export class PilotSwarmUiController {
                 }
                 const existing = this.getState().history.bySessionId.get(sessionId)
                     || { chat: [], activity: [], events: [], lastSeq: 0 };
+                const liveHistory = this.preservePausedChatWindow(sessionId, existing);
                 this.dispatch({
                     type: "history/set",
                     sessionId,
-                    history: applyLiveTurnToHistory(existing, event.data, {
+                    history: applyLiveTurnToHistory(liveHistory, event.data, {
                         sessionId,
                         seq: event.liveSeq,
                         createdAt: Date.now(),
@@ -5872,7 +5879,10 @@ export class PilotSwarmUiController {
             this._liveTurnIdleTimers.delete(sessionId);
         }
         const state = this.getState();
-        const existing = state.history.bySessionId.get(sessionId) || { chat: [], activity: [], lastSeq: 0 };
+        const existing = this.preservePausedChatWindow(
+            sessionId,
+            state.history.bySessionId.get(sessionId) || { chat: [], activity: [], events: [], lastSeq: 0 },
+        );
         if (event.seq <= (existing.lastSeq || 0)) return false;
         this.dispatch({
             type: "history/set",
@@ -5887,7 +5897,11 @@ export class PilotSwarmUiController {
         // misrouted into the outbox queue, where it would sit until a later send
         // flushed it. The eventual detail-sync reconciles to the authoritative
         // customStatus.
-        if (event.eventType === "session.input_required_started" && event.data?.question) {
+        const questionSession = this.getState().sessions.byId[sessionId];
+        const questionEventTime = timestampMs(event.createdAt);
+        const currentSessionTime = timestampMs(questionSession?.updatedAt);
+        if (event.eventType === "session.input_required_started" && event.data?.question
+            && (!questionEventTime || !currentSessionTime || questionEventTime >= currentSessionTime)) {
             this.dispatch({
                 type: "sessions/merged",
                 session: {
@@ -5895,12 +5909,27 @@ export class PilotSwarmUiController {
                     status: "input_required",
                     pendingQuestion: {
                         question: event.data.question,
+                        ...(questionEventTime ? { askedAt: questionEventTime } : {}),
+                        ...(Number.isSafeInteger(event.data.questionIteration) ? { iteration: event.data.questionIteration } : {}),
                         choices: Array.isArray(event.data.choices) ? event.data.choices : undefined,
                         allowFreeform: event.data.allowFreeform ?? true,
                     },
                 },
             });
         }
+        // Catch-up events also include answers from other windows/writers.
+        // Retire the matching question before another send can use sendAnswer.
+        if (event.eventType === "user.message" && questionSession?.pendingQuestion) {
+            const exchange = parseAskedAndAnsweredExchange(event.data?.content);
+            const pendingSince = Math.max(currentSessionTime, timestampMs(questionSession.pendingQuestion.askedAt));
+            if (exchange?.question === questionSession.pendingQuestion.question
+                && (!questionEventTime || !pendingSince || questionEventTime >= pendingSince)) {
+                this.dispatch({ type: "sessions/merged", session: {
+                    sessionId, pendingQuestion: null,
+                    resolvedInputQuestion: { question: exchange.question, answeredAt: questionEventTime },
+                } });
+            }
+        }
         // show_artifact: the agent is presenting something to look at, so the
         // inspector switches to Files and opens that preview live.
         //
@@ -5954,6 +5983,31 @@ export class PilotSwarmUiController {
         return true;
     }
 
+    /**
+     * Do not evict the first rendered item while its active chat is paused.
+     * A fixed-size history window normally drops one old item for each live
+     * append. Keeping the same numeric scrollTop then moves the actual text the
+     * user is reading. Grow the in-memory window just enough for arrivals made
+     * during that pause; normal bottom-follow appends resume bounded trimming.
+     */
+    preservePausedChatWindow(sessionId, history) {
+        const state = this.getState();
+        if (state.sessions.activeSessionId !== sessionId || state.ui.followBottom?.chat !== false) {
+            return history;
+        }
+        const currentLimit = Math.max(
+            DEFAULT_HISTORY_EVENT_LIMIT,
+            Number(history?.loadedEventLimit ?? DEFAULT_HISTORY_EVENT_LIMIT) || DEFAULT_HISTORY_EVENT_LIMIT,
+        );
+        const requiredLimit = Math.max(
+            currentLimit,
+            (Array.isArray(history?.events) ? history.events.length : 0) + 1,
+            (Array.isArray(history?.chat) ? history.chat.length : 0) + 4,
+            (Array.isArray(history?.activity) ? history.activity.length : 0) + 1,
+        );
+        return requiredLimit === currentLimit ? history : { ...history, loadedEventLimit: requiredLimit };
+    }
+
     async syncSessionEvents(sessionId) {
         if (!sessionId || typeof this.transport.getSessionEvents !== "function") return;
         const existing = this.getState().history.bySessionId.get(sessionId);
@@ -8685,7 +8739,10 @@ export class PilotSwarmUiController {
             });
             this.dispatch({ type: "ui/status", text: "Sending answer..." });
             try {
-                await this.transport.sendAnswer(sessionId, prompt);
+                await this.transport.sendAnswer(sessionId, prompt, { expectedQuestion: {
+                    question: activePendingQuestion.question,
+                    ...(Number.isSafeInteger(activePendingQuestion.iteration) ? { iteration: activePendingQuestion.iteration } : {}),
+                } });
                 this.dispatch({
                     type: "sessions/merged",
                     session: {
@@ -9150,6 +9207,7 @@ export class PilotSwarmUiController {
     }
 
     paneUsesStickyBottomFollow(pane, state = this.getState()) {
+        if (pane === "chat") return true;
         if (pane === "activity") return true;
         if (pane === "inspector") return state.ui.inspectorTab === "logs";
         return false;
@@ -9223,6 +9281,15 @@ export class PilotSwarmUiController {
             const current = this.getPaneVisualScrollOffset(pane, state);
             const nextOffset = Math.max(0, Math.min(current - delta, maxOffset));
             this.applyPaneVisualScrollOffset(pane, nextOffset, { followBottom: nextOffset >= maxOffset }, state);
+            if (pane === "chat" && delta > 0) {
+                if (current <= 0) {
+                    this.handleChatTopHistoryScrollIntent(nextOffset).catch(() => {});
+                } else if (nextOffset <= 0) {
+                    this.armChatTopHistoryLoad();
+                }
+            } else if (pane === "chat" && delta < 0) {
+                this.disarmChatTopHistoryLoad();
+            }
             return;
         }
         const current = Math.max(0, Math.min(Number(state.ui.scroll?.[pane]) || 0, maxOffset));
@@ -9245,6 +9312,10 @@ export class PilotSwarmUiController {
         const nextOffset = Math.max(0, Math.min(Number(offset) || 0, maxOffset));
         if (this.paneUsesStickyBottomFollow(pane, state)) {
             this.applyPaneVisualScrollOffset(pane, nextOffset, { followBottom: nextOffset >= maxOffset }, state);
+            if (pane === "chat") {
+                if (maxOffset > 0 && nextOffset <= 0) this.armChatTopHistoryLoad();
+                else this.disarmChatTopHistoryLoad();
+            }
             return;
         }
         this.dispatch({ type: "ui/scroll", pane, offset: nextOffset });
@@ -9280,6 +9351,7 @@ export class PilotSwarmUiController {
 
         await this.maybeAutoExpandActiveHistory(requestedScrollOffset, {
             pages: AUTO_HISTORY_SCROLL_PAGE_COUNT,
+            preserveDomAnchor: options.preserveDomAnchor === true,
             // Always bypass the offset gate. Every caller of this method fires
             // only when the DOM scroller is already AT the top — a direct
             // measurement. The gate is a second, weaker guess that compares a
@@ -9341,7 +9413,7 @@ export class PilotSwarmUiController {
         const pane = this.getScrollablePaneForFocus();
         if (!pane) return;
         if (this.paneUsesStickyBottomFollow(pane)) {
-            this.applyPaneVisualScrollOffset(pane, 0, { followBottom: false });
+            this.scrollPaneTo(pane, 0);
             return;
         }
         const inspectorUsesBottomScroll = pane === "inspector" && this.inspectorUsesBottomScroll();
@@ -9621,6 +9693,7 @@ export class PilotSwarmUiController {
             requestedScrollOffset: targetOffset,
             autoTriggered: true,
             pages: options.pages,
+            preserveDomAnchor: options.preserveDomAnchor === true,
             // Chat-driven pull: page backward over renderable message types
             // only, so each page is transcript instead of raw event noise.
             eventTypes: CHAT_HISTORY_EVENT_TYPES,
@@ -9757,9 +9830,12 @@ export class PilotSwarmUiController {
                     pane: "chat",
                     offset: 0,
                 });
-            } else if (preserveChatView && previousScrollOffset > 0 && !options.autoTriggered) {
-                // EXPLICIT "load older" (the TUI's `e`): jump up to the start
-                // of what was just fetched — the user asked to SEE it.
+            } else if (preserveChatView && options.autoTriggered && !options.preserveDomAnchor) {
+                // Terminal panes store paused chat as a top offset. Prepending
+                // must advance that offset by the rendered rows inserted above
+                // it, preserving the same visible message. Browser panes use
+                // measured DOM height because rich cards and wrapping do not
+                // match terminal row metrics.
                 const nextState = this.getState();
                 const nextRenderedLines = this.getActiveChatRenderMetrics(nextState).totalLines;
                 const addedLines = Math.max(0, nextRenderedLines - previousRenderedLines);
@@ -9771,14 +9847,6 @@ export class PilotSwarmUiController {
                     });
                 }
             }
-            // AUTO-triggered (scrolling reached the top): change NOTHING. The
-            // offset is distance-from-BOTTOM, which prepended content cannot
-            // move — leaving it alone keeps the viewport glued to the exact
-            // messages the user was reading, and they scroll on into the new
-            // page naturally. Adding the delta here teleported the view to
-            // the TOP of a 3.3x-larger window — observed as "loading history
-            // takes you way back instead of a few pages up".
-
             const stateLabel = history.hasOlderEvents
                 ? options.autoTriggered
                     ? `Loaded older history page from CMS (${history.loadedEventCount} events loaded)`

package/ui/core/src/history.js

@@ -3,6 +3,7 @@ import { isCanvasActionContent, parseCanvasActionContent } from "./canvas-action
 import { formatCompactionActivityRuns } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
 import { buildSessionWarning } from "./session-errors.js";
+import { appendChatCall, CHAT_CALL_EVENT_TYPES } from "./chat-activity.js";
 
 export const DEFAULT_HISTORY_EVENT_LIMIT = 300;
 export const HISTORY_EVENT_LIMIT_STEPS = [
@@ -17,6 +18,7 @@ export const HISTORY_EVENT_LIMIT_STEPS = [
 // noisy sessions (thousands of tool/orchestration events between messages)
 // load transcript pages instead of raw-stream pages.
 export const CHAT_HISTORY_EVENT_TYPES = [
+    ...CHAT_CALL_EVENT_TYPES,
     "session.error",
     "user.message",
     "assistant.message",
@@ -354,6 +356,7 @@ function buildSessionMessageChatCard(event, text) {
             time: formatTimestamp(event.createdAt),
             createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
             cardTitle: expectsResponse ? "Session Request" : "Session Message",
+            agentCallPreview: body,
             cardTitleColor: "cyan",
             cardBorderColor: "cyan",
         };
@@ -381,6 +384,7 @@ function buildSessionMessageChatCard(event, text) {
             time: formatTimestamp(event.createdAt),
             createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
             cardTitle: "Session Reply",
+            agentCallPreview: body,
             cardTitleColor: "green",
             cardBorderColor: "green",
         };
@@ -405,6 +409,13 @@ function sharesClientMessageId(left, right) {
 function areMessagesEquivalent(left, right) {
     if (!left || !right) return false;
     if (left.role !== right.role) return false;
+    // Different agents can send the same short acknowledgement. Only a
+    // durable identity or a redelivered queue envelope can merge those calls.
+    if (left.sender?.kind === "agent" || right.sender?.kind === "agent") {
+        return left.sender?.kind === right.sender?.kind
+            && left.sender?.sessionId === right.sender?.sessionId
+            && (left.id === right.id || sharesClientMessageId(left, right) === true);
+    }
     // Identical text in separate model messages still represents separate
     // preview slots (and one may later become the final answer).
     if (left.role === "assistant" && left.messageId && right.messageId) {
@@ -415,6 +426,7 @@ function areMessagesEquivalent(left, right) {
     // link) — the redelivery time-window below would eat rev N-1 on every
     // reload, making the transcript disagree with what live append showed.
     if (left.kind === "canvas-update" || right.kind === "canvas-update"
+        || left.kind === "chat-call" || right.kind === "chat-call"
         || left.kind === "session-warning" || right.kind === "session-warning") {
         return left.kind === right.kind && left.id === right.id;
     }
@@ -1214,6 +1226,7 @@ export function buildHistoryModel(events = [], options = {}) {
 
     for (const event of events) {
         storedEvents.push(event);
+        appendChatCall(chat, event);
         if (event.eventType === "session.error") {
             const warning = buildSessionWarning(event);
             if (warning) chat.push(warning);
@@ -1322,6 +1335,8 @@ export function appendEventToHistory(history, event) {
         }
     }
 
+    appendChatCall(next.chat, event);
+
     if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
         settleAssistantResponses(next.chat, event);
     }

package/ui/core/src/moa.js

@@ -1,4 +1,5 @@
-// One personal desktop layout, containing references and geometry only.
+// Personal dashboards contain references and geometry only, never session data.
+export const MOA_MAX_DASHBOARDS = 5;
 export const MOA_MAX_PANELS = 16;
 export const MOA_BREAKPOINT = 920;
 const object = (v) => v && typeof v === "object" && !Array.isArray(v);
@@ -24,17 +25,46 @@ export function normalizeMoaLayout(value) {
     return { name: typeof value.name === "string" ? value.name.trim().slice(0, 64) || "Untitled MoA" : "Untitled MoA", tree: value.tree == null ? null : walk(value.tree) };
 }
 export function normalizeMoa(value) {
-    const safeTree = layout => { try { return normalizeMoaLayout(layout).tree; } catch { return null; } };
-    // Version 2 has one layout. A deliberately cleared layout must stay empty.
-    if (value?.version === 2 || (object(value) && Object.hasOwn(value, "tree"))) {
-        return { version: 2, tree: safeTree(value), ...(Number.isFinite(value.aspectRatio) && value.aspectRatio >= 0.2 && value.aspectRatio <= 8 ? { aspectRatio: value.aspectRatio } : {}) };
+    const safeLayout = (layout, dashboardId = "moa-1", name = "MoA 1") => {
+        let tree = null;
+        try { tree = normalizeMoaLayout(layout).tree; } catch {}
+        const leaves = moaLeaves(tree);
+        return { id: dashboardId, name: typeof layout?.name === "string" ? layout.name.trim().slice(0, 64) || name : name, tree,
+            ...(Number.isFinite(layout?.aspectRatio) && layout.aspectRatio >= .2 && layout.aspectRatio <= 8 ? { aspectRatio: layout.aspectRatio } : {}),
+            focusedPanelId: leaves.some(p => p.id === layout?.focusedPanelId) ? layout.focusedPanelId : leaves[0]?.id || null };
+    };
+    if (value?.version === 3 && Array.isArray(value.dashboards)) {
+        const used = new Set();
+        const dashboards = value.dashboards.slice(0, MOA_MAX_DASHBOARDS).map((dashboard, index) => {
+            let key = id(dashboard?.id) && !used.has(dashboard.id) ? dashboard.id : `moa-${index + 1}`;
+            while (used.has(key)) key += "-copy";
+            used.add(key);
+            return safeLayout(dashboard, key, `MoA ${index + 1}`);
+        });
+        if (!dashboards.length) dashboards.push(safeLayout(null));
+        return { version: 3, activeDashboardId: dashboards.some(d => d.id === value.activeDashboardId) ? value.activeDashboardId : dashboards[0].id, dashboards };
     }
-    // Migrate the selected legacy dashboard when populated; otherwise keep
-    // the first populated dashboard rather than a previously selected blank tab.
-    const slots = Array.isArray(value?.slots) ? value.slots.slice(0, 5) : [];
-    const active = Number.isInteger(value?.activeSlot) ? Math.max(0, Math.min(4, value.activeSlot)) : 0;
-    const tree = safeTree(slots[active]) || slots.map(safeTree).find(Boolean) || null;
-    return { version: 2, tree };
+    let source = value;
+    if (!(value?.version === 2 || (object(value) && Object.hasOwn(value, "tree")))) {
+        // Match the old single-workspace migration; do not resurrect discarded tabs.
+        const slots = Array.isArray(value?.slots) ? value.slots.slice(0, 5) : [];
+        const active = Number.isInteger(value?.activeSlot) ? Math.max(0, Math.min(4, value.activeSlot)) : 0;
+        source = safeLayout(slots[active]).tree ? slots[active] : slots.find(slot => safeLayout(slot).tree);
+    }
+    return { version: 3, activeDashboardId: "moa-1", dashboards: [safeLayout(source)] };
+}
+export const activeMoaDashboard = value => value.dashboards.find(d => d.id === value.activeDashboardId) || value.dashboards[0];
+export function updateMoaDashboard(value, dashboardId, patch) {
+    return normalizeMoa({ ...value, dashboards: value.dashboards.map(d => d.id === dashboardId ? { ...d, ...patch } : d) });
+}
+export function moveMoaDashboard(value, dashboardId, toIndex) {
+    const normalized = normalizeMoa(value);
+    const fromIndex = normalized.dashboards.findIndex(d => d.id === dashboardId);
+    if (fromIndex < 0 || !Number.isInteger(toIndex)) return normalized;
+    const dashboards = [...normalized.dashboards];
+    const [dashboard] = dashboards.splice(fromIndex, 1);
+    dashboards.splice(Math.max(0, Math.min(dashboards.length, toIndex)), 0, dashboard);
+    return { ...normalized, dashboards };
 }
 export function replaceMoaNode(tree, nodeId, next) {
     if (!tree) return null;

package/ui/core/src/reducer.js

@@ -379,7 +379,7 @@ function mergeDefinedSessionFields(previousSession = {}, nextSession = {}) {
         // An absent/invalid counter must not erase the last known server version.
         if (key === "statusVersion" && previousVersion != null
             && sessionStatusVersion(nextSession) == null) continue;
-        if (key === "pendingQuestion" && isAnsweredPendingQuestion(previousSession, value)) {
+        if (key === "pendingQuestion" && isAnsweredPendingQuestion(previousSession, value, nextSession)) {
             if (merged === previousSession) {
                 merged = { ...(previousSession || {}) };
             }
@@ -555,10 +555,18 @@ function normalizedPendingQuestionText(pendingQuestion) {
     return String(pendingQuestion?.question || "").trim();
 }
 
-function isAnsweredPendingQuestion(previousSession, pendingQuestion) {
-    const answeredQuestion = normalizedPendingQuestionText(previousSession?.answeredPendingQuestion);
+function isAnsweredPendingQuestion(previousSession, pendingQuestion, nextSession) {
     const incomingQuestion = normalizedPendingQuestionText(pendingQuestion);
-    return Boolean(answeredQuestion && incomingQuestion && answeredQuestion === incomingQuestion);
+    if (!incomingQuestion) return false;
+    const incomingTime = sessionUpdateTimestampMs({ updatedAt: pendingQuestion?.askedAt })
+        || sessionUpdateTimestampMs(nextSession);
+    return [previousSession?.answeredPendingQuestion, previousSession?.resolvedInputQuestion].some(answered => {
+        if (normalizedPendingQuestionText(answered) !== incomingQuestion) return false;
+        const answeredAt = sessionUpdateTimestampMs({ updatedAt: answered?.answeredAt });
+        // Preserve the answer fence across stale detail polls, but let a new
+        // instance of the same question through when it was asked later.
+        return !incomingTime || !answeredAt || incomingTime <= answeredAt;
+    });
 }
 
 function pickDefaultActiveSessionId(sessions = []) {
@@ -638,6 +646,7 @@ function updateUiForSessionSelection(state, nextActiveSessionId) {
         },
         followBottom: {
             ...(state.ui.followBottom || {}),
+            chat: true,
             inspector: true,
             activity: true,
         },
@@ -1473,7 +1482,7 @@ function baseReducer(state, action) {
             };
 
         case "ui/followBottom": {
-            if (action.pane !== "inspector" && action.pane !== "activity") {
+            if (action.pane !== "chat" && action.pane !== "inspector" && action.pane !== "activity") {
                 return state;
             }
             const nextFollowBottom = Boolean(action.followBottom);
@@ -1868,14 +1877,15 @@ function baseReducer(state, action) {
 
         case "sessions/selected": {
             state = { ...state, sessions: { ...state.sessions, listDeselected: false } };
-            // Per-session chat scroll memory: stash the outgoing session's
-            // offset and restore the incoming one's. If new chat arrives on
-            // re-entry, history/set's activeChatUpdated reset still snaps to
-            // latest — "latest chat, or where you left it".
+            // Per-session chat scroll memory: stash both the outgoing offset
+            // and whether it follows the bottom. A paused reading position
+            // stays paused as new messages arrive and across session switches.
             const previousActiveId = state.sessions.activeSessionId;
             const savedChatScroll = { ...(state.ui.chatScrollBySession || {}) };
+            const savedChatFollowBottom = { ...(state.ui.chatFollowBottomBySession || {}) };
             if (previousActiveId && previousActiveId !== action.sessionId) {
                 savedChatScroll[previousActiveId] = Number(state.ui.scroll?.chat) || 0;
+                savedChatFollowBottom[previousActiveId] = state.ui.followBottom?.chat !== false;
             }
             // Per-session prompt drafts: a half-written message belongs to the
             // session it was written in. Stash the outgoing draft (text +
@@ -1928,6 +1938,7 @@ function baseReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: savedChatScroll,
+                    chatFollowBottomBySession: savedChatFollowBottom,
                     promptDraftBySession: savedDrafts,
                     prompt: nextPrompt,
                     promptCursor: nextPromptCursor,
@@ -1946,6 +1957,7 @@ function baseReducer(state, action) {
                     },
                     followBottom: {
                         ...(state.ui.followBottom || {}),
+                        chat: savedChatFollowBottom[action.sessionId] !== false,
                         inspector: true,
                         activity: true,
                     },
@@ -2193,7 +2205,7 @@ function baseReducer(state, action) {
                     ...state.history,
                     bySessionId: nextHistory,
                 },
-                ui: activeChatUpdated
+                ui: activeChatUpdated && state.ui.followBottom?.chat !== false
                     ? {
                         ...state.ui,
                         scroll: {
@@ -2214,6 +2226,8 @@ function baseReducer(state, action) {
             for (const id of ids) delete nextOutbox[id];
             const nextChatScroll = { ...(state.ui.chatScrollBySession || {}) };
             for (const id of ids) delete nextChatScroll[id];
+            const nextChatFollowBottom = { ...(state.ui.chatFollowBottomBySession || {}) };
+            for (const id of ids) delete nextChatFollowBottom[id];
             const nextDrafts = { ...(state.ui.promptDraftBySession || {}) };
             for (const id of ids) delete nextDrafts[id];
             return {
@@ -2229,6 +2243,7 @@ function baseReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: nextChatScroll,
+                    chatFollowBottomBySession: nextChatFollowBottom,
                     promptDraftBySession: nextDrafts,
                 },
             };

package/ui/core/src/selectors.js

@@ -1,4 +1,5 @@
 import { INSPECTOR_TABS, FOCUS_REGIONS } from "./commands.js";
+import { chatCallLine, firstCallLine } from "./chat-activity.js";
 import { canvasKey as canvasSlotKey, parseCanvasKey } from "./state.js";
 import { isManuallyOrderableSession } from "./session-tree.js";
 import {
@@ -28,7 +29,7 @@ import {
     getContextHeaderBadge,
 } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
-import { withSessionWarnings } from "./session-errors.js";
+import { withSessionWarnings, isActivityOnlySessionError } from "./session-errors.js";
 import {
     BUDGET_PERIODS,
     BUDGET_SERIES_DAYS,
@@ -1645,7 +1646,7 @@ function chatAlreadyContainsPendingQuestion(chat, question) {
 
 function buildSessionErrorMessage(session, events = []) {
     const errorText = String(session?.error || "").trim();
-    if (!errorText) return null;
+    if (!errorText || isActivityOnlySessionError(errorText)) return null;
 
     const errorKind = getSessionErrorVisualKind(session);
     if (!errorKind) return null;
@@ -2251,6 +2252,7 @@ function chatMessageSpacingKind(message) {
 
 function shouldInsertChatSpacer(currentMessage, nextMessage) {
     if (!currentMessage || !nextMessage) return false;
+    if (currentMessage.kind === "chat-call" || nextMessage.kind === "chat-call") return false;
     return chatMessageSpacingKind(currentMessage) !== chatMessageSpacingKind(nextMessage);
 }
 
@@ -2287,7 +2289,7 @@ function buildCollapsedSystemNoticeLine(text, timestamp = "") {
     };
 }
 
-function buildSystemNoticeLine({ title, summary, body, timestamp = "", color = "gray" }) {
+function buildSystemNoticeLine({ title, summary, body, timestamp = "", color = "gray", callPreview, callKey }) {
     const normalizedTitle = String(title || "System").trim() || "System";
     const normalizedSummary = String(summary || "").replace(/\s+/g, " ").trim();
     return {
@@ -2296,6 +2298,7 @@ function buildSystemNoticeLine({ title, summary, body, timestamp = "", color = "
         summary: normalizedSummary,
         body: decorateArtifactLinksForChat(body || normalizedSummary),
         color,
+        ...(callPreview !== undefined ? { callPreview: `${normalizedTitle} — ${firstCallLine(callPreview)}`, callKey } : {}),
     };
 }
 
@@ -2401,6 +2404,8 @@ function buildSystemNoticeCardLines(systemText, message, maxWidth) {
         ].filter((line, index) => index === 2 || line).join("\n");
         return [buildSystemNoticeLine({
             title: `Sub-agent Response — ${shortId}`,
+            callPreview: subAgent.result || subAgent.status,
+            callKey: `${message.id}:agent:${shortId}`,
             summary: subAgent.status || "completed",
             timestamp,
             body,
@@ -2420,6 +2425,8 @@ function buildSystemNoticeCardLines(systemText, message, maxWidth) {
             .join(" · ");
         return [buildSystemNoticeLine({
             title: `Sub-agent Responses (${subAgent.agents.length})`,
+            callPreview: subAgent.agents.map(agent => firstCallLine(agent.result) || agent.status).join(" · "),
+            callKey: `${message.id}:agents`,
             summary,
             timestamp,
             body: sections.join("\n\n---\n\n"),
@@ -2505,6 +2512,17 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
 }
 
 function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
+    if (message?.kind === "chat-call") {
+        return options.tableMode === "sentinel" ? [chatCallLine(message)] : [];
+    }
+    if (options.tableMode === "sentinel" && (message?.sender?.kind === "agent" || message?.agentCallPreview !== undefined)) {
+        const label = message.cardTitle || message.sender?.display || "Agent message";
+        return [{
+            kind: "chatCall", callKey: message.id, category: "Agent",
+            text: `${label} — ${firstCallLine(message.agentCallPreview ?? message.text)}`,
+            body: message.text, time: message.time,
+        }];
+    }
     if (message?.splash) {
         // Swap in the narrow-viewport variant when the main art would
         // overflow the pane (mobile portal, narrow terminals). When the
@@ -2574,7 +2592,9 @@ function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
         const askedAndAnswered = parseAskedAndAnsweredExchange(message?.text || "");
         if (askedAndAnswered) {
             return [
-                ...buildMessageCardLines({
+                // Older runtimes inserted this placeholder for late answers.
+                // Keep the user's answer, without displaying a fabricated card.
+                ...(askedAndAnswered.question === "a question" ? [] : buildMessageCardLines({
                     title: "Question",
                     timestamp: formatTimestamp(message?.createdAt || message?.time),
                     body: askedAndAnswered.question,
@@ -2582,7 +2602,7 @@ function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
                     titleColor: USER_CHAT_COLOR,
                     borderColor: USER_CHAT_COLOR,
                     tableMode: options.tableMode,
-                }),
+                })),
                 ...buildChatMessageLines({
                     ...message,
                     text: askedAndAnswered.answer,

package/ui/core/src/session-errors.js

@@ -1,3 +1,10 @@
+// Copilot emits this diagnostic for an accepted turn without visible text.
+// Keep its durable event and Activity entry, but do not turn it into a chat
+// warning. Match only this message and the runtime's known retry wrapper.
+export function isActivityOnlySessionError(text) {
+    return /^(?:Execution failed:\s*)?No response was returned\. Send your message again to retry\.(?: \(retry \d+\/\d+ in \d+s\))?$/.test(String(text || "").trim());
+}
+
 export function shouldKeepSessionWarning(previousSession, nextSession) {
     if (!String(previousSession?.error || "").trim()) return false;
     if (nextSession?.error !== undefined) return false;
@@ -26,7 +33,7 @@ const sameError = (statusText, eventText) => Boolean(eventText) && statusText.in
 
 export function buildSessionWarning(event) {
     const text = errorText(event);
-    if (!text) return null;
+    if (!text || isActivityOnlySessionError(text)) return null;
     const failed = event?.data?.fatal === true;
     return {
         id: `${event.sessionId}:${event.seq}:warning`,
@@ -79,8 +86,9 @@ export function retainSessionWarnings(previous, next, events = [], now = Date.no
 }
 
 export function withSessionWarnings(chat, session, events = []) {
-    const messages = [...chat];
+    const messages = chat.filter(message => message.kind !== "session-warning" || !isActivityOnlySessionError(message.text));
     for (const warning of session?.chatWarnings || []) {
+        if (isActivityOnlySessionError(warning.text)) continue;
         // Status often wins the race against its durable event. Match only
         // that boundary, never a later failure after a new user/agent message.
         const following = events.filter(e => Number(e.seq) > warning.afterSeq);

package/ui/core/src/state.js

@@ -448,10 +448,14 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
                 activity: 0,
                 filePreview: 0,
             },
-            // Per-session chat scroll memory (rows from bottom), restored on
-            // sessions/selected and evicted with the session's history.
+            // Per-session chat scroll memory. While following, the offset is
+            // distance from the bottom; once the reader scrolls up it becomes
+            // a stable viewport offset from the top. The paired follow flag
+            // disambiguates the two modes across session switches.
             chatScrollBySession: {},
+            chatFollowBottomBySession: {},
             followBottom: {
+                chat: true,
                 inspector: true,
                 activity: true,
             },

package/ui/core/src/system-titles.js

@@ -5,12 +5,14 @@ export function canonicalSystemTitle(session, brandingTitle = "PilotSwarm") {
     if (agentId === "sweeper") return "Sweeper Agent";
     if (agentId === "resourcemgr") return "Resource Manager Agent";
     if (agentId === "facts-manager") return "Facts Manager";
+    if (agentId === "agent-manager") return "Agent Smith";
 
     const rawTitle = String(session?.title || "").trim();
     if (/^pilotswarm(?: agent)?$/i.test(rawTitle)) return brandedRootTitle;
     if (/^sweeper agent$/i.test(rawTitle) || /^sweeper$/i.test(rawTitle)) return "Sweeper Agent";
     if (/^resource manager agent$/i.test(rawTitle) || /^resourcemgr$/i.test(rawTitle)) return "Resource Manager Agent";
     if (/^facts manager$/i.test(rawTitle) || /^facts-manager$/i.test(rawTitle)) return "Facts Manager";
+    if (/^agent manager$/i.test(rawTitle)) return "Agent Smith";
     return rawTitle || "System Agent";
 }