pilotswarm 0.5.60 → 0.5.62

package/ui/core/src/moa.js

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

package/ui/core/src/reducer.js

@@ -319,63 +319,67 @@ 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 (key === "pendingQuestion" && isAnsweredPendingQuestion(previousSession, value)) {
+        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, nextSession)) {
             if (merged === previousSession) {
                 merged = { ...(previousSession || {}) };
             }
@@ -551,10 +555,18 @@ function normalizedPendingQuestionText(pendingQuestion) {
     return String(pendingQuestion?.question || "").trim();
 }
 
-function isAnsweredPendingQuestion(previousSession, pendingQuestion) {
-    const answeredQuestion = normalizedPendingQuestionText(previousSession?.answeredPendingQuestion);
+function isAnsweredPendingQuestion(previousSession, pendingQuestion, nextSession) {
     const incomingQuestion = normalizedPendingQuestionText(pendingQuestion);
-    return Boolean(answeredQuestion && incomingQuestion && answeredQuestion === incomingQuestion);
+    if (!incomingQuestion) return false;
+    const incomingTime = sessionUpdateTimestampMs({ updatedAt: pendingQuestion?.askedAt })
+        || sessionUpdateTimestampMs(nextSession);
+    return [previousSession?.answeredPendingQuestion, previousSession?.resolvedInputQuestion].some(answered => {
+        if (normalizedPendingQuestionText(answered) !== incomingQuestion) return false;
+        const answeredAt = sessionUpdateTimestampMs({ updatedAt: answered?.answeredAt });
+        // Preserve the answer fence across stale detail polls, but let a new
+        // instance of the same question through when it was asked later.
+        return !incomingTime || !answeredAt || incomingTime <= answeredAt;
+    });
 }
 
 function pickDefaultActiveSessionId(sessions = []) {

package/ui/core/src/selectors.js

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

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

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

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

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