pilotswarm 0.5.14 → 0.5.16

package/ui/core/src/controller.js

@@ -92,7 +92,9 @@ function normalizeSessionListRow(session) {
     if (session.isGroup) return session;
     return {
         ...session,
-        groupId: session.groupId ?? null,
+        // The wire DTO carries the viewer-private placement as viewerGroupId;
+        // the local groupId field is what the tree/selectors key off.
+        groupId: session.viewerGroupId ?? null,
         parentSessionId: session.parentSessionId ?? null,
     };
 }
@@ -101,6 +103,30 @@ function sessionGroupIdFromRowId(sessionId) {
     return String(sessionId || "").startsWith("group:") ? String(sessionId).slice("group:".length) : null;
 }
 
+// Per-row placement skip reasons ('system', 'not_found') folded into a short
+// status-bar suffix, e.g. "2 system, 1 not found".
+function summarizePlacementSkips(rows) {
+    const counts = new Map();
+    for (const row of rows || []) {
+        const label = row?.reason === "system" ? "system" : "not found";
+        counts.set(label, (counts.get(label) || 0) + 1);
+    }
+    return [...counts.entries()].map(([label, count]) => `${count} ${label}`).join(", ");
+}
+
+// Deep-link load failures split into two renderable kinds: a definitive
+// not-found/no-access answer from the server (the API deliberately returns
+// identical shapes for unknown vs unshared sessions), and everything else —
+// network/server faults — which stays retryable.
+function classifyNavigationLoadError(error) {
+    const status = Number(error?.status);
+    const code = String(error?.code || "").toUpperCase();
+    if (status === 404 || status === 403 || code === "NOT_FOUND" || code === "FORBIDDEN") {
+        return "not_found";
+    }
+    return "network";
+}
+
 async function loadSessionCatalogPageWindow(transport) {
     if (typeof transport.listSessionsPage !== "function") {
         return transport.listSessions();
@@ -190,6 +216,22 @@ const CONTEXT_TIER_LABELS = {
     long_context: "Long context (larger window, higher cost)",
 };
 
+function formatContextWindowSize(value) {
+    const tokens = Number(value);
+    if (!Number.isSafeInteger(tokens) || tokens <= 0) return null;
+    if (tokens % 1_000_000 === 0) return `${tokens / 1_000_000}M`;
+    if (tokens % 1_000 === 0) return `${tokens / 1_000}K`;
+    return tokens.toLocaleString("en-US");
+}
+
+function formatContextTierLabel(tier, tokenLimit) {
+    const size = formatContextWindowSize(tokenLimit);
+    if (!size) return CONTEXT_TIER_LABELS[tier] || tier;
+    return tier === "long_context"
+        ? `Long context (${size} tokens, higher cost)`
+        : `Default (${size} tokens)`;
+}
+
 function extractSessionModelFromEvents(events = []) {
     // Only explicit model-change events may update the session's model.
     // Deriving it from any event that happens to carry a `model` field lets
@@ -506,6 +548,12 @@ function buildSessionOwnerFilterItems(state) {
             ownerKey: principalKey,
             description: "Show sessions owned by the authenticated user currently signed in.",
         });
+        items.push({
+            id: "shared",
+            kind: "shared",
+            label: "Shared with me",
+            description: "Show sessions other users have shared with you.",
+        });
     }
 
     const ownersByKey = new Map();
@@ -542,6 +590,7 @@ export function defaultOwnerFilterForPrincipal(principal) {
             includeSystem: true,
             includeUnowned: false,
             includeMe: true,
+            includeShared: true,
             ownerKeys: [],
         }
         : {
@@ -549,6 +598,7 @@ export function defaultOwnerFilterForPrincipal(principal) {
             includeSystem: false,
             includeUnowned: false,
             includeMe: false,
+            includeShared: false,
             ownerKeys: [],
         };
 }
@@ -558,6 +608,7 @@ function ownerFilterHasSelections(filter) {
         filter?.includeSystem
         || filter?.includeUnowned
         || filter?.includeMe
+        || filter?.includeShared
         || (Array.isArray(filter?.ownerKeys) && filter.ownerKeys.length > 0),
     );
 }
@@ -571,6 +622,7 @@ function toggleOwnerFilterItem(currentFilter, item, principal) {
             includeSystem: false,
             includeUnowned: false,
             includeMe: false,
+            includeShared: false,
             ownerKeys: [],
         };
     }
@@ -583,6 +635,7 @@ function toggleOwnerFilterItem(currentFilter, item, principal) {
     if (item.kind === "system") next.includeSystem = !next.includeSystem;
     if (item.kind === "unowned") next.includeUnowned = !next.includeUnowned;
     if (item.kind === "me") next.includeMe = !next.includeMe;
+    if (item.kind === "shared") next.includeShared = !next.includeShared;
     if (item.kind === "owner" && item.ownerKey) {
         const existingIndex = next.ownerKeys.indexOf(item.ownerKey);
         if (existingIndex >= 0) {
@@ -594,7 +647,7 @@ function toggleOwnerFilterItem(currentFilter, item, principal) {
 
     return ownerFilterHasSelections(next)
         ? next
-        : { all: true, includeSystem: false, includeUnowned: false, includeMe: false, ownerKeys: [] };
+        : { all: true, includeSystem: false, includeUnowned: false, includeMe: false, includeShared: false, ownerKeys: [] };
 }
 
 function getRenameSessionPrefix(session) {
@@ -1066,6 +1119,7 @@ export class PilotSwarmUiController {
             text: String(prompt || ""),
             createdAt: Date.now(),
             phase: normalizedPhase,
+            attempted: false,
             clientMessageIds: [id],
         };
     }
@@ -1085,9 +1139,9 @@ export class PilotSwarmUiController {
     }
 
     getEditableOutboxItems(sessionId) {
-        // Only pending items are editable/cancelable on the client; queued items
-        // are durable and need a durable cancel API to remove.
-        return this.getPendingOutboxItems(sessionId);
+        // Attempted envelopes are immutable because the server may already
+        // have accepted their IDs even when the client saw a transport error.
+        return this.getPendingOutboxItems(sessionId).filter((item) => item?.attempted !== true);
     }
 
     getPromptEditSessionMatch(sessionId = this.getState().sessions.activeSessionId) {
@@ -1375,7 +1429,11 @@ export class PilotSwarmUiController {
             return false;
         }
 
-        const pendingItems = this.getPendingOutboxItems(sessionId);
+        const allPendingItems = this.getPendingOutboxItems(sessionId);
+        const attemptedItem = allPendingItems.find((item) => item?.attempted === true);
+        const pendingItems = attemptedItem
+            ? [attemptedItem]
+            : allPendingItems.filter((item) => item?.attempted !== true);
         if (pendingItems.length === 0) return false;
 
         // Merge all current pending items into a single durable envelope.
@@ -1393,6 +1451,7 @@ export class PilotSwarmUiController {
             text: mergedText,
             createdAt: pendingItems[0].createdAt || Date.now(),
             phase: "pending",
+            attempted: true,
             clientMessageIds: mergedClientMessageIds,
         };
         const pendingIdSet = new Set(pendingItems.map((item) => item.id));
@@ -1443,10 +1502,11 @@ export class PilotSwarmUiController {
                     }
                 }, 6000);
             } else {
-                // Transient failure: revert the merged envelope back to the
-                // original pending items so the user can edit/retry them.
-                const reverted = items.flatMap((item) => (
-                    item.id === mergedItem.id ? pendingItems : [item]
+                // Transient failure: preserve the exact attempted envelope.
+                // Re-merging it with fresh messages could make server-side
+                // duplicate suppression drop the fresh content too.
+                const reverted = items.map((item) => (
+                    item.id === mergedItem.id ? { ...mergedItem, phase: "pending", attempted: true } : item
                 ));
                 this.setSessionOutboxItems(sessionId, reverted);
             }
@@ -1696,7 +1756,7 @@ export class PilotSwarmUiController {
         }).catch(() => {});
     }
 
-    async start() {
+    async start({ initialSessionId = null } = {}) {
         await this.transport.start();
         const authContext = typeof this.transport.getAuthContext === "function"
             ? this.transport.getAuthContext()
@@ -1727,6 +1787,13 @@ export class PilotSwarmUiController {
             workersOnline: typeof this.transport.getWorkerCount === "function" ? this.transport.getWorkerCount() : null,
             statusText: "Connected",
         });
+        // Latch the deep-link intent AFTER the default owner-filter dispatch
+        // (a filter change releases the latch) and BEFORE the first refresh,
+        // so the first catalog load resolves selection onto the link target.
+        const deepLinkSessionId = String(initialSessionId || "").trim();
+        if (deepLinkSessionId) {
+            this.dispatch({ type: "sessions/navigationIntent", sessionId: deepLinkSessionId });
+        }
         await this.refreshSessions();
         this.catalogTimer = setInterval(() => {
             this.refreshSessions().catch((error) => {
@@ -1782,6 +1849,36 @@ export class PilotSwarmUiController {
                 sessions = [...groupRows, ...sessions];
             }
         }
+        // A pending deep-link target may be readable but absent from the
+        // paged catalog window — fetch it explicitly. A definitive failure
+        // (unknown or unshared: identical 404 shapes) fails the intent; the
+        // reducer then refuses fallback selection so the renderer can show
+        // the nav error instead of silently landing somewhere else.
+        const pendingIntent = preRefreshState.sessions.navigationIntent;
+        if (
+            pendingIntent?.status === "pending"
+            && !sessions.some((session) => session?.sessionId === pendingIntent.sessionId)
+            && typeof this.transport.getSession === "function"
+        ) {
+            try {
+                const intentSession = await this.transport.getSession(pendingIntent.sessionId);
+                if (intentSession?.sessionId) {
+                    sessions = [...sessions, normalizeSessionListRow(intentSession)];
+                } else {
+                    this.dispatch({
+                        type: "sessions/navigationIntentFailed",
+                        sessionId: pendingIntent.sessionId,
+                        errorKind: "not_found",
+                    });
+                }
+            } catch (error) {
+                this.dispatch({
+                    type: "sessions/navigationIntentFailed",
+                    sessionId: pendingIntent.sessionId,
+                    errorKind: classifyNavigationLoadError(error),
+                });
+            }
+        }
         const active = previousActive;
         if (
             active
@@ -1807,7 +1904,20 @@ export class PilotSwarmUiController {
         if (selected) {
             if (selected !== previousActive) {
                 if (!this.getState().sessions.byId[selected]?.isGroup) {
-                    await this.loadSession(selected);
+                    const selectedIntent = this.getState().sessions.navigationIntent;
+                    if (selectedIntent && selectedIntent.sessionId === selected && selectedIntent.status !== "failed") {
+                        try {
+                            await this.loadSession(selected);
+                        } catch (error) {
+                            this.dispatch({
+                                type: "sessions/navigationIntentFailed",
+                                sessionId: selected,
+                                errorKind: classifyNavigationLoadError(error),
+                            });
+                        }
+                    } else {
+                        await this.loadSession(selected);
+                    }
                 }
                 return;
             }
@@ -3019,6 +3129,32 @@ export class PilotSwarmUiController {
         });
     }
 
+    /**
+     * Latch a navigation intent (deep link) onto a session id. The intent
+     * outranks in-memory selection and the profile's activeSessionId until
+     * the user navigates manually or changes a filter. Also the retry path
+     * for a failed intent: re-latching resets it to pending.
+     */
+    setNavigationIntent(sessionId) {
+        const id = String(sessionId || "").trim();
+        if (!id) return;
+        this.dispatch({ type: "sessions/navigationIntent", sessionId: id });
+        const state = this.getState();
+        if (state.sessions.byId[id]) {
+            this.loadSession(id).catch((error) => {
+                this.dispatch({
+                    type: "sessions/navigationIntentFailed",
+                    sessionId: id,
+                    errorKind: classifyNavigationLoadError(error),
+                });
+            });
+            return;
+        }
+        if (Object.keys(state.sessions.byId).length > 0) {
+            this.scheduleSessionsRefresh(0);
+        }
+    }
+
     async loadSession(sessionId) {
         if (!sessionId) return;
         const active = this.getState().sessions.activeSessionId;
@@ -3194,7 +3330,9 @@ export class PilotSwarmUiController {
 
     async createSession(options = {}) {
         try {
-            const created = await this.transport.createSession(this.applyActiveGroupDefault(options));
+            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.setFocus(FOCUS_REGIONS.PROMPT);
@@ -3211,7 +3349,9 @@ export class PilotSwarmUiController {
             throw new Error("Named-agent session creation is not supported by this transport");
         }
         try {
-            const created = await this.transport.createSessionForAgent(agentName, this.applyActiveGroupDefault(options));
+            const requestOptions = this.applyActiveGroupDefault(options);
+            const created = await this.transport.createSessionForAgent(agentName, requestOptions);
+            await this.placeCreatedSessionInGroup(created, requestOptions.groupId ?? null);
             await this.refreshSessions();
             await this.loadSession(created.sessionId);
             this.setFocus(FOCUS_REGIONS.PROMPT);
@@ -3226,6 +3366,20 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * Post-create placement follow-up. createSession's groupId only places
+     * when an owner principal reaches the catalog (web mode places
+     * server-side; the local TUI passes no owner), so when a group was
+     * requested, place explicitly — idempotent where the server already did.
+     * Skipped when the create response already reports the placement.
+     */
+    async placeCreatedSessionInGroup(created, groupId) {
+        if (!groupId || !created?.sessionId) return;
+        if (typeof this.transport.placeSessionsInGroup !== "function") return;
+        if ((created.viewerGroupId ?? null) === groupId) return;
+        await this.transport.placeSessionsInGroup([created.sessionId], groupId).catch(() => {});
+    }
+
     getMovableGroupSessionSelection() {
         const state = this.getState();
         const selectedIds = Array.isArray(state.sessions.selectedIds) && state.sessions.selectedIds.length > 0
@@ -3249,16 +3403,12 @@ export class PilotSwarmUiController {
             return null;
         }
 
+        // The server returns only the viewer's own groups, and placement is
+        // viewer-private — any readable non-system selection is movable, so
+        // mixed-owner selections are allowed and every group is offered.
         const groups = await this.transport.listSessionGroups().catch(() => []);
         const sessionIds = eligible.map((session) => session.sessionId);
         const firstGroupId = eligible.length === 1 ? eligible[0].groupId || null : null;
-        const selectedOwnerKeys = new Set(eligible.map((session) => ownerKeyForPrincipal(session.owner) || ""));
-        const singleOwnerKey = selectedOwnerKeys.size === 1 ? [...selectedOwnerKeys][0] : null;
-        const singleOwner = selectedOwnerKeys.size === 1 ? eligible[0]?.owner ?? null : null;
-        const compatibleGroups = selectedOwnerKeys.size === 1
-            ? (Array.isArray(groups) ? groups : []).filter((group) => (ownerKeyForPrincipal(group.owner) || "") === singleOwnerKey)
-            : [];
-        const canCreateOrAssignGroup = selectedOwnerKeys.size === 1;
         const items = [
             {
                 id: "__no_group__",
@@ -3268,22 +3418,20 @@ export class PilotSwarmUiController {
                 groupId: null,
                 memberCount: 0,
             },
-            ...(canCreateOrAssignGroup ? [{
+            {
                 id: "__new_group__",
                 kind: "newGroup",
                 label: "[New Group]",
-                description: "Create a new group for this owner, then move the selected session(s) into it.",
+                description: "Create a new group, then move the selected session(s) into it.",
                 groupId: null,
                 memberCount: 0,
-                owner: singleOwner,
-            }] : []),
-            ...compatibleGroups.map((group) => ({
+            },
+            ...(Array.isArray(groups) ? groups : []).map((group) => ({
                 id: group.groupId,
                 kind: "group",
                 label: group.title || group.groupId,
                 description: group.description || "Move selected session(s) into this group.",
                 groupId: group.groupId,
-                owner: group.owner ?? null,
                 memberCount: group.memberCount ?? 0,
             })),
         ];
@@ -3305,9 +3453,7 @@ export class PilotSwarmUiController {
         });
         this.dispatch({
             type: "ui/status",
-            text: canCreateOrAssignGroup
-                ? "Choose a group, [New Group], or [No Group]"
-                : "Selected sessions have different owners; only [No Group] is available",
+            text: "Choose a group, [New Group], or [No Group]",
         });
         return items;
     }
@@ -3322,7 +3468,10 @@ export class PilotSwarmUiController {
             this.dispatch({ type: "ui/status", text: "No sessions selected to move" });
             return null;
         }
-        if (typeof this.transport.moveSessionsToGroup === "function") {
+        let placementResults = null;
+        if (typeof this.transport.placeSessionsInGroup === "function") {
+            placementResults = await this.transport.placeSessionsInGroup(ids, groupId ?? null);
+        } else if (typeof this.transport.moveSessionsToGroup === "function") {
             await this.transport.moveSessionsToGroup(groupId ?? null, ids);
         } else if (groupId && typeof this.transport.assignSessionsToGroup === "function") {
             await this.transport.assignSessionsToGroup(groupId, ids);
@@ -3331,17 +3480,28 @@ export class PilotSwarmUiController {
             return null;
         }
 
+        const resultRows = Array.isArray(placementResults) ? placementResults.filter(Boolean) : null;
+        const skippedRows = resultRows ? resultRows.filter((row) => row.placed !== true) : [];
+        const placedCount = resultRows
+            ? resultRows.filter((row) => row.placed === true).length
+            : ids.length;
+
         this.dispatch({ type: "sessions/selectClear" });
         await this.refreshSessions();
-        if (groupId) {
+        if (groupId && placedCount > 0) {
             await this.loadSession(`group:${groupId}`).catch(() => {});
         }
         const target = groupId ? `group ${statusTitle || groupId}` : "No Group";
+        const skippedSummary = skippedRows.length > 0
+            ? ` · skipped ${skippedRows.length} (${summarizePlacementSkips(skippedRows)})`
+            : "";
         this.dispatch({
             type: "ui/status",
-            text: `Moved ${ids.length} session${ids.length === 1 ? "" : "s"} to ${target}`,
+            text: placedCount > 0
+                ? `Moved ${placedCount} session${placedCount === 1 ? "" : "s"} to ${target}${skippedSummary}`
+                : `No sessions moved to ${target}${skippedSummary}`,
         });
-        return true;
+        return placedCount > 0;
     }
 
     async confirmSessionGroupPickerModal() {
@@ -3360,7 +3520,6 @@ export class PilotSwarmUiController {
                     title: "New Group",
                     previousFocus: modal.previousFocus,
                     sessionIds: modal.sessionIds || [],
-                    owner: item.owner ?? null,
                     value: baseTitle,
                     cursorIndex: baseTitle.length,
                     maxLength: 80,
@@ -3440,11 +3599,14 @@ export class PilotSwarmUiController {
         if (previousFocus) this.setFocus(previousFocus);
 
         try {
+            // No owner key: the transport/server stamps the caller's
+            // principal. The UI never infers group ownership from the
+            // selected sessions (owner: null is reserved for the portal
+            // runtime's anonymous path).
             const group = await this.transport.createSessionGroup({
                 title,
                 description: `${(modal.sessionIds || []).length} grouped session${(modal.sessionIds || []).length === 1 ? "" : "s"}`,
                 sessionIds: modal.sessionIds || [],
-                owner: modal.owner ?? null,
             });
             await this.moveSessionsToGroup(group.groupId, modal.sessionIds || [], { statusTitle: group.title || title });
         } catch (error) {
@@ -3624,7 +3786,8 @@ export class PilotSwarmUiController {
         const items = supported.map((tier) => ({
             id: tier,
             tier,
-            label: CONTEXT_TIER_LABELS[tier] || tier,
+            tokenLimit: modelItem?.contextWindowSizes?.[tier] || null,
+            label: formatContextTierLabel(tier, modelItem?.contextWindowSizes?.[tier]),
             isDefault: selectedTier === tier,
         }));
         const selectedIndex = Math.max(0, items.findIndex((item) => item.id === selectedTier));
@@ -3661,25 +3824,38 @@ export class PilotSwarmUiController {
         const groupedModels = typeof this.transport.getModelsByProvider === "function"
             ? this.transport.getModelsByProvider()
             : groupModelsByProvider(models);
+        // Whether the current user has a per-user GitHub Copilot key:
+        // true/false when known, null when the transport can't tell (then
+        // no model gets disabled — never lock models out on a guess).
+        const ghcpUserKeySet = await this._resolveGhcpUserKeySet();
         const items = [];
         const groups = groupedModels
             .map((group) => ({
                 providerId: group.providerId,
                 providerType: group.type || group.providerType,
                 models: (group.models || []).map((model) => {
+                    const providerType = model.providerType || group.type || group.providerType;
+                    // Copilot models with no worker-level token are unusable
+                    // for users who haven't stored their own GitHub key.
+                    const ghcpKeyMissing = providerType === "github"
+                        && model.credentialAvailable === false
+                        && ghcpUserKeySet === false;
                     const item = {
                         id: model.qualifiedName,
                         qualifiedName: model.qualifiedName,
                         modelName: model.modelName || model.qualifiedName,
                         providerId: model.providerId || group.providerId,
-                        providerType: model.providerType || group.type || group.providerType,
+                        providerType,
                         description: model.description || "",
                         cost: model.cost || null,
                         supportedReasoningEfforts: normalizeReasoningEfforts(model.supportedReasoningEfforts),
                         defaultReasoningEffort: model.defaultReasoningEffort || null,
                         supportedContextTiers: normalizeContextTiers(model.supportedContextTiers),
                         defaultContextTier: model.defaultContextTier || null,
+                        contextWindowSizes: model.contextWindowSizes || null,
                         isDefault: defaultModel === model.qualifiedName,
+                        ghcpKeyMissing,
+                        disabled: ghcpKeyMissing,
                     };
                     items.push(item);
                     return item;
@@ -3688,7 +3864,12 @@ export class PilotSwarmUiController {
             .filter((group) => group.models.length > 0);
 
         const preferredModel = sessionOptions?.model || defaultModel;
-        const selectedIndex = Math.max(0, items.findIndex((model) => model.qualifiedName === preferredModel));
+        // Never preselect a key-blocked Copilot model: when the preferred
+        // model (often the catalog default) is unusable, land on the first
+        // usable model instead.
+        let selectedIndex = items.findIndex((model) => model.qualifiedName === preferredModel && !model.disabled);
+        if (selectedIndex < 0) selectedIndex = items.findIndex((model) => !model.disabled);
+        if (selectedIndex < 0) selectedIndex = 0;
         this.dispatch({
             type: "ui/modal",
             modal: {
@@ -3704,15 +3885,42 @@ export class PilotSwarmUiController {
         this.dispatch({ type: "ui/status", text: "Select a model and press Enter" });
     }
 
-    async openSwitchModelPicker() {
+    async _resolveGhcpUserKeySet() {
+        // Freshest signal first: the profile the Admin console loaded in this
+        // session (updates immediately after the user saves a key there).
+        const adminProfile = this.getState().admin?.profile;
+        if (typeof adminProfile?.githubCopilotKeySet === "boolean") {
+            return adminProfile.githubCopilotKeySet;
+        }
+        if (typeof this.transport.getCurrentUserProfile !== "function") return null;
+        try {
+            const profile = await this.transport.getCurrentUserProfile();
+            if (profile && typeof profile.githubCopilotKeySet === "boolean") {
+                return profile.githubCopilotKeySet;
+            }
+            // Profile fetch succeeded but no stored flag — a user with no
+            // profile row has no key.
+            return false;
+        } catch {
+            return null;
+        }
+    }
+
+    async openSwitchModelPicker(onApplied = null) {
+        // Callers (e.g. the portal Manage modal) can be notified when a switch
+        // is actually applied — distinct from cancelling the picker — so they
+        // can close/reopen their own chrome accordingly.
+        this._onSwitchModelApplied = typeof onApplied === "function" ? onApplied : null;
         const state = this.getState();
         const sessionId = state.sessions.activeSessionId;
         const session = sessionId ? state.sessions.byId[sessionId] || null : null;
         if (!session || session.isGroup) {
+            this._onSwitchModelApplied = null;
             this.dispatch({ type: "ui/status", text: "Select a session before switching model" });
             return;
         }
         if (typeof this.transport.setSessionModel !== "function") {
+            this._onSwitchModelApplied = null;
             this.dispatch({ type: "ui/status", text: "Model switching is not supported by this transport" });
             return;
         }
@@ -3745,6 +3953,11 @@ export class PilotSwarmUiController {
         const tierSuffix = options.contextTier ? ` · ${CONTEXT_TIER_LABELS[options.contextTier] || options.contextTier}` : "";
         this.dispatch({ type: "ui/status", text: `Next turn will use ${modelLabel}${tierSuffix}` });
         await this.refreshSessions();
+        // Notify a Manage-modal-style caller that the switch was applied (vs
+        // cancelled), so it can close rather than reopen.
+        const onApplied = this._onSwitchModelApplied;
+        this._onSwitchModelApplied = null;
+        if (typeof onApplied === "function") onApplied();
     }
 
     openHelpModal() {
@@ -4753,6 +4966,16 @@ export class PilotSwarmUiController {
         }
         if (modal.type === "modelPicker") {
             const item = modal.items?.[modal.selectedIndex || 0];
+            if (item?.disabled) {
+                // Keep the picker open — the selection is unusable, not wrong.
+                this.dispatch({
+                    type: "ui/status",
+                    text: item.ghcpKeyMissing
+                        ? "This model needs a GitHub Copilot key — add yours in the Admin console first"
+                        : "This model is not available",
+                });
+                return;
+            }
             const previousFocus = modal.previousFocus;
             this.dispatch({ type: "ui/modal", modal: null });
             if (previousFocus) {
@@ -5093,6 +5316,7 @@ export class PilotSwarmUiController {
             const items = this.getSessionOutbox(currentUi.promptEdit.sessionId);
             const nextItems = items.map((item) => (
                 item.id === currentUi.promptEdit.itemId && item.phase === "pending"
+                    && item.attempted !== true
                     ? { ...item, text: nextPrompt }
                     : item
             ));

package/ui/core/src/formatting.js

@@ -992,6 +992,7 @@ export function buildMessageCardLines({
     borderColor = "gray",
     bodyColor = null,
     fitToContent = false,
+    tableMode = null,
 } = {}) {
     const maxWidth = Math.max(fitToContent ? 12 : 20, Number(width) || (fitToContent ? 12 : 20));
     const maxContentWidth = Math.max(1, maxWidth - 4);
@@ -999,6 +1000,30 @@ export function buildMessageCardLines({
         { text: ` ${String(title || "SYSTEM").toUpperCase()} `, color: titleColor, bold: true },
         ...(timestamp ? [{ text: ` ${String(timestamp)} `, color: "gray" }] : []),
     ];
+
+    // Sentinel mode (browser portal): the card is laid out with CSS, so
+    // emit cardStart/cardEnd bounds around the UNWRAPPED markdown body
+    // instead of drawing box art. Hard-wrapping here would mangle
+    // preformatted content (box-drawn tables, ASCII art) that the browser
+    // renders as real HTML tables or scrollable lines.
+    if (tableMode === "sentinel") {
+        const sentinelBodyLines = parseMarkdownLines(String(body || ""), {
+            width: maxContentWidth,
+            tableMode,
+        });
+        const sentinelTinted = bodyColor
+            ? sentinelBodyLines.map((lineRuns) => (Array.isArray(lineRuns)
+                ? recolorRuns(lineRuns, bodyColor)
+                : lineRuns))
+            : sentinelBodyLines;
+        return [
+            { kind: "cardStart", runs: titleRuns, borderColor },
+            ...sentinelTinted,
+            { kind: "cardEnd" },
+            [{ text: "", color: null }],
+        ];
+    }
+
     const bodyLines = parseMarkdownLines(String(body || ""), { width: maxContentWidth });
     const normalizedBodyLines = bodyLines.length > 0
         ? bodyLines.flatMap((lineRuns) => wrapRunsToDisplayWidth(lineRuns, maxContentWidth))