pilotswarm 0.5.7 → 0.5.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
   "type": "module",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "hono": "^4.12.10",
     "ink": "^6.8.0",
     "jose": "^6.2.2",
-    "pilotswarm-sdk": "^0.5.7",
+    "pilotswarm-sdk": "^0.5.9",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "ws": "^8.18.2"

package/ui/core/src/controller.js

@@ -467,6 +467,12 @@ function ownerDisplayName(owner, fallback = "unknown user") {
     return String(owner?.displayName || owner?.email || "").trim() || fallback;
 }
 
+// Owner key of the first-class System user. System-agent children inherit this
+// owner; they belong to the static "System" filter entry, so we never mint a
+// second, duplicate "System" owner bucket for them. Computed via the join
+// helper so it stays byte-identical to real owner keys.
+const SYSTEM_OWNER_KEY = ownerKeyForPrincipal({ provider: "system", subject: "system" });
+
 function buildSessionOwnerFilterItems(state) {
     const principal = state.auth?.principal || null;
     const principalKey = ownerKeyForPrincipal(principal);
@@ -506,7 +512,9 @@ function buildSessionOwnerFilterItems(state) {
     for (const session of Object.values(state.sessions?.byId || {})) {
         const owner = session?.owner;
         const key = ownerKeyForPrincipal(owner);
-        if (!key || key === principalKey || ownersByKey.has(key)) continue;
+        // Skip the current user (covered by "Me") and the System user (covered
+        // by the static "System" entry — never a duplicate owner bucket).
+        if (!key || key === principalKey || key === SYSTEM_OWNER_KEY || ownersByKey.has(key)) continue;
         ownersByKey.set(key, owner);
     }
 
@@ -527,7 +535,7 @@ function buildSessionOwnerFilterItems(state) {
     return items;
 }
 
-function defaultOwnerFilterForPrincipal(principal) {
+export function defaultOwnerFilterForPrincipal(principal) {
     return ownerKeyForPrincipal(principal)
         ? {
             all: false,
@@ -1574,6 +1582,36 @@ export class PilotSwarmUiController {
         });
     }
 
+    // Keep the open Session Filter modal's entry list in sync with the live
+    // session set. The item list is snapshotted into modal.items at open time
+    // (it must be — the shared keyboard-nav handler indexes into it), but the
+    // periodic catalog refresh mutates owners underneath it: a user whose first
+    // session arrives after the modal opened would otherwise never see their
+    // owner bucket without reopening. Rebuild in place, preserving the
+    // highlighted row by its stable id, and only when the shape actually
+    // changed (so we don't churn the modal on every 4s refresh).
+    refreshOpenSessionOwnerFilterModal() {
+        const state = this.getState();
+        const modal = state.ui.modal;
+        if (!modal || modal.type !== "sessionOwnerFilter") return;
+        const nextItems = buildSessionOwnerFilterItems(state);
+        const prevItems = Array.isArray(modal.items) ? modal.items : [];
+        const sameShape = prevItems.length === nextItems.length
+            && prevItems.every((item, i) => item?.id === nextItems[i]?.id);
+        if (sameShape) return;
+        const prevSelectedId = prevItems[Math.max(0, Number(modal.selectedIndex) || 0)]?.id;
+        const remappedIndex = prevSelectedId != null
+            ? nextItems.findIndex((item) => item.id === prevSelectedId)
+            : -1;
+        const nextSelectedIndex = remappedIndex >= 0
+            ? remappedIndex
+            : Math.max(0, Math.min(Number(modal.selectedIndex) || 0, Math.max(0, nextItems.length - 1)));
+        this.dispatch({
+            type: "ui/modal",
+            modal: { ...modal, items: nextItems, selectedIndex: nextSelectedIndex },
+        });
+    }
+
     setFilesFilter(patch = {}) {
         this.dispatch({
             type: "files/filter",
@@ -1743,6 +1781,7 @@ export class PilotSwarmUiController {
             });
         }
         this.dispatch({ type: "sessions/loaded", sessions });
+        this.refreshOpenSessionOwnerFilterModal();
         const selected = this.getState().sessions.activeSessionId;
         const syncedIds = new Set();
         if (selected) {

package/ui/core/src/selectors.js

@@ -198,6 +198,13 @@ function ownerDisplayName(owner, fallback = "unknown user") {
     return String(owner?.displayName || owner?.email || "").trim() || fallback;
 }
 
+// The owner key of the first-class System user. Sessions a system agent spawns
+// on a user's behalf inherit this owner (they are NOT is_system, so they stay
+// deletable) — but they belong to the same "System" bucket as the real system
+// agents, so the single System filter entry covers both. Computed via the same
+// join helper so it stays byte-identical to real owner keys.
+const SYSTEM_OWNER_KEY = ownerKeyForOwner({ provider: "system", subject: "system" });
+
 function initialsFromText(value) {
     const text = String(value || "").trim();
     if (!text) return "";
@@ -335,6 +342,10 @@ function matchesOwnerFilterDirect(session, ownerFilter = {}, auth = {}, ownerOve
     if (session?.isSystem) return ownerFilter.includeSystem === true;
     const ownerKey = ownerKeyForOwner(ownerOverride !== undefined ? ownerOverride : session?.owner);
     if (!ownerKey) return ownerFilter.includeUnowned === true;
+    // Sessions OWNED BY the System user (children a system agent spawned) share
+    // the "System" bucket with the real is_system agents — one entry, one
+    // meaning. Gate them on includeSystem, never on Me / owner keys.
+    if (ownerKey === SYSTEM_OWNER_KEY) return ownerFilter.includeSystem === true;
     const currentUserKey = ownerKeyForOwner(auth?.principal);
     if (ownerFilter.includeMe && currentUserKey && ownerKey === currentUserKey) return true;
     return Array.isArray(ownerFilter.ownerKeys) && ownerFilter.ownerKeys.includes(ownerKey);

package/ui/react/src/web-app.js

@@ -40,6 +40,7 @@ import {
     selectStatusBar,
     selectThemePickerModal,
     selectConfirmModal,
+    defaultOwnerFilterForPrincipal,
     normalizeStoredLayoutAdjustments,
     normalizeStoredPinnedSessionIds,
 } from "pilotswarm/ui-core";
@@ -204,7 +205,13 @@ function profileSettingsFromViewState(state) {
 function buildDefaultProfileSettingsFromState(state) {
     return normalizeProfileSettings({
         themeId: state?.ui?.themeId,
-        sessionOwnerFilter: state?.sessions?.ownerFilter,
+        // Derive the owner-filter default from the RESOLVED principal, never a
+        // snapshot of state.sessions.ownerFilter — at mount that snapshot is
+        // still {all:true} (principal not yet applied), and using it as the
+        // "no persisted filter" fallback would drift an authenticated user's
+        // saved filter to All (or, mid-resolve, hide their own sessions). This
+        // guarantees the fallback is always Me+System for a signed-in user.
+        sessionOwnerFilter: defaultOwnerFilterForPrincipal(state?.auth?.principal ?? null),
         layoutAdjustments: state?.ui?.layout,
         pinnedSessionIds: state?.sessions?.pinnedIds,
         collapsedSessionIds: state?.sessions?.collapsedIds,
@@ -4333,6 +4340,11 @@ export function PilotSwarmWebApp({ controller }) {
             try {
                 const profile = await transport.getCurrentUserProfile();
                 if (!active) return;
+                // Recompute the fallback defaults from CURRENT state each poll:
+                // the principal is resolved by now (it was likely null at mount),
+                // so the "no persisted filter" fallback becomes the correct
+                // principal-scoped default (Me+System) instead of {all:true}.
+                defaultProfileSettingsRef.current = buildDefaultProfileSettingsFromState(controller.getState());
                 const settings = materializeProfileSettings(
                     profile?.profileSettings,
                     defaultProfileSettingsRef.current,