pilotswarm 0.5.1 → 0.5.2

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,
                     },
                 },
             };

package/ui/core/src/selectors.js

@@ -1887,60 +1887,6 @@ const LIVE_ACTIVITY_SKIP = new Set([
     "tool.execution_progress",
 ]);
 
-// Consecutive events of these types collapse into a single line (streaming
-// reasoning/intent fires many events per turn).
-const LIVE_ACTIVITY_COLLAPSE = new Set(["assistant.reasoning", "assistant.intent"]);
-
-// Friendly verbs for the live activity lines, keyed by event type. An empty
-// string means "show the detail as-is" (e.g. tool calls, where the tool name is
-// the action). Types absent from the map fall back to their cleaned detail.
-const LIVE_ACTIVITY_VERBS = {
-    "tool.execution_start": "",
-    "tool.execution_complete": "",
-    "assistant.reasoning": "Thinking",
-    "assistant.intent": "Planning",
-    "session.agent_spawned": "Spawning sub-agent",
-    "session.wait_started": "Waiting",
-    "session.input_required_started": "Awaiting input",
-    "session.command_received": "Command",
-    "session.command_completed": "Command",
-    "session.compaction_start": "Compacting context",
-    "session.compaction_complete": "Context compacted",
-    "session.dehydrated": "Dehydrating",
-    "session.hydrated": "Rehydrated",
-    "session.rehydrated": "Rehydrated",
-    "session.lossy_handoff": "Handed off to a new worker",
-    "session.error": "Error",
-    "session.cron_started": "Scheduled",
-    "session.cron_scheduled": "Scheduled",
-    "session.cron_fired": "Woke on schedule",
-    "session.cron_at_scheduled": "Scheduled",
-    "session.cron_at_started": "Scheduled",
-    "session.cron_at_fired": "Woke on schedule",
-    "system.message": "",
-};
-
-// Turn a raw activity item into a friendly one-line action label: strip the
-// timestamp and [bracket] tag, then prefix a human verb where one applies.
-function friendlyLiveActivity(item, maxLen = 96) {
-    const raw = String(item?.text || "")
-        .replace(/^\s*\d{1,2}:\d{2}(?::\d{2})?\s*/, "")
-        .replace(/^\[[^\]]+\]\s*/, "")
-        .replace(/\s+/g, " ")
-        .trim();
-    const verb = LIVE_ACTIVITY_VERBS[item?.eventType];
-    let text;
-    if (verb === undefined || verb === "") {
-        text = raw;
-    } else if (raw) {
-        text = `${verb} \u2014 ${raw}`;
-    } else {
-        text = verb;
-    }
-    text = text || "Working";
-    return text.length > maxLen ? `${text.slice(0, maxLen - 1)}\u2026` : text;
-}
-
 // Format an elapsed duration for the live activity card header (e.g. "12s",
 // "1m 05s", "1h 02m").
 function formatElapsed(ms) {
@@ -1954,12 +1900,87 @@ function formatElapsed(ms) {
     return `${hours}h ${String(mins).padStart(2, "0")}m`;
 }
 
-// Claude-style live activity: while a turn is running, surface the last few
-// actions as a short text scrollback. Assistant messages can land before the
-// turn is actually done (streamed/tool-interleaved replies), so the card is
-// governed by session status rather than by the newest transcript role.
-// `options.spinnerFrame` animates the active (latest) line's marker;
-// `options.maxActions` caps the line count.
+// Fact-store, graph-store, and skill tools get first-class phases instead of
+// the generic "running tool: X". Classification is pattern-based so new tools
+// in these families inherit the right phase without a table update.
+const FACTS_READ_TOOLS = new Set(["read_facts", "facts_search", "facts_similar", "facts_read_uncrawled", "facts_tombstone_stats"]);
+const FACTS_WRITE_TOOLS = new Set(["store_fact", "delete_fact", "facts_set_crawled", "facts_purge_tombstones", "facts_force_purge"]);
+function knowledgeToolPhase(name, starting) {
+    const n = String(name || "").toLowerCase();
+    if (n === "search_skills" || n.includes("skill")) {
+        return starting ? "loading skills\u2026" : "loaded skills";
+    }
+    if (FACTS_READ_TOOLS.has(n)) return starting ? "reading facts\u2026" : "read facts";
+    if (FACTS_WRITE_TOOLS.has(n)) return starting ? "writing facts\u2026" : "wrote facts";
+    if (n.startsWith("graph_")) {
+        const writes = /upsert|delete|archive|merge|remove|set_/.test(n);
+        if (writes) return starting ? "writing to the graph\u2026" : "wrote to the graph";
+        return starting ? "reading the graph\u2026" : "read the graph";
+    }
+    if (n.startsWith("facts_") || n.endsWith("_fact") || n.endsWith("_facts")) {
+        // Unrecognized fact-family tool: read/write by verb.
+        const writes = /store|write|set|delete|purge|update/.test(n);
+        return writes ? (starting ? "writing facts\u2026" : "wrote facts") : (starting ? "reading facts\u2026" : "read facts");
+    }
+    return "";
+}
+
+// High-level phase for the live activity status line. Maps the newest
+// activity event to a short human description ("thinking\u2026", "running tool:
+// read_file\u2026") — never raw payloads; detail lives in the Inspector.
+function liveActivityPhaseText(item) {
+    const type = String(item?.eventType || "");
+    if (type === "tool.execution_start" || type === "tool.execution_complete") {
+        const raw = String(item?.text || "")
+            .replace(/^\s*\d{1,2}:\d{2}(?::\d{2})?\s*/, "")
+            .replace(/^\[[^\]]+\]\s*/, "")
+            .replace(/^[^A-Za-z0-9_]+/, "")
+            .trim();
+        const name = (raw.match(/^[A-Za-z0-9_.:-]+/) || [""])[0];
+        if (!name) return "running tools\u2026";
+        const knowledge = knowledgeToolPhase(name, type === "tool.execution_start");
+        if (knowledge) return knowledge;
+        const shortName = name.length > 28 ? `${name.slice(0, 27)}\u2026` : name;
+        return type === "tool.execution_start"
+            ? `running tool: ${shortName}\u2026`
+            : `finished tool: ${shortName}`;
+    }
+    switch (type) {
+        case "skill.invoked": return "loading skills\u2026";
+        case "learned_skill.read": return "loading skills\u2026";
+        case "skills.searched": return "loading skills\u2026";
+        case "facts.searched":
+        case "facts.similar": return "reading facts\u2026";
+        case "graph.searched":
+        case "graph.node_searched":
+        case "graph.node_loaded": return "reading the graph\u2026";
+        case "graph.namespace_mutated": return "writing to the graph\u2026";
+        case "assistant.reasoning": return "thinking\u2026";
+        case "assistant.intent": return "planning\u2026";
+        case "assistant.message_start":
+        case "assistant.message": return "writing reply\u2026";
+        case "session.compaction_start": return "compacting context\u2026";
+        case "session.compaction_complete": return "context compacted";
+        case "session.dehydrated": return "dehydrating\u2026";
+        case "session.hydrated":
+        case "session.rehydrated": return "rehydrating\u2026";
+        case "session.agent_spawned": return "coordinating agents\u2026";
+        case "session.wait_started": return "waiting\u2026";
+        case "session.input_required_started": return "awaiting input\u2026";
+        case "session.lossy_handoff": return "moving to a new worker\u2026";
+        case "session.error": return "recovering from an error\u2026";
+        default: return "";
+    }
+}
+
+// Single-line live activity status: while a turn is running, one dim line —
+// spinner + "Working" + elapsed + a high-level phase. Replaces the old
+// bordered multi-line card: hosts pin it OUTSIDE the scrolling transcript
+// (portal: bottom-sticky strip above the composer; TUI: appended below the
+// transcript, which autoscroll keeps at the bottom). Assistant messages can
+// land before the turn is actually done (streamed/tool-interleaved replies),
+// so visibility is governed by session status rather than transcript role.
+// `options.spinnerFrame` animates the marker.
 export function selectLiveActivityLines(state, options = {}) {
     if (state?.ui?.chatViewMode === "summary") return [];
     const session = selectActiveSession(state);
@@ -1967,76 +1988,60 @@ export function selectLiveActivityLines(state, options = {}) {
     const status = String(session?.status || "").toLowerCase();
     if (status !== "running") return [];
     const history = state.history?.bySessionId?.get(session.sessionId) || null;
-    // Use the latest user message as the elapsed-time anchor when available,
-    // but do not hide the card just because assistant text has already landed;
-    // the session may still be running tools or follow-up model work.
+    // Latest user message anchors the elapsed clock when available.
     const chat = Array.isArray(history?.chat) ? history.chat : [];
     let turnStartAt = 0;
     for (let i = chat.length - 1; i >= 0; i -= 1) {
-        const role = chat[i]?.role;
-        if (role === "user") {
+        if (chat[i]?.role === "user") {
             turnStartAt = Number(chat[i]?.createdAt || 0);
             break;
         }
     }
     const activity = Array.isArray(history?.activity) ? history.activity : [];
-    const maxActions = Number.isFinite(options.maxActions) ? options.maxActions : 3;
-    const recent = [];
-    let acceptedType = null;
-    let oldestGatheredAt = 0;
-    for (let i = activity.length - 1; i >= 0 && recent.length < maxActions; i -= 1) {
+    // Current-turn boundaries. When a new turn starts, status flips to
+    // "running" BEFORE fresh history lands; anchoring the clock on stale
+    // data flashes a huge elapsed (the whole idle gap) that then snaps to
+    // the real value. Anchor only on evidence belonging to THIS turn — a
+    // user message or turn_start newer than the last turn end — and show
+    // no timer (and no phase) until such evidence exists.
+    let lastTurnStartAt = 0;
+    let lastTurnEndAt = 0;
+    for (let i = activity.length - 1; i >= 0; i -= 1) {
+        const item = activity[i];
+        const type = item?.eventType;
+        const at = Number(item?.createdAt || 0);
+        if (!lastTurnStartAt && type === "assistant.turn_start") lastTurnStartAt = at;
+        if (!lastTurnEndAt && (type === "assistant.turn_end" || type === "session.turn_completed")) lastTurnEndAt = at;
+        if (lastTurnStartAt && lastTurnEndAt) break;
+    }
+    let startAt = 0;
+    if (turnStartAt > lastTurnEndAt) {
+        startAt = turnStartAt;                       // user-triggered turn
+    } else if (lastTurnStartAt > lastTurnEndAt) {
+        startAt = lastTurnStartAt;                   // cron/command-triggered turn
+    }
+    let latest = null;
+    for (let i = activity.length - 1; i >= 0; i -= 1) {
         const item = activity[i];
         if (!item || LIVE_ACTIVITY_SKIP.has(item.eventType)) continue;
-        if (item.eventType === acceptedType && LIVE_ACTIVITY_COLLAPSE.has(item.eventType)) continue;
-        const detail = friendlyLiveActivity(item);
-        if (!detail) continue;
-        recent.unshift(detail);
-        acceptedType = item.eventType;
-        const at = Number(item.createdAt || 0);
-        if (at > 0) oldestGatheredAt = oldestGatheredAt ? Math.min(oldestGatheredAt, at) : at;
-    }
-    if (recent.length === 0) return [];
-    // Render as a bordered card: the portal turns box-drawing lines whose top
-    // row has >2 runs into a `ps-chat-card`; the terminal shows the box art.
-    // Header carries the animated spinner + "Working"; body lists the recent
-    // actions, most recent highlighted.
-    const borderColor = "cyan";
-    const spinner = String(options.spinnerFrame || "").trim() || "\u25cf";
+        // Phase must come from the current turn — a stale "finished tool"
+        // from the previous turn must not flash on turn start.
+        if (Number(item.createdAt || 0) <= lastTurnEndAt) break;
+        latest = item;
+        break;
+    }
     const nowMs = Number.isFinite(options.now) ? options.now : Date.now();
-    const startAt = turnStartAt || oldestGatheredAt;
     const elapsedLabel = startAt > 0 ? formatElapsed(nowMs - startAt) : "";
-    const titleRuns = [
-        { text: ` ${spinner} Working `, color: borderColor, bold: true },
-        ...(elapsedLabel ? [{ text: `\u00b7 ${elapsedLabel} `, color: "gray" }] : []),
+    const spinner = String(options.spinnerFrame || "").trim() || "\u25cf";
+    const phase = latest ? liveActivityPhaseText(latest) : "";
+    const runs = [
+        { text: `${spinner} `, color: "cyan" },
+        { text: "Working", color: "cyan" },
+        ...(elapsedLabel ? [{ text: ` \u00b7 ${elapsedLabel}`, color: "gray" }] : []),
+        ...(phase ? [{ text: ` \u2014 ${phase}`, color: "gray" }] : []),
     ];
-    const titleWidth = titleRuns.reduce((sum, run) => sum + String(run.text || "").length, 0);
-    const maxWidth = Math.max(24, Math.min(96, Math.floor(Number(options.maxWidth) || 64)));
-    const widestBody = recent.reduce((max, detail) => Math.max(max, detail.length + 2), 0);
-    const cardWidth = Math.max(20, Math.min(maxWidth, Math.max(titleWidth + 3, widestBody + 4)));
-    const contentWidth = Math.max(1, cardWidth - 4);
-    const bodyLines = recent.map((detail, index) => {
-        const isLatest = index === recent.length - 1;
-        return fitRuns([
-            { text: isLatest ? "\u25cf " : "\u00b7 ", color: isLatest ? "cyan" : "gray", bold: isLatest },
-            { text: detail, color: isLatest ? "cyan" : "gray" },
-        ], contentWidth);
-    });
-    const topFill = Math.max(0, cardWidth - titleWidth - 3);
-    const card = [[
-        { text: "\u250c\u2500", color: borderColor },
-        ...titleRuns,
-        { text: `${"\u2500".repeat(topFill)}\u2510`, color: borderColor },
-    ]];
-    for (const runs of bodyLines) {
-        card.push([
-            { text: "\u2502 ", color: borderColor },
-            ...padRunsToDisplayWidth(runs, contentWidth),
-            { text: " \u2502", color: borderColor },
-        ]);
-    }
-    card.push([{ text: `\u2514${"\u2500".repeat(Math.max(1, cardWidth - 2))}\u2518`, color: borderColor }]);
-    card.push([{ text: "", color: null }]);
-    return card;
+    const maxWidth = Math.max(24, Math.min(120, Math.floor(Number(options.maxWidth) || 80)));
+    return [fitRuns(runs, maxWidth)];
 }
 
 export function selectChatLines(state, maxWidth = 80, options = {}) {
@@ -2735,19 +2740,34 @@ export function selectAdminConsole(state) {
         }
         : (state.auth?.principal || null);
 
+    const systemGhcpKey = admin.systemGhcpKey || { supported: false, loading: false, configured: false, changedBy: null, changedAt: null, error: null };
+    const isAdmin = Boolean(profile?.isAdmin);
+    // Admin-only target switch: when on, Set/Replace/Clear act on the
+    // SYSTEM user's key (ownerless system sessions run on it).
+    const storeAsSystem = isAdmin && Boolean(ghcpKey.storeAsSystem);
+    const targetConfigured = storeAsSystem ? Boolean(systemGhcpKey.configured) : Boolean(profile?.githubCopilotKeySet);
+    const keyNoun = storeAsSystem ? "System key" : "key";
+
+    const systemProvenance = systemGhcpKey.configured && systemGhcpKey.changedBy
+        ? ` (set by ${systemGhcpKey.changedBy})`
+        : "";
     const ghcpStatusText = ghcpKey.saving
         ? "Saving..."
         : ghcpKey.editing
             ? "Editing — Enter to save, Esc to cancel"
-            : (profile?.githubCopilotKeySet
-                ? "Configured (overrides env GITHUB_TOKEN for this user)"
-                : "Not configured (using env GITHUB_TOKEN fallback)");
+            : storeAsSystem
+                ? (systemGhcpKey.configured
+                    ? `System key configured — ownerless system sessions use it for GitHub Copilot models${systemProvenance}`
+                    : "System key not configured — ownerless system sessions fall back to env GITHUB_TOKEN")
+                : (profile?.githubCopilotKeySet
+                    ? "Configured (overrides env GITHUB_TOKEN for this user)"
+                    : "Not configured (using env GITHUB_TOKEN fallback)");
 
     const actions = [];
     if (!ghcpKey.editing) {
-        actions.push({ id: "edit", label: profile?.githubCopilotKeySet ? "Replace key" : "Set key", key: "e" });
-        if (profile?.githubCopilotKeySet) {
-            actions.push({ id: "clear", label: "Clear key", key: "c" });
+        actions.push({ id: "edit", label: targetConfigured ? `Replace ${keyNoun}` : `Set ${keyNoun}`, key: "e" });
+        if (targetConfigured) {
+            actions.push({ id: "clear", label: `Clear ${keyNoun}`, key: "c" });
         }
         actions.push({ id: "refresh", label: "Refresh", key: "r" });
     } else {
@@ -2761,8 +2781,11 @@ export function selectAdminConsole(state) {
         loading: Boolean(admin.loading),
         loadError: admin.loadError || null,
         principal,
+        isAdmin,
         ghcpKey: {
             configured: Boolean(profile?.githubCopilotKeySet),
+            targetConfigured,
+            storeAsSystem,
             editing: Boolean(ghcpKey.editing),
             draft: ghcpKey.draft || "",
             cursorIndex: Math.max(0, Math.min(Number(ghcpKey.cursorIndex) || 0, String(ghcpKey.draft || "").length)),
@@ -2770,6 +2793,14 @@ export function selectAdminConsole(state) {
             error: ghcpKey.error || null,
             statusText: ghcpStatusText,
         },
+        systemGhcpKey: {
+            supported: Boolean(systemGhcpKey.supported),
+            loading: Boolean(systemGhcpKey.loading),
+            configured: Boolean(systemGhcpKey.configured),
+            changedBy: systemGhcpKey.changedBy || null,
+            changedAt: systemGhcpKey.changedAt || null,
+            error: systemGhcpKey.error || null,
+        },
         actions,
     };
 }

package/ui/core/src/state.js

@@ -247,6 +247,21 @@ export function createInitialState({ mode = "local", branding = null, themeId =
                 saving: false,
                 error: null,
                 lastSavedAt: 0,
+                // Admin-only target switch: when true, Set/Replace/Clear
+                // act on the SYSTEM user's key (used by ownerless system
+                // sessions) instead of the caller's own key.
+                storeAsSystem: false,
+            },
+            // Status of the SYSTEM user's Copilot key (admins only; never
+            // the key itself). `supported` flips on the first successful
+            // status load so non-admin/legacy transports hide the toggle.
+            systemGhcpKey: {
+                supported: false,
+                loading: false,
+                configured: false,
+                changedBy: null,
+                changedAt: null,
+                error: null,
             },
         },
     };

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

@@ -431,13 +431,19 @@ function compactTitleRuns(title, maxWidth = 40) {
         return [{ text: text.length > maxWidth ? `${text.slice(0, maxWidth - 1)}…` : text, color: "white", bold: true }];
     }
     const compactRuns = [];
+    // Gray runs are dropped on tight widths as decoration (ids, badges) —
+    // EXCEPT pure separators (" · "). Dropping those fuses adjacent values:
+    // "running · gpt-5.4 · ctx 33%" became "runninggpt-5.4ctx…".
+    const isSeparator = (run) => /^[\s·—-]+$/.test(String(run?.text || ""));
     let remaining = Math.max(8, maxWidth);
     for (const run of title) {
         if (remaining <= 0) break;
         const color = run?.color;
-        if (color === "gray" && compactRuns.length > 0) continue;
+        if (color === "gray" && compactRuns.length > 0 && !isSeparator(run)) continue;
         const text = String(run?.text || "");
         if (!text) continue;
+        // Don't start a separator we can't follow with content.
+        if (isSeparator(run) && remaining < text.length + 2) break;
         const chunk = text.length > remaining && remaining > 1
             ? `${text.slice(0, remaining - 1)}…`
             : text.slice(0, remaining);
@@ -445,6 +451,10 @@ function compactTitleRuns(title, maxWidth = 40) {
         compactRuns.push({ ...run, text: chunk });
         remaining -= chunk.length;
     }
+    // Never end on a dangling separator.
+    while (compactRuns.length > 0 && isSeparator(compactRuns[compactRuns.length - 1])) {
+        compactRuns.pop();
+    }
     return compactRuns.length > 0 ? compactRuns : title;
 }
 
@@ -1715,6 +1725,7 @@ function PortalSequenceLines({ lines, theme, completionByTurn }) {
     );
 }
 
+
 function ScrollLinesPanel({ title, titleRight = null, color, focused, actions, lines, stickyLines = [], bottomStickyLines = [], scrollOffset = 0, scrollMode = "top", paneKey, controller, className = "", panelClassName = "", topContent = null, bottomContent = null, structuredBlocks = false, stickyBottom = false, renderBody = null }) {
     const themeId = useControllerSelector(controller, (state) => state.ui.themeId);
     const theme = getTheme(themeId);
@@ -1736,11 +1747,21 @@ function ScrollLinesPanel({ title, titleRight = null, color, focused, actions, l
         });
     }, []);
 
+    const [scrolledUp, setScrolledUp] = React.useState(false);
+    const updateScrolledUp = React.useCallback((el) => {
+        if (!el) return;
+        const up = el.scrollHeight - el.scrollTop - el.clientHeight > 4;
+        setScrolledUp((current) => (current === up ? current : up));
+    }, []);
     const handleBodyScroll = React.useCallback((event) => {
         onScroll();
+        updateScrolledUp(event.currentTarget);
         if (!preserveHorizontalScroll || syncingHorizontalRef.current) return;
         syncScrollLeft(event.currentTarget, stickyRef.current);
-    }, [onScroll, preserveHorizontalScroll, syncScrollLeft]);
+    }, [onScroll, preserveHorizontalScroll, syncScrollLeft, updateScrolledUp]);
+    React.useEffect(() => {
+        updateScrolledUp(ref.current);
+    });
 
     const handleStickyScroll = React.useCallback((event) => {
         if (!preserveHorizontalScroll || syncingHorizontalRef.current) return;
@@ -1758,7 +1779,7 @@ function ScrollLinesPanel({ title, titleRight = null, color, focused, actions, l
                 normalizedSticky.map((line, index) => React.createElement(Line, { key: `sticky:${index}`, line, theme })),
             )
             : null,
-        React.createElement("div", { ref, className: `ps-scroll-panel ${className}`.trim(), onScroll: handleBodyScroll, onWheel, onTouchStart, onTouchMove, onTouchEnd, onTouchCancel: onTouchEnd },
+        React.createElement("div", { ref, className: `ps-scroll-panel ${className}${scrolledUp ? " is-scrolled-up" : ""}`.trim(), onScroll: handleBodyScroll, onWheel, onTouchStart, onTouchMove, onTouchEnd, onTouchCancel: onTouchEnd },
             typeof renderBody === "function"
                 ? renderBody(normalizedLines, theme)
                 : structuredBlocks
@@ -2117,19 +2138,18 @@ function ChatPane({ controller, mobile = false, fullWidth = false, showComposer
         () => selectLiveActivityLines(selectorState, { spinnerFrame, maxWidth: viewState.contentWidth }),
         [selectorState, spinnerFrame, viewState.contentWidth],
     );
-    // Concatenate the isolated live-activity block onto the (expensive) message
-    // lines so the spinner tick only recomputes the small block, not the whole
-    // transcript. The block clears itself once the reply lands.
-    const chatLines = React.useMemo(
-        () => (liveActivityLines.length > 0
-            ? [...lines, [{ text: "", color: null }], ...liveActivityLines]
-            : lines),
-        [lines, liveActivityLines],
-    );
+    // The live-activity line is pinned in the bottom-sticky strip (with the
+    // outbox overlay), NOT appended to the transcript — it must stay put while
+    // chat content scrolls, and it drops the instant the turn ends.
+    const pinnedActivityLines = liveActivityLines;
     const outboxLines = React.useMemo(
         () => selectOutboxOverlayLines(selectorState, viewState.contentWidth, { tableMode: "sentinel" }),
         [selectorState, viewState.contentWidth],
     );
+    const stickyBottom = React.useMemo(
+        () => (pinnedActivityLines.length > 0 ? [...outboxLines, ...pinnedActivityLines] : outboxLines),
+        [outboxLines, pinnedActivityLines],
+    );
     const composer = showComposer && !viewState.activeSessionIsGroup && viewState.chatViewMode !== "summary"
         ? React.createElement("div", { className: "ps-chat-composer" },
             React.createElement(PromptComposer, { controller, mobile, active: true }))
@@ -2144,8 +2164,8 @@ function ChatPane({ controller, mobile = false, fullWidth = false, showComposer
         actions: null,
         color: chrome.color,
         focused: viewState.focused,
-        lines: chatLines,
-        bottomStickyLines: outboxLines,
+        lines,
+        bottomStickyLines: stickyBottom,
         scrollOffset: viewState.scroll,
         scrollMode: "bottom",
         paneKey: "chat",
@@ -4105,11 +4125,27 @@ function AdminConsolePanel({ controller }) {
             : null,
         React.createElement("section", { className: "ps-admin-console__section" },
             React.createElement("h3", null, "GitHub Copilot key"),
-            React.createElement("p", { className: "ps-admin-console__hint" },
-                "Per-user override for the GitHub Copilot model provider token. ",
-                "When set, this key is used instead of the worker's env-supplied ",
-                "GITHUB_TOKEN for sessions you own. Clearing the key reverts to ",
-                "the worker default."),
+            view.ghcpKey.storeAsSystem
+                ? React.createElement("p", { className: "ps-admin-console__hint" },
+                    "System-wide key for platform-managed (ownerless) system ",
+                    "sessions — agent tuners, repo cache managers, and other ",
+                    "sessions with no owner resolve this key for GitHub Copilot ",
+                    "models. Clearing it reverts them to the worker default.")
+                : React.createElement("p", { className: "ps-admin-console__hint" },
+                    "Per-user override for the GitHub Copilot model provider token. ",
+                    "When set, this key is used instead of the worker's env-supplied ",
+                    "GITHUB_TOKEN for sessions you own. Clearing the key reverts to ",
+                    "the worker default."),
+            view.isAdmin && view.systemGhcpKey.supported
+                ? React.createElement("label", { className: "ps-admin-console__system-toggle" },
+                    React.createElement("input", {
+                        type: "checkbox",
+                        checked: view.ghcpKey.storeAsSystem,
+                        disabled: view.ghcpKey.saving,
+                        onChange: (event) => controller.setAdminGhcpKeyStoreAsSystem(event.target.checked),
+                    }),
+                    "Store as System key")
+                : null,
             React.createElement("p", { className: `ps-admin-console__status${view.ghcpKey.error ? " is-error" : ""}` },
                 view.ghcpKey.error || view.ghcpKey.statusText),
             view.ghcpKey.editing
@@ -4141,13 +4177,15 @@ function AdminConsolePanel({ controller }) {
                         type: "button",
                         className: "ps-primary-button",
                         onClick: onBeginEdit,
-                    }, view.ghcpKey.configured ? "Replace key" : "Set key"),
-                    view.ghcpKey.configured
+                    }, view.ghcpKey.targetConfigured
+                        ? (view.ghcpKey.storeAsSystem ? "Replace System key" : "Replace key")
+                        : (view.ghcpKey.storeAsSystem ? "Set System key" : "Set key")),
+                    view.ghcpKey.targetConfigured
                         ? React.createElement("button", {
                             type: "button",
                             className: "ps-mini-button",
                             onClick: onClear,
-                        }, "Clear key")
+                        }, view.ghcpKey.storeAsSystem ? "Clear System key" : "Clear key")
                         : null,
                     React.createElement("button", {
                         type: "button",