pilotswarm 0.5.1 → 0.5.3

package/ui/core/src/controller.js

@@ -2160,6 +2160,7 @@ export class PilotSwarmUiController {
         try {
             const profile = await this.transport.getCurrentUserProfile();
             this.dispatch({ type: "admin/profile/loaded", profile });
+            await this.refreshSystemGhcpKeyStatus(profile);
             return profile || null;
         } catch (error) {
             this.dispatch({ type: "admin/profile/loadFailed", error: error?.message || String(error) });
@@ -2167,6 +2168,35 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * Load the SYSTEM user's Copilot key status (admins only). Quietly a
+     * no-op when the caller is not admin or the transport predates the
+     * feature, so the Admin Console degrades to the per-user-only view.
+     */
+    async refreshSystemGhcpKeyStatus(profile = null) {
+        const effective = profile || this.getState().admin?.profile || null;
+        if (!effective?.isAdmin) return null;
+        if (typeof this.transport.getSystemGitHubCopilotKeyStatus !== "function") return null;
+        this.dispatch({ type: "admin/systemGhcpKey/loading" });
+        try {
+            const status = await this.transport.getSystemGitHubCopilotKeyStatus();
+            this.dispatch({ type: "admin/systemGhcpKey/loaded", status });
+            return status || null;
+        } catch (error) {
+            this.dispatch({ type: "admin/systemGhcpKey/loadFailed", error: error?.message || String(error) });
+            return null;
+        }
+    }
+
+    /**
+     * Admin-only: switch the key editor between "your key" and
+     * "System key" (the key ownerless system sessions run on).
+     */
+    setAdminGhcpKeyStoreAsSystem(value) {
+        if (value && !this.getState().admin?.profile?.isAdmin) return;
+        this.dispatch({ type: "admin/ghcpKey/setSystemTarget", value: Boolean(value) });
+    }
+
     beginAdminEditGhcpKey() {
         this.dispatch({ type: "admin/ghcpKey/beginEdit", draft: "" });
     }
@@ -2218,8 +2248,12 @@ export class PilotSwarmUiController {
      * use `clearAdminGhcpKey()` for that.
      */
     async saveAdminGhcpKey() {
-        if (typeof this.transport.setCurrentUserGitHubCopilotKey !== "function") {
-            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: "Admin Console is not available on this transport." });
+        const storeAsSystem = Boolean(this.getState().admin.ghcpKey.storeAsSystem);
+        const setter = storeAsSystem ? "setSystemGitHubCopilotKey" : "setCurrentUserGitHubCopilotKey";
+        if (typeof this.transport[setter] !== "function") {
+            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: storeAsSystem
+                ? "This deployment does not support System keys yet."
+                : "Admin Console is not available on this transport." });
             return;
         }
         const draft = String(this.getState().admin.ghcpKey.draft || "").trim();
@@ -2229,8 +2263,13 @@ export class PilotSwarmUiController {
         }
         this.dispatch({ type: "admin/ghcpKey/saving" });
         try {
-            const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: draft });
-            this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            if (storeAsSystem) {
+                const status = await this.transport.setSystemGitHubCopilotKey({ key: draft });
+                this.dispatch({ type: "admin/systemGhcpKey/saved", status });
+            } else {
+                const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: draft });
+                this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            }
         } catch (error) {
             this.dispatch({ type: "admin/ghcpKey/saveFailed", error: error?.message || String(error) });
         }
@@ -2241,14 +2280,23 @@ export class PilotSwarmUiController {
      * worker's env-supplied default token.
      */
     async clearAdminGhcpKey() {
-        if (typeof this.transport.setCurrentUserGitHubCopilotKey !== "function") {
-            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: "Admin Console is not available on this transport." });
+        const storeAsSystem = Boolean(this.getState().admin.ghcpKey.storeAsSystem);
+        const setter = storeAsSystem ? "setSystemGitHubCopilotKey" : "setCurrentUserGitHubCopilotKey";
+        if (typeof this.transport[setter] !== "function") {
+            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: storeAsSystem
+                ? "This deployment does not support System keys yet."
+                : "Admin Console is not available on this transport." });
             return;
         }
         this.dispatch({ type: "admin/ghcpKey/saving" });
         try {
-            const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: null });
-            this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            if (storeAsSystem) {
+                const status = await this.transport.setSystemGitHubCopilotKey({ key: null });
+                this.dispatch({ type: "admin/systemGhcpKey/saved", status });
+            } else {
+                const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: null });
+                this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            }
         } catch (error) {
             this.dispatch({ type: "admin/ghcpKey/saveFailed", error: error?.message || String(error) });
         }
@@ -5172,11 +5220,14 @@ export class PilotSwarmUiController {
 
         const contentWidth = Math.max(20, layout.leftWidth - 4);
         const contentHeight = Math.max(1, layout.chatPaneHeight - 2);
-        const lines = [
-            ...selectChatLines(state, contentWidth),
+        const lines = selectChatLines(state, contentWidth);
+        // The live "Working" strip and the queued-prompt overlay are both
+        // pinned in the bottom-sticky region (matching the ChatPane render),
+        // so the transcript scroll math must reserve them here — not inline.
+        const bottomStickyLines = [
+            ...selectOutboxOverlayLines(state, contentWidth),
             ...selectLiveActivityLines(state),
         ];
-        const bottomStickyLines = selectOutboxOverlayLines(state, contentWidth);
         const bottomStickyHeight = Math.min(
             Math.max(0, Math.floor(contentHeight * 0.34)),
             countWrappedRenderableLines(bottomStickyLines, contentWidth),

package/ui/core/src/history.js

@@ -360,12 +360,16 @@ function buildChatMessage(event, role) {
 
     const text = extractVisibleChatText(rawText, role);
     if (!hasVisibleMessageText(text)) return null;
+    const clientMessageIds = Array.isArray(event?.data?.clientMessageIds)
+        ? event.data.clientMessageIds.filter((id) => typeof id === "string" && id)
+        : [];
     return {
         id: `${event.sessionId}:${event.seq}`,
         role: deriveChatRole(event, role, text),
         text,
         time: formatTimestamp(event.createdAt),
         createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+        ...(clientMessageIds.length > 0 ? { clientMessageIds } : {}),
     };
 }
 
@@ -873,13 +877,43 @@ export function appendEventToHistory(history, event) {
         loadedEventLimit,
         loadedEventCount: Math.max(Number(history?.loadedEventCount || 0), nextEvents.length),
         hasOlderEvents: Boolean(history?.hasOlderEvents),
+        // clientMessageIds whose turn was user-stopped mid-flight. Carried
+        // across appends so a prompt stays flagged even as the transcript
+        // clamps/reloads.
+        stoppedMessageIds: Array.isArray(history?.stoppedMessageIds) ? history.stoppedMessageIds : [],
     };
 
+    // A stopped turn leaves a durable session.turn_stopped carrying the
+    // interrupted prompt's clientMessageIds. Record them and retroactively
+    // flag any matching transcript message (the user.message usually lands
+    // first, at turn start; the stop lands at turn end).
+    if (event.eventType === "session.turn_stopped") {
+        const ids = Array.isArray(event?.data?.clientMessageIds)
+            ? event.data.clientMessageIds.filter((id) => typeof id === "string" && id)
+            : [];
+        if (ids.length > 0) {
+            const merged = new Set([...next.stoppedMessageIds, ...ids]);
+            next.stoppedMessageIds = Array.from(merged);
+            next.chat = next.chat.map((m) => (
+                Array.isArray(m.clientMessageIds) && m.clientMessageIds.some((id) => merged.has(id))
+                    ? { ...m, stopped: true }
+                    : m
+            ));
+        }
+        return next;
+    }
+
     if (event.eventType === "user.message") {
         next.activity.push(...buildEmbeddedSystemNoticeActivityItems(event, "user"));
         next.activity = clampHistoryItems(next.activity, loadedEventLimit);
         const message = buildChatMessage(event, "user");
         if (!message) return next;
+        // Prospective flag: covers a bulk load where the stop event arrived
+        // before this message in the reduce order.
+        if (Array.isArray(message.clientMessageIds)
+            && message.clientMessageIds.some((id) => next.stoppedMessageIds.includes(id))) {
+            message.stopped = true;
+        }
         next.chat = reconcileOptimisticMessage(next.chat, message);
         next.chat.push(message);
         next.chat = clampHistoryItems(dedupeChatMessages(next.chat), loadedEventLimit);

package/ui/core/src/reducer.js

@@ -1488,6 +1488,7 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: state.admin.ghcpKey.lastSavedAt,
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
                     },
                 },
             };
@@ -1524,6 +1525,7 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: state.admin.ghcpKey.lastSavedAt,
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
                     },
                 },
             };
@@ -1567,6 +1569,91 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: Date.now(),
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
+                    },
+                },
+            };
+        }
+        case "admin/ghcpKey/setSystemTarget": {
+            const storeAsSystem = Boolean(action.value);
+            if (Boolean(state.admin.ghcpKey.storeAsSystem) === storeAsSystem) return state;
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    ghcpKey: {
+                        ...state.admin.ghcpKey,
+                        storeAsSystem,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loading": {
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        ...state.admin.systemGhcpKey,
+                        loading: true,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loaded": {
+            const status = action.status || {};
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        supported: true,
+                        loading: false,
+                        configured: Boolean(status.configured),
+                        changedBy: status.changedBy || null,
+                        changedAt: status.changedAt || null,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loadFailed": {
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        ...state.admin.systemGhcpKey,
+                        loading: false,
+                        error: action.error ? String(action.error) : "Failed to load System key status",
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/saved": {
+            const status = action.status || {};
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    ghcpKey: {
+                        editing: false,
+                        draft: "",
+                        cursorIndex: 0,
+                        saving: false,
+                        error: null,
+                        lastSavedAt: Date.now(),
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
+                    },
+                    systemGhcpKey: {
+                        supported: true,
+                        loading: false,
+                        configured: Boolean(status.configured),
+                        changedBy: status.changedBy || null,
+                        changedAt: status.changedAt || null,
+                        error: null,
                     },
                 },
             };