pilotswarm 0.5.0 → 0.5.2

package/ui/core/src/selectors.js

@@ -1868,6 +1868,182 @@ function buildChatMessageLines(message, maxWidth, options = {}) {
     return renderedLines;
 }
 
+// Activity-log event types that are not surfaced as live "recent action" lines
+// in the chat pane: bookkeeping, high-frequency streaming noise, and the turn
+// bracket markers (which don't read well as prose).
+const LIVE_ACTIVITY_SKIP = new Set([
+    "assistant.usage",
+    "session.info",
+    "session.idle",
+    "session.usage_info",
+    "pending_messages.modified",
+    "pending_messages.cancelled",
+    "abort",
+    "assistant.turn_start",
+    "assistant.turn_end",
+    "assistant.streaming_progress",
+    "session.turn_completed",
+    "tool.execution_partial_result",
+    "tool.execution_progress",
+]);
+
+// Format an elapsed duration for the live activity card header (e.g. "12s",
+// "1m 05s", "1h 02m").
+function formatElapsed(ms) {
+    const totalSec = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
+    if (totalSec < 60) return `${totalSec}s`;
+    const minutes = Math.floor(totalSec / 60);
+    const seconds = totalSec % 60;
+    if (minutes < 60) return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+    const hours = Math.floor(minutes / 60);
+    const mins = minutes % 60;
+    return `${hours}h ${String(mins).padStart(2, "0")}m`;
+}
+
+// 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);
+    if (!session || session.isGroup) return [];
+    const status = String(session?.status || "").toLowerCase();
+    if (status !== "running") return [];
+    const history = state.history?.bySessionId?.get(session.sessionId) || null;
+    // 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) {
+        if (chat[i]?.role === "user") {
+            turnStartAt = Number(chat[i]?.createdAt || 0);
+            break;
+        }
+    }
+    const activity = Array.isArray(history?.activity) ? history.activity : [];
+    // 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;
+        // 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 elapsedLabel = startAt > 0 ? formatElapsed(nowMs - startAt) : "";
+    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 maxWidth = Math.max(24, Math.min(120, Math.floor(Number(options.maxWidth) || 80)));
+    return [fitRuns(runs, maxWidth)];
+}
+
 export function selectChatLines(state, maxWidth = 80, options = {}) {
     const messages = selectActiveChat(state);
     if (!messages || messages.length === 0) {
@@ -2020,10 +2196,19 @@ export function selectChatPaneChrome(state, options = {}) {
         ? null
         : buildLiveProgressState(session, history, history?.chat || [], outboxItems);
 
+    // Border top-right: status · model · context (mirrors the session-row meta),
+    // with the live turn-progress label appended while a turn is running.
+    const mode = state.connection?.mode || "local";
+    const metaRuns = buildSelectedSessionMetaRuns(session, mode);
+    const progressRuns = buildChatProgressTitleRuns(progress);
+    const titleRight = progressRuns
+        ? [...metaRuns, ...(metaRuns.length ? [{ text: " · ", color: "gray" }] : []), ...progressRuns]
+        : metaRuns;
+
     return {
         color: session.isSystem ? "yellow" : "cyan",
         title,
-        titleRight: buildChatProgressTitleRuns(progress),
+        titleRight: titleRight.length ? titleRight : null,
         animateTitleRight: Boolean(progress),
     };
 }
@@ -2555,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 {
@@ -2581,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)),
@@ -2590,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,
     };
 }
@@ -2759,22 +2970,24 @@ export function selectStatusBar(state) {
     const chatViewMode = state.ui?.chatViewMode === "summary" ? "summary" : "transcript";
     const chatViewHint = chatViewMode === "summary" ? "s transcript" : "s summary";
     const hints = {
-        [FOCUS_REGIONS.SESSIONS]: `up/down switch · ctrl-u/ctrl-d page · ctrl-g move group · f filter · P pin · V select · d done · D delete · r refresh · t title · ${fullscreenHint} · {/} session pane · [/] side pane · T themes · a linked items · drag copy · tab next pane · p prompt`,
-        [FOCUS_REGIONS.CHAT]: `${chatViewHint} · j/k scroll · ctrl-u/ctrl-d page · e older history · g/G top/bottom · d done · ${fullscreenHint} · {/} session pane · [/] side pane · T themes · a linked items · drag copy · tab next pane · p prompt`,
+        [FOCUS_REGIONS.SESSIONS]: `up/down switch · ctrl-u/ctrl-d page · ctrl-g move group · f filter · P pin · V select · d done · D delete · r refresh · t title · ${fullscreenHint} · [/] resize pane · {/} columns · T themes · ? help · a linked items · drag copy · tab next pane · p prompt`,
+        [FOCUS_REGIONS.CHAT]: `${chatViewHint} · j/k scroll · ctrl-u/ctrl-d page · e older history · g/G top/bottom · d done · ${fullscreenHint} · [/] resize pane · {/} columns · T themes · ? help · a linked items · drag copy · tab next pane · p prompt`,
         [FOCUS_REGIONS.INSPECTOR]: state.ui.inspectorTab === "logs"
-            ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · t tail · f filter · ${fullscreenHint} · left/right tab · [/] side pane · T themes · a linked items · drag copy · tab next pane`
+            ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · t tail · f filter · ${fullscreenHint} · left/right tab · [/] resize pane · {/} columns · T themes · ? help · a linked items · drag copy · tab next pane`
             : state.ui.inspectorTab === "stats"
-                ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · f cycle session/fleet/users · d done · ${fullscreenHint} · left/right tab · [/] side pane · T themes · m next tab · tab next pane`
+                ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · f cycle session/fleet/users · d done · ${fullscreenHint} · left/right tab · [/] resize pane · {/} columns · T themes · ? help · m next tab · tab next pane`
             : state.ui.inspectorTab === "files"
                 ? state.files?.fullscreen
-                    ? "a download · x delete · u/ctrl-a upload · o open · f filter · j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · v/esc close fullscreen · left/right tab · {/} session pane · [/] side pane · T themes · tab next pane"
-                    : "j/k files · a download · x delete · u/ctrl-a upload · o open · f filter · ctrl-u/ctrl-d page preview · g/G preview top/bottom · d done · v fullscreen · left/right tab · {/} session pane · [/] side pane · T themes · tab next pane"
+                    ? "a download · x delete · u/ctrl-a upload · o open · f filter · j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · v/esc close fullscreen · left/right tab · [/] resize pane · {/} columns · T themes · ? help · tab next pane"
+                    : "j/k files · a download · x delete · u/ctrl-a upload · o open · f filter · ctrl-u/ctrl-d page preview · g/G preview top/bottom · d done · v fullscreen · left/right tab · [/] resize pane · {/} columns · T themes · ? help · tab next pane"
                 : state.ui.inspectorTab === "history"
-                    ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · f format · r refresh · a save artifact · d done · ${fullscreenHint} · left/right tab · [/] side pane · T themes · m next tab · tab next pane`
-                    : `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · ${fullscreenHint} · left/right tab · [/] side pane · T themes · h/l focus · a linked items · drag copy · m next tab · tab next pane`,
-        [FOCUS_REGIONS.ACTIVITY]: `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · ${fullscreenHint} · {/} session pane · [/] side pane · T themes · a linked items · drag copy · h left · tab next pane`,
+                    ? `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · f format · r refresh · a save artifact · d done · ${fullscreenHint} · left/right tab · [/] resize pane · {/} columns · T themes · ? help · m next tab · tab next pane`
+                    : state.ui.inspectorTab === "sequence"
+                        ? `j/k turn · enter expand · ctrl-u/ctrl-d page · g/G top/bottom · d done · ${fullscreenHint} · left/right tab · [/] resize pane · {/} columns · T themes · ? help · m next tab · tab next pane`
+                        : `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · ${fullscreenHint} · left/right tab · [/] resize pane · {/} columns · T themes · ? help · h/l focus · a linked items · drag copy · m next tab · tab next pane`,
+        [FOCUS_REGIONS.ACTIVITY]: `j/k scroll · ctrl-u/ctrl-d page · g/G top/bottom · d done · ${fullscreenHint} · [/] resize pane · {/} columns · T themes · ? help · a linked items · drag copy · h left · tab next pane`,
         [FOCUS_REGIONS.PROMPT]: hasPendingQuestion
-            ? `type answer · enter reply · alt-enter newline · T themes · arrows move · alt-left/right word · alt-delete word · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`
+            ? `type answer · enter reply · alt-enter newline · T themes · ? help · arrows move · alt-left/right word · alt-delete word · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`
             : editingPendingOutbox
                 ? selectedQueuedOutbox
                     ? `queued prompt selected · d delete · up/down cycle queued · enter/esc new prompt · ${paneFullscreen ? "esc pane" : "esc sessions"}`
@@ -2785,12 +2998,18 @@ export function selectStatusBar(state) {
                     ? `type message · enter queues · enter on empty sends batch · up/down recall pending · alt-enter newline · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`
                     : hasOutbox
                         ? `type message · enter queues behind durable items · up/down recall pending · alt-enter newline · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`
-                        : `type message · enter send · alt-enter newline · T themes · arrows move · alt-left/right word · alt-delete word · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`,
+                        : `type message · enter send · alt-enter newline · T themes · ? help · arrows move · alt-left/right word · alt-delete word · @ artifacts · @@ sessions · ${paneFullscreen ? "esc pane" : "esc sessions"}`,
     };
 
+    let right = hints[focus] || hints[FOCUS_REGIONS.SESSIONS];
+    // Surface the Stop-turn hint at the front (so truncation never eats it)
+    // exactly while a turn is running; it stays listed, grayed, in `?` help.
+    if (canStopSessionTurn(selectActiveSession(state))) {
+        right = `ctrl-x stop · ${right}`;
+    }
     return {
         left: state.ui.statusText,
-        right: hints[focus] || hints[FOCUS_REGIONS.SESSIONS],
+        right,
     };
 }
 
@@ -3355,6 +3574,77 @@ function buildNodeMapHeaderLine(nodeLabels, colWidth) {
     return runs;
 }
 
+const SEQ_REASONING_EFFORTS = new Set(["low", "medium", "high", "xhigh", "minimal", "none"]);
+
+function shortModelForSequence(value) {
+    const model = String(value || "").trim();
+    if (!model) return "unknown";
+    const parts = model.split(":").filter(Boolean);
+    if (parts.length === 0) return "unknown";
+    const last = String(parts[parts.length - 1]).toLowerCase();
+    const index = parts.length > 1 && SEQ_REASONING_EFFORTS.has(last) ? parts.length - 2 : parts.length - 1;
+    return parts[Math.max(0, index)] || parts[0] || "unknown";
+}
+
+function formatTokenCountK(value) {
+    const tokens = Number(value || 0);
+    if (!Number.isFinite(tokens)) return "?K";
+    const scaled = tokens / 1000;
+    return `${scaled.toFixed(Math.abs(scaled) >= 10 ? 1 : 2)}K`;
+}
+
+function formatSeqCount(value) {
+    return Number(value || 0).toLocaleString("en-US");
+}
+
+// Turn index -> turn_completed event data, mirroring the portal's per-turn
+// completion model so the TUI sequence tab can show the same detail.
+export function buildSequenceCompletionByTurn(events) {
+    const map = new Map();
+    for (const event of events || []) {
+        if (event?.eventType !== "session.turn_completed") continue;
+        const turn = Number(event?.data?.turnIndex ?? event?.data?.iteration);
+        if (!Number.isFinite(turn)) continue;
+        map.set(turn, event.data || {});
+    }
+    return map;
+}
+
+// The magenta "Mod: ..." divider (+ optional detail lines) inserted under a
+// completed-turn row when the TUI sequence tab is showing turn expansion.
+function buildSequenceTurnLines(data, { expanded, selected, maxWidth }) {
+    const caret = expanded ? "v" : ">";
+    const model = shortModelForSequence(data?.model);
+    const dur = data?.durationMs != null ? `${(Number(data.durationMs) / 1000).toFixed(1)}s` : "n/a";
+    const dividerText = `${caret} Mod: ${model}  tok ${formatTokenCountK(data?.tokensInput)}/${formatTokenCountK(data?.tokensOutput)}  dur ${dur}`;
+    const lines = [];
+    if (selected) {
+        lines.push(buildActiveHighlightLine(padDisplayText(dividerText, Math.max(18, maxWidth))));
+    } else {
+        lines.push([{ text: dividerText, color: "magenta" }]);
+    }
+    if (expanded) {
+        const details = [
+            ["model", data?.reasoningEffort ? `${data?.model || "(unknown)"}:${data.reasoningEffort}` : (data?.model || "(unknown)")],
+            ["duration", data?.durationMs != null ? `${formatSeqCount(data.durationMs)} ms` : null],
+            ["tokens", `${formatSeqCount(data?.tokensInput)} in / ${formatSeqCount(data?.tokensOutput)} out`],
+            ["cache", `${formatSeqCount(data?.tokensCacheRead)} read / ${formatSeqCount(data?.tokensCacheWrite)} write`],
+            ["tools", `${formatSeqCount(data?.toolCalls)} calls / ${formatSeqCount(data?.toolErrors)} errors`],
+            ["names", Array.isArray(data?.toolNames) && data.toolNames.length ? data.toolNames.join(", ") : null],
+            ["worker", data?.workerNodeId || null],
+            ["result", data?.resultType || null],
+            ["error", data?.errorMessage || null],
+        ].filter(([, value]) => value != null && value !== "");
+        for (const [label, value] of details) {
+            lines.push([
+                { text: `      ${label}: `, color: "gray" },
+                { text: String(value), color: "white" },
+            ]);
+        }
+    }
+    return lines;
+}
+
 function buildSequenceViewForSession(state, session, maxWidth, options = {}) {
     const allowWideColumns = Boolean(options?.allowWideColumns);
     const statsLines = buildSequenceStatsLines(state, session, maxWidth);
@@ -3396,6 +3686,29 @@ function buildSequenceViewForSession(state, session, maxWidth, options = {}) {
         Math.floor((availableWidth - timeWidth - 1 - gapWidth) / Math.max(1, nodeLabels.length)),
     );
 
+    const expansion = options?.sequenceExpansion || null;
+    const completionByTurn = expansion ? buildSequenceCompletionByTurn(history?.events || []) : null;
+    const expandedTurns = expansion ? new Set((expansion.expandedTurns || []).map(Number)) : null;
+    const selectedTurn = expansion && expansion.selectedTurn != null ? Number(expansion.selectedTurn) : null;
+
+    const lines = [];
+    for (const entry of visibleEntries) {
+        lines.push(buildSequenceEventLine(entry, nodeLabels, timeWidth, colWidth));
+        if (expansion && entry.completedTurn != null) {
+            const turn = Number(entry.completedTurn);
+            const data = completionByTurn.get(turn);
+            if (data) {
+                for (const detailLine of buildSequenceTurnLines(data, {
+                    expanded: expandedTurns.has(turn),
+                    selected: selectedTurn === turn,
+                    maxWidth: availableWidth,
+                })) {
+                    lines.push(detailLine);
+                }
+            }
+        }
+    }
+
     return {
         stickyLines: [
             ...statsLines,
@@ -3403,7 +3716,7 @@ function buildSequenceViewForSession(state, session, maxWidth, options = {}) {
             buildSequenceHeaderLine(nodeLabels, timeWidth, colWidth),
             buildSequenceDividerLine(nodeLabels, timeWidth, colWidth),
         ],
-        lines: visibleEntries.map((entry) => buildSequenceEventLine(entry, nodeLabels, timeWidth, colWidth)),
+        lines,
     };
 }
 
@@ -5184,7 +5497,7 @@ export function selectInspector(state, options = {}) {
     switch (activeTab) {
         case "sequence": {
             const sequenceView = session
-                ? buildSequenceViewForSession(state, session, maxWidth, { allowWideColumns })
+                ? buildSequenceViewForSession(state, session, maxWidth, { allowWideColumns, sequenceExpansion: options?.sequenceExpansion || null })
                 : { stickyLines: [], lines: ["No session selected."] };
             stickyLines = sequenceView.stickyLines || [];
             lines = sequenceView.lines;
@@ -5369,6 +5682,100 @@ function buildThemeSwatchRuns(entries = []) {
     return runs;
 }
 
+const KEYBINDING_HELP = [
+    { section: "Global", bindings: [
+        ["Tab / Shift-Tab", "focus next / previous pane"],
+        ["h l   ← →", "focus left / right pane"],
+        ["p", "focus the prompt"],
+        ["[  ]", "shrink / grow the focused pane"],
+        ["{  }", "grow left / right column"],
+        ["v", "fullscreen the focused pane"],
+        ["n / r", "new session / refresh"],
+        ["a", "linked items — artifacts to download, links to open"],
+        ["m", "cycle inspector tab"],
+        ["c / d / D", "cancel / done / delete session"],
+        ["ctrl-x  (ctrl-esc)", "stop the current turn", { dim: true }],
+        ["T / N / A", "theme / model / admin"],
+        ["?", "toggle this help"],
+        ["q", "quit (double-tap)"],
+        ["Esc", "back / focus sessions"],
+    ] },
+    { section: "Sessions pane", bindings: [
+        ["j k   ↑ ↓", "move selection"],
+        ["ctrl-u / ctrl-d", "page up / down"],
+        ["ctrl-g", "move to group"],
+        ["+ / -", "expand / collapse subtree"],
+        ["t", "rename"],
+        ["P", "pin / unpin"],
+        ["V / space", "select mode / toggle selection"],
+        ["f", "filter"],
+    ] },
+    { section: "Chat / transcript", bindings: [
+        ["s", "toggle transcript / summary"],
+        ["j k   ↑ ↓", "scroll"],
+        ["ctrl-u / ctrl-d", "page"],
+        ["e", "expand older history"],
+        ["g / G", "top / bottom"],
+    ] },
+    { section: "Inspector pane", bindings: [
+        ["← →   m", "previous / next / cycle tab"],
+        ["j k", "scroll"],
+        ["enter", "expand / collapse a turn (Sequence tab)"],
+        ["logs", "t tail · f filter"],
+        ["stats", "f cycle session/fleet/users"],
+        ["files", "a download · x delete · u upload · o open · f filter · v full"],
+        ["history", "r refresh · a export · f format"],
+    ] },
+    { section: "Activity pane", bindings: [
+        ["j k   ↑ ↓", "scroll"],
+        ["g / G", "top / bottom"],
+    ] },
+    { section: "Prompt", bindings: [
+        ["enter", "send"],
+        ["alt/ctrl-j", "newline"],
+        ["ctrl-a", "attach artifact"],
+        ["@ / @@", "artifact / session reference"],
+    ] },
+    { section: "Overlays", bindings: [
+        ["Esc / q", "close"],
+        ["enter", "confirm / apply"],
+        ["j k   ↑ ↓", "navigate"],
+        ["Tab", "switch modal pane"],
+    ] },
+];
+
+export function buildHelpModalRows() {
+    const rows = [];
+    const keysWidth = 18;
+    for (const group of KEYBINDING_HELP) {
+        if (rows.length > 0) rows.push([{ text: "", color: "gray" }]);
+        rows.push([{ text: group.section, color: "cyan", bold: true }]);
+        for (const [keys, desc, opts] of group.bindings) {
+            const dim = Boolean(opts?.dim);
+            rows.push([
+                { text: "  " + String(keys).padEnd(keysWidth), color: dim ? "gray" : "yellow" },
+                { text: String(desc), color: dim ? "gray" : "white" },
+            ]);
+        }
+    }
+    return rows;
+}
+
+// TUI-only help overlay (the portal relies on tooltips). Reuses the single
+// modal slot; opened with `?` and dismissed with `?`/Esc.
+export function selectHelpModal(state, maxWidth = 88) {
+    const modal = state.ui?.modal;
+    if (!modal || modal.type !== "help") return null;
+    const rows = buildHelpModalRows();
+    const selectedRowIndex = Math.max(0, Math.min(Number(modal.selectedIndex) || 0, rows.length - 1));
+    return {
+        title: "Keybindings — ? or Esc to close",
+        idealWidth: Math.max(64, Math.min(maxWidth, 88)),
+        rows,
+        selectedRowIndex,
+    };
+}
+
 export function selectThemePickerModal(state, maxWidth = 80) {
     const modal = state.ui.modal;
     if (!modal || modal.type !== "themePicker") return null;

package/ui/core/src/state.js

@@ -126,6 +126,8 @@ export function createInitialState({ mode = "local", branding = null, themeId =
         ui: {
             focusRegion: FOCUS_REGIONS.SESSIONS,
             inspectorTab: INSPECTOR_TABS[0],
+            sequenceExpandedTurns: [],
+            sequenceSelectedTurn: null,
             chatViewMode: chatViewMode === "summary" ? "summary" : "transcript",
             statsViewMode: "session",
             prompt: "",
@@ -245,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/chat-status.js

@@ -2,6 +2,28 @@ import React from "react";
 
 const DOT_FRAMES = [".\u00a0\u00a0", "..\u00a0", "..."];
 
+const SPINNER_FRAMES = ["\u280b", "\u2819", "\u2839", "\u2838", "\u283c", "\u2834", "\u2826", "\u2827", "\u2807", "\u280f"];
+
+// Braille spinner frame that advances while `active`, for the live activity
+// line's leading marker. Returns "" when inactive so callers can fall back to a
+// static glyph.
+export function useSpinnerFrame(active, intervalMs = 120) {
+    const [frameIndex, setFrameIndex] = React.useState(0);
+
+    React.useEffect(() => {
+        if (!active) {
+            setFrameIndex(0);
+            return undefined;
+        }
+        const timer = setInterval(() => {
+            setFrameIndex((current) => (current + 1) % SPINNER_FRAMES.length);
+        }, intervalMs);
+        return () => clearInterval(timer);
+    }, [active, intervalMs]);
+
+    return active ? SPINNER_FRAMES[frameIndex] : "";
+}
+
 export function useAnimatedDots(active, intervalMs = 360) {
     const [frameIndex, setFrameIndex] = React.useState(0);