pilotswarm 0.5.1 → 0.5.3

package/ui/core/src/selectors.js

@@ -10,7 +10,6 @@ import {
     decorateArtifactLinksForChat,
     extractArtifactLinks,
     extractHttpLinks,
-    formatDisplayDateTime,
     formatHumanDurationSeconds,
     formatTimestamp,
     padRunsToDisplayWidth,
@@ -21,9 +20,9 @@ import {
     wrapRunsToDisplayWidth,
 } from "./formatting.js";
 import {
+    computeContextPercent,
     getContextCompactionBadge,
     getContextHeaderBadge,
-    getContextListBadge,
 } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
 import { normalizeArtifactEntries } from "./state.js";
@@ -217,19 +216,22 @@ function ownerInitials(owner) {
 }
 
 function shouldDecorateSessionOwners(state) {
-    if (state.auth?.principal) return true;
+    // Decorate owners only when the list actually surfaces more than one
+    // distinct human owner — otherwise the owner chip is pure noise on every
+    // row (you are always "you"). A narrowed owner filter is an explicit
+    // multi-user context, so honor that too.
     if (state.sessions?.ownerFilter && state.sessions.ownerFilter.all !== true) return true;
-    if (Object.values(state.sessions?.byId || {}).some((session) => session?.owner)) return true;
+    const owners = new Set();
+    for (const session of Object.values(state.sessions?.byId || {})) {
+        if (!session || session.isSystem || session.isGroup) continue;
+        const key = ownerKeyForOwner(session.owner);
+        if (!key) continue;
+        owners.add(key);
+        if (owners.size > 1) return true;
+    }
     return false;
 }
 
-function buildSessionListTitle(session, brandingTitle, decorateOwners = false) {
-    const title = buildSessionTitle(session, brandingTitle);
-    if (!decorateOwners || session?.isSystem) return title;
-    const prefix = session?.owner ? ownerInitials(session.owner) : "?";
-    return `(${prefix}) ${title}`;
-}
-
 function groupMemberSessions(group, byId = {}) {
     if (!group?.isGroup || !group?.groupId) return [];
     return Object.values(byId || {}).filter((session) => (
@@ -575,68 +577,118 @@ function buildSessionRowView(entry, session, state, totalDescendantCounts, visib
 
     const mainColor = session?.isGroup ? "cyan" : session?.isSystem ? "yellow" : sessionStatusColor(session, mode);
     const effectiveOwner = effectiveSessionOwner(session, state.sessions?.byId || {});
-    const titleText = buildSessionListTitle(
-        effectiveOwner !== (session?.owner ?? null) ? { ...session, owner: effectiveOwner } : session,
-        state.branding?.title || "PilotSwarm",
-        shouldDecorateSessionOwners(state),
-    );
-    // Show the session's last-updated time at the end of the row. For groups,
-    // keep the member-count badge but append the last-updated timestamp so the
-    // row reflects the same value the list is sorted by. `formatDisplayDateTime`
-    // uses the system locale/timezone, so the timestamp renders in the
-    // browser/client local zone.
+
+    const shortId = shortSessionId(session?.sessionId);
+
+    // Row age — last-updated (the value the list is sorted by). Coarse buckets
+    // so it doesn't tick every second: <1min · Nmin · NhMMm · NdHHh · Nw.
     const rowTimestampMs = session?.updatedAt
         || session?.summaryUpdatedAt
         || session?.latestSummaryUpdatedAt
         || session?.createdAt
         || 0;
-    const formattedRowTimestamp = rowTimestampMs ? formatDisplayDateTime(rowTimestampMs) : "";
-    const titleRuns = [
-        ...prefixRuns,
-        {
-        text: titleText,
-        color: mainColor,
-        bold: Boolean(session?.isSystem),
-        },
-    ];
+    const relTime = rowTimestampMs ? formatSessionAge(rowTimestampMs) : "";
+    const modelLabel = shortModelReasoningLabel(session?.model, session?.reasoningEffort);
+
+    // A regular session with no human title otherwise renders as a bare
+    // "(guid)" — an empty, ugly line. For those, pull the meta (id · age ·
+    // model) UP onto the main line so it carries information. Titled rows keep
+    // the title on the line and expand id·age·model·ctx only when selected.
+    const rawTitle = session?.isSystem
+        ? canonicalSystemTitle(session, state.branding?.title || "PilotSwarm")
+        : buildSessionDisplayTitle(session);
+    const hasRealTitle = Boolean(session?.isSystem || session?.isGroup || (rawTitle && rawTitle.trim()));
+
+    const titleRuns = [...prefixRuns];
+    // Owner chip — only when the list actually surfaces more than one human
+    // owner (shouldDecorateSessionOwners). Otherwise it's noise on every row.
+    if (shouldDecorateSessionOwners(state) && !session?.isSystem && !session?.isGroup) {
+        const initials = effectiveOwner ? ownerInitials(effectiveOwner) : "?";
+        titleRuns.push({ text: `${initials} · `, color: "cyan" });
+    }
+    if (hasRealTitle) {
+        titleRuns.push({ text: rawTitle, color: mainColor, bold: Boolean(session?.isSystem || session?.isGroup) });
+    } else {
+        // Untitled → id · age · model on one line (no wasted title line).
+        titleRuns.push({ text: shortId, color: mainColor });
+        if (relTime) { titleRuns.push({ text: " · ", color: "gray" }); titleRuns.push({ text: relTime, color: "gray" }); }
+        if (modelLabel) { titleRuns.push({ text: " · ", color: "gray" }); titleRuns.push({ text: modelLabel, color: "green" }); }
+    }
+
     const collapseBadge = getCollapseBadge(session?.sessionId, entry, totalDescendantCounts, visibleDescendantCounts);
     if (collapseBadge) {
         titleRuns.push({ text: ` ${collapseBadge.text}`, color: collapseBadge.color, bold: collapseBadge.bold });
     }
+    // Scheduled sessions keep a compact clock glyph on the title; the full
+    // cron cadence rides in the detail line.
+    const cronBadge = getCronBadge(session);
+    if (cronBadge) {
+        titleRuns.push({ text: " ⏱", color: "magenta" });
+    }
 
+    // Right-column context %: on every row that has usage. Compaction in
+    // flight takes precedence; else green normally, amber ≥70, red ≥85.
+    const ctxRuns = [];
+    const compactionState = session?.contextUsage?.compaction?.state;
+    const ctxPercent = computeContextPercent(session?.contextUsage);
+    if (session?.isGroup) {
+        if (session?.memberCount != null) ctxRuns.push({ text: `${session.memberCount}`, color: "gray" });
+    } else if (compactionState === "running") {
+        ctxRuns.push({ text: "⇊", color: "magenta" });
+    } else if (compactionState === "failed") {
+        ctxRuns.push({ text: "!", color: "red" });
+    } else if (ctxPercent != null) {
+        ctxRuns.push({ text: `${ctxPercent}%`, color: ctxPercent >= 85 ? "red" : ctxPercent >= 70 ? "yellow" : "green" });
+    } else {
+        ctxRuns.push({ text: "—", color: "gray" });
+    }
+
+    // Kept for backward-compat consumers; groups carry a member/time meta.
     const metaRuns = [];
     if (session?.isGroup && session?.memberCount != null) {
         metaRuns.push({ text: `${session.memberCount} member${session.memberCount === 1 ? "" : "s"}`, color: "gray" });
+        if (relTime) { metaRuns.push({ text: " · ", color: "gray" }); metaRuns.push({ text: relTime, color: "gray" }); }
     }
-    if (formattedRowTimestamp) {
-        if (metaRuns.length > 0) metaRuns.push({ text: " · ", color: "gray" });
-        metaRuns.push({ text: formattedRowTimestamp, color: "gray" });
-    }
-
-    const badgeRuns = [];
 
-    for (const badge of [
-        getCronBadge(session),
-        getContextListBadge(session?.contextUsage),
-    ]) {
-        if (!badge) continue;
-        if (badgeRuns.length > 0) badgeRuns.push({ text: " ", color: "gray" });
-        badgeRuns.push({ text: badge.text, color: badge.color, bold: badge.bold });
+    // Detail — expanded under the SELECTED row. Titled rows repeat
+    // id · age · model here; untitled rows already carry those on the main
+    // line, so their detail starts at the ctx breakdown to avoid repetition.
+    const detailRuns = [];
+    const pushSep = () => { if (detailRuns.length) detailRuns.push({ text: " · ", color: "gray" }); };
+    if (session?.isGroup) {
+        detailRuns.push(...metaRuns);
+    } else {
+        if (hasRealTitle) {
+            detailRuns.push({ text: shortId, color: "cyan" });
+            if (relTime) { pushSep(); detailRuns.push({ text: relTime, color: "gray" }); }
+            if (modelLabel) { pushSep(); detailRuns.push({ text: modelLabel, color: "green" }); }
+        }
+        const cu = session?.contextUsage;
+        if (cu && Number.isFinite(cu.currentTokens) && Number.isFinite(cu.tokenLimit) && cu.tokenLimit > 0) {
+            pushSep();
+            detailRuns.push({ text: `ctx ${formatCompactNumber(cu.currentTokens)}/${formatCompactNumber(cu.tokenLimit)}`, color: "gray" });
+        }
+        const childCount = totalDescendantCounts?.[session?.sessionId];
+        if (childCount) { pushSep(); detailRuns.push({ text: `${childCount} child${childCount === 1 ? "" : "ren"}`, color: "gray" }); }
+        if (cronBadge) { pushSep(); detailRuns.push({ text: cronBadge.text, color: cronBadge.color }); }
     }
 
-    const selectedMetaRuns = buildSelectedSessionMetaRuns(session, mode);
+    // Flat runs for the TUI: title + (for titled rows) dim age + context.
     const runs = [
         ...titleRuns,
-        ...(metaRuns.length > 0 ? [{ text: " ", color: "gray" }, ...metaRuns] : []),
-        ...(badgeRuns.length > 0 ? [{ text: " ", color: "gray" }, ...badgeRuns] : []),
+        ...(hasRealTitle && relTime && !session?.isGroup ? [{ text: "  ", color: "gray" }, { text: relTime, color: "gray" }] : []),
+        ...(ctxRuns.length && !session?.isGroup ? [{ text: " · ", color: "gray" }, ...ctxRuns] : []),
+        ...(session?.isGroup && metaRuns.length ? [{ text: " ", color: "gray" }, ...metaRuns] : []),
     ];
 
     return {
         runs,
         titleRuns,
+        ctxRuns,
         metaRuns,
-        badgeRuns,
-        selectedMetaRuns,
+        badgeRuns: [],
+        selectedMetaRuns: detailRuns,
+        detailRuns,
     };
 }
 
@@ -1245,9 +1297,16 @@ function buildChatMessagePrefix(message) {
         glyph = "x";
         glyphColor = "red";
     } else if (message?.role === "user" && !message?.optimistic && !message?.pendingPhase) {
-        // Real durable user.message in transcript — show the "sent" double-check.
-        glyph = "✓✓";
-        glyphColor = "green";
+        if (message?.stopped) {
+            // Delivered, but its turn was user-stopped mid-flight — the model
+            // may not have acted on it. Amber prohibition ("no parking") sign.
+            glyph = "⊘";
+            glyphColor = "yellow";
+        } else {
+            // Real durable user.message in transcript — show the "sent" double-check.
+            glyph = "✓✓";
+            glyphColor = "green";
+        }
     }
 
     const roleColor = message?.pendingPhase === "pending"
@@ -1887,60 +1946,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 +1959,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 +2047,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 +2799,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 +2840,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 +2852,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,
     };
 }
@@ -4607,6 +4697,23 @@ function formatRelativeTime(ts) {
     return `${Math.floor(ms / 86_400_000)}d ago`;
 }
 
+// Coarse session-age buckets for the list. Seconds tick too fast and just
+// distract, so the smallest bucket is "<1min"; then whole minutes to an hour,
+// then hours+minutes, then days+hours, then weeks. No "ago" suffix — the age
+// column context makes it clear.
+function formatSessionAge(ts) {
+    if (!ts) return "—";
+    const ms = Date.now() - ts;
+    if (ms < 60_000) return "<1min";
+    const totalMin = Math.floor(ms / 60_000);
+    if (totalMin < 60) return `${totalMin}min`;
+    const totalHours = Math.floor(totalMin / 60);
+    if (totalHours < 24) return `${totalHours}h${String(totalMin % 60).padStart(2, "0")}m`;
+    const days = Math.floor(totalHours / 24);
+    if (days < 14) return `${days}d${String(totalHours % 24).padStart(2, "0")}h`;
+    return `${Math.floor(days / 7)}w`;
+}
+
 function formatLocalTimestamp(ts) {
     if (!ts) return "—";
     const date = ts instanceof Date ? ts : new Date(ts);

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