pilotswarm 0.5.57 → 0.5.59

package/ui/core/src/selectors.js

@@ -35,7 +35,6 @@ import {
     normalizeArtifactEntries,
     normalizeSessionPause,
 } from "./state.js";
-import { isRecoverableTransportErrorText } from "./session-errors.js";
 
 export const ACTIVE_HIGHLIGHT_BACKGROUND = "activeHighlightBackground";
 export const ACTIVE_HIGHLIGHT_FOREGROUND = "activeHighlightForeground";
@@ -297,9 +296,15 @@ function isTerminalOrchestrationStatus(status) {
 
 function getSessionErrorVisualKind(session) {
     const status = getSessionVisualStatus(session);
-    if (session?.orchestrationStatus === "Failed" || status === "failed") return "failed";
+    if (session?.orchestrationStatus === "Failed") return "failed";
+    if (isTerminalOrchestrationStatus(session?.orchestrationStatus)) return null;
+    if (status === "failed") return "failed";
     if (status === "error") return "warning";
-    if (status === "running" && isRecoverableTransportErrorText(session?.error) && !isTerminalOrchestrationStatus(session?.orchestrationStatus)) return "warning";
+    // The CMS row may already say idle/waiting while the live detail still
+    // carries the retry. Keep its card visible until detail sync clears it.
+    if (!["completed", "cancelled", "terminated", "input_required"].includes(session?.status)
+        && String(session?.error || "").trim()
+        && !isTerminalOrchestrationStatus(session?.orchestrationStatus)) return "warning";
     return null;
 }
 
@@ -457,17 +462,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 +560,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 +1411,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),
@@ -1601,7 +1655,7 @@ function buildSessionErrorMessage(session, events = []) {
         : `${errorText}\n\nThe orchestration is still running, so this may be transient.`;
 
     return {
-        id: `session-error:${session.sessionId}:${errorKind}:${errorText}`,
+        id: `session-error:${session.sessionId}`,
         role: "system",
         text: body,
         time: "",
@@ -1904,7 +1958,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 +2485,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 +2520,36 @@ 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 || message?.assistantPreview) && options.tableMode === "sentinel") {
+        // Carry raw markdown: collapsed previews never parse their hidden body.
+        return [{
+            kind: "assistantPreview",
+            width: maxWidth,
+            text: "Message preview",
+            previewKey: `assistant:${message?.liveKey || message?.messageId || message?.id || "active-turn"}`,
+            body: decorateArtifactLinksForChat(message?.text || ""),
+            reasoningText: String(message?.reasoningText || message?.liveReasoningText || ""),
+            isLive: message?.liveTurn === true,
+            final: message?.responseFinal === true,
+            truncated: message?.truncated === true,
+            liveStartedAt: Number(message?.liveStartedAt || message?.createdAt) || 0,
+            time: message?.time || "",
+            headerRuns: buildChatMessagePrefix(message, options),
+        }];
+    }
+
+    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
@@ -2559,6 +2662,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
             && (!message?.cardTitle || String(message.cardTitle).toLowerCase() === "system");
         return buildMessageCardLines({
             title: message?.cardTitle || (message?.role === "system" ? "System" : "PilotSwarm"),
+            cardKey: message?.id,
             timestamp: formatTimestamp(message?.createdAt || message?.time),
             body: decorateArtifactLinksForChat(message?.text || ""),
             width: Math.max(20, maxWidth),
@@ -2589,6 +2693,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 +2715,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 +2848,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 +3013,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 } : {}),
@@ -4001,6 +4130,8 @@ export function selectAdminConsole(state) {
 
     const systemGhcpKey = admin.systemGhcpKey || { supported: false, loading: false, configured: false, changedBy: null, changedAt: null, error: null };
     const isAdmin = Boolean(profile?.isAdmin);
+    const adminScope = state.auth?.adminScope ?? profile?.adminScope ?? "unrestricted";
+    const resourceAdmin = isAdmin && adminScope === "unrestricted";
     const modelProviderState = admin.modelProviders || {};
     const providerRows = Array.isArray(modelProviderState.providers) ? modelProviderState.providers : [];
     const modelRows = Array.isArray(modelProviderState.models) ? modelProviderState.models : [];
@@ -4153,7 +4284,7 @@ export function selectAdminConsole(state) {
     const pkgState = admin.packages || {};
     const pkgList = Array.isArray(pkgState.list) ? pkgState.list : [];
     const ownsPackage = (pkg) => Boolean(
-        isAdmin
+        resourceAdmin
         || (pkg?.owner && principal
             && pkg.owner.provider === principal.provider
             && pkg.owner.subject === principal.subject),
@@ -4165,6 +4296,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 +4345,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),
@@ -4314,8 +4447,11 @@ export function selectAdminConsole(state) {
             ? workerRows.filter((worker) => installedRowFor(worker)?.semver === activeVersion.semver
                 && installedRowFor(worker)?.status === "ok").length
             : 0;
-        const canManage = detail ? ownsPackage(detail) : (summary ? ownsPackage(summary) : false);
-        const canEdit = detail ? canEditPackage(detail) : (summary ? canEditPackage(summary) : false);
+        // The periodically refreshed list carries current editor grants; an
+        // older open detail must not preserve a revoked edit affordance.
+        const permissionSource = summary ?? detail;
+        const canManage = permissionSource ? ownsPackage(permissionSource) : false;
+        const canEdit = permissionSource ? canEditPackage(permissionSource) : false;
         packageDetail = {
             name: pkgState.selectedName,
             loading: Boolean(pkgState.detailLoading),
@@ -4542,6 +4678,8 @@ export function selectAdminConsole(state) {
             loadError: admin.loadError || null,
             principal,
             isAdmin,
+            adminScope,
+            adminPolicyLabel: adminScope === "cluster" ? "Cluster-scoped admin · system-session access retained" : "Unrestricted admin access",
             section,
             settingsTree,
             packages: packagesView,
@@ -4581,6 +4719,8 @@ export function selectAdminConsole(state) {
             loadError: admin.loadError || null,
             principal,
             isAdmin,
+            adminScope,
+            adminPolicyLabel: adminScope === "cluster" ? "Cluster-scoped admin · system-session access retained" : "Unrestricted admin access",
             section,
             settingsTree,
             packages: packagesView,
@@ -4626,6 +4766,8 @@ export function selectAdminConsole(state) {
             loadError: admin.loadError || null,
             principal,
             isAdmin,
+            adminScope,
+            adminPolicyLabel: adminScope === "cluster" ? "Cluster-scoped admin · system-session access retained" : "Unrestricted admin access",
             section,
             settingsTree,
             packages: packagesView,
@@ -4674,6 +4816,8 @@ export function selectAdminConsole(state) {
         loadError: admin.loadError || null,
         principal,
         isAdmin,
+        adminScope,
+        adminPolicyLabel: adminScope === "cluster" ? "Cluster-scoped admin · system-session access retained" : "Unrestricted admin access",
         section,
         settingsTree,
         packages: packagesView,

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

@@ -1,14 +1,19 @@
-export function isRecoverableTransportErrorText(text) {
-    const value = String(text || "");
-    return /\bConnection is closed\b/i.test(value)
-        || /\bLive Copilot connection lost\b/i.test(value);
-}
-
-export function shouldKeepRecoverableTransportWarning(previousSession, nextSession) {
-    if (!isRecoverableTransportErrorText(previousSession?.error)) return false;
+export function shouldKeepSessionWarning(previousSession, nextSession) {
+    if (!String(previousSession?.error || "").trim()) return false;
     if (nextSession?.error !== undefined) return false;
-    const nextStatus = String(nextSession?.status || "");
-    if (nextStatus !== "running") return false;
     if (["Completed", "Failed", "Terminated"].includes(String(nextSession?.orchestrationStatus || ""))) return false;
-    return true;
+    if (["completed", "failed", "cancelled", "terminated"].includes(previousSession?.status)) return false;
+    const nextStatus = String(nextSession?.status || "");
+    if (["running", "error"].includes(nextStatus)) return true;
+    if (!["idle", "waiting", "unknown", "pending", ""].includes(nextStatus)) return false;
+    // Catalog/detail snapshots can lag a retry. A genuinely newer idle detail
+    // (or a new durable wait) clears it; a same-age snapshot is not evidence
+    // of recovery. Do not infer retry semantics from provider error wording.
+    const previousVersion = Number(previousSession?.statusVersion);
+    const nextVersion = Number(nextSession?.statusVersion);
+    if (previousVersion > 0 && nextVersion > 0) return nextVersion <= previousVersion;
+    const time = (value) => typeof value === "number" ? value : Date.parse(value || "");
+    const previousAt = time(previousSession?.updatedAt);
+    const nextAt = time(nextSession?.updatedAt);
+    return previousAt > 0 && nextAt > 0 && nextAt <= previousAt;
 }

package/ui/react/src/components.js

@@ -2180,6 +2180,7 @@ function buildAdminModelProviderLines(view) {
 
 function buildAdminConsoleLines(view) {
     const lines = [];
+    if (view.isAdmin && view.adminPolicyLabel) lines.push([{ text: view.adminPolicyLabel, color: "gray" }]);
     lines.push([
         { text: "Signed in as ", color: "gray" },
         { text: formatAdminPrincipalLabelTui(view.principal), color: "white", bold: true },