pilotswarm 0.5.57 → 0.5.58

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.57",
+    "version": "0.5.58",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
     "type": "module",
     "license": "MIT",
@@ -81,7 +81,7 @@
         "ink": "^6.8.0",
         "jose": "^6.2.2",
         "mermaid": "^11.16.0",
-        "pilotswarm-sdk": "0.5.57",
+        "pilotswarm-sdk": "0.5.58",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

package/tui/src/node-sdk-transport.js

@@ -1976,6 +1976,11 @@ export class NodeSdkTransport {
         return this.mgmt.getCanvasLive(sessionId);
     }
 
+    async getLive(sessionId, topics) {
+        if (typeof this.mgmt.getLive !== "function") return [];
+        return this.mgmt.getLive(sessionId, topics);
+    }
+
     // The canvas KV store. The portal runtime hands a resolved principal
     // (door 1); the native TUI has no canvas surface and never calls these.
     async readCanvasKv(sessionId, slot, principal, query = {}) {

package/ui/core/src/controller.js

@@ -4,8 +4,10 @@ import { parseAgentSourceLink } from "./repo-links.js";
 import { importPackageFilesFromLink, readImportedPackageName } from "./repo-import.js";
 import {
     appendEventToHistory,
+    applyLiveTurnToHistory,
     buildHistoryModel,
     CHAT_HISTORY_EVENT_TYPES,
+    clearLiveTurnFromHistory,
     DEFAULT_HISTORY_EVENT_LIMIT,
     dedupeChatMessages,
     getNextHistoryEventLimit,
@@ -2503,6 +2505,8 @@ export class PilotSwarmUiController {
     }
 
     async stop() {
+        for (const timer of this._liveTurnIdleTimers?.values() || []) clearTimeout(timer);
+        this._liveTurnIdleTimers?.clear();
         if (this.catalogTimer) clearInterval(this.catalogTimer);
         this.catalogTimer = null;
         if (this.activeSessionDetailTimer) clearTimeout(this.activeSessionDetailTimer);
@@ -2518,6 +2522,16 @@ export class PilotSwarmUiController {
     }
 
     detachActiveSession() {
+        // Timers belong to the subscription, not to a future visit to this session.
+        const sessionId = this.activeSessionSubscriptionId;
+        if (sessionId) {
+            clearTimeout(this._liveTurnIdleTimers?.get(sessionId));
+            this._liveTurnIdleTimers?.delete(sessionId);
+            const history = this.getState().history.bySessionId.get(sessionId);
+            if (history) this.dispatch({ type: "history/set", sessionId, history: {
+                ...history, chat: history.chat.filter((item) => !item.liveTurn),
+            } });
+        }
         if (this.activeSessionUnsub) {
             this.activeSessionUnsub();
             this.activeSessionUnsub = null;
@@ -2866,8 +2880,9 @@ export class PilotSwarmUiController {
         if (newEvents.length === 0) {
             return existingHistory;
         }
-        let history = existingHistory;
+        let history = this.getState().history.bySessionId.get(sessionId) || existingHistory;
         for (const event of newEvents) {
+            if (event.seq <= (history.lastSeq || 0)) continue;
             history = appendEventToHistory(history, event);
         }
         history = {
@@ -2937,10 +2952,37 @@ export class PilotSwarmUiController {
                 }
                 throw error;
             }
-            const history = {
-                ...buildHistoryModel(events, { requestedLimit }),
-                lastSeq: events[events.length - 1]?.seq || 0,
+            const current = this.getState().history.bySessionId.get(sessionId);
+            // Durable events and previews can arrive while REST is pending.
+            // Merge that newer truth before replacing the loaded window.
+            const mergedEvents = [...new Map([...(events || []), ...(current?.events || [])]
+                .map((event) => [event.seq, event])).values()].sort((a, b) => a.seq - b.seq);
+            let history = {
+                ...buildHistoryModel(mergedEvents, { requestedLimit }),
+                lastSeq: mergedEvents.at(-1)?.seq || 0,
             };
+            history.closedLiveKeys = current?.closedLiveKeys || [];
+            history.closedLiveStreams = current?.closedLiveStreams || [];
+            const newTerminal = mergedEvents.some((event) => event.seq > (current?.lastSeq || 0)
+                && ["session.turn_completed", "session.turn_stopped"].includes(event.eventType));
+            for (const item of current?.chat || []) {
+                if (item.streamSettling) {
+                    history.chat = history.chat.map((message) => message.messageId === item.messageId
+                        ? { ...item, ...message } : message);
+                } else if (item.liveTurn && !newTerminal) {
+                    // Reuse the item itself: its key, reveal clock and memoized
+                    // rendering belong to this visit, not the REST response.
+                    if (!history.chat.some((message) => message.messageId && message.messageId === item.messageId)) {
+                        history.chat.push(item);
+                    } else {
+                        const finalEvent = mergedEvents.find((event) => event.eventType === "assistant.message" && event.data?.messageId === item.messageId);
+                        if (finalEvent) {
+                            const reconciled = appendEventToHistory({ chat: [item], events: [], activity: [], lastSeq: 0 }, finalEvent).chat[0];
+                            history.chat = history.chat.map((message) => message.messageId === item.messageId ? { ...reconciled, ...message } : message);
+                        }
+                    }
+                }
+            }
             this.dispatch({
                 type: "history/set",
                 sessionId,
@@ -5708,6 +5750,71 @@ export class PilotSwarmUiController {
         // history would corrupt the replay cursor — and they must never
         // appear in the transcript.
         if (event.transient === true) {
+            if (event.eventType === "assistant.live_tick") {
+                // A worker can die leaving a reasoning-only retained row.
+                // On re-entry its message ID cannot match a durable final;
+                // use database timestamps to reject snapshots older than an
+                // already-loaded terminal event. Never use client wall time.
+                const snapshotTime = event.liveUpdatedAt ? new Date(event.liveUpdatedAt).getTime() : NaN;
+                if (event.data?.phase === "live" && Number.isFinite(snapshotTime)) {
+                    const history = this.getState().history.bySessionId.get(sessionId);
+                    if (history?.events?.some((entry) => ["session.turn_completed", "session.turn_stopped"].includes(entry.eventType)
+                        && new Date(entry.createdAt).getTime() > snapshotTime)) return false;
+                }
+                if (!this._liveTurnIdleTimers) this._liveTurnIdleTimers = new Map();
+                const pendingIdle = this._liveTurnIdleTimers.get(sessionId);
+                if (pendingIdle && event.data?.phase === "idle") {
+                    clearTimeout(pendingIdle);
+                    this._liveTurnIdleTimers.delete(sessionId);
+                }
+                // The live plane and durable event stream are independent.
+                // An idle tick commonly wins the race by a few milliseconds;
+                // tearing down immediately makes the live answer flash out
+                // before its durable replacement lands. Give reconciliation a
+                // bounded grace window, then clear only if it is still live.
+                if (event.data?.phase === "idle") {
+                    const ended = this.getState().history.bySessionId.get(sessionId);
+                    if (!ended) return true;
+                    const streamId = event.data?.streamId || null;
+                    const endedKeys = new Set(ended.chat.filter((item) => item.liveTurn && (
+                        !streamId || item.streamId === streamId
+                        || (ended.closedLiveStreams || []).includes(item.streamId)
+                        || (ended.closedLiveKeys || []).includes(item.liveKey)
+                    )).map((item) => item.liveKey));
+                    // Never reveal a preview that has already finished. Keep
+                    // only previews that crossed the reveal threshold, and
+                    // close their keys now so late packets cannot revive them.
+                    this.dispatch({ type: "history/set", sessionId, history: {
+                        ...clearLiveTurnFromHistory(ended, null, streamId),
+                        chat: ended.chat.filter((item) => !item.liveTurn || !endedKeys.has(item.liveKey) || Date.now() - item.liveStartedAt >= 200),
+                    } });
+                    const timer = setTimeout(() => {
+                        this._liveTurnIdleTimers?.delete(sessionId);
+                        const current = this.getState().history.bySessionId.get(sessionId);
+                        if (!current) return;
+                        const chat = current.chat.filter((item) => !item.liveTurn || !endedKeys.has(item.liveKey));
+                        const cleared = chat.length === current.chat.length ? current : { ...current, chat };
+                        if (cleared !== current) {
+                            this.dispatch({ type: "history/set", sessionId, history: cleared });
+                        }
+                    }, 1_200);
+                    timer.unref?.();
+                    this._liveTurnIdleTimers.set(sessionId, timer);
+                    return true;
+                }
+                const existing = this.getState().history.bySessionId.get(sessionId)
+                    || { chat: [], activity: [], events: [], lastSeq: 0 };
+                this.dispatch({
+                    type: "history/set",
+                    sessionId,
+                    history: applyLiveTurnToHistory(existing, event.data, {
+                        sessionId,
+                        seq: event.liveSeq,
+                        createdAt: Date.now(),
+                    }),
+                });
+                return true;
+            }
             if (event.eventType === "session.canvas_data") {
                 this.applyCanvasDataEvent(sessionId, event);
             }
@@ -5730,6 +5837,12 @@ export class PilotSwarmUiController {
             }
             return false;
         }
+        if (this._liveTurnIdleTimers?.has(sessionId)
+            && (event.eventType === "session.turn_completed"
+                || event.eventType === "session.turn_stopped")) {
+            clearTimeout(this._liveTurnIdleTimers.get(sessionId));
+            this._liveTurnIdleTimers.delete(sessionId);
+        }
         const state = this.getState();
         const existing = state.history.bySessionId.get(sessionId) || { chat: [], activity: [], lastSeq: 0 };
         if (event.seq <= (existing.lastSeq || 0)) return false;

package/ui/core/src/history.js

@@ -530,6 +530,9 @@ 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;
     return {
         id: `${event.sessionId}:${event.seq}`,
         role: deriveChatRole(event, role, text),
@@ -539,9 +542,76 @@ function buildChatMessage(event, role) {
         ...(clientMessageIds.length > 0 ? { clientMessageIds } : {}),
         ...(sender ? { sender } : {}),
         ...(attachments.length > 0 ? { attachments } : {}),
+        ...(messageId ? { messageId } : {}),
     };
 }
 
+/** 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 +835,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");
@@ -1167,6 +1243,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,
@@ -1201,6 +1279,7 @@ export function appendEventToHistory(history, event) {
                     : m
             ));
         }
+        Object.assign(next, clearLiveTurnFromHistory(next));
         return next;
     }
 
@@ -1241,10 +1320,42 @@ 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;
+            const liveAgeMs = Math.max(0, settledAt - liveStartedAt);
+            // A live surface that never crossed the reveal threshold remains
+            // invisible and the durable answer renders normally. Once it was
+            // eligible to be seen, preserve the key and reasoning long enough
+            // for the browser to morph it smoothly into committed transcript.
+            if (liveAgeMs >= 200) {
+                const streamSettleDelayMs = Math.max(0, 900 - liveAgeMs);
+                Object.assign(message, {
+                    streamSettling: true,
+                    liveKey: liveItem?.liveKey || message.messageId,
+                    liveStartedAt,
+                    liveReasoningText: liveItem?.reasoningText || "",
+                    streamSettleDelayMs,
+                    streamSettleAt: settledAt + streamSettleDelayMs + 180,
+                });
+            }
+            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/selectors.js

@@ -457,17 +457,65 @@ export function manualOrderContainerKey(session, pinned = false) {
  * The one owner-badge descriptor both lists render from. Same person ⇒ same
  * initials and same colour, wherever they appear.
  */
-export function ownerBadgeFor(owner, { isMine = false } = {}) {
+export function ownerBadgeFor(owner, { isMine = false, hueByKey = null } = {}) {
     if (!owner) return null;
     const name = ownerDisplayName(owner, owner?.email || "");
+    const key = ownerBadgeKey(owner, owner?.email);
     return {
         initials: ownerInitials(owner),
-        hue: ownerBadgeHue(ownerBadgeKey(owner, owner?.email)),
+        // The list-wide assignment when the caller has one (no two people in
+        // the same list share a colour); the bare hash otherwise.
+        hue: hueByKey?.get?.(key) ?? ownerBadgeHue(key),
         name: name || "unknown user",
         isMine: Boolean(isMine),
     };
 }
 
+/**
+ * One colour per PERSON in a list, no two alike while the palette lasts.
+ *
+ * The hash alone puts different people on the same colour far too often
+ * (three people, twelve colours: one collision in four), and a badge whose
+ * colour does not tell people apart is not doing its job. So: everyone
+ * gets their hash hue first; anyone landing on a taken hue walks to the next
+ * free one. Walk order is the sorted identity key, so the outcome depends
+ * only on WHO is in the list — the same people get the same colours across
+ * reloads and in both panes, and a newcomer only ever takes a free colour.
+ */
+export function assignOwnerBadgeHues(keys) {
+    const sorted = [...new Set([...keys].map((k) => String(k || "").trim().toLowerCase()).filter(Boolean))].sort();
+    const taken = new Set();
+    const out = new Map();
+    for (const key of sorted) {
+        let hue = ownerBadgeHue(key);
+        if (taken.size < OWNER_BADGE_HUES) {
+            let steps = 0;
+            while (taken.has(hue) && steps < OWNER_BADGE_HUES) { hue = (hue + 1) % OWNER_BADGE_HUES; steps += 1; }
+        }
+        taken.add(hue);
+        out.set(key, hue);
+    }
+    return out;
+}
+
+// The assignment for every human owner in the session catalog, memoised on
+// the catalog's identity: the row selector runs per row and per dispatch.
+let ownerHueMapCache = null;
+export function ownerHueMapForSessions(byId) {
+    if (ownerHueMapCache && ownerHueMapCache.byId === byId) return ownerHueMapCache.map;
+    const keys = [];
+    for (const session of Object.values(byId || {})) {
+        if (!session || session.isSystem || session.isGroup) continue;
+        const owner = session.owner;
+        const ownerKey = ownerKeyForOwner(owner);
+        if (!ownerKey || ownerKey === SYSTEM_OWNER_KEY) continue;
+        keys.push(ownerBadgeKey(owner, owner?.email));
+    }
+    const map = assignOwnerBadgeHues(keys);
+    ownerHueMapCache = { byId, map };
+    return map;
+}
+
 function ownerDirectoryFromSessions(byId) {
     const directory = new Map();
     for (const session of Object.values(byId || {})) {
@@ -507,11 +555,11 @@ function resolvePackageOwner(pkg, directory) {
  * the badge is telling owners APART at a glance, which two-letter initials
  * alone do poorly (and did not do at all while they were all "?").
  *
- * Eight hues, all legible on both the light and dark portal grounds; the
+ * Twelve hues, all legible on both the light and dark portal grounds; the
  * viewer's own rows are styled separately by the caller, so this palette
  * never has to encode "mine".
  */
-const OWNER_BADGE_HUES = 8;
+export const OWNER_BADGE_HUES = 12;
 
 export function ownerBadgeHue(key) {
     const text = String(key || "").trim().toLowerCase();
@@ -1358,6 +1406,7 @@ export function selectSessionRows(state) {
                 ? ownerBadgeFor(effectiveSessionOwner(session, state.sessions.byId), {
                     isMine: Boolean(ownerKeyForOwner(state?.auth?.principal)
                         && ownerKeyForOwner(effectiveSessionOwner(session, state.sessions.byId)) === ownerKeyForOwner(state?.auth?.principal)),
+                    hueByKey: ownerHueMapForSessions(state.sessions.byId),
                 })
                 : null,
             orderable: isManuallyOrderableSession(session),
@@ -1904,7 +1953,11 @@ function describeChatMessageHeader(message, options = {}) {
     const sharedContext = options?.sharedContext === true;
     const isUser = message?.role === "user";
     const isSelf = isUser && senderKey && viewerKey && senderKey === viewerKey;
-    const fromOtherPerson = sharedContext && isUser && senderKey && !isSelf;
+    // A user-stamped message whose key is not the viewer's IS from someone
+    // else, whatever the session's visibility says: a targeted share leaves
+    // the session "private" but still puts another person's messages in the
+    // transcript. Naming them never needs the shared-context gate.
+    const fromOtherPerson = isUser && Boolean(senderKey) && Boolean(viewerKey) && !isSelf;
     // Owner tag: the sender is the session owner (or, for a sender-less own
     // message, the viewer themselves is the owner).
     const senderIsOwner = sharedContext && isUser && ownerKey && (
@@ -2427,7 +2480,22 @@ function splashArtWidth(text) {
         .reduce((widest, line) => Math.max(widest, stripTerminalMarkupTags(line).length), 0);
 }
 
+// Immutable history items survive live ticks. Do not re-parse thousands of
+// committed lines because the last message gained a handful of characters.
+const chatMessageLinesCache = new WeakMap();
 function buildChatMessageLines(message, maxWidth, options = {}) {
+    if (!message || typeof message !== "object") return buildChatMessageLinesUncached(message, maxWidth, options);
+    const key = JSON.stringify([maxWidth, options]);
+    let entries = chatMessageLinesCache.get(message);
+    if (entries?.has(key)) return entries.get(key);
+    const lines = buildChatMessageLinesUncached(message, maxWidth, options);
+    if (!entries) { entries = new Map(); chatMessageLinesCache.set(message, entries); }
+    if (entries.size >= 4) entries.delete(entries.keys().next().value);
+    entries.set(key, lines);
+    return lines;
+}
+
+function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
     if (message?.splash) {
         // Swap in the narrow-viewport variant when the main art would
         // overflow the pane (mobile portal, narrow terminals). When the
@@ -2447,6 +2515,66 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
         return buildThinkingCardLines(message, maxWidth);
     }
 
+    // The browser gives an in-flight assistant answer its own stable surface.
+    // Previously it was flattened into the ordinary transcript on every
+    // snapshot. As partial markdown changed shape (plain lines -> table/code
+    // block), React could replace several adjacent nodes and the whole answer
+    // appeared to flash. One keyed card keeps the outer DOM and its shading in
+    // place while only the body grows. The TUI deliberately keeps its existing
+    // line-oriented rendering.
+    if ((message?.liveTurn || message?.streamSettling) && options.tableMode === "sentinel") {
+        const isLive = message?.liveTurn === true;
+        const reasoningText = String(message?.reasoningText || message?.liveReasoningText || "");
+        const cardLines = buildMessageCardLines({
+            title: isLive
+                ? (message?.text ? "Agent is responding" : "Agent is thinking")
+                : "Agent responded",
+            body: decorateArtifactLinksForChat(message?.text || ""),
+            width: Math.max(20, maxWidth),
+            titleColor: "cyan",
+            borderColor: "cyan",
+            tableMode: "sentinel",
+        });
+        const cardEndIndex = cardLines.findIndex((line) => line?.kind === "cardEnd");
+        if (cardEndIndex > 0) {
+            const bodyLines = cardLines.slice(1, cardEndIndex);
+            if (reasoningText) {
+                bodyLines.unshift({
+                    ...buildSystemNoticeLine({
+                        title: isLive ? "Thinking" : "Thought",
+                        summary: isLive ? "In progress" : "Completed",
+                        body: reasoningText,
+                        color: "gray",
+                    }),
+                    liveReasoning: isLive,
+                    streamReasoning: true,
+                });
+            }
+            // Keep the progress marker out of markdown syntax: appending it
+            // to a closing fence or an empty row can change parsing/height.
+            if (isLive) cardLines[0].runs.push({ text: " ▍", color: "cyan", role: "streamingCaret" });
+            if (isLive && message.truncated) bodyLines.push([{ text: "Preview paused — the full answer will appear when complete.", color: "gray" }]);
+            const liveKey = message?.liveKey || message?.messageId || message?.id || "active-turn";
+            return [
+                {
+                    ...cardLines[0],
+                    cardVariant: isLive ? "live" : "settling",
+                    cardKey: `live:${liveKey}`,
+                    liveStartedAt: message?.liveStartedAt || message?.createdAt || Date.now(),
+                    settleDelayMs: Number(message?.streamSettleDelayMs) || 0,
+                    settleAt: Number(message?.streamSettleAt) || null,
+                },
+                ...bodyLines,
+                ...cardLines.slice(cardEndIndex),
+            ];
+        }
+    }
+
+    if (message?.liveTurn && options.tableMode !== "sentinel" && message.reasoningText) {
+        const reasoning = buildThinkingCardLines({ ...message, text: message.reasoningText }, maxWidth);
+        return message.text ? [...reasoning, ...buildChatMessageLines({ ...message, reasoningText: "" }, maxWidth, options)] : reasoning;
+    }
+
     // Chrome-less message: render the text as plain markdown directly into
     // the chat pane (no card border, no speaker prefix, no timestamp). Used
     // for the session summary view so the summary feels like the pane's
@@ -2589,6 +2717,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
 
     if (startsWithStructuredBlock(tintedMarkdownLines)) {
         const structured = prefix.length > 0 ? [prefix, ...tintedMarkdownLines] : tintedMarkdownLines;
+        if (message?.streaming) appendStreamingCaret(structured);
         return attachmentChipLines.length > 0 ? [...structured, ...attachmentChipLines] : structured;
     }
 
@@ -2610,10 +2739,23 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
             renderedLines.push(lineRuns);
         }
     }
+    if (message?.streaming) {
+        appendStreamingCaret(renderedLines);
+    }
     renderedLines.push(...attachmentChipLines);
     return renderedLines;
 }
 
+function appendStreamingCaret(lines) {
+    const lastRuns = [...lines].reverse().find((line) => Array.isArray(line)
+        && line.some((run) => String(run?.text || "").trim()));
+    if (lastRuns) {
+        lastRuns.push({ text: " ▍", color: "cyan", role: "streamingCaret" });
+    } else {
+        lines.push([{ text: "▍", color: "cyan", role: "streamingCaret" }]);
+    }
+}
+
 // Image attachment chips under a message. In sentinel mode (browser portal)
 // a single structured line carries the refs so the web renderer can show
 // authenticated thumbnails; everywhere else (TUI) each file renders as a
@@ -2730,6 +2872,10 @@ function liveActivityPhaseText(item) {
         case "assistant.intent": return "planning\u2026";
         case "assistant.message_start":
         case "assistant.message": return "writing reply\u2026";
+        case "model.call_start": {
+            const model = String(item?.text || "").replace(/^.*\bcalling\s+/i, "").trim();
+            return `calling ${model || "model"}\u2026`;
+        }
         case "session.compaction_start": return "compacting context\u2026";
         case "session.compaction_complete": return "context compacted";
         case "session.dehydrated": return "dehydrating\u2026";
@@ -2891,12 +3037,19 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     const activeSessionId = state?.sessions?.activeSessionId;
     const activeSession = activeSessionId ? state?.sessions?.byId?.[activeSessionId] : null;
     const ownerKey = ownerKeyForOwner(activeSession?.owner);
-    // A shared context = the session is shared deployment-wide, or the viewer
-    // is not its owner (someone shared it with them). Only then does the
-    // transcript name speakers and tag the owner.
+    // A shared context = the session is shared deployment-wide, the viewer is
+    // not its owner (someone shared it with them), or someone other than the
+    // viewer has written to it (the owner shared it with a writer; the session
+    // row still says "private" — targeted shares are not on the row, but the
+    // other person's stamped messages are in the transcript). Only then does
+    // the transcript name speakers and tag the owner.
     const sharedContext = Boolean(activeSession && (
         (activeSession.visibility && activeSession.visibility !== "private")
         || (ownerKey && viewerKey && ownerKey !== viewerKey)
+        || (viewerKey && messages.some((message) => message?.role === "user"
+            && message?.sender?.kind === "user"
+            && ownerKeyForOwner(message.sender)
+            && ownerKeyForOwner(message.sender) !== viewerKey))
     ));
     const buildOptions = {
         ...(options?.tableMode ? { tableMode: options.tableMode } : {}),
@@ -4165,6 +4318,8 @@ export function selectAdminConsole(state) {
     const canEditPackage = (pkg) => ownsPackage(pkg) || Boolean(pkg?.canEdit);
     // Built once per render, not per row.
     const ownerDirectory = ownerDirectoryFromSessions(state?.sessions?.byId);
+    // Same assignment as the session list, so the same person is the same colour in both panes.
+    const packageHueByKey = ownerHueMapForSessions(state?.sessions?.byId);
     // Same rule as the session list: the owner chip only earns its place when
     // this list actually holds more than one owner. Shared packages belong to
     // the deployment, not a person, so they neither carry a chip nor count
@@ -4212,7 +4367,7 @@ export function selectAdminConsole(state) {
         // PERSON's, matching the session list exactly.
         ownerBadge: (pkg.scope === "shared" || !decoratePackageOwners)
             ? null
-            : ownerBadgeFor(resolvePackageOwner(pkg, ownerDirectory)),
+            : ownerBadgeFor(resolvePackageOwner(pkg, ownerDirectory), { hueByKey: packageHueByKey }),
         // Highlight only while the Agents section is active — otherwise the
         // GitHub Keys screen shows a double selection.
         selected: rowMatchesSelection(pkg),