pilotswarm 0.5.62 → 0.5.64

package/ui/core/src/history.js

@@ -2,6 +2,8 @@ import { formatHumanDurationSeconds, formatTimestamp, shortModelName, shortSessi
 import { isCanvasActionContent, parseCanvasActionContent } from "./canvas-actions.js";
 import { formatCompactionActivityRuns } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
+import { matchesSessionError } from "./session-warning.js";
+import { appendNativeTaskEvent } from "./native-tasks.js";
 import { buildSessionWarning } from "./session-errors.js";
 import { appendChatCall, CHAT_CALL_EVENT_TYPES } from "./chat-activity.js";
 
@@ -19,13 +21,20 @@ export const HISTORY_EVENT_LIMIT_STEPS = [
 // load transcript pages instead of raw-stream pages.
 export const CHAT_HISTORY_EVENT_TYPES = [
     ...CHAT_CALL_EVENT_TYPES,
-    "session.error",
     "user.message",
     "assistant.message",
     // Needed to distinguish interim assistant output from the final answer
     // when an older transcript page is loaded.
     "session.turn_completed",
     "session.turn_stopped",
+    // Warnings belong at the error's position in the transcript, including
+    // after recovery and when paging backward through a noisy session.
+    "session.error",
+    "subagent.started",
+    "subagent.configured",
+    "subagent.completed",
+    "subagent.failed",
+    "native.task_updated",
     "system.message",
     // Session regeneration boundary — rendered as an inline epoch divider in
     // the transcript, so it must survive backward chat-history paging.
@@ -90,6 +99,63 @@ function buildRegenFailedItem(event) {
     };
 }
 
+function buildSessionWarningItem(event) {
+    const completed = event.eventType === "session.turn_completed" && event.data?.resultType === "error";
+    if (event.eventType !== "session.error" && !completed) return null;
+    const warning = buildSessionWarning(event);
+    if (!warning) return null;
+    return {
+        ...warning,
+        errorText: warning.text,
+        sourceEventType: event.eventType,
+        ...(completed ? { turnCompletedSeq: event.seq } : {}),
+        time: formatTimestamp(event.createdAt),
+    };
+}
+
+function appendSessionWarning(chat, event) {
+    const warning = buildSessionWarningItem(event);
+    if (!warning) return;
+    if (chat.some((item) => item.id === warning.id
+        || (item.turnCompletedSeq != null && item.turnCompletedSeq === event.seq))) return;
+    // Tool disclosures can arrive between the SDK error and the failed-turn
+    // summary. They do not start a different conversation/failure episode.
+    const previousIndex = chat.findLastIndex(item => item.kind !== "chat-call" && item.kind !== "native-task-group");
+    const previous = chat[previousIndex];
+    // A runtime error and its failed-turn summary can describe one failure.
+    // Retain the original anchor; subsequent failed turns remain distinct.
+    if (previous?.kind === "session-warning"
+        && previous.sourceEventType === "session.error"
+        && previous.turnCompletedSeq == null
+        && event.eventType === "session.turn_completed"
+        && matchesSessionError(previous.errorText, warning.errorText)) {
+        chat[previousIndex] = { ...previous, turnCompletedSeq: event.seq };
+        return;
+    }
+    chat.push(warning);
+}
+
+const parentChatCallTypes = new Set(CHAT_CALL_EVENT_TYPES);
+function appendParentChatCall(chat, event) {
+    if (!parentChatCallTypes.has(event?.eventType)) return;
+    const data = event?.data || {};
+    // Native tasks have their own abridged disclosure. Generic call cards
+    // would duplicate them and reveal the full native prompt/arguments.
+    const name = data.toolName || data.name;
+    const namespace = `${event.sessionId}:${data.durableSessionId || ""}`;
+    const keys = [data.toolCallId && `call:${data.toolCallId}`, data.requestId && `request:${data.requestId}`].filter(Boolean);
+    // An empty diagnostic completion has neither a call to update nor useful
+    // content. Keep it in Activity without evicting real conversation cards.
+    const hasContent = name || data.arguments != null || data.args != null || data.result != null || data.output != null
+        || data.error || data.partialOutput || data.progressMessage || data.childSessionId || data.agentId || data.task;
+    if (!keys.length && !hasContent) return;
+    const parentCall = !name && chat.some(item => item.kind === "chat-call" && item.namespace === namespace
+        && item.callKeys.some(key => keys.includes(key)));
+    const nativeCall = name === "task" || Boolean(!name && !parentCall && data.toolCallId && chat.some(item =>
+        item.kind === "native-task-group" && item.tasks.some(task => task.toolCallId === data.toolCallId)));
+    if (!nativeCall) appendChatCall(chat, event);
+}
+
 function clampHistoryItems(items, maxItems) {
     const list = Array.isArray(items) ? items.filter(Boolean) : [];
     const safeMax = Math.max(DEFAULT_HISTORY_EVENT_LIMIT, Number(maxItems) || DEFAULT_HISTORY_EVENT_LIMIT);
@@ -881,7 +947,21 @@ function formatActivity(event) {
     const body = formatEventSnippet(event);
     let runs = null;
 
+    // Native child transcripts remain inspectable as events, but only their
+    // lifecycle belongs in the parent's activity feed.
+    if (event.eventType?.startsWith("native.") || event.eventType === "session.background_tasks_changed") return null;
     switch (event.eventType) {
+        case "subagent.started":
+        case "subagent.completed":
+        case "subagent.failed": {
+            const phase = event.eventType.slice("subagent.".length);
+            const name = event.data?.agentDisplayName || event.data?.agentName || "agent";
+            const duration = Number.isFinite(event.data?.durationMs)
+                ? ` (${formatHumanDurationSeconds(event.data.durationMs / 1000)})` : "";
+            runs = buildLabeledActivityRuns(time, "[native agent]", "cyan", `${name} ${phase}${duration}`, phase === "failed" ? "red" : "white");
+            break;
+        }
+        case "subagent.configured":
         case "assistant.usage":
         case "session.info":
         case "session.idle":
@@ -1226,11 +1306,9 @@ 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);
-        }
+        appendNativeTaskEvent(chat, event);
+        appendParentChatCall(chat, event);
+        appendSessionWarning(chat, event);
         if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
             settleAssistantResponses(chat, event);
         }
@@ -1309,6 +1387,7 @@ export function appendEventToHistory(history, event) {
         ? existingEvents
         : [...existingEvents, event].slice(-loadedEventLimit);
     const next = {
+        nativeTaskSnapshot: history?.nativeTaskSnapshot,
         closedLiveKeys: history?.closedLiveKeys || [],
         closedLiveStreams: history?.closedLiveStreams || [],
         chat: clampHistoryItems(history?.chat || [], loadedEventLimit),
@@ -1328,14 +1407,10 @@ export function appendEventToHistory(history, event) {
         stoppedMessageIds: Array.isArray(history?.stoppedMessageIds) ? history.stoppedMessageIds : [],
     };
 
-    if (event.eventType === "session.error") {
-        const warning = buildSessionWarning(event);
-        if (warning && !next.chat.some(item => item.id === warning.id)) {
-            next.chat = clampHistoryItems([...next.chat, warning], loadedEventLimit);
-        }
-    }
-
-    appendChatCall(next.chat, event);
+    appendNativeTaskEvent(next.chat, event);
+    appendParentChatCall(next.chat, event);
+    appendSessionWarning(next.chat, event);
+    next.chat = clampHistoryItems(next.chat, loadedEventLimit);
 
     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

@@ -57,6 +57,15 @@ export const activeMoaDashboard = value => value.dashboards.find(d => d.id === v
 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;
     if (tree.id === nodeId) return next;

package/ui/core/src/native-tasks.js

@@ -0,0 +1,197 @@
+// Native Copilot work is local to one parent turn. Durable spawn_agent
+// sessions deliberately do not enter this projection.
+const TERMINAL = new Set(["completed", "failed", "cancelled", "interrupted"]);
+const clip = (value, max = 240) => typeof value === "string" ? value.trim().slice(0, max) : "";
+const timeMs = value => {
+    const ms = typeof value === "number" ? value : new Date(value).getTime();
+    return Number.isFinite(ms) && ms > 0 ? ms : null;
+};
+const resultText = value => typeof value === "string" ? value
+    : value?.detailedContent || value?.content || value?.textResultForLlm || value?.message || value?.error?.message || "";
+
+export const NATIVE_TASK_LABELS = {
+    starting: "Starting", running: "Running", waiting: "Waiting", completed: "Done",
+    failed: "Failed", cancelled: "Cancelled", interrupted: "Interrupted",
+};
+
+function findTask(chat, task) {
+    for (let groupIndex = chat.length - 1; groupIndex >= 0; groupIndex--) {
+        const group = chat[groupIndex];
+        if (group.kind !== "native-task-group") continue;
+        const taskIndex = group.tasks.findLastIndex(item =>
+            (task.toolCallId && item.toolCallId === task.toolCallId)
+            || (task.agentId && item.agentId === task.agentId && (!task.toolCallId || !item.toolCallId))
+            || (task.id && item.id === task.id));
+        if (taskIndex >= 0) return { groupIndex, taskIndex };
+    }
+    return null;
+}
+
+function updateTask(chat, patch, event, { authoritative = false } = {}) {
+    const match = findTask(chat, patch);
+    const previous = match ? chat[match.groupIndex].tasks[match.taskIndex] : null;
+    if (previous?.ownerId && patch.ownerId && previous.ownerId !== patch.ownerId) return;
+    if (patch.revision != null && previous?.revision != null && patch.revision < previous.revision) return;
+    const next = {
+        id: patch.toolCallId || patch.agentId || patch.id,
+        title: "Native task", status: "starting", toolCalls: 0,
+        startedAt: timeMs(patch.startedAt) || timeMs(event.createdAt),
+        ...previous,
+        ...Object.fromEntries(Object.entries(patch).filter(([,value]) => value !== undefined)),
+        telemetryStale: false,
+    };
+    if (!next.id) return;
+    next.id = previous?.id || next.id;
+    next.startedAt = previous?.startedAt || timeMs(patch.startedAt) || timeMs(event.createdAt);
+    next.completedAt = timeMs(next.completedAt);
+    // Cleanup and late progress must not replace a confirmed outcome. A
+    // cancelled:true completion is handled before it becomes terminal.
+    if (previous && TERMINAL.has(previous.status)
+        && (!previous.inferredTerminal || !TERMINAL.has(patch.status))) {
+        next.status = previous.status;
+        next.error = previous.error;
+        next.completedAt = previous.completedAt;
+        next.durationMs = previous.durationMs;
+        if (!TERMINAL.has(patch.status) || patch.status === "cancelled") next.toolCalls = previous.toolCalls;
+        if (!patch.result && !patch.error) next.preview = previous.preview;
+    } else if (TERMINAL.has(patch.status) && !patch.inferredTerminal) {
+        next.inferredTerminal = false;
+        // A late real outcome replaces the explanatory text of an inferred
+        // interruption, rather than displaying that stale error under Done.
+        if (previous?.inferredTerminal) next.error = patch.error || "";
+    }
+    next.title = clip(next.title, 160) || "Native task";
+    next.preview = clip(next.preview);
+    next.result = clip(next.result, 4000);
+    next.error = clip(next.error, 1000);
+    next.toolCalls = Math.max(Number(previous?.toolCalls) || 0, Number(next.toolCalls) || 0);
+    next.recentActivity = Array.isArray(next.recentActivity)
+        ? next.recentActivity.slice(-5).map(a => ({ message: clip(a.message), timestamp: a.timestamp })) : [];
+    if (match) {
+        const group = chat[match.groupIndex];
+        const tasks = [...group.tasks];
+        tasks[match.taskIndex] = next;
+        chat[match.groupIndex] = { ...group, tasks };
+        return;
+    }
+    // A retained snapshot can arrive after newer chat. Insert at its original
+    // start time instead of attaching it permanently to the transcript tail.
+    const later = next.startedAt ? chat.findIndex(item => Number(item.createdAt) > next.startedAt) : -1;
+    const insertion = later < 0 ? chat.length : later;
+    const prior = chat[insertion - 1];
+    if (prior?.kind === "native-task-group" && prior.tasks.length < 32) {
+        chat[insertion - 1] = { ...prior, tasks: [...prior.tasks, next] };
+    } else {
+        chat.splice(insertion, 0, {
+            id: `native-tasks:${event.sessionId}:${next.id}`, kind: "native-task-group", role: "system",
+            createdAt: next.startedAt, tasks: [next],
+        });
+    }
+}
+
+export function appendNativeTaskEvent(chat, event) {
+    const type = event?.eventType || "";
+    const data = event?.data || {};
+    if (type === "native.task_updated") {
+        if (data.id && NATIVE_TASK_LABELS[data.status]) updateTask(chat, data, event, { authoritative: true });
+        return;
+    }
+    if (type === "session.turn_completed" || type === "session.turn_stopped") {
+        for (let i = 0; i < chat.length; i++) {
+            if (chat[i].kind !== "native-task-group") continue;
+            chat[i] = { ...chat[i], tasks: chat[i].tasks.map(task => TERMINAL.has(task.status) ? task : {
+                ...task, status: "interrupted", inferredTerminal: true, completedAt: timeMs(event.createdAt),
+                error: type === "session.turn_stopped" ? "The parent turn was stopped." : "The parent turn ended before a task result was confirmed.",
+            }) };
+        }
+        return;
+    }
+    const lifecycle = type.startsWith("subagent.");
+    const child = type.startsWith("native.");
+    const taskTool = !child && !data.nativeAgentId && (data.toolName || data.name) === "task"
+        && ["tool.execution_start", "tool.execution_complete"].includes(type);
+    if (!lifecycle && !child && !taskTool) return;
+    const args = data.arguments || data.args || {};
+    const toolCallId = child ? data.parentToolCallId : data.toolCallId;
+    const agentId = data.nativeAgentId || data.agentId;
+    const patch = { toolCallId, agentId };
+    const found = findTask(chat, patch);
+    const previous = found ? chat[found.groupIndex].tasks[found.taskIndex] : null;
+    if (!previous && !lifecycle && !taskTool) return;
+    if (!previous || taskTool || type === "subagent.started") Object.assign(patch, {
+        title: args.description || data.agentDisplayName || args.name || data.agentName || "Native task",
+        profile: args.agent_type || data.agentName || data.agentType,
+        model: data.model,
+    });
+    if (type === "subagent.configured") {
+        Object.assign(patch, { model: data.model, reasoningEffort: data.reasoningEffort });
+    } else if (type === "subagent.started") {
+        patch.status = "running";
+    } else if (type === "subagent.completed" || type === "subagent.failed") {
+        Object.assign(patch, {
+            status: data.cancelled ? "cancelled" : type === "subagent.failed" ? "failed" : "completed",
+            completedAt: event.createdAt, durationMs: data.durationMs, toolCalls: data.totalToolCalls,
+            ...(data.cancelled ? { error: "Task was cancelled before returning a result." }
+                : type === "subagent.failed" ? { error: clip(resultText(data.error) || data.message || "Native task failed.", 1000) } : {}),
+        });
+    } else if (type === "tool.execution_start") {
+        patch.status = "starting";
+    } else if (type === "tool.execution_complete") {
+        const failed = data.success === false || data.result?.success === false || Boolean(data.error)
+            || ["failure", "failed", "rejected", "denied"].includes(data.result?.resultType ?? data.resultType);
+        const text = resultText(data.result) || resultText(data.error);
+        Object.assign(patch, { status: failed ? "failed" : "completed", completedAt: event.createdAt,
+            ...(failed ? { error: clip(text, 1000) || "Native task request failed." } : { result: clip(text, 4000) }) });
+    } else if (type === "native.tool.execution_start") {
+        const ids = previous.toolCallIds || [];
+        patch.toolCallIds = data.toolCallId && !ids.includes(data.toolCallId) ? [...ids, data.toolCallId].slice(-500) : ids;
+        patch.toolCalls = (previous.toolCalls || 0) + (patch.toolCallIds !== ids ? 1 : 0);
+        patch.preview = args.description || (data.toolName ? `Using ${data.toolName}` : "Working");
+    } else if (type === "native.assistant.message") {
+        // Do not expose reasoning, tool arguments, or the whole child transcript.
+        patch.preview = clip(data.content);
+    } else return;
+    updateTask(chat, patch, event);
+}
+
+export function applyNativeTaskSnapshot(history, payload, meta = {}) {
+    if (payload?.phase === "unavailable" && history) return { ...history,
+        nativeTaskSnapshot: history.nativeTaskSnapshot ? { ...history.nativeTaskSnapshot, liveSeq: undefined } : undefined,
+        chat: history.chat.map(group => group.kind !== "native-task-group" ? group : { ...group,
+            tasks: group.tasks.map(task => TERMINAL.has(task.status) ? task : { ...task, telemetryStale: true }) }) };
+    if (payload?.version !== 1 || !Array.isArray(payload.tasks) || !payload.ownerId) return history;
+    const current = history || { chat: [], activity: [], events: [], lastSeq: 0 };
+    const latest = current.nativeTaskSnapshot;
+    const newestRecordedOwner = Math.max(0, ...current.chat
+        .filter(group => group.kind === "native-task-group")
+        .flatMap(group => group.tasks.map(task => Number(task.ownerStartedAt) || 0)));
+    // The retained live row can belong to an old publisher that finished
+    // writing after a newer turn. On reconnect, durable summary owners fence
+    // that row even when this viewer has not received a live snapshot yet.
+    if (Number.isFinite(payload.ownerStartedAt) && payload.ownerStartedAt < newestRecordedOwner) {
+        if (latest?.ownerStartedAt >= newestRecordedOwner) return current;
+        return { ...current, chat: current.chat.map(group => group.kind !== "native-task-group" ? group : { ...group,
+            tasks: group.tasks.map(task => !TERMINAL.has(task.status) && task.ownerStartedAt === newestRecordedOwner
+                ? { ...task, telemetryStale: true } : task) }) };
+    }
+    if (Number.isFinite(latest?.ownerStartedAt) && Number.isFinite(payload.ownerStartedAt)
+        && payload.ownerStartedAt < latest.ownerStartedAt) return current;
+    if (latest?.ownerId === payload.ownerId && latest.revision >= payload.revision) return current;
+    if (latest?.ownerId === payload.ownerId && Number.isFinite(meta.seq)
+        && Number.isFinite(latest?.liveSeq) && meta.seq <= latest.liveSeq) return current;
+    const chat = [...current.chat];
+    for (const task of payload.tasks.slice(0, 32)) {
+        if (!task?.id || !NATIVE_TASK_LABELS[task.status]) continue;
+        const ended = current.events?.some(e => ["session.turn_completed", "session.turn_stopped"].includes(e.eventType)
+            && timeMs(e.createdAt) > timeMs(task.startedAt));
+        const patch = { ...task, ownerId: payload.ownerId, ownerStartedAt: payload.ownerStartedAt, revision: payload.revision };
+        if (ended && !TERMINAL.has(patch.status)) {
+            patch.status = "interrupted";
+            patch.inferredTerminal = true;
+            patch.error = "The parent turn ended before a task result was confirmed.";
+        }
+        updateTask(chat, patch, { sessionId: meta.sessionId, createdAt: task.startedAt }, { authoritative: true });
+    }
+    return { ...current, chat, nativeTaskSnapshot: { ownerId: payload.ownerId, ownerStartedAt: payload.ownerStartedAt,
+        revision: payload.revision, liveSeq: meta.seq } };
+}

package/ui/core/src/question-display.js

@@ -0,0 +1,13 @@
+/**
+ * Some model-authored questions contain literal newline escapes. Decode those
+ * for presentation before markdown parsing, including mixed real/escaped lines.
+ * Keep stored question/choice identity intact for answers and history matching.
+ * Code spans/fences, Windows paths, quoted escape literals and doubled slashes
+ * are literal content, not formatting. Do not run a general JSON unescape here.
+ */
+export function normalizeQuestionForDisplay(value) {
+    const source = String(value ?? "");
+    if (!source.includes("\\n")) return source;
+    const tokens = /(`+)[\s\S]*?\1(?!`)|(~{3,})[\s\S]*?\2|(["'])[A-Za-z]:\\[^\r\n]*?\3|(?<!\w)(?:[A-Za-z]:\\|\\\\)(?:(?!\\n\\n|\\r\\n\\r\\n)[^\s"'`])+|(["'])(?:\\r\\n|\\[nr])\4|\\\\|\\r\\n|\\n/g;
+    return source.replace(tokens, token => token === "\\n" || token === "\\r\\n" ? "\n" : token);
+}

package/ui/core/src/reducer.js

@@ -41,6 +41,15 @@ function packageResponseIsStale(packages, action) {
     return false;
 }
 
+function clearFeatureIdentity(features) {
+    return { mode: "mine", userId: null, data: null, users: [], drafts: {}, loading: false, saving: false,
+        error: null, generation: (features?.generation || 0) + 1, fetchedAt: null, userQuery: "" };
+}
+
+function featurePrincipalKey(principal) {
+    return JSON.stringify([principal?.provider, principal?.subject]);
+}
+
 /** A provider name, or null. Names are cluster-unique and never blank. */
 function normalizeProviderName(value) {
     const name = String(value ?? "").trim();
@@ -646,6 +655,7 @@ function updateUiForSessionSelection(state, nextActiveSessionId) {
         },
         followBottom: {
             ...(state.ui.followBottom || {}),
+            chat: true,
             inspector: true,
             activity: true,
         },
@@ -964,6 +974,9 @@ function baseReducer(state, action) {
         case "auth/context":
             return {
                 ...state,
+                admin: featurePrincipalKey(state.auth?.principal) !== featurePrincipalKey(action.principal)
+                    || state.auth?.authorization?.role !== action.authorization?.role
+                    ? { ...state.admin, features: clearFeatureIdentity(state.admin.features) } : state.admin,
                 auth: {
                     principal: action.principal ?? null,
                     authorization: action.authorization ?? null,
@@ -1481,7 +1494,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);
@@ -1876,14 +1889,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 +
@@ -1936,6 +1950,7 @@ function baseReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: savedChatScroll,
+                    chatFollowBottomBySession: savedChatFollowBottom,
                     promptDraftBySession: savedDrafts,
                     prompt: nextPrompt,
                     promptCursor: nextPromptCursor,
@@ -1954,6 +1969,7 @@ function baseReducer(state, action) {
                     },
                     followBottom: {
                         ...(state.ui.followBottom || {}),
+                        chat: savedChatFollowBottom[action.sessionId] !== false,
                         inspector: true,
                         activity: true,
                     },
@@ -2201,7 +2217,7 @@ function baseReducer(state, action) {
                     ...state.history,
                     bySessionId: nextHistory,
                 },
-                ui: activeChatUpdated
+                ui: activeChatUpdated && state.ui.followBottom?.chat !== false
                     ? {
                         ...state.ui,
                         scroll: {
@@ -2222,6 +2238,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 {
@@ -2237,6 +2255,7 @@ function baseReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: nextChatScroll,
+                    chatFollowBottomBySession: nextChatFollowBottom,
                     promptDraftBySession: nextDrafts,
                 },
             };
@@ -2506,6 +2525,9 @@ function baseReducer(state, action) {
                     loading: false,
                     loadError: null,
                     profile: action.profile || null,
+                    features: featurePrincipalKey(state.admin.profile) !== featurePrincipalKey(action.profile)
+                        || Boolean(state.admin.profile?.isAdmin) !== Boolean(action.profile?.isAdmin)
+                        ? clearFeatureIdentity(state.admin.features) : state.admin.features,
                     ghcpKey: {
                         ...state.admin.ghcpKey,
                         // A successful load doesn't clobber an in-progress
@@ -2957,9 +2979,11 @@ function baseReducer(state, action) {
             };
         }
         case "admin/section": {
-            const section = ["packages", "workers", "ghcp"].includes(action.section) ? action.section : "ghcp";
+            const section = ["providers", "packages", "workers", "features", "ghcp"].includes(action.section) ? action.section : "ghcp";
             return { ...state, admin: { ...state.admin, section } };
         }
+        case "admin/features":
+            return { ...state, admin: { ...state.admin, features: { ...state.admin.features, ...action.patch } } };
         case "admin/workers/attempt": {
             const workers = state.admin.workers || {};
             return { ...state, admin: { ...state.admin, workers: { ...workers, attempts: (workers.attempts || 0) + 1, lastAttemptAt: Date.now(), lastSkip: action.skip || null } } };

package/ui/core/src/selectors.js

@@ -29,6 +29,8 @@ import {
     getContextHeaderBadge,
 } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
+import { matchesSessionError } from "./session-warning.js";
+import { normalizeQuestionForDisplay } from "./question-display.js";
 import { withSessionWarnings, isActivityOnlySessionError } from "./session-errors.js";
 import {
     BUDGET_PERIODS,
@@ -1543,11 +1545,11 @@ export function canStopSessionTurn(session) {
 // raised them. They used to stamp session.updatedAt, which moves on EVERY
 // poll and status tick — so the card's clock jumped forward with each update
 // and read as flicker.
-function latestEventCreatedAtMs(events = [], eventTypes = []) {
+function latestEventCreatedAtMs(events = [], eventTypes = [], predicate = () => true) {
     const wanted = new Set(eventTypes);
     for (let index = (events || []).length - 1; index >= 0; index -= 1) {
         const event = events[index];
-        if (!event || !wanted.has(event.eventType)) continue;
+        if (!event || !wanted.has(event.eventType) || !predicate(event)) continue;
         const createdAt = event.createdAt;
         const ms = createdAt instanceof Date
             ? createdAt.getTime()
@@ -1561,7 +1563,7 @@ function buildPendingQuestionMessage(session, events = []) {
     const pendingQuestion = session?.pendingQuestion;
     if (!pendingQuestion?.question) return null;
 
-    const body = [String(pendingQuestion.question).trim()];
+    const body = [normalizeQuestionForDisplay(pendingQuestion.question).trim()];
     const choices = Array.isArray(pendingQuestion.choices)
         ? pendingQuestion.choices.filter((choice) => typeof choice === "string" && choice.trim())
         : [];
@@ -1569,7 +1571,7 @@ function buildPendingQuestionMessage(session, events = []) {
     if (choices.length > 0) {
         body.push("", "Choices:");
         for (const choice of choices) {
-            body.push(`- ${choice}`);
+            body.push(`- ${normalizeQuestionForDisplay(choice)}`);
         }
     }
 
@@ -1661,10 +1663,11 @@ function buildSessionErrorMessage(session, events = []) {
         role: "system",
         text: body,
         time: "",
-        // The error event when one was recorded, else the end of the turn
-        // that produced the error; never the session's rolling updatedAt.
-        createdAt: latestEventCreatedAtMs(events, ["session.error"])
-            ?? latestEventCreatedAtMs(events, ["session.turn_completed", "assistant.turn_end"]),
+        // Only an actual failure can anchor this card. A later successful
+        // turn must never move an earlier warning's timestamp forward.
+        createdAt: latestEventCreatedAtMs(events, ["session.error", "session.turn_completed"],
+            (event) => matchesSessionError(event.eventType === "session.error" ? event.data?.message
+                : event.data?.resultType === "error" ? event.data?.errorMessage : null, errorText)),
         cardTitle: isFailed ? "Error" : "Warning",
         cardTitleColor: isFailed ? "red" : "yellow",
         cardBorderColor: isFailed ? "red" : "yellow",
@@ -1912,8 +1915,24 @@ export function selectActiveChat(state) {
         messages.push(answeredQuestionMessage);
     }
     if (sessionErrorMessage) {
-        const index = messages.findIndex(message => sessionErrorMessage.createdAt != null && message.createdAt > sessionErrorMessage.createdAt);
-        messages.splice(index < 0 ? messages.length : index, 0, sessionErrorMessage);
+        // History owns the warning's position and identity. Status may add
+        // current retry/failure details, but must not append the same warning
+        // after the newer conversation on every poll.
+        const warningIndex = messages.findLastIndex((message) => message.kind === "session-warning"
+            && matchesSessionError(message.text, session.error));
+        if (warningIndex < 0) {
+            const index = messages.findIndex(message => sessionErrorMessage.createdAt != null && message.createdAt > sessionErrorMessage.createdAt);
+            messages.splice(index < 0 ? messages.length : index, 0, sessionErrorMessage);
+        } else if (warningIndex === messages.length - 1 || sessionErrorMessage.cardTitle === "Error") {
+            const warning = messages[warningIndex];
+            messages[warningIndex] = {
+                ...warning,
+                ...sessionErrorMessage,
+                id: warning.id,
+                createdAt: warning.createdAt,
+                time: warning.time,
+            };
+        }
     }
     return messages;
 }
@@ -2597,7 +2616,7 @@ function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
                 ...(askedAndAnswered.question === "a question" ? [] : buildMessageCardLines({
                     title: "Question",
                     timestamp: formatTimestamp(message?.createdAt || message?.time),
-                    body: askedAndAnswered.question,
+                    body: normalizeQuestionForDisplay(askedAndAnswered.question),
                     width: Math.max(20, maxWidth),
                     titleColor: USER_CHAT_COLOR,
                     borderColor: USER_CHAT_COLOR,
@@ -3069,7 +3088,20 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     };
     const lines = [];
     for (const [index, message] of messages.entries()) {
-        if (message?.kind === "epoch-divider") {
+        if (message?.kind === "native-task-group") {
+            if (options.tableMode === "sentinel") {
+                lines.push({ kind: "nativeTasks", group: message });
+            } else {
+                const labels = { starting: "Starting", running: "Running", waiting: "Waiting", completed: "Done",
+                    failed: "Failed", cancelled: "Cancelled", interrupted: "Interrupted" };
+                appendChatBlockLines(lines, buildChatMessageLines({ ...message, cardTitle: "Native tasks",
+                    cardTitleColor: "cyan", cardBorderColor: "cyan",
+                    text: message.tasks.map(task => `[${labels[task.status] || task.status}] ${task.title}`
+                        + (task.toolCalls ? ` · ${task.toolCalls} calls` : "")
+                        + (task.error || task.result || task.preview ? `\n  ${String(task.error || task.result || task.preview).replace(/\s+/g, " ").slice(0, 240)}` : "")).join("\n\n"),
+                }, maxWidth, buildOptions));
+            }
+        } else if (message?.kind === "epoch-divider") {
             lines.push(buildEpochDividerLine(message, maxWidth));
         } else if (message?.kind === "regen-refused") {
             lines.push(buildRegenRefusedLine(message, maxWidth));
@@ -4422,11 +4454,12 @@ export function selectAdminConsole(state) {
     // Settings tree — the session-list-slot navigation. Rendered by both
     // hosts; `kind` drives affordances (section rows switch panes, package
     // rows select a package).
-    const section = ["providers", "packages", "workers"].includes(admin.section) ? admin.section : "providers";
+    const section = ["providers", "packages", "workers", "features"].includes(admin.section) ? admin.section : "providers";
     const settingsTree = [
         { id: "providers", kind: "section", depth: 0, label: "Model Providers", selected: false },
         { id: "myProviders", kind: "subsection", depth: 1, label: "My Providers", selected: section === "providers" && providerPage === "mine" },
         ...(isAdmin ? [{ id: "sharedProviders", kind: "subsection", depth: 1, label: "Shared Providers", selected: section === "providers" && providerPage === "shared" }] : []),
+        { id: "features", kind: "section", depth: 0, label: "Feature flags", selected: section === "features" },
         { id: "agents", kind: "section", depth: 0, label: "Agents", selected: section === "packages" && !pkgState.selectedName },
         { id: "group:shared", kind: "group", depth: 1, label: "Shared", count: sharedRows.length },
         ...sharedRows.map((row) => ({ id: `pkg:shared:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),