pilotswarm 0.5.69 → 0.5.71

package/package.json

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

package/ui/core/src/controller.js

@@ -7545,6 +7545,7 @@ export class PilotSwarmUiController {
         force = true,
         fullscreen = false,
         pane = false,
+        preserveSession = false,
     } = {}) {
         const resolvedSessionId = sessionId || this.getState().sessions.activeSessionId;
         const name = String(filename || "").trim();
@@ -7558,7 +7559,7 @@ export class PilotSwarmUiController {
             restoreArtifactId: this.getState().files.selectedArtifactId || null,
         });
 
-        if (this.getState().sessions.activeSessionId !== resolvedSessionId) {
+        if (!preserveSession && this.getState().sessions.activeSessionId !== resolvedSessionId) {
             await this.loadSession(resolvedSessionId).catch(() => null);
         }
         // The reader REPLACES the inspector, so it has no business changing
@@ -8996,6 +8997,7 @@ export class PilotSwarmUiController {
             return;
         }
 
+        this.dispatch({ type: "sessions/used", sessionId });
         const activePendingQuestion = activeSession?.pendingQuestion || null;
         const answeringPendingQuestion = Boolean(activePendingQuestion?.question);
         const promptEdit = this.getPromptEditSessionMatch(sessionId);

package/ui/core/src/history.js

@@ -3,7 +3,7 @@ import { isCanvasActionContent, parseCanvasActionContent } from "./canvas-action
 import { formatCompactionActivityRuns } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
 import { matchesSessionError } from "./session-warning.js";
-import { appendNativeTaskEvent } from "./native-tasks.js";
+import { appendNativeTaskEvent, appendNativeTaskCall } from "./native-tasks.js";
 import { buildSessionWarning } from "./session-errors.js";
 import { appendChatCall, CHAT_CALL_EVENT_TYPES } from "./chat-activity.js";
 
@@ -21,6 +21,7 @@ export const HISTORY_EVENT_LIMIT_STEPS = [
 // load transcript pages instead of raw-stream pages.
 export const CHAT_HISTORY_EVENT_TYPES = [
     ...CHAT_CALL_EVENT_TYPES,
+    ...CHAT_CALL_EVENT_TYPES.filter(type => type !== "session.agent_spawned").map(type => `native.${type}`),
     "user.message",
     "assistant.message",
     // Needed to distinguish interim assistant output from the final answer
@@ -137,6 +138,7 @@ function appendSessionWarning(chat, event) {
 
 const parentChatCallTypes = new Set(CHAT_CALL_EVENT_TYPES);
 function appendParentChatCall(chat, event) {
+    if (appendNativeTaskCall(chat, event)) return;
     if (!parentChatCallTypes.has(event?.eventType)) return;
     const data = event?.data || {};
     // Native tasks have their own abridged disclosure. Generic call cards

package/ui/core/src/moa.js

@@ -42,7 +42,7 @@ export function normalizeMoa(value) {
             return safeLayout(dashboard, key, `MoA ${index + 1}`);
         });
         if (!dashboards.length) dashboards.push(safeLayout(null));
-        return { version: 3, activeDashboardId: dashboards.some(d => d.id === value.activeDashboardId) ? value.activeDashboardId : dashboards[0].id, dashboards };
+        return { version: 3, composerMode: value?.composerMode === "shared" ? "shared" : "per-chat", activeDashboardId: dashboards.some(d => d.id === value.activeDashboardId) ? value.activeDashboardId : dashboards[0].id, dashboards };
     }
     let source = value;
     if (!(value?.version === 2 || (object(value) && Object.hasOwn(value, "tree")))) {
@@ -51,7 +51,7 @@ export function normalizeMoa(value) {
         const active = Number.isInteger(value?.activeSlot) ? Math.max(0, Math.min(4, value.activeSlot)) : 0;
         source = safeLayout(slots[active]).tree ? slots[active] : slots.find(slot => safeLayout(slot).tree);
     }
-    return { version: 3, activeDashboardId: "moa-1", dashboards: [safeLayout(source)] };
+    return { version: 3, composerMode: value?.composerMode === "shared" ? "shared" : "per-chat", activeDashboardId: "moa-1", dashboards: [safeLayout(source)] };
 }
 export const activeMoaDashboard = value => value.dashboards.find(d => d.id === value.activeDashboardId) || value.dashboards[0];
 export function updateMoaDashboard(value, dashboardId, patch) {

package/ui/core/src/native-tasks.js

@@ -1,3 +1,5 @@
+import { appendChatCall, CHAT_CALL_EVENT_TYPES } from "./chat-activity.js";
+
 // Native Copilot work is local to one parent turn. Durable spawn_agent
 // sessions deliberately do not enter this projection.
 const TERMINAL = new Set(["completed", "failed", "cancelled", "interrupted"]);
@@ -61,6 +63,7 @@ function updateTask(chat, patch, event, { authoritative = false } = {}) {
         if (previous?.inferredTerminal) next.error = patch.error || "";
     }
     next.title = clip(next.title, 160) || "Native task";
+    if (next.title === "Native task" && previous?.title) next.title = previous.title;
     next.preview = clip(next.preview);
     next.result = clip(next.result, 4000);
     next.error = clip(next.error, 1000);
@@ -89,6 +92,47 @@ function updateTask(chat, patch, event, { authoritative = false } = {}) {
     }
 }
 
+// Correlate by runtime identity, never by tool name or arrival time. External
+// callbacks may arrive before the child event; move that existing disclosure
+// under its owner as soon as the explicit relationship becomes available.
+export function appendNativeTaskCall(chat, event) {
+    const type = (event?.eventType || "").replace(/^native\./, "");
+    if (!CHAT_CALL_EVENT_TYPES.includes(type) || type === "session.agent_spawned") return false;
+    const data = event.data || {};
+    const explicit = Boolean(data.nativeAgentId || data.parentToolCallId || event.eventType.startsWith("native."));
+    const keys = [data.toolCallId && `call:${data.toolCallId}`, data.requestId && `request:${data.requestId}`].filter(Boolean);
+    let match = explicit ? findTask(chat, { toolCallId: data.parentToolCallId, agentId: data.nativeAgentId }) : null;
+    const namespace = `${event.sessionId}:${data.durableSessionId || ""}`;
+    if (!match && !explicit) {
+        for (let g = chat.length - 1; g >= 0 && !match; g--) {
+            if (chat[g].kind !== "native-task-group") continue;
+            const t = chat[g].tasks.findIndex(task => task.calls?.some(call => call.namespace === namespace
+                && call.callKeys.some(key => keys.includes(key))));
+            if (t >= 0) match = { groupIndex: g, taskIndex: t };
+        }
+    }
+    if (!match && explicit && (data.parentToolCallId || data.nativeAgentId)) {
+        updateTask(chat, { toolCallId: data.parentToolCallId, agentId: data.nativeAgentId, status: "running" }, event);
+        match = findTask(chat, { toolCallId: data.parentToolCallId, agentId: data.nativeAgentId });
+    }
+    if (!match) return explicit; // Unknown child activity must not impersonate the parent.
+    const group = chat[match.groupIndex];
+    const task = group.tasks[match.taskIndex];
+    const calls = [...(task.calls || [])];
+    for (let i = chat.length - 1; i >= 0; i--) {
+        const call = chat[i];
+        if (call.kind !== "chat-call" || call.namespace !== namespace || !call.callKeys.some(key => keys.includes(key))) continue;
+        if (!calls.some(item => item.callKeys.some(key => call.callKeys.includes(key)))) calls.push(call);
+        chat.splice(i, 1);
+    }
+    appendChatCall(calls, { ...event, eventType: type });
+    const tasks = [...group.tasks];
+    tasks[match.taskIndex] = { ...task, calls, toolCalls: Math.max(task.toolCalls || 0, calls.length) };
+    // Removing a parent disclosure can shift the group's index.
+    chat[chat.indexOf(group)] = { ...group, tasks };
+    return true;
+}
+
 export function appendNativeTaskEvent(chat, event) {
     const type = event?.eventType || "";
     const data = event?.data || {};
@@ -119,7 +163,7 @@ export function appendNativeTaskEvent(chat, event) {
     const previous = found ? chat[found.groupIndex].tasks[found.taskIndex] : null;
     if (!previous && !lifecycle && !taskTool) return;
     if (!previous || taskTool || type === "subagent.started") Object.assign(patch, {
-        title: args.description || data.agentDisplayName || args.name || data.agentName || "Native task",
+        title: args.description || args.name || (previous?.title !== "Native task" ? previous?.title : null) || data.agentDisplayName || "Native task",
         profile: args.agent_type || data.agentName || data.agentType,
         model: data.model,
     });
@@ -145,7 +189,7 @@ export function appendNativeTaskEvent(chat, event) {
     } else if (type === "native.tool.execution_start") {
         const ids = previous.toolCallIds || [];
         patch.toolCallIds = data.toolCallId && !ids.includes(data.toolCallId) ? [...ids, data.toolCallId].slice(-500) : ids;
-        patch.toolCalls = (previous.toolCalls || 0) + (patch.toolCallIds !== ids ? 1 : 0);
+        patch.toolCalls = Math.max(previous.toolCalls || 0, patch.toolCallIds.length);
         patch.preview = args.description || (data.toolName ? `Using ${data.toolName}` : "Working");
     } else if (type === "native.assistant.message") {
         // Do not expose reasoning, tool arguments, or the whole child transcript.

package/ui/core/src/reducer.js

@@ -1,3 +1,4 @@
+import { normalizeSessionSortMode, normalizeSessionUsage, reconcileSessionSort } from "./session-sort.js";
 import { normalizeMoa } from "./moa.js";
 import { retainSessionWarnings } from "./session-errors.js";
 import { buildSessionTree, isManuallyOrderableSession } from "./session-tree.js";
@@ -846,7 +847,7 @@ export function appReducer(state, action) {
     if (sessionId && contentUpdate && state.sessions?.goneIds?.includes(sessionId)) return state;
     const next = baseReducer(state, action);
     if (next === state) return next;
-    return reconcileSessionView(state, next, action);
+    return reconcileSessionView(state, reconcileSessionSort(state, next, action), action);
 }
 
 // Per-session desktop views, kept in step with the ui slice.
@@ -1101,6 +1102,7 @@ function baseReducer(state, action) {
             const nextActiveSessionId = hasActive
                 ? normalizeStoredActiveSessionId(settings.activeSessionId)
                 : state.sessions.activeSessionId;
+            const remoteUsage = normalizeSessionUsage(settings.sessionUsedAt);
             const nextSessions = {
                 ...state.sessions,
                 ...(hasOwnerFilter
@@ -1117,6 +1119,9 @@ function baseReducer(state, action) {
                     : {}),
                 pinnedIds: nextPinnedIds,
                 manualOrder: nextManualOrder,
+                sortMode: Object.hasOwn(settings, "sessionSortMode") ? normalizeSessionSortMode(settings.sessionSortMode) : state.sessions.sortMode,
+                usedAt: Object.fromEntries([...new Set([...Object.keys(remoteUsage), ...Object.keys(state.sessions.usedAt || {})])]
+                    .map(id => [id, Math.max(remoteUsage[id] || 0, state.sessions.usedAt?.[id] || 0)])),
                 collapsedIds: nextCollapsedIds,
                 collapsedIdsExplicit: hasCollapsed ? true : state.sessions.collapsedIdsExplicit,
                 activeSessionId: nextActiveSessionId,
@@ -1891,8 +1896,15 @@ function baseReducer(state, action) {
             };
         }
 
+        case "sessions/sortMode":
+            return { ...state, sessions: { ...state.sessions, sortMode: normalizeSessionSortMode(action.mode) } };
+        case "sessions/refreshSort":
+            return { ...state, sessions: { ...state.sessions } };
+        case "sessions/used":
+            if (!action.sessionId) return state;
+            return { ...state, sessions: { ...state.sessions, usedAt: { ...state.sessions.usedAt, [action.sessionId]: action.at || Date.now() } } };
         case "sessions/selected": {
-            state = { ...state, sessions: { ...state.sessions, listDeselected: false, localSelectionMade: true } };
+            state = { ...state, sessions: { ...state.sessions, listDeselected: false, localSelectionMade: true, usedAt: action.sessionId ? { ...state.sessions.usedAt, [action.sessionId]: Date.now() } : state.sessions.usedAt } };
             // Per-session chat scroll memory: stash both the outgoing offset
             // and whether it follows the bottom. A paused reading position
             // stays paused as new messages arrive and across session switches.

package/ui/core/src/selectors.js

@@ -638,11 +638,20 @@ function distinctHumanOwnerCount(state, stopAt = Infinity) {
     return owners.size;
 }
 
+const sessionOwnerDecorationCache = new WeakMap();
 function shouldDecorateSessionOwners(state) {
     // One rule: the chip earns its place when the list holds more than one
     // distinct human owner. Otherwise it is noise on every row — you are
     // always "you".
-    return distinctHumanOwnerCount(state, 2) > 1;
+    const byId = state?.sessions?.byId;
+    if (!byId) return false;
+    const filter = state.sessions.ownerFilter;
+    const auth = state.auth;
+    const cached = sessionOwnerDecorationCache.get(byId);
+    if (cached && cached.filter === filter && cached.auth === auth) return cached.value;
+    const value = distinctHumanOwnerCount(state, 2) > 1;
+    sessionOwnerDecorationCache.set(byId, { filter, auth, value });
+    return value;
 }
 
 function groupMemberSessions(group, byId = {}) {
@@ -1293,6 +1302,7 @@ function matchesSearchQuery(value, query) {
 }
 
 const searchedSessionFlatCache = new WeakMap();
+const sessionSearchIndexCache = new WeakMap();
 
 function sessionGroupTitle(session, byId) {
     if (session?.isGroup) return session.title || "";
@@ -1320,20 +1330,17 @@ function sessionSearchOwner(session, byId) {
     return null;
 }
 
-function buildSearchedSessionFlat(state, query) {
-    const existingFlat = Array.isArray(state.sessions?.flat) ? state.sessions.flat : [];
-    if (!query) return existingFlat;
-    const cached = searchedSessionFlatCache.get(existingFlat);
-    if (cached?.query === query) return cached.result;
-
+function sessionSearchIndex(state) {
     const byId = state.sessions?.byId || {};
-    const parsed = parseSessionSearchQuery(query);
+    const deps = [state.sessions?.orderById, state.sessions?.pinnedIds, (state.sessions?.sortMode && state.sessions.sortMode !== "saved" ? state.sessions.sortSnapshot : state.sessions?.manualOrder)];
+    const cached = sessionSearchIndexCache.get(byId);
+    if (cached && sameRowDeps(cached.deps, deps)) return cached;
     const expanded = buildSessionTree(
         Object.values(byId),
         new Set(),
         state.sessions?.orderById,
         state.sessions?.pinnedIds,
-        state.sessions?.manualOrder,
+        (state.sessions?.sortMode && state.sessions.sortMode !== "saved" ? state.sessions.sortSnapshot : state.sessions?.manualOrder),
     );
     const parentById = new Map();
     const entryById = new Map();
@@ -1348,16 +1355,34 @@ function buildSearchedSessionFlat(state, query) {
         baseIndex.set(entry.sessionId, index);
     }
 
+    const documents = new Map(expanded.map(entry => {
+        const session = byId[entry.sessionId] || entry.standIn;
+        return [entry.sessionId, buildSessionSearchDocument(session, {
+            owner: sessionSearchOwner(session, byId), groupTitle: sessionGroupTitle(session, byId),
+        })];
+    }));
+    const index = { deps, expanded, parentById, entryById, baseIndex, documents };
+    sessionSearchIndexCache.set(byId, index);
+    return index;
+}
+
+function buildSearchedSessionFlat(state, query) {
+    const existingFlat = Array.isArray(state.sessions?.flat) ? state.sessions.flat : [];
+    if (!query) return existingFlat;
+    const cached = searchedSessionFlatCache.get(existingFlat);
+    const deps = [state.sessions?.byId, state.sessions?.ownerFilter, state.auth, state.sessions?.orderById,
+        state.sessions?.pinnedIds, (state.sessions?.sortMode && state.sessions.sortMode !== "saved" ? state.sessions.sortSnapshot : state.sessions?.manualOrder), state.sessions?.filterExceptionId];
+    if (cached?.query === query && sameRowDeps(cached.deps, deps)) return cached.result;
+
+    const byId = state.sessions?.byId || {};
+    const parsed = parseSessionSearchQuery(query);
+    const { expanded, parentById, entryById, baseIndex, documents } = sessionSearchIndex(state);
+
     const directScores = new Map();
     for (const entry of expanded) {
         const session = byId[entry.sessionId] || entry.standIn;
         if (!session || !matchesOwnerFilter(session, state.sessions?.ownerFilter, state.auth || {}, byId)) continue;
-        const owner = sessionSearchOwner(session, byId);
-        const document = buildSessionSearchDocument(session, {
-            owner,
-            groupTitle: sessionGroupTitle(session, byId),
-        });
-        const score = scoreSessionSearchDocument(document, parsed);
+        const score = scoreSessionSearchDocument(documents.get(entry.sessionId), parsed);
         if (score > 0) directScores.set(entry.sessionId, score);
     }
     const matchedIds = new Set(directScores.keys());
@@ -1414,7 +1439,7 @@ function buildSearchedSessionFlat(state, query) {
     // A user can type an unbounded number of distinct queries while the
     // catalog array keeps the same identity. Keep only the latest result for
     // that catalog rather than retaining every intermediate keystroke.
-    searchedSessionFlatCache.set(existingFlat, { query, result });
+    searchedSessionFlatCache.set(existingFlat, { query, deps, result });
     return result;
 }
 

package/ui/core/src/session-sort.js

@@ -0,0 +1,45 @@
+import { buildSessionTree } from "./session-tree.js";
+
+export const normalizeSessionSortMode = mode => ["used", "updated"].includes(mode) ? mode : "saved";
+export function normalizeSessionUsage(value) {
+    return Object.fromEntries(Object.entries(value || {}).filter(([id, at]) => id && Number.isFinite(at) && at > 0));
+}
+export function snapshotSessionOrder(sessions, mode) {
+    const saved = buildSessionTree(Object.values(sessions.byId), new Set(), sessions.orderById, sessions.pinnedIds, sessions.manualOrder);
+    const rank = new Map(saved.map((row, index) => [row.sessionId, index]));
+    const timestamp = session => {
+        if (mode === "used") return sessions.usedAt?.[session.sessionId] || 0;
+        const raw = session.updatedAt ?? session.summaryUpdatedAt ?? session.latestSummaryUpdatedAt;
+        const value = typeof raw === "number" ? raw : Date.parse(raw || "");
+        return Number.isFinite(value) ? value : 0;
+    };
+    return Object.values(sessions.byId).sort((a, b) => timestamp(b) - timestamp(a)
+        || (rank.get(a.sessionId) ?? Infinity) - (rank.get(b.sessionId) ?? Infinity))
+        .map(session => session.sessionId);
+}
+
+// Live catalog and usage changes update row contents, never existing positions.
+// A mode change or explicit refresh captures the next order. New rows append.
+export function reconcileSessionSort(previous, next, action) {
+    const sessions = next.sessions;
+    if (!sessions) return next;
+    const mode = normalizeSessionSortMode(sessions.sortMode);
+    const modeChanged = mode !== normalizeSessionSortMode(previous.sessions?.sortMode);
+    const refresh = action.type === "sessions/refreshSort";
+    const rebuild = sessions.flat !== previous.sessions?.flat || sessions.byId !== previous.sessions?.byId || modeChanged || refresh;
+    if (!rebuild) return next;
+    let sortSnapshot = sessions.sortSnapshot;
+    if (mode !== "saved") {
+        if (!sessions.listingSeen) sortSnapshot = [];
+        else if (modeChanged || refresh || !sortSnapshot?.length) sortSnapshot = snapshotSessionOrder(sessions, mode);
+        else {
+            const known = new Set(sortSnapshot);
+            const added = Object.keys(sessions.byId).filter(id => !known.has(id));
+            if (added.length) sortSnapshot = [...sortSnapshot, ...added];
+        }
+    }
+    const flat = mode === "saved" && !modeChanged ? sessions.flat : buildSessionTree(
+        Object.values(sessions.byId), sessions.collapsedIds, sessions.orderById,
+        sessions.pinnedIds, mode === "saved" ? sessions.manualOrder : sortSnapshot);
+    return { ...next, sessions: { ...sessions, sortSnapshot, flat } };
+}

package/ui/core/src/state.js

@@ -480,6 +480,9 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             pinnedIds: normalizeStoredPinnedSessionIds(pinnedSessionIds),
             // Explicit user placement (desktop drag); read by every surface.
             manualOrder: normalizeStoredSessionOrder(sessionOrder),
+            sortMode: "saved",
+            sortSnapshot: [],
+            usedAt: {},
             // Whether a listing of each kind has been processed. "This row is
             // new" is only answerable against a previous listing OF THE SAME
             // KIND — inferring it from byId being non-empty was wrong, because

package/ui/react/src/chat-call-line.js

@@ -0,0 +1,17 @@
+import React from "react";
+
+export function ChatCallLine({ line }) {
+    const [open, setOpen] = React.useState(false);
+    return React.createElement("details", {
+        className: "ps-system-notice ps-chat-call",
+        "data-call-id": line.callKey,
+        onToggle: event => setOpen(event.currentTarget.open),
+    },
+    React.createElement("summary", { className: "ps-system-notice-summary ps-chat-call-summary" },
+        React.createElement("span", { className: "ps-chat-call-tag" }, line.category || "Tool"),
+        React.createElement("span", { className: "ps-system-notice-summary-text" }, line.text),
+        line.status ? React.createElement("span", { className: `ps-chat-call-status${line.status === "Failed" ? " is-failed" : ""}` }, line.status) : null),
+    open ? React.createElement("div", { className: "ps-system-notice-body" },
+        line.time ? React.createElement("div", { className: "ps-chat-call-time" }, line.time) : null,
+        React.createElement("pre", { className: "ps-chat-call-payload" }, line.body)) : null);
+}

package/ui/react/src/native-task-card.js

@@ -1,4 +1,6 @@
 import React from "react";
+import { ChatCallLine } from "./chat-call-line.js";
+import { chatCallLine } from "../../core/src/chat-activity.js";
 import { NATIVE_TASK_LABELS } from "../../core/src/native-tasks.js";
 
 const TERMINAL = new Set(["completed", "failed", "cancelled", "interrupted"]);
@@ -31,29 +33,57 @@ export const NativeTaskCard = React.memo(function NativeTaskCard({ group, colors
             React.createElement("span", { className: "ps-native-tasks-title" },
                 React.createElement("span", { className: "ps-native-task-branch", "aria-hidden": true }, "⑂"), "Native tasks"),
             React.createElement("span", { className: "ps-native-tasks-count", "aria-live": "polite" }, countLabel)),
-        tasks.map(task => {
-            const color = colors[task.status] || colors.running;
-            const preview = task.error || task.result || task.preview || (task.status === "completed" ? "Task completed." : "");
-            const time = duration(task, now);
-            return React.createElement("details", { key: task.id, className: "ps-native-task", "data-task-id": task.id, "data-status": task.status,
-                style: { "--ps-native-task-accent": color } },
-                React.createElement("summary", null,
-                    React.createElement("span", { className: "ps-native-task-mark", "aria-hidden": true }, MARKS[task.status] || "?"),
-                    React.createElement("span", { className: "ps-native-task-main" },
-                        React.createElement("span", { className: "ps-native-task-title" }, task.title),
-                        preview ? React.createElement("span", { className: "ps-native-task-preview" }, preview.replace(/\s+/g, " ").slice(0, 240)) : null),
-                    React.createElement("span", { className: "ps-native-task-meta" },
-                        React.createElement("span", { className: "ps-native-task-status" }, task.telemetryStale ? "Reconnecting" : NATIVE_TASK_LABELS[task.status] || task.status),
-                        React.createElement("span", null, [time, `${task.toolCalls || 0} calls`].filter(Boolean).join(" · "))),
-                    React.createElement("span", { className: "ps-native-task-chevron", "aria-hidden": true }, "›")),
-                React.createElement("div", { className: "ps-native-task-detail" },
-                    React.createElement("div", { className: "ps-native-task-scope" }, [task.profile, task.model, task.reasoningEffort, "Same worker"].filter(Boolean).join(" · ")),
-                    task.result && !task.error ? React.createElement("div", { className: "ps-native-task-scope" }, "Result excerpt") : null,
-                    React.createElement("p", { className: "ps-native-task-result" }, task.error || task.result || task.preview
-                        || (task.status === "completed" ? "Task completed. A result excerpt is not available in this recording." : "No result available yet.")),
-                    task.recentActivity?.length ? React.createElement("ul", { className: "ps-native-task-activity" },
-                        task.recentActivity.map((activity, i) => React.createElement("li", { key: i }, activity.message))) : null));
-        }),
+        tasks.map(task => React.createElement(NativeTask, { key: task.id, task, colors, now })),
         group.tasks.length > 3 ? React.createElement("button", { type: "button", className: "ps-native-tasks-more", "aria-expanded": showAll,
             onClick: () => setShowAll(value => !value) }, showAll ? "Show fewer tasks" : `Show ${group.tasks.length - 3} more tasks`) : null);
 });
+
+function NativeTask({ task, colors, now }) {
+    const failed = ["failed", "cancelled", "interrupted"].includes(task.status);
+    const [open, setOpen] = React.useState(!TERMINAL.has(task.status) || failed);
+    const inspected = React.useRef(false);
+    const viewport = React.useRef(null);
+    const follow = React.useRef(true);
+    const calls = React.useMemo(() => (task.calls || []).map(chatCallLine), [task.calls]);
+    React.useLayoutEffect(() => {
+        if (open && viewport.current && follow.current) viewport.current.scrollTop = viewport.current.scrollHeight;
+    }, [open, calls.length]);
+    React.useEffect(() => {
+        if (failed || !inspected.current) setOpen(!TERMINAL.has(task.status) || failed);
+    }, [task.status, failed]);
+    const preview = task.error || task.result || task.preview || (task.status === "completed" ? "Task completed." : "");
+    const time = duration(task, now);
+    const profile = task.profile === "swarm-explore" ? "Explore" : task.profile === "swarm-task" ? "Task" : "Native task";
+    return React.createElement("details", {
+        className: "ps-native-task", "data-task-id": task.id, "data-status": task.status, open,
+        onToggle: event => { if (event.target === event.currentTarget) setOpen(event.currentTarget.open); },
+        style: { "--ps-native-task-accent": colors[task.status] || colors.running },
+    },
+        React.createElement("summary", {
+            onClick: () => { inspected.current = true; },
+            onKeyDown: event => { if (["Enter", " "].includes(event.key)) inspected.current = true; },
+        },
+            React.createElement("span", { className: "ps-native-task-mark", "aria-hidden": true }, MARKS[task.status] || "?"),
+            React.createElement("span", { className: "ps-native-task-main" },
+                React.createElement("span", { className: "ps-native-task-title" },
+                    React.createElement("span", { className: "ps-native-task-profile" }, profile),
+                    task.title === "Native task" ? "Working on delegated request" : task.title),
+                preview ? React.createElement("span", { className: "ps-native-task-preview" }, preview.replace(/\s+/g, " ").slice(0, 240)) : null),
+            React.createElement("span", { className: "ps-native-task-meta" },
+                React.createElement("span", { className: "ps-native-task-status" }, task.telemetryStale ? "Reconnecting" : NATIVE_TASK_LABELS[task.status] || task.status),
+                React.createElement("span", null, [time, `${task.toolCalls || 0} ${task.toolCalls === 1 ? "call" : "calls"}`].filter(Boolean).join(" · "))),
+            React.createElement("span", { className: "ps-native-task-chevron", "aria-hidden": true }, "›")),
+        React.createElement("div", { className: "ps-native-task-detail", onClick: () => { inspected.current = true; } },
+            React.createElement("div", { className: "ps-native-task-scope" }, [task.model, task.reasoningEffort, "Same worker"].filter(Boolean).join(" · ")),
+            calls.length ? React.createElement("div", {
+                ref: viewport, className: "ps-native-task-calls", role: "region", "aria-label": `Tool calls for ${task.title}`, tabIndex: 0,
+                onScroll: event => { const node = event.currentTarget; follow.current = node.scrollHeight - node.scrollTop - node.clientHeight <= 24; },
+                onWheel: event => { inspected.current = true; if (event.deltaY < 0) follow.current = false; },
+                onTouchStart: () => { inspected.current = true; follow.current = false; },
+                onFocus: () => { inspected.current = true; },
+            }, calls.map(line => React.createElement(ChatCallLine, { key: line.callKey, line }))) :
+                React.createElement("p", { className: "ps-native-task-scope" }, task.toolCalls ? "Tool details are not available in this recording." : "Waiting for task activity…"),
+            task.result || task.error ? React.createElement("p", { className: "ps-native-task-result" }, task.error || task.result) : null,
+            task.recentActivity?.length && !task.calls?.length ? React.createElement("ul", { className: "ps-native-task-activity" },
+                task.recentActivity.map((activity, i) => React.createElement("li", { key: i }, activity.message))) : null));
+}