pilotswarm 0.5.59 → 0.5.61

package/README.md

@@ -260,3 +260,10 @@ Docs: [Quick Start](https://github.com/affandar/pilotswarm/blob/main/docs/quicks
 [MCP Setup](https://github.com/affandar/pilotswarm/blob/main/docs/user-guide/mcp-local-setup.md) ·
 [Web API Reference](https://github.com/affandar/pilotswarm/blob/main/docs/api/reference.md) ·
 [Architecture / Layering](https://github.com/affandar/pilotswarm/blob/main/docs/architecture/layering.md)
+
+## Master of Agents
+
+The portal includes a personal multi-session workspace with resizable desktop
+chat/canvas panels, one focused composer, and zen mode. Phones show one panel
+at a time with a layout minimap and swipe navigation. Layouts save automatically.
+See the [MoA guide](https://github.com/affandar/PilotSwarm/blob/main/docs/user-guide/master-of-agents.md).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.59",
+    "version": "0.5.61",
     "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.59",
+        "pilotswarm-sdk": "0.5.61",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

package/ui/core/src/controller.js

@@ -362,6 +362,16 @@ function timestampMs(value) {
 }
 
 function isSameOrOlderSessionUpdate(previousSession, nextSession) {
+    // Detail patch construction must use the same ordering as the reducer.
+    // Client event timestamps can exceed the server's next status write.
+    const version = (value) => {
+        if (value == null || value === "" || typeof value === "boolean") return null;
+        const number = Number(value);
+        return Number.isSafeInteger(number) && number > 0 ? number : null;
+    };
+    const previousVersion = version(previousSession?.statusVersion);
+    const nextVersion = version(nextSession?.statusVersion);
+    if (previousVersion != null && nextVersion != null) return nextVersion <= previousVersion;
     const previousUpdatedAt = timestampMs(previousSession?.updatedAt);
     const nextUpdatedAt = timestampMs(nextSession?.updatedAt);
     return previousUpdatedAt > 0 && nextUpdatedAt > 0 && nextUpdatedAt <= previousUpdatedAt;
@@ -473,6 +483,13 @@ function buildSessionMergePatch(previousSession, nextSession) {
         changed = true;
     }
 
+    // Ordering metadata is required even when unchanged. A conflicting status
+    // at the same version must not masquerade as an unversioned live event.
+    if (changed) {
+        for (const key of ["statusVersion", "updatedAt"]) {
+            if (nextSession[key] !== undefined) patch[key] = nextSession[key];
+        }
+    }
     return changed ? patch : null;
 }
 
@@ -3255,6 +3272,8 @@ export class PilotSwarmUiController {
      */
     revealCreatedSession() {
         if (this.getState().admin?.visible) this.closeAdminConsole();
+        this.closeBudget();
+        this.dispatch({ type: "ui/revealCreatedSession", sessionId: this.getState().sessions.activeSessionId });
         this.setFocus(FOCUS_REGIONS.PROMPT);
     }
 
@@ -5454,7 +5473,9 @@ export class PilotSwarmUiController {
             return;
         }
         await this.ensureSessionHistory(sessionId, { force: true });
+        if (this.getState().sessions.activeSessionId !== sessionId) return;
         await this.syncSessionDetail(sessionId).catch(() => {});
+        if (this.getState().sessions.activeSessionId !== sessionId) return;
         this.attachActiveSession(sessionId);
         this.ensureInspectorData().catch(() => {});
         // Canvas snapshot rides the selection burst. Invalidate-then-fetch on
@@ -5590,8 +5611,9 @@ export class PilotSwarmUiController {
      * history pipeline recognizes the canonical prefix and keeps it out of
      * the portal chat pane; the transcript still records it for provenance.
      */
-    submitCanvasAction(sessionId, message) {
+    submitCanvasAction(sessionId, message, slot = 1) {
         if (!sessionId) return Promise.resolve({ ok: false, reason: "no session" });
+        if (!Number.isInteger(slot) || slot < 1 || slot > 5) return Promise.resolve({ ok: false, reason: "invalid canvas slot" });
         // Creator-only, mirrored from the server's enforcement (the server is
         // the authority; this is the friendly refusal). The canvas mutates —
         // a shared viewer may be looking at a different revision than the one
@@ -5601,7 +5623,7 @@ export class PilotSwarmUiController {
         // longer pre-refuses non-owners: a write-shared collaborator's click
         // must reach the agent, and the server's refusal for a read-only
         // viewer comes back as the result's reason.
-        const contract = this.getState().canvas.bySessionId[sessionId]?.responseContract || null;
+        const contract = this.getState().canvas.bySessionId[canvasPrefKey(sessionId, slot)]?.responseContract || null;
         const verdict = validateCanvasAction(contract, message);
         if (!verdict.ok) return Promise.resolve(verdict);
         if (!this.canvasActionLimiters) this.canvasActionLimiters = new Map();
@@ -6011,15 +6033,42 @@ export class PilotSwarmUiController {
         this.maybeFlushQueuedOutbox(sessionId, session);
     }
 
+    async openCreatedSession(created, options = {}) {
+        const sessionId = created.sessionId;
+        // Creation is explicit navigation, even if a paged/stale catalog or
+        // the current filters omit the new row. Seed the response, preserve
+        // the outgoing draft, and latch the same visibility rules as a link.
+        // Invalidate catalog reads that started before this row existed.
+        this.sessionRefreshSeq = (this.sessionRefreshSeq || 0) + 1;
+        if (this.getState().ui.promptEdit) this.exitPendingPromptEdit({ restoreDraft: true });
+        this.dispatch({ type: "sessions/selected", sessionId });
+        this.dispatch({ type: "ui/sequenceExpandedTurns", turns: [] });
+        this.dispatch({ type: "ui/sequenceSelectedTurn", turn: null });
+        this.dispatch({ type: "sessions/navigationIntent", sessionId });
+        this.dispatch({ type: "sessions/merged", session: normalizeSessionListRow({
+            ...created,
+            ...(options.groupId ? { viewerGroupId: options.groupId } : {}),
+        }) });
+        this.revealCreatedSession();
+        this.dispatch({ type: "ui/status", text: `Created session ${sessionId.slice(0, 8)}` });
+        // A follow-up read failure must not masquerade as a failed create and
+        // invite a duplicate. The regular refresh loop can finish hydration.
+        try {
+            await this.loadSession(sessionId);
+        } catch (error) {
+            if (this.getState().sessions.activeSessionId === sessionId) {
+                this.dispatch({ type: "ui/status", text: `Created session ${sessionId.slice(0, 8)}; could not load it yet: ${error?.message || error}` });
+            }
+        }
+        this.scheduleSessionsRefresh(0);
+    }
+
     async createSession(options = {}) {
         try {
             const requestOptions = this.applyActiveGroupDefault(options);
             const created = await this.transport.createSession(requestOptions);
             await this.placeCreatedSessionInGroup(created, requestOptions.groupId ?? null);
-            await this.refreshSessions();
-            await this.loadSession(created.sessionId);
-            this.revealCreatedSession();
-            this.dispatch({ type: "ui/status", text: `Created session ${created.sessionId.slice(0, 8)}` });
+            await this.openCreatedSession(created, requestOptions);
             return created;
         } catch (error) {
             this.dispatch({ type: "ui/status", text: error?.message || String(error) || "Failed to create session" });
@@ -6039,13 +6088,7 @@ export class PilotSwarmUiController {
             // session that was just created, and a lost count only reorders a list.
             this._recordAgentPickerUse(agentName);
             await this.placeCreatedSessionInGroup(created, requestOptions.groupId ?? null);
-            await this.refreshSessions();
-            await this.loadSession(created.sessionId);
-            this.revealCreatedSession();
-            this.dispatch({
-                type: "ui/status",
-                text: `Created ${formatAgentDisplayTitle(agentName, options.title)} session ${created.sessionId.slice(0, 8)}`,
-            });
+            await this.openCreatedSession(created, requestOptions);
             return created;
         } catch (error) {
             this.dispatch({ type: "ui/status", text: error?.message || String(error) || "Failed to create session" });

package/ui/core/src/history.js

@@ -2,6 +2,7 @@ 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 { buildSessionWarning } from "./session-errors.js";
 
 export const DEFAULT_HISTORY_EVENT_LIMIT = 300;
 export const HISTORY_EVENT_LIMIT_STEPS = [
@@ -16,6 +17,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 = [
+    "session.error",
     "user.message",
     "assistant.message",
     // Needed to distinguish interim assistant output from the final answer
@@ -412,7 +414,8 @@ function areMessagesEquivalent(left, right) {
     // event per rev), and share identical text by design (the artifact://
     // 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") {
+    if (left.kind === "canvas-update" || right.kind === "canvas-update"
+        || left.kind === "session-warning" || right.kind === "session-warning") {
         return left.kind === right.kind && left.id === right.id;
     }
 
@@ -1211,6 +1214,10 @@ export function buildHistoryModel(events = [], options = {}) {
 
     for (const event of events) {
         storedEvents.push(event);
+        if (event.eventType === "session.error") {
+            const warning = buildSessionWarning(event);
+            if (warning) chat.push(warning);
+        }
         if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
             settleAssistantResponses(chat, event);
         }
@@ -1308,6 +1315,13 @@ 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);
+        }
+    }
+
     if (["user.message", "session.turn_completed", "session.turn_stopped", "session.epoch_committed"].includes(event.eventType)) {
         settleAssistantResponses(next.chat, event);
     }

package/ui/core/src/index.js

@@ -16,3 +16,5 @@ export { isThemeLight } from "./themes/helpers.js";
 export * from "./themes/index.js";
 export { validateCanvasAction, formatCanvasActionPrompt, parseCanvasActionContent, isCanvasActionContent, createCanvasActionLimiter, CANVAS_ACTION_PREFIX } from "./canvas-actions.js";
 export * from "./table-layout.js";
+
+export * from "./moa.js";

package/ui/core/src/moa.js

@@ -0,0 +1,47 @@
+// One personal desktop layout, containing references and geometry only.
+export const MOA_MAX_PANELS = 16;
+export const MOA_BREAKPOINT = 920;
+const object = (v) => v && typeof v === "object" && !Array.isArray(v);
+const id = (v) => typeof v === "string" && /^[a-zA-Z0-9_-]{1,100}$/.test(v);
+export const emptyMoaPanel = () => ({ id: crypto.randomUUID(), type: "empty" });
+export const moaLeaves = (n) => !n ? [] : n.type === "split" ? [...moaLeaves(n.first), ...moaLeaves(n.second)] : [n];
+export function normalizeMoaLayout(value) {
+    if (!object(value)) throw new Error("Invalid MoA layout.");
+    const seen = new Set(); let panels = 0; let nodes = 0;
+    function walk(n, depth = 0) {
+        if (!object(n) || depth > 15 || ++nodes > 31 || !id(n.id) || seen.has(n.id)) throw new Error("Invalid MoA panel tree.");
+        seen.add(n.id);
+        if (n.type === "split") {
+            if (!["row", "column"].includes(n.direction) || !Number.isFinite(n.ratio)) throw new Error("Invalid MoA split.");
+            return { id: n.id, type: "split", direction: n.direction, ratio: Math.min(90, Math.max(10, n.ratio)), first: walk(n.first, depth + 1), second: walk(n.second, depth + 1) };
+        }
+        if (++panels > MOA_MAX_PANELS) throw new Error(`A MoA supports up to ${MOA_MAX_PANELS} panels.`);
+        if (n.type === "empty") return { id: n.id, type: "empty" };
+        if (!["chat", "canvas"].includes(n.type) || !id(n.sessionId)) throw new Error("Invalid MoA session reference.");
+        if (n.type === "canvas" && (!Number.isInteger(n.slot) || n.slot < 1 || n.slot > 5)) throw new Error("Invalid canvas slot.");
+        return { id: n.id, type: n.type, sessionId: n.sessionId, ...(n.type === "canvas" ? { slot: n.slot } : {}) };
+    }
+    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 } : {}) };
+    }
+    // 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 };
+}
+export function replaceMoaNode(tree, nodeId, next) {
+    if (!tree) return null;
+    if (tree.id === nodeId) return next;
+    if (tree.type !== "split") return tree;
+    const first = replaceMoaNode(tree.first, nodeId, next), second = replaceMoaNode(tree.second, nodeId, next);
+    if (!first) return second;
+    if (!second) return first;
+    return first === tree.first && second === tree.second ? tree : { ...tree, first, second };
+}

package/ui/core/src/reducer.js

@@ -1,3 +1,5 @@
+import { normalizeMoa } from "./moa.js";
+import { retainSessionWarnings } from "./session-errors.js";
 import { buildSessionTree, isManuallyOrderableSession } from "./session-tree.js";
 import { FOCUS_REGIONS } from "./commands.js";
 import { DEFAULT_HISTORY_EVENT_LIMIT, dedupeChatMessages } from "./history.js";
@@ -317,62 +319,66 @@ function isSameOrOlderSessionUpdate(previousSession, nextSession) {
     return previousAt > 0 && nextAt > 0 && nextAt <= previousAt;
 }
 
-// A run that has ended for good. These are authoritative and must always land,
-// even from an update that looks stale — stranding a finished session as
-// "running" is far worse than a brief wrong status.
+// Completion can come from orchestration metadata without another custom
+// status write. Allow it at the same version, but never at an older version.
 const TERMINAL_SESSION_STATUSES = new Set(["completed", "failed", "cancelled", "error"]);
 
-// Session state is written from several concurrent sources: the session-list
-// poll, live events, and a per-session detail fetch. They do not agree
-// instant-to-instant, and the list poll in particular can report a status the
-// orchestration has already moved on from — observed live as:
-//
-//   sessions/loaded  running + waiting -> waiting   prevAt == incomingAt
-//   sessions/merged  waiting + running -> running   (105ms later)
-//
-// while the server's own session row and orchestration both read "running"
-// throughout. Consumers gated on status === "running" — the live-activity
-// strip, the composer's Stop button — blink off for the width of that gap.
-//
-// Refuse ANY non-terminal downgrade out of "running" unless the incoming
-// update is genuinely newer. Deliberately not restricted to idle-like
-// statuses: the status actually observed clobbering a live run was "waiting",
-// and an earlier version of this guard missed the bug by excluding it.
-// Terminal statuses are exempt so a finished run can never be stranded.
-//
-// "Genuinely newer" is decided by the server's monotonic statusVersion when
-// both sides carry one — wall-clock updatedAt is only the fallback. The
-// timestamp heuristic alone can WEDGE a finished turn as "running" forever:
-// client-side event merges (turn_completed, context usage) inflate the held
-// session's updatedAt past the server row's idle-write timestamp, so every
-// subsequent idle poll compares as stale and only a terminal status could
-// ever land. Observed live (2026-07-21, local portal): server row idle at
-// statusVersion 5 while the client showed "Working.." indefinitely.
-function shouldPreserveRunningStatus(previousSession, nextSession) {
-    const nextStatus = String(nextSession?.status ?? "").toLowerCase();
-    if (previousSession?.status !== "running"
-        || nextStatus === "running"
-        || TERMINAL_SESSION_STATUSES.has(nextStatus)) {
-        return false;
-    }
-    const previousVersion = Number(previousSession?.statusVersion);
-    const nextVersion = Number(nextSession?.statusVersion);
-    if (Number.isFinite(previousVersion) && previousVersion > 0
-        && Number.isFinite(nextVersion) && nextVersion > 0) {
-        // Monotonic server counter: a higher version is authoritative and
-        // must land; a same-or-lower version is provably stale and is held
-        // regardless of what the timestamps claim.
-        return nextVersion <= previousVersion;
+function sessionStatusVersion(session) {
+    const value = session?.statusVersion;
+    if (value == null || value === "" || typeof value === "boolean") return null;
+    const version = Number(value);
+    return Number.isSafeInteger(version) && version > 0 ? version : null;
+}
+
+// List polls and detail requests can arrive out of order. Compare the server
+// counter in both directions: an old running row must not revive an idle
+// session, and an old idle row must not hide a running one. Keep the version
+// with its status; accepting an older counter would let the next stale row win.
+function shouldPreserveSessionStatus(previousSession, nextSession) {
+    const previousVersion = sessionStatusVersion(previousSession);
+    const nextVersion = sessionStatusVersion(nextSession);
+    if (previousVersion != null && nextVersion != null) {
+        if (nextVersion < previousVersion) return true;
+        if (nextVersion > previousVersion) return false;
     }
-    return isSameOrOlderSessionUpdate(previousSession, nextSession);
+    const previousStatus = previousSession?.status;
+    const nextStatus = nextSession?.status;
+    if (!previousStatus || !nextStatus || previousStatus === nextStatus
+        || TERMINAL_SESSION_STATUSES.has(nextStatus)) return false;
+    if (previousVersion != null && nextVersion != null) return true;
+    // Legacy rows and live event patches may lack a counter. Do not guess
+    // their order without timestamps. Preserve the terminal-status escape
+    // hatch, since updatedAt also changes for non-status events.
+    if (previousStatus === "running") return isSameOrOlderSessionUpdate(previousSession, nextSession);
+    // An unversioned new turn may share its timestamp with the preceding idle
+    // row. Equal timestamps alone are not evidence that a start is stale.
+    const previousAt = sessionUpdateTimestampMs(previousSession);
+    const nextAt = sessionUpdateTimestampMs(nextSession);
+    return nextStatus === "running" && previousAt > 0 && nextAt > 0 && nextAt < previousAt;
 }
 
+// These values describe the same run as status. Mixing an old question or
+// pause reason with a newer status can change composer routing and controls.
+const SESSION_STATUS_FIELDS = new Set([
+    "status", "statusVersion", "updatedAt", "orchestrationStatus",
+    "pendingQuestion", "waitReason", "pauseState", "error", "result",
+]);
+
 function mergeDefinedSessionFields(previousSession = {}, nextSession = {}) {
     let merged = previousSession || {};
-    const preserveRunning = shouldPreserveRunningStatus(previousSession, nextSession);
+    const preserveStatus = shouldPreserveSessionStatus(previousSession, nextSession);
+    const previousVersion = sessionStatusVersion(previousSession);
     for (const [key, value] of Object.entries(nextSession || {})) {
         if (value === undefined) continue;
-        if (key === "status" && preserveRunning) continue;
+        if (preserveStatus && SESSION_STATUS_FIELDS.has(key)) continue;
+        // Repeated snapshots of one server version cannot roll its timestamp
+        // back and then admit an older unversioned running update.
+        if (key === "updatedAt" && previousVersion != null
+            && previousVersion === sessionStatusVersion(nextSession)
+            && sessionUpdateTimestampMs(nextSession) < sessionUpdateTimestampMs(previousSession)) continue;
+        // 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 (merged === previousSession) {
                 merged = { ...(previousSession || {}) };
@@ -995,6 +1001,10 @@ function baseReducer(state, action) {
             if (Boolean(action.collapsed) === Boolean(state.ui.sessionDetailCollapsed)) return state;
             return { ...state, ui: { ...state.ui, sessionDetailCollapsed: Boolean(action.collapsed) } };
 
+        case "ui/moaSaveStatus":
+            return { ...state, ui: { ...state.ui, moaSaveStatus: action.status, moaDirty: action.status === "saved" && state.ui.moaRevision === action.revision ? false : state.ui.moaDirty } };
+        case "ui/moa":
+            return { ...state, ui: { ...state.ui, moa: normalizeMoa(action.value), moaDirty: true, moaRevision: (state.ui.moaRevision || 0) + 1 } };
         case "profileSettings/apply": {
             const settings = action.settings && typeof action.settings === "object" && !Array.isArray(action.settings)
                 ? action.settings
@@ -1098,6 +1108,8 @@ function baseReducer(state, action) {
                 sessions: selection.sessions,
                 ui: {
                     ...selection.ui,
+                    moa: !state.ui.moaDirty && Object.prototype.hasOwnProperty.call(settings, "moa") ? normalizeMoa(settings.moa) : selection.ui.moa,
+                    moaLoaded: true,
                     themeId: hasTheme ? settings.themeId.trim() : selection.ui.themeId,
                     touchScale: hasTouchScale ? settings.touchScale : selection.ui.touchScale,
                     sessionDetailCollapsed: hasSessionDetailCollapsed
@@ -1624,7 +1636,8 @@ function baseReducer(state, action) {
             }
             for (const session of action.sessions) {
                 const previous = state.sessions.byId[session.sessionId];
-                byId[session.sessionId] = mergeDefinedSessionFields(previous, session);
+                byId[session.sessionId] = retainSessionWarnings(previous, mergeDefinedSessionFields(previous, session),
+                    state.history.bySessionId.get(session.sessionId)?.events, nowMs);
             }
             if (
                 state.sessions.activeSessionId
@@ -1807,7 +1820,8 @@ function baseReducer(state, action) {
         case "sessions/merged": {
             if (!action.session?.sessionId) return state;
             const previousSession = state.sessions.byId[action.session.sessionId];
-            const mergedSession = mergeDefinedSessionFields(previousSession, action.session);
+            const mergedSession = retainSessionWarnings(previousSession, mergeDefinedSessionFields(previousSession, action.session),
+                state.history.bySessionId.get(action.session.sessionId)?.events);
             // A single session going running/idle changes its ANCESTORS' counts
             // and therefore their visual status, so both passes run over the
             // whole map rather than the one row. buildSessionTree below is
@@ -1939,6 +1953,13 @@ function baseReducer(state, action) {
             };
         }
 
+        case "ui/revealCreatedSession":
+            return {
+                ...state,
+                files: { ...state.files, fullscreen: false, paneOpen: false },
+                ui: { ...state.ui, revealedCreatedSessionId: action.sessionId, fullscreenPane: null },
+            };
+
         case "ui/fullscreenPane": {
             const fullscreenPane = normalizeFullscreenPane(action.fullscreenPane);
             return {

package/ui/core/src/selectors.js

@@ -28,6 +28,7 @@ import {
     getContextHeaderBadge,
 } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
+import { withSessionWarnings } from "./session-errors.js";
 import {
     BUDGET_PERIODS,
     BUDGET_SERIES_DAYS,
@@ -1894,13 +1895,15 @@ export function selectActiveChat(state) {
         ? buildPendingQuestionMessage(session, events)
         : null;
     const answeredQuestionMessage = buildAnsweredPendingQuestionMessage(session, chat);
-    const sessionErrorMessage = buildSessionErrorMessage(session, events);
+    // Legacy/synthetic selector callers may not have passed through the
+    // reducer that captures status-only notices. Keep their fallback too.
+    const sessionErrorMessage = session?.chatWarnings?.length ? null : buildSessionErrorMessage(session, events);
 
-    if ((!history || chat.length === 0) && !pendingQuestionMessage && !answeredQuestionMessage && !sessionErrorMessage) {
+    if ((!history || chat.length === 0) && !pendingQuestionMessage && !answeredQuestionMessage && !sessionErrorMessage && !session?.chatWarnings?.length) {
         return createSplashCard(state.branding, session);
     }
 
-    const messages = chat.length > 0 ? [...chat] : createSplashCard(state.branding, session);
+    const messages = withSessionWarnings(chat.length > 0 ? chat : createSplashCard(state.branding, session), session, events);
     if (pendingQuestionMessage) {
         messages.push(pendingQuestionMessage);
     }
@@ -1908,7 +1911,8 @@ export function selectActiveChat(state) {
         messages.push(answeredQuestionMessage);
     }
     if (sessionErrorMessage) {
-        messages.push(sessionErrorMessage);
+        const index = messages.findIndex(message => sessionErrorMessage.createdAt != null && message.createdAt > sessionErrorMessage.createdAt);
+        messages.splice(index < 0 ? messages.length : index, 0, sessionErrorMessage);
     }
     return messages;
 }
@@ -2520,19 +2524,23 @@ function buildChatMessageLinesUncached(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.
+    // One stable disclosure spans live output, saved updates and the final
+    // answer. Its identity is not evidence of streaming: durable history uses
+    // this shell too, including turns created with PILOTSWARM_LIVE_TURN=0.
+    // Only actual transient content may use preview labels/status. The native
+    // TUI keeps its line-oriented rendering of these same durable messages.
     if ((message?.liveTurn || message?.streamSettling || message?.assistantPreview) && options.tableMode === "sentinel") {
+        // streamSettling also preserves DOM through durable arrival; it does
+        // not mean those saved bytes are still provisional.
+        const provisional = !message?.assistantPreview && Boolean(message?.liveTurn || message?.streamSettling);
         // Carry raw markdown: collapsed previews never parse their hidden body.
         return [{
             kind: "assistantPreview",
             width: maxWidth,
-            text: "Message preview",
+            text: provisional ? "Message preview" : "Agent update",
+            statusText: !provisional ? "" : message?.liveTurn
+                ? (message?.text ? "Responding" : "Thinking")
+                : message?.streamSettling ? "Finishing" : "",
             previewKey: `assistant:${message?.liveKey || message?.messageId || message?.id || "active-turn"}`,
             body: decorateArtifactLinksForChat(message?.text || ""),
             reasoningText: String(message?.reasoningText || message?.liveReasoningText || ""),
@@ -2971,11 +2979,16 @@ let chatLinesMemo = [];
 
 export function selectChatLines(state, maxWidth = 80, options = {}) {
     const memoSessionId = state?.sessions?.activeSessionId ?? null;
+    const memoSession = memoSessionId ? state?.sessions?.byId?.[memoSessionId] ?? null : null;
     const memoKey = {
         sessionId: memoSessionId,
-        session: memoSessionId ? state?.sessions?.byId?.[memoSessionId] ?? null : null,
+        session: memoSession,
         byId: state?.sessions?.byId ?? null,
         chat: state?.history?.bySessionId?.get?.(memoSessionId)?.chat ?? null,
+        // Raw tool activity affects warning/question reconciliation, but must
+        // not re-wrap an ordinary, unchanged transcript on every event.
+        events: memoSession?.chatWarnings?.length || memoSession?.error || memoSession?.pendingQuestion
+            ? state?.history?.bySessionId?.get?.(memoSessionId)?.events ?? null : null,
         branding: state?.branding ?? null,
         principal: state?.auth?.principal ?? null,
         maxWidth,
@@ -2986,6 +2999,7 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
             && entry.session === memoKey.session
             && entry.byId === memoKey.byId
             && entry.chat === memoKey.chat
+            && entry.events === memoKey.events
             && entry.viewMode === memoKey.viewMode
             && entry.branding === memoKey.branding
             && entry.principal === memoKey.principal

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

@@ -17,3 +17,100 @@ export function shouldKeepSessionWarning(previousSession, nextSession) {
     const nextAt = time(nextSession?.updatedAt);
     return previousAt > 0 && nextAt > 0 && nextAt <= previousAt;
 }
+
+const timeMs = value => value instanceof Date ? value.getTime()
+    : typeof value === "number" ? value : Date.parse(value || "");
+const errorText = event => typeof event?.data === "string" ? event.data
+    : String(event?.data?.message || event?.data?.error || event?.data?.text || "").trim();
+const sameError = (statusText, eventText) => Boolean(eventText) && statusText.includes(eventText);
+
+export function buildSessionWarning(event) {
+    const text = errorText(event);
+    if (!text) return null;
+    const failed = event?.data?.fatal === true;
+    return {
+        id: `${event.sessionId}:${event.seq}:warning`,
+        kind: "session-warning", role: "system", text,
+        warningSeq: Number(event.seq),
+        createdAt: timeMs(event.createdAt) || null,
+        cardTitle: failed ? "Error" : "Warning",
+        cardTitleColor: failed ? "red" : "yellow",
+        cardBorderColor: failed ? "red" : "yellow",
+    };
+}
+
+// Status-only failures have no chat event yet (some never get one). Capture
+// their position ONCE in shared state, not on each render/poll. Recovery ends
+// the active episode but does not erase its notice. Durable error events are
+// rendered separately and survive reload/history paging.
+export function retainSessionWarnings(previous, next, events = [], now = Date.now()) {
+    const warnings = previous?.chatWarnings || [];
+    const last = warnings.at(-1);
+    const text = String(next?.error || "").trim();
+    const failed = next?.status === "failed" || next?.orchestrationStatus === "Failed";
+    const active = Boolean(text) && (failed || !["completed", "cancelled", "terminated", "input_required"].includes(next?.status))
+        && !["Completed", "Terminated"].includes(next?.orchestrationStatus);
+    if (!active) {
+        if (!last?.active) return next;
+        return { ...next, chatWarnings: [...warnings.slice(0, -1), { ...last, active: false }] };
+    }
+    const since = last?.createdAt || 0;
+    const event = events.findLast(e => e.eventType === "session.error"
+        && timeMs(e.createdAt) > since && sameError(text, errorText(e)));
+    // A retained error field can outlive a terminal/wait state. A later
+    // running snapshot alone is not evidence of another failure episode.
+    if (last && !last.active && text === last.text && text === String(previous?.error || "").trim() && !event) return next;
+    const movedOn = last && text !== last.text && events.some(e =>
+        Number(e.seq) > last.afterSeq && timeMs(e.createdAt) > last.createdAt
+        && ["user.message", "assistant.message"].includes(e.eventType));
+    if (last?.active && !movedOn) {
+        if (last.text === text && last.failed === failed) return next;
+        return { ...next, chatWarnings: [...warnings.slice(0, -1), { ...last, text, failed }] };
+    }
+    const ordinal = (last?.ordinal || 0) + 1;
+    const previousWarnings = last?.active ? [...warnings.slice(0, -1), { ...last, active: false }] : warnings;
+    return { ...next, chatWarnings: [...previousWarnings, {
+        id: `session-error:${next.sessionId}:${ordinal}`, ordinal, text, failed, active: true,
+        eventSeq: event ? Number(event.seq) : null,
+        afterSeq: Number(events.at(-1)?.seq) || 0,
+        since,
+        createdAt: timeMs(event?.createdAt) || timeMs(next.updatedAt) || now,
+    }].slice(-300) };
+}
+
+export function withSessionWarnings(chat, session, events = []) {
+    const messages = [...chat];
+    for (const warning of session?.chatWarnings || []) {
+        // 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);
+        const boundary = following.find(e => ["session.error", "user.message", "assistant.message"].includes(e.eventType));
+        // On initial load the catalog can arrive before any history at all.
+        // Find its matching older event by the captured failure time, without
+        // reusing an event from a previous error episode with identical text.
+        // Chat can outlive the raw-event window when tool activity is noisy.
+        // Reconcile from the retained warning rows, not only from raw events.
+        const recorded = chat.findLast(m => m.kind === "session-warning"
+            && timeMs(m.createdAt) > (warning.since || 0)
+            && timeMs(m.createdAt) <= warning.createdAt
+            && sameError(warning.text, m.text));
+        const eventSeq = warning.eventSeq ?? recorded?.warningSeq
+            ?? (boundary?.eventType === "session.error" && sameError(warning.text, errorText(boundary)) ? Number(boundary.seq) : null);
+        const index = messages.findIndex(m => m.kind === "session-warning" && m.warningSeq === eventSeq);
+        const notice = {
+            id: warning.id, kind: "session-warning", role: "system", text: warning.text,
+            createdAt: warning.createdAt,
+            cardTitle: warning.failed ? "Error" : "Warning",
+            cardTitleColor: warning.failed ? "red" : "yellow",
+            cardBorderColor: warning.failed ? "red" : "yellow",
+        };
+        if (index >= 0) {
+            // Preserve the mounted card while the durable row takes over.
+            messages[index] = { ...messages[index], ...notice, createdAt: messages[index].createdAt };
+        } else {
+            const nextIndex = messages.findIndex(m => timeMs(m.createdAt) > warning.createdAt);
+            messages.splice(nextIndex < 0 ? messages.length : nextIndex, 0, notice);
+        }
+    }
+    return messages;
+}