pilotswarm 0.5.14 → 0.5.16

package/ui/core/src/reducer.js

@@ -324,6 +324,12 @@ function resolveVisibleActiveSessionId(state, fallbackSessions = []) {
     if (currentSessionId && visibleRows.some((row) => row.sessionId === currentSessionId)) {
         return currentSessionId;
     }
+    // A navigation intent (deep link) owns selection until it is cleared by
+    // manual navigation or a filter change. While one exists — pending target
+    // still loading, or failed — never fall back to a default selection.
+    if (state.sessions?.navigationIntent) {
+        return currentSessionId;
+    }
     if (currentSessionId && state.sessions?.byId?.[currentSessionId] && !hasSessionVisibilityFilter(state.sessions)) {
         return currentSessionId;
     }
@@ -361,20 +367,67 @@ function updateUiForSessionSelection(state, nextActiveSessionId) {
 }
 
 function applyVisibleSessionSelection(state, nextSessions) {
+    let sessions = nextSessions;
+
+    // Navigation intent (deep link) outranks in-memory selection and profile
+    // activeSessionId: once its target session is present, latch the selection
+    // onto it and mark the intent resolved.
+    const intent = sessions.navigationIntent || null;
+    const intentTargetId = intent && intent.status !== "failed" && sessions.byId?.[intent.sessionId]
+        ? intent.sessionId
+        : null;
+    if (intentTargetId) {
+        sessions = {
+            ...sessions,
+            activeSessionId: intentTargetId,
+            navigationIntent: intent.status === "resolved"
+                ? intent
+                : { sessionId: intent.sessionId, status: "resolved" },
+        };
+    }
+
+    // Expand ancestors BEFORE resolving visibility: a selected session inside
+    // a collapsed group/parent is absent from the flat tree, so resolving
+    // first would drop the selection instead of revealing it.
+    const selectionCandidateId = sessions.activeSessionId || null;
+    if (selectionCandidateId && sessions.byId?.[selectionCandidateId]) {
+        const expandedCollapsedIds = reconcileCollapsedIdsForActiveSession(sessions.collapsedIds, sessions.byId, selectionCandidateId);
+        if (!setsEqual(expandedCollapsedIds, sessions.collapsedIds)) {
+            sessions = {
+                ...sessions,
+                collapsedIds: expandedCollapsedIds,
+                flat: buildSessionTree(Object.values(sessions.byId || {}), expandedCollapsedIds, sessions.orderById, sessions.pinnedIds),
+            };
+        }
+    }
+
+    // A resolved intent target excluded by the current filters gets a
+    // transient exception so the linked session is shown anyway. Never
+    // persisted; cleared on manual navigation or filter change.
+    if (intentTargetId && sessions.filterExceptionId !== intentTargetId) {
+        const probeRows = selectSessionRows({ ...state, sessions });
+        if (!probeRows.some((row) => row.sessionId === intentTargetId)) {
+            sessions = {
+                ...sessions,
+                filterExceptionId: intentTargetId,
+            };
+        }
+    }
+
     const nextState = {
         ...state,
-        sessions: nextSessions,
+        sessions,
     };
-    const nextActiveSessionId = resolveVisibleActiveSessionId(nextState, Object.values(nextSessions.byId || {}));
-    const nextCollapsedIds = reconcileCollapsedIdsForActiveSession(nextSessions.collapsedIds, nextSessions.byId, nextActiveSessionId);
-    const collapsedChanged = !setsEqual(nextCollapsedIds, nextSessions.collapsedIds);
+    const nextActiveSessionId = resolveVisibleActiveSessionId(nextState, Object.values(sessions.byId || {}));
+    const nextCollapsedIds = reconcileCollapsedIdsForActiveSession(sessions.collapsedIds, sessions.byId, nextActiveSessionId);
+    const collapsedChanged = !setsEqual(nextCollapsedIds, sessions.collapsedIds);
     const reconciledSessions = collapsedChanged
         ? {
-            ...nextSessions,
+            ...sessions,
             collapsedIds: nextCollapsedIds,
-            flat: buildSessionTree(Object.values(nextSessions.byId || {}), nextCollapsedIds, nextSessions.orderById, nextSessions.pinnedIds),
+            flat: buildSessionTree(Object.values(sessions.byId || {}), nextCollapsedIds, sessions.orderById, sessions.pinnedIds),
         }
-        : nextSessions;
+        : sessions;
     return {
         sessions: {
             ...reconciledSessions,
@@ -515,7 +568,15 @@ export function appReducer(state, action) {
                 && (settings.chatViewMode === "summary" || settings.chatViewMode === "transcript");
             const hasPins = Object.prototype.hasOwnProperty.call(settings, "pinnedSessionIds");
             const hasCollapsed = Object.prototype.hasOwnProperty.call(settings, "collapsedSessionIds");
-            const hasActive = Object.prototype.hasOwnProperty.call(settings, "activeSessionId");
+            // A pending/resolved deep-link intent outranks the profile's
+            // persisted activeSessionId — a remote profile poll must not
+            // yank selection away from the linked session.
+            const navigationIntentLatched = Boolean(
+                state.sessions.navigationIntent
+                && state.sessions.navigationIntent.status !== "failed",
+            );
+            const hasActive = Object.prototype.hasOwnProperty.call(settings, "activeSessionId")
+                && !navigationIntentLatched;
             const hasLoadedSessions = Object.keys(state.sessions.byId || {}).length > 0;
             const nextLayout = hasLayout
                 ? {
@@ -693,6 +754,10 @@ export function appReducer(state, action) {
                 const nextSessions = {
                     ...state.sessions,
                     filterQuery: typeof action.query === "string" ? action.query : "",
+                    // A filter change is an explicit user action: it releases
+                    // the deep-link latch and its transient filter exception.
+                    navigationIntent: null,
+                    filterExceptionId: null,
                 };
                 const selection = applyVisibleSessionSelection(state, nextSessions);
                 return {
@@ -708,6 +773,8 @@ export function appReducer(state, action) {
                     ...state.sessions,
                     ownerFilterExplicit: true,
                     ownerFilter: normalizeSessionOwnerFilter(action.filter),
+                    navigationIntent: null,
+                    filterExceptionId: null,
                 };
                 const selection = applyVisibleSessionSelection(state, nextSessions);
                 return {
@@ -717,6 +784,39 @@ export function appReducer(state, action) {
                 };
             }
 
+        case "sessions/navigationIntent": {
+            const sessionId = String(action.sessionId || "").trim();
+            if (!sessionId) return state;
+            const nextSessions = {
+                ...state.sessions,
+                navigationIntent: { sessionId, status: "pending" },
+                filterExceptionId: null,
+            };
+            const selection = applyVisibleSessionSelection(state, nextSessions);
+            return {
+                ...state,
+                sessions: selection.sessions,
+                ui: selection.ui,
+            };
+        }
+
+        case "sessions/navigationIntentFailed": {
+            const intent = state.sessions.navigationIntent;
+            const sessionId = String(action.sessionId || "").trim();
+            if (!intent || (sessionId && intent.sessionId !== sessionId)) return state;
+            return {
+                ...state,
+                sessions: {
+                    ...state.sessions,
+                    navigationIntent: {
+                        sessionId: intent.sessionId,
+                        status: "failed",
+                        errorKind: action.errorKind === "not_found" ? "not_found" : "network",
+                    },
+                },
+            };
+        }
+
         case "ui/modalSelection": {
             const modal = state.ui.modal;
             if (!modal) return state;
@@ -991,11 +1091,20 @@ export function appReducer(state, action) {
             if (previousActiveId && previousActiveId !== action.sessionId) {
                 savedChatScroll[previousActiveId] = Number(state.ui.scroll?.chat) || 0;
             }
+            // Manual navigation to a different session releases the deep-link
+            // latch and its transient filter exception.
+            const releasesNavigationLatch = Boolean(
+                state.sessions.navigationIntent
+                && state.sessions.navigationIntent.sessionId !== action.sessionId,
+            );
             return {
                 ...state,
                 sessions: {
                     ...state.sessions,
                     activeSessionId: action.sessionId,
+                    ...(releasesNavigationLatch
+                        ? { navigationIntent: null, filterExceptionId: null }
+                        : {}),
                 },
                 ui: {
                     ...state.ui,

package/ui/core/src/selectors.js

@@ -350,6 +350,10 @@ function matchesOwnerFilterDirect(session, ownerFilter = {}, auth = {}, ownerOve
     if (ownerKey === SYSTEM_OWNER_KEY) return ownerFilter.includeSystem === true;
     const currentUserKey = ownerKeyForOwner(auth?.principal);
     if (ownerFilter.includeMe && currentUserKey && ownerKey === currentUserKey) return true;
+    // "Shared with me": any non-system session owned by someone else. The
+    // catalog is viewer-scoped server-side, so a foreign owner implies the
+    // session was shared with (or is otherwise readable by) the viewer.
+    if (ownerFilter.includeShared === true && ownerKey !== currentUserKey) return true;
     return Array.isArray(ownerFilter.ownerKeys) && ownerFilter.ownerKeys.includes(ownerKey);
 }
 
@@ -728,6 +732,31 @@ function matchesSearchQuery(value, query) {
     return String(value || "").toLowerCase().includes(normalizedQuery);
 }
 
+// The transient deep-link filter exception covers the linked session AND its
+// ancestor chain (real parents plus the synthetic group:<id> row) so the
+// linked row renders with its tree context instead of as an orphan.
+function collectFilterExceptionIds(sessions) {
+    const exceptionId = sessions?.filterExceptionId || null;
+    const byId = sessions?.byId || {};
+    if (!exceptionId || !byId[exceptionId]) return null;
+    const ids = new Set([exceptionId]);
+    let current = byId[exceptionId];
+    let hops = 0;
+    while (current && hops < 16) {
+        let parentId = null;
+        if (current.parentSessionId && byId[current.parentSessionId]) {
+            parentId = current.parentSessionId;
+        } else if (!current.isGroup && current.groupId && byId[`group:${current.groupId}`]) {
+            parentId = `group:${current.groupId}`;
+        }
+        if (!parentId || ids.has(parentId)) break;
+        ids.add(parentId);
+        current = byId[parentId];
+        hops += 1;
+    }
+    return ids;
+}
+
 export function selectSessionRows(state) {
     const totalDescendantCounts = getTotalDescendantCounts(state.sessions.byId);
     const visibleDescendantCounts = getVisibleDescendantCounts(state.sessions.flat, state.sessions.byId);
@@ -736,6 +765,7 @@ export function selectSessionRows(state) {
     const auth = state.auth || {};
     const pinnedSet = new Set(Array.isArray(state.sessions?.pinnedIds) ? state.sessions.pinnedIds : []);
     const selectedSet = new Set(Array.isArray(state.sessions?.selectedIds) ? state.sessions.selectedIds : []);
+    const filterExceptionIds = collectFilterExceptionIds(state.sessions);
 
     return state.sessions.flat.map((entry) => {
         const session = state.sessions.byId[entry.sessionId];
@@ -757,6 +787,7 @@ export function selectSessionRows(state) {
             canPin: canPinSessionRow(session),
         };
     }).filter((row) => {
+        if (filterExceptionIds?.has(row.sessionId)) return true;
         const session = state.sessions.byId[row.sessionId];
         if (!matchesOwnerFilter(session, ownerFilter, auth, state.sessions.byId)) return false;
         const effectiveOwner = effectiveSessionOwner(session, state.sessions.byId);
@@ -806,6 +837,39 @@ export function selectActiveSession(state) {
     return sessionId ? state.sessions.byId[sessionId] || null : null;
 }
 
+export function selectNavigationIntent(state) {
+    return state.sessions?.navigationIntent || null;
+}
+
+/**
+ * Deep-link failure state for renderers. `not_found` deliberately covers both
+ * unknown and inaccessible sessions (no existence oracle); network/server
+ * failures keep a retryable flavor.
+ */
+export function selectNavigationError(state) {
+    const intent = state.sessions?.navigationIntent;
+    if (!intent || intent.status !== "failed") return null;
+    const errorKind = intent.errorKind === "not_found" ? "not_found" : "network";
+    return {
+        sessionId: intent.sessionId,
+        errorKind,
+        retryable: errorKind === "network",
+        message: errorKind === "not_found"
+            ? "This session was not found or has not been shared with you."
+            : "Could not load the linked session. Check your connection and try again.",
+    };
+}
+
+/**
+ * Status copy for the transient deep-link filter exception — non-null while a
+ * linked session is being shown despite the current filters excluding it.
+ */
+export function selectSessionFilterExceptionNotice(state) {
+    const exceptionId = state.sessions?.filterExceptionId || null;
+    if (!exceptionId || !state.sessions?.byId?.[exceptionId]) return null;
+    return "Showing linked session outside your current filters.";
+}
+
 /**
  * True when the session row is actively running a turn that Stop can target.
  * Applies to user AND system sessions; group/container rows are not sessions.
@@ -1859,6 +1923,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
                     width: Math.max(20, maxWidth),
                     titleColor: USER_CHAT_COLOR,
                     borderColor: USER_CHAT_COLOR,
+                    tableMode: options.tableMode,
                 }),
                 ...buildChatMessageLines({
                     ...message,
@@ -1936,6 +2001,7 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
             width: Math.max(20, maxWidth),
             titleColor: message?.cardTitleColor || (message?.role === "system" ? "yellow" : "cyan"),
             borderColor: message?.cardBorderColor || "gray",
+            tableMode: options.tableMode,
             ...(isSystemCard ? { bodyColor: "gray", fitToContent: true } : {}),
         });
     }
@@ -3714,7 +3780,7 @@ function buildNodeMapHeaderLine(nodeLabels, colWidth) {
     return runs;
 }
 
-const SEQ_REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh", "minimal", "none"]);
+const SEQ_REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 function shortModelForSequence(value) {
     const model = String(value || "").trim();
@@ -4022,10 +4088,12 @@ export function selectModelPickerModal(state, maxWidth = 72) {
                 ? modal.items.findIndex((item) => item.id === model.id)
                 : -1;
             const isSelected = itemIndex === selectedIndex;
+            const isDisabled = Boolean(model.disabled);
             const labelRuns = fitRuns([
                 { text: "· ", color: "gray" },
-                { text: model.modelName || model.qualifiedName || model.id, color: "white", bold: Boolean(model.isDefault) },
+                { text: model.modelName || model.qualifiedName || model.id, color: isDisabled ? "gray" : "white", bold: Boolean(model.isDefault) && !isDisabled },
                 ...(model.cost ? [{ text: ` [${model.cost}]`, color: "gray" }] : []),
+                ...(isDisabled ? [{ text: " ⊘ needs GitHub key", color: "yellow" }] : []),
                 ...(model.isDefault ? [{ text: " ← current default", color: "gray" }] : []),
             ], contentWidth);
 
@@ -4062,6 +4130,9 @@ export function selectModelPickerModal(state, maxWidth = 72) {
                 ? [[{ text: `Reasoning: ${supportedReasoning.join(", ")}`, color: "gray" }]]
                 : []),
             ...(defaultReasoning ? [[{ text: `Default reasoning: ${defaultReasoning}`, color: "gray" }]] : []),
+            ...(selectedItem.disabled
+                ? [[{ text: "Unavailable: requires a GitHub Copilot key. Add yours in the Admin console, then reopen this picker.", color: "yellow" }]]
+                : []),
             [{ text: "", color: "gray" }],
             [{
                 text: selectedItem.description || "No description available for this model.",
@@ -4234,11 +4305,12 @@ export function selectContextTierPickerModal(state, maxWidth = 64) {
 
     const selectedItem = items[selectedIndex] || null;
     const modelItem = modal.modelItem || null;
+    const selectedLabel = selectedItem?.label || selectedItem?.id;
     const detailsLines = [
         [{ text: modelItem?.modelName || modelItem?.qualifiedName || "Selected model", color: "white", bold: true }],
         [{ text: `${modelItem?.providerId || "provider"} (${modelItem?.providerType || "provider"})`, color: "gray" }],
         [{ text: "", color: "gray" }],
-        [{ text: selectedItem?.id ? `Using context window: ${selectedItem.id}` : "Choose a context window.", color: "white" }],
+        [{ text: selectedLabel ? `Using context window: ${selectedLabel}` : "Choose a context window.", color: "white" }],
         [{ text: "Long context costs more per token.", color: "gray" }],
     ];
 
@@ -4640,6 +4712,7 @@ function isOwnerFilterItemSelected(item, ownerFilter = {}, auth = {}) {
     if (item.kind === "system") return ownerFilter?.includeSystem === true;
     if (item.kind === "unowned") return ownerFilter?.includeUnowned === true;
     if (item.kind === "me") return ownerFilter?.includeMe === true && Boolean(ownerKeyForOwner(auth?.principal));
+    if (item.kind === "shared") return ownerFilter?.includeShared === true;
     if (item.kind === "owner") return Array.isArray(ownerFilter?.ownerKeys) && ownerFilter.ownerKeys.includes(item.ownerKey);
     return false;
 }

package/ui/core/src/state.js

@@ -13,6 +13,7 @@ export function normalizeSessionOwnerFilter(filter) {
         includeSystem: filter?.includeSystem === true,
         includeUnowned: filter?.includeUnowned === true,
         includeMe: filter?.includeMe === true,
+        includeShared: filter?.includeShared === true,
         ownerKeys,
     };
 }
@@ -180,6 +181,8 @@ export function createInitialState({ mode = "local", branding = null, themeId =
             filterQuery: "",
             ownerFilterExplicit: hasStoredSessionOwnerFilter,
             ownerFilter: normalizeSessionOwnerFilter(sessionOwnerFilter),
+            navigationIntent: null,
+            filterExceptionId: null,
         },
         history: {
             bySessionId: new Map(),