pilotswarm 0.5.57 → 0.5.59

package/ui/core/src/history.js

@@ -18,6 +18,10 @@ export const HISTORY_EVENT_LIMIT_STEPS = [
 export const CHAT_HISTORY_EVENT_TYPES = [
     "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",
     "system.message",
     // Session regeneration boundary — rendered as an inline epoch divider in
     // the transcript, so it must survive backward chat-history paging.
@@ -246,14 +250,18 @@ function comparableMessageText(message) {
 export function parseAskedAndAnsweredExchange(text) {
     const source = String(text || "").replace(/\r\n/g, "\n").trim();
     const prefix = 'The user was asked: "';
-    const marker = '"\nThe user responded: "';
-
     if (!source.startsWith(prefix) || !source.endsWith('"')) return null;
-    const markerIndex = source.indexOf(marker, prefix.length);
-    if (markerIndex === -1) return null;
-
-    const question = source.slice(prefix.length, markerIndex);
-    const answer = source.slice(markerIndex + marker.length, -1);
+    // Multi-writer sessions include the answering participant in the runtime
+    // wrapper. This is still an agent question followed by a human answer,
+    // not a human-authored copy of the entire question. Identity comes from
+    // the event's sender metadata, never from this display-only wrapper.
+    const marker = /"\nThe user responded(?: \(answered by [^\r\n]+?\))?: "/g;
+    marker.lastIndex = prefix.length;
+    const match = marker.exec(source);
+    if (!match) return null;
+
+    const question = source.slice(prefix.length, match.index);
+    const answer = source.slice(marker.lastIndex, -1);
     if (!question.trim() || !answer.trim()) return null;
     return { question, answer };
 }
@@ -395,6 +403,11 @@ function sharesClientMessageId(left, right) {
 function areMessagesEquivalent(left, right) {
     if (!left || !right) return false;
     if (left.role !== right.role) return false;
+    // 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) {
+        return left.messageId === right.messageId;
+    }
     // Canvas revision lines are platform-minted, exactly-once (one durable
     // event per rev), and share identical text by design (the artifact://
     // link) — the redelivery time-window below would eat rev N-1 on every
@@ -530,18 +543,118 @@ function buildChatMessage(event, role) {
     const attachments = Array.isArray(event?.data?.attachments)
         ? event.data.attachments.filter((a) => a && typeof a.filename === "string" && a.filename)
         : [];
+    const messageId = typeof event?.data?.messageId === "string" && event.data.messageId
+        ? event.data.messageId
+        : null;
+    const chatRole = deriveChatRole(event, role, text);
     return {
         id: `${event.sessionId}:${event.seq}`,
-        role: deriveChatRole(event, role, text),
+        role: chatRole,
         text,
         time: formatTimestamp(event.createdAt),
         createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
         ...(clientMessageIds.length > 0 ? { clientMessageIds } : {}),
         ...(sender ? { sender } : {}),
         ...(attachments.length > 0 ? { attachments } : {}),
+        ...(messageId ? { messageId } : {}),
+        ...(chatRole === "assistant" ? {
+            assistantPreview: true,
+            responsePending: true,
+            responseFinal: false,
+            responseCanFinalize: !event?.data?.parentToolCallId && !event?.data?.toolRequests?.length,
+            ...(typeof event?.data?.reasoningText === "string" && event.data.reasoningText
+                ? { liveReasoningText: event.data.reasoningText } : {}),
+        } : {}),
     };
 }
 
+// A saved assistant.message is not necessarily the answer: a single runTurn
+// can contain many tool-loop utterances. Only its successful durable boundary
+// promotes the last eligible message. Use the same rule for replay and append.
+function settleAssistantResponses(chat, event) {
+    const resultType = event?.data?.resultType || event?.data?.result;
+    const successful = event?.eventType === "session.turn_completed"
+        && (!resultType || resultType === "completed");
+    let finalIndex = -1;
+    for (let index = chat.length - 1; index >= 0; index -= 1) {
+        if (chat[index]?.responsePending) {
+            if (successful && chat[index].responseCanFinalize) finalIndex = index;
+            break;
+        }
+    }
+    for (let index = 0; index < chat.length; index += 1) {
+        if (chat[index]?.responsePending) chat[index] = {
+            ...chat[index], responsePending: false, responseFinal: index === finalIndex,
+        };
+    }
+}
+
+/** Apply one transient `turn` topic snapshot without touching durable events/seq. */
+export function applyLiveTurnToHistory(history, payload, meta = {}) {
+    if (!payload) return history;
+    if (payload.phase === "idle") return clearLiveTurnFromHistory(history, null, payload.streamId || null);
+    if (payload.phase !== "live") return history;
+    const messageId = typeof payload.messageId === "string" && payload.messageId ? payload.messageId : null;
+    const reasoningId = typeof payload.reasoningId === "string" && payload.reasoningId ? payload.reasoningId : null;
+    const liveKey = messageId || (reasoningId ? `reasoning:${reasoningId}` : "active-turn");
+    const createdAt = Number(meta.createdAt) || Date.now();
+    const current = history || { chat: [], activity: [], events: [], lastSeq: 0 };
+    const oldChat = current.chat || [];
+    // Durable truth wins even when a delayed retained snapshot arrives later.
+    if ((messageId && oldChat.some((item) => !item.liveTurn && item.messageId === messageId))
+        || (current.closedLiveKeys || []).includes(liveKey)
+        || (payload.streamId && (current.closedLiveStreams || []).includes(payload.streamId))) return current;
+    const matches = (item) => item?.liveTurn === true && (
+        item?.liveKey === liveKey
+        || (messageId && item?.messageId === messageId)
+        || (reasoningId && item?.reasoningId === reasoningId && (!item.messageId || !messageId))
+    );
+    const firstMatch = oldChat.findIndex(matches);
+    const previous = firstMatch >= 0 ? oldChat[firstMatch] : null;
+    const chat = oldChat.filter((item) => !matches(item));
+    const reasoningText = typeof payload.reasoningText === "string" ? payload.reasoningText : "";
+    const text = typeof payload.text === "string" ? payload.text : "";
+    const liveStartedAt = Number(previous?.liveStartedAt || previous?.createdAt) || createdAt;
+    // Reasoning and answer text are one visual turn, not two independently
+    // mounted transcript rows. Keeping them in one keyed item lets the browser
+    // collapse reasoning above the answer and lets the durable final settle
+    // into the exact same React component instead of flashing between nodes.
+    const replacement = (reasoningText || text) ? [{
+        id: previous?.id || `live:${meta.sessionId || ""}:${liveKey}`,
+        role: "assistant",
+        ...(messageId ? { messageId } : {}),
+        ...(reasoningId ? { reasoningId } : {}),
+        liveKey: previous?.liveKey || liveKey,
+        liveTurn: true,
+        streamId: payload.streamId || previous?.streamId || null,
+        streaming: true,
+        truncated: payload.truncated === true,
+        text,
+        reasoningText,
+        liveStartedAt,
+        createdAt: liveStartedAt,
+        time: "",
+    }] : [];
+    chat.splice(firstMatch < 0 ? chat.length : Math.min(firstMatch, chat.length), 0, ...replacement);
+    return { ...current, chat };
+}
+
+export function clearLiveTurnFromHistory(history, messageId = null, streamId = null) {
+    if (!history?.chat) return history;
+    const chat = history.chat.filter((item) => !(
+        item?.liveTurn === true && (!messageId || item?.messageId === messageId) && (!streamId || item?.streamId === streamId)
+    ));
+    const retired = history.chat.filter((item) => item.liveTurn && (!messageId || item.messageId === messageId) && (!streamId || item.streamId === streamId));
+    const closedLiveKeys = [...new Set([...(history.closedLiveKeys || []),
+        ...retired.flatMap((item) => [item.liveKey, item.messageId, item.reasoningId && `reasoning:${item.reasoningId}`].filter(Boolean)),
+    ])].slice(-256);
+    const closedLiveStreams = [...new Set([...(history.closedLiveStreams || []),
+        ...(!messageId ? retired.map((item) => item.streamId).filter(Boolean) : []),
+        ...(streamId ? [streamId] : []),
+    ])].slice(-256);
+    return chat.length === history.chat.length && !streamId ? history : { ...history, chat, closedLiveKeys, closedLiveStreams };
+}
+
 // The Copilot SDK echoes the system prompt as a system.message on EVERY
 // turn, and the worker keeps only a 120-char snippet of it (session-proxy.ts,
 // "Full content omitted from CMS"). For one release (0.5.47) each echo also
@@ -765,6 +878,12 @@ function formatActivity(event) {
         case "assistant.streaming_progress":
             return null;
 
+        case "model.call_start": {
+            const model = String(event?.data?.model || event?.data?.modelId || "model").split(":").pop();
+            runs = buildLabeledActivityRuns(time, "[model]", "cyan", `calling ${model}`, "white");
+            break;
+        }
+
         case "session.artifact_presented": {
             const data = (event?.data ?? {}) || {};
             const filename = String(data.filename || "artifact");
@@ -1092,6 +1211,9 @@ export function buildHistoryModel(events = [], options = {}) {
 
     for (const event of events) {
         storedEvents.push(event);
+        if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
+            settleAssistantResponses(chat, event);
+        }
         if (event.eventType === "user.message") {
             activity.push(...buildEmbeddedSystemNoticeActivityItems(event, "user"));
             const message = buildChatMessage(event, "user");
@@ -1167,6 +1289,8 @@ export function appendEventToHistory(history, event) {
         ? existingEvents
         : [...existingEvents, event].slice(-loadedEventLimit);
     const next = {
+        closedLiveKeys: history?.closedLiveKeys || [],
+        closedLiveStreams: history?.closedLiveStreams || [],
         chat: clampHistoryItems(history?.chat || [], loadedEventLimit),
         activity: clampHistoryItems(history?.activity || [], loadedEventLimit),
         events: nextEvents,
@@ -1184,6 +1308,10 @@ export function appendEventToHistory(history, event) {
         stoppedMessageIds: Array.isArray(history?.stoppedMessageIds) ? history.stoppedMessageIds : [],
     };
 
+    if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
+        settleAssistantResponses(next.chat, event);
+    }
+
     // A stopped turn leaves a durable session.turn_stopped carrying the
     // interrupted prompt's clientMessageIds. Record them and retroactively
     // flag any matching transcript message (the user.message usually lands
@@ -1201,6 +1329,7 @@ export function appendEventToHistory(history, event) {
                     : m
             ));
         }
+        Object.assign(next, clearLiveTurnFromHistory(next));
         return next;
     }
 
@@ -1241,10 +1370,34 @@ export function appendEventToHistory(history, event) {
         next.activity = clampHistoryItems(next.activity, loadedEventLimit);
         const message = buildChatMessage(event, "assistant");
         if (!message) return next;
-        next.chat.push(message);
+        const liveIndex = message.messageId
+            ? next.chat.findIndex((item) => item?.liveTurn === true && item?.messageId === message.messageId)
+            : -1;
+        const liveItem = liveIndex >= 0 ? next.chat[liveIndex] : null;
+        Object.assign(next, clearLiveTurnFromHistory(next, message.messageId || null));
+        // Preserve the model-call slot when several assistant messages are
+        // interleaved: the durable final replaces its own live bubble in
+        // place instead of jumping behind a later streaming message.
+        if (liveIndex >= 0) {
+            const settledAt = Date.now();
+            const liveStartedAt = Number(liveItem?.liveStartedAt || liveItem?.createdAt) || settledAt;
+            // Keep the disclosure identity even for short streams. Committing
+            // an interim message must not reset expansion or its scroll box.
+            Object.assign(message, {
+                streamSettling: true,
+                liveKey: liveItem?.liveKey || message.messageId,
+                liveStartedAt,
+                liveReasoningText: message.liveReasoningText || liveItem?.reasoningText || "",
+            });
+            next.chat.splice(Math.min(liveIndex, next.chat.length), 0, message);
+        }
+        else next.chat.push(message);
         next.chat = clampHistoryItems(dedupeChatMessages(next.chat), loadedEventLimit);
         return next;
     }
+    if (event.eventType === "session.turn_completed" || event.eventType === "session.turn_stopped") {
+        Object.assign(next, clearLiveTurnFromHistory(next));
+    }
     if (event.eventType === "system.message") {
         if (shouldRenderSystemMessageAsActivity(event)) {
             const activityItem = formatActivity(event);

package/ui/core/src/reducer.js

@@ -817,6 +817,9 @@ function normalizePromptAttachments(prompt, attachments) {
 }
 
 export function appReducer(state, action) {
+    const sessionId = action.sessionId ?? action.session?.sessionId;
+    const contentUpdate = /^(history|files|canvas|orchestration|executionHistory|sessionStats|outbox)\//.test(action.type) || action.type === "sessions/merged";
+    if (sessionId && contentUpdate && state.sessions?.goneIds?.includes(sessionId)) return state;
     const next = baseReducer(state, action);
     if (next === state) return next;
     return reconcileSessionView(state, next, action);
@@ -1567,7 +1570,10 @@ function baseReducer(state, action) {
             if (!goneId) return state;
             const hadRow = Boolean(state.sessions.byId[goneId]);
             const wasActive = state.sessions.activeSessionId === goneId;
-            if (!hadRow && !wasActive) return state;
+            const hadContent = state.history.bySessionId.has(goneId)
+                || [state.files, state.canvas, state.orchestration, state.executionHistory, state.outbox, state.sessionStats]
+                    .some((slice) => Object.hasOwn(slice?.bySessionId || {}, goneId));
+            if (!hadRow && !wasActive && !hadContent) return state;
             const evictedById = { ...state.sessions.byId };
             delete evictedById[goneId];
             // Re-derive: the evicted row may have been the running CHILD that
@@ -1578,13 +1584,29 @@ function baseReducer(state, action) {
             const selectedIds = Array.isArray(state.sessions.selectedIds)
                 ? state.sessions.selectedIds.filter((id) => id !== goneId)
                 : state.sessions.selectedIds;
-            return {
-                ...state,
+            const history = new Map(state.history.bySessionId);
+            history.delete(goneId);
+            const discard = (slice) => {
+                if (!slice?.bySessionId) return slice;
+                const bySessionId = { ...slice.bySessionId };
+                delete bySessionId[goneId];
+                return { ...slice, bySessionId };
+            };
+            return {
+                ...state,
+                history: { ...state.history, bySessionId: history },
+                files: discard(state.files),
+                orchestration: discard(state.orchestration),
+                executionHistory: discard(state.executionHistory),
+                canvas: discard(state.canvas),
+                outbox: discard(state.outbox),
+                sessionStats: discard(state.sessionStats),
                 sessions: {
                     ...state.sessions,
                     byId,
                     selectedIds,
                     activeSessionId: wasActive ? null : state.sessions.activeSessionId,
+                    goneIds: [...new Set([...(state.sessions.goneIds || []), goneId])].slice(-1000),
                 },
             };
         }
@@ -1681,6 +1703,7 @@ function baseReducer(state, action) {
             const nextSessions = {
                 ...state.sessions,
                 byId: rowStatusById,
+                goneIds: (state.sessions.goneIds || []).filter((id) => !action.sessions.some((row) => row.sessionId === id)),
                 collapsedIds,
                 collapsedIdsExplicit: previousCollapsedIdsExplicit,
                 listingSeen: true,
@@ -2940,7 +2963,10 @@ function baseReducer(state, action) {
             const list = Array.isArray(action.list) ? action.list : [];
             // Keep the selection when the package still exists; otherwise clear
             // the dependent detail/workspace state with it.
-            const stillThere = previous.selectedName && list.some((p) => p.name === previous.selectedName);
+            const selector = previous.selectedSelector;
+            const stillThere = previous.selectedName && list.some((p) => p.name === previous.selectedName
+                && (!selector?.scope || p.scope === selector.scope)
+                && (!selector?.owner || (p.owner?.provider === selector.owner.provider && p.owner?.subject === selector.owner.subject)));
             return {
                 ...state,
                 admin: {
@@ -2954,7 +2980,8 @@ function baseReducer(state, action) {
                         fetchedAt: Date.now(),
                         selectedName: stillThere ? previous.selectedName : null,
                         selectedSelector: stillThere ? (previous.selectedSelector ?? null) : null,
-                        ...(stillThere ? {} : { detail: null, workspace: { ...previous.workspace, tree: null, selectedPath: null, file: null } }),
+                        ...(stillThere ? {} : { selectionSeq: (previous.selectionSeq ?? 0) + 1, detail: null, changelog: null,
+                            workspace: { ...previous.workspace, tree: null, selectedPath: null, file: null } }),
                     },
                 },
             };