pilotswarm 0.5.62 → 0.5.64

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

@@ -1,3 +1,5 @@
+import { matchesSessionError } from "./session-warning.js";
+
 // Copilot emits this diagnostic for an accepted turn without visible text.
 // Keep its durable event and Activity entry, but do not turn it into a chat
 // warning. Match only this message and the runtime's known retry wrapper.
@@ -27,9 +29,13 @@ export function shouldKeepSessionWarning(previousSession, nextSession) {
 
 const timeMs = value => value instanceof Date ? value.getTime()
     : typeof value === "number" ? value : Date.parse(value || "");
-const errorText = event => typeof event?.data === "string" ? event.data
+const isWarningEvent = event => event?.eventType === "session.error"
+    || event?.eventType === "session.turn_completed" && event.data?.resultType === "error";
+const errorText = event => event?.eventType === "session.turn_completed"
+    ? String(event.data?.resultType === "error" ? event.data.errorMessage || "" : "").trim()
+    : typeof event?.data === "string" ? event.data
     : String(event?.data?.message || event?.data?.error || event?.data?.text || "").trim();
-const sameError = (statusText, eventText) => Boolean(eventText) && statusText.includes(eventText);
+const sameError = (statusText, eventText) => matchesSessionError(eventText, statusText);
 
 export function buildSessionWarning(event) {
     const text = errorText(event);
@@ -62,7 +68,7 @@ export function retainSessionWarnings(previous, next, events = [], now = Date.no
         return { ...next, chatWarnings: [...warnings.slice(0, -1), { ...last, active: false }] };
     }
     const since = last?.createdAt || 0;
-    const event = events.findLast(e => e.eventType === "session.error"
+    const event = events.findLast(e => isWarningEvent(e)
         && timeMs(e.createdAt) > since && sameError(text, errorText(e)));
     // A retained error field can outlive a terminal/wait state. A later
     // running snapshot alone is not evidence of another failure episode.
@@ -92,7 +98,7 @@ export function withSessionWarnings(chat, session, events = []) {
         // Status often wins the race against its durable event. Match only
         // that boundary, never a later failure after a new user/agent message.
         const following = events.filter(e => Number(e.seq) > warning.afterSeq);
-        const boundary = following.find(e => ["session.error", "user.message", "assistant.message"].includes(e.eventType));
+        const boundary = following.find(e => isWarningEvent(e) || ["user.message", "assistant.message"].includes(e.eventType));
         // On initial load the catalog can arrive before any history at all.
         // Find its matching older event by the captured failure time, without
         // reusing an event from a previous error episode with identical text.
@@ -103,8 +109,9 @@ export function withSessionWarnings(chat, session, events = []) {
             && timeMs(m.createdAt) <= warning.createdAt
             && sameError(warning.text, m.text));
         const eventSeq = warning.eventSeq ?? recorded?.warningSeq
-            ?? (boundary?.eventType === "session.error" && sameError(warning.text, errorText(boundary)) ? Number(boundary.seq) : null);
-        const index = messages.findIndex(m => m.kind === "session-warning" && m.warningSeq === eventSeq);
+            ?? (isWarningEvent(boundary) && sameError(warning.text, errorText(boundary)) ? Number(boundary.seq) : null);
+        const index = messages.findIndex(m => m.kind === "session-warning"
+            && (m.warningSeq === eventSeq || eventSeq != null && m.turnCompletedSeq === eventSeq));
         const notice = {
             id: warning.id, kind: "session-warning", role: "system", text: warning.text,
             createdAt: warning.createdAt,

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

@@ -0,0 +1,14 @@
+function canonicalErrorText(value) {
+    // ManagedSession adds this wrapper when promoting an SDK session.error
+    // to a failed turn. The SDK event itself retains the original message.
+    return String(value || "").trim().replace(/^Execution failed:\s*/, "");
+}
+
+export function matchesSessionError(recorded, current) {
+    const error = canonicalErrorText(recorded);
+    const statusError = canonicalErrorText(current);
+    // Orchestration status can append retry details to the recorded failure.
+    // Match only the whole message or its detail suffix, never an arbitrary
+    // substring shared by different errors.
+    return Boolean(error) && (statusError === error || statusError.startsWith(`${error} (`));
+}

package/ui/core/src/state.js

@@ -448,10 +448,14 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
                 activity: 0,
                 filePreview: 0,
             },
-            // Per-session chat scroll memory (rows from bottom), restored on
-            // sessions/selected and evicted with the session's history.
+            // Per-session chat scroll memory. While following, the offset is
+            // distance from the bottom; once the reader scrolls up it becomes
+            // a stable viewport offset from the top. The paired follow flag
+            // disambiguates the two modes across session switches.
             chatScrollBySession: {},
+            chatFollowBottomBySession: {},
             followBottom: {
+                chat: true,
                 inspector: true,
                 activity: true,
             },
@@ -767,6 +771,7 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             // replaces the legacy GitHub-key editor in new UI; the legacy
             // state remains available for rollback compatibility only.
             section: "providers",
+            features: { mode: "mine", userId: null, data: null, users: [], drafts: {}, loading: false, saving: false, error: null, generation: 0, fetchedAt: null, userQuery: "" },
             // Agent packages (docs/proposals/agent-packages.md) — registry
             // list, selected package detail, and the workspace viewer.
             packages: {

package/ui/react/src/components.js

@@ -354,6 +354,7 @@ const ChatPane = React.memo(function ChatPane({ controller, width, height, frame
             connectionError: state.connection.error,
             connectionMode: state.connection.mode,
             chatScroll: state.ui.scroll.chat,
+            followBottom: state.ui.followBottom?.chat !== false,
             focused: state.ui.focusRegion === "chat",
         };
     }, shallowEqualObject);
@@ -449,7 +450,7 @@ const ChatPane = React.memo(function ChatPane({ controller, width, height, frame
         lines: elements,
         bottomStickyLines,
         scrollOffset: chatView.chatScroll,
-        scrollMode: "bottom",
+        scrollMode: chatView.followBottom ? "bottom" : "top",
         paneId: "chat",
         paneLabel: "Chat",
         frame,

package/ui/react/src/feature-flags-panel.js

@@ -0,0 +1,186 @@
+import React from "react";
+
+const h = React.createElement;
+const onOff = enabled => enabled ? "On" : "Off";
+const validRevision = value => typeof value === "string" && /^[1-9]\d{0,18}$/.test(value)
+    && BigInt(value) <= 9223372036854775807n;
+const isRecord = value => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** Missing diagnostics are unknown, including telemetry redacted by older servers. */
+export function featureWorkerStatus(flag, workers = [], now = Date.now()) {
+    const reports = workers.map(worker => {
+        const age = now - new Date(worker.updatedAt).getTime();
+        const state = worker.state?.["feature-flags"];
+        const recent = Number.isFinite(age) && age >= -5_000 && age < 90_000;
+        const eligible = worker.phase === "ready" && recent;
+        const validState = isRecord(state) && state.protocolVersion === 1
+            && typeof state.initialized === "boolean" && Array.isArray(state.supportedKeys)
+            && state.supportedKeys.every(key => typeof key === "string") && isRecord(state.appliedRevisions);
+        let delivery = "unknown";
+        if (eligible && validState && validRevision(flag.revision)) {
+            if (!state.supportedKeys.includes(flag.featureKey)) delivery = "unsupported";
+            else if (!state.initialized) delivery = "loading";
+            else if (validRevision(state.appliedRevisions[flag.featureKey])) {
+                delivery = BigInt(state.appliedRevisions[flag.featureKey]) >= BigInt(flag.revision) ? "updated" : "pending";
+            }
+        }
+        const capability = eligible && validState && ["sync", "off"].includes(state.nativeCapability)
+            ? state.nativeCapability : "unknown";
+        return { workerNodeId: worker.workerNodeId, phase: worker.phase, recent, eligible, delivery, capability,
+            revision: validState && validRevision(state.appliedRevisions[flag.featureKey]) ? state.appliedRevisions[flag.featureKey] : null,
+            refreshError: eligible && validState && (state.hasRefreshError === true || typeof state.lastError === "string" && state.lastError.length > 0) };
+    });
+    const eligible = reports.filter(report => report.eligible);
+    return { reports, eligible: eligible.length,
+        updated: eligible.filter(report => report.delivery === "updated").length,
+        unknown: eligible.filter(report => report.delivery === "unknown").length,
+        unsupported: eligible.filter(report => report.delivery === "unsupported").length,
+        capable: eligible.filter(report => report.capability === "sync").length,
+        incapable: eligible.filter(report => report.capability === "off").length,
+        capabilityUnknown: eligible.filter(report => report.capability === "unknown").length,
+        refreshErrors: eligible.filter(report => report.refreshError).length,
+        stale: reports.filter(report => !report.recent && report.phase !== "draining").length,
+        draining: reports.filter(report => report.phase === "draining").length,
+        other: reports.filter(report => report.recent && !report.eligible && report.phase !== "draining").length };
+}
+
+function deliveryText(status, workersError) {
+    if (workersError || !status.eligible || status.unknown === status.eligible) return "Settings delivery: status unavailable";
+    return `Settings delivery: ${status.updated} of ${status.eligible} reporting workers updated.${status.unknown ? ` Status unavailable for ${status.unknown}.` : ""}${status.unsupported ? ` ${status.unsupported} do not support this feature.` : ""}${status.refreshErrors ? ` ${status.refreshErrors} reported a refresh problem.` : ""}`;
+}
+
+function clusterSummary(enabled, allowPersonal) {
+    return `${onOff(enabled)} ${allowPersonal ? "by default. Users can choose On or Off." : "for everyone. Personal settings do not apply."}`;
+}
+
+function RadioChoices({ legend, name, value, options, disabled, onChange }) {
+    return h("fieldset", { className: "ps-feature-choice-group", disabled },
+        h("legend", null, legend),
+        h("div", { className: "ps-feature-choices" }, options.map(option => h("label", {
+            className: `ps-feature-choice${value === option.value ? " is-selected" : ""}`, key: option.value,
+        }, h("input", { type: "radio", name, value: option.value, checked: value === option.value,
+            onChange: () => onChange(option.value) }), h("span", null, option.label)))));
+}
+
+function FeatureFlagRow({ flag, mode, busy, saving, controller, workers, workersError, isAdmin, userName }) {
+    const id = React.useId();
+    const draft = controller.getFeatureDraft?.(flag.featureKey);
+    const dirty = draft !== undefined;
+    const conflict = dirty && (draft.needsReview || draft.expectedRevision !== flag.revision);
+    const conflictNeedsRefresh = conflict && draft.needsReview && draft.expectedRevision === flag.revision;
+    const storedEnabled = flag.cluster?.enabled ?? flag.defaultEnabled;
+    const storedOverride = flag.cluster?.allowUserOverride ?? flag.defaultAllowUserOverride;
+    const locked = mode !== "cluster" && !storedOverride;
+    const savedChoice = flag.user ? String(flag.user.enabled) : "inherit";
+    const choice = dirty ? draft.values === null ? "inherit" : String(draft.values.enabled) : savedChoice;
+    const clusterDraft = dirty ? draft.values ?? { enabled: flag.defaultEnabled, allowUserOverride: flag.defaultAllowUserOverride }
+        : { enabled: storedEnabled, allowUserOverride: storedOverride };
+    const target = mode === "mine" ? "you" : userName;
+    const futureTarget = mode === "mine" ? "Your" : `${userName}’s`;
+    const savedValue = mode === "cluster" ? `${onOff(storedEnabled)} ${storedOverride ? "by default" : "for everyone"}`
+        : `${onOff(flag.effective)} for ${target}`;
+    const reason = mode === "cluster" ? storedOverride ? "Users can choose On or Off." : "Personal settings do not apply."
+        : locked ? "Required by the cluster." : flag.user ? mode === "mine" ? "Using your choice." : "Using the saved personal choice." : "Following the cluster setting.";
+    const status = featureWorkerStatus(flag, workers);
+    const isNative = flag.featureKey === "copilot.native_tasks";
+    const savedOn = mode === "cluster" ? storedEnabled : flag.effective;
+    const knownBlocked = isAdmin && isNative && savedOn && !workersError && status.eligible > 0 && status.incapable === status.eligible;
+    const editDisabled = busy || !flag.supported;
+    let preview = null;
+    if (dirty) {
+        if (mode === "cluster") preview = `${draft.values === null ? "Restore the default policy. " : ""}${clusterSummary(clusterDraft.enabled, clusterDraft.allowUserOverride)}${!storedOverride && clusterDraft.allowUserOverride ? " Previously saved personal choices will apply again." : ""}`;
+        else if (locked) preview = `${futureTarget} future preference will ${choice === "inherit" ? "follow the cluster setting" : `be ${onOff(choice === "true")}`}. ${onOff(storedEnabled)} still applies while the cluster requires it.`;
+        else preview = `${onOff(choice === "inherit" ? storedEnabled : choice === "true")} for ${target}. ${choice === "inherit" ? "Following the cluster setting." : "Using the personal choice."}`;
+    }
+    return h("section", { className: "ps-feature-flag", "data-feature-key": flag.featureKey, "aria-labelledby": `${id}-title` },
+        h("div", { className: "ps-feature-flag-heading" }, h("h3", { id: `${id}-title` }, flag.displayName),
+            dirty ? h("span", { className: "ps-feature-unsaved" }, "Unsaved changes") : null),
+        h("p", { className: "ps-feature-description" }, isNative ? "Lets Copilot delegate short tasks in the same session workspace. On permits use; Copilot decides when to use native tasks." : flag.description),
+        h("div", { className: "ps-feature-saved" },
+            h("span", { className: "ps-feature-label" }, "Saved setting"),
+            h("strong", { className: `ps-feature-value${(mode === "cluster" ? storedEnabled : flag.effective) ? " is-on" : ""}` }, savedValue),
+            h("p", { className: "ps-feature-explanation" }, reason),
+            mode !== "cluster" ? h("p", { className: "ps-feature-context" }, `Cluster setting: ${onOff(storedEnabled)}. Personal settings ${storedOverride ? "allowed" : "not allowed"}.`) : null,
+            locked ? h("p", { className: "ps-feature-retained" }, `Saved future preference: ${savedChoice === "inherit" ? "Use cluster setting" : onOff(flag.user.enabled)}. This will apply if personal settings are allowed again.`) : null),
+        !flag.supported ? h("p", { role: "status" }, "This server does not support changing this feature.") : null,
+        knownBlocked ? h("p", { className: "ps-feature-blocker", role: "status" }, `The saved setting is On, but none of the ${status.eligible} reporting workers is configured for native tasks. Native tasks cannot run on those workers.`) : null,
+        h("div", { className: "ps-feature-editor" }, mode === "cluster" ? [
+            h(RadioChoices, { key: "enabled", legend: "Cluster setting", name: `${id}-cluster`, value: String(clusterDraft.enabled), disabled: editDisabled,
+                options: [{ value: "false", label: "Off" }, { value: "true", label: "On" }],
+                onChange: value => controller.setFeatureDraft(flag.featureKey, { ...clusterDraft, enabled: value === "true" }) }),
+            h(RadioChoices, { key: "override", legend: "Personal settings", name: `${id}-override`, value: String(clusterDraft.allowUserOverride), disabled: editDisabled,
+                options: [{ value: "true", label: "Allowed" }, { value: "false", label: "Not allowed" }],
+                onChange: value => controller.setFeatureDraft(flag.featureKey, { ...clusterDraft, allowUserOverride: value === "true" }) }),
+        ] : h(RadioChoices, { legend: locked ? "Preference for when personal settings are allowed" : mode === "mine" ? "Your choice" : `${userName}’s choice`,
+            name: `${id}-user`, value: choice, disabled: editDisabled,
+            options: [{ value: "inherit", label: `Use cluster setting (currently ${onOff(storedEnabled)})` },
+                { value: "true", label: mode === "mine" ? "On for me" : "On for this user" },
+                { value: "false", label: mode === "mine" ? "Off for me" : "Off for this user" }],
+            onChange: value => controller.setFeatureDraft(flag.featureKey, value === "inherit" ? null : { enabled: value === "true" }) })),
+        dirty ? h("div", { className: "ps-feature-preview", role: "status" }, h("strong", null, "After saving: "), preview) : null,
+        conflict ? h("p", { className: "ps-feature-conflict", role: "status" }, conflictNeedsRefresh
+            ? "Settings changed since this edit began. Refresh settings to load the latest saved value."
+            : "Settings changed since this edit began. Review the saved setting and your proposed change before saving.") : null,
+        h("div", { className: "ps-feature-actions" },
+            h("button", { type: "button", className: "ps-mini-button ps-feature-save", disabled: editDisabled || !dirty || conflict,
+                onClick: () => controller.saveFeatureDraft(flag.featureKey) }, saving && dirty ? "Saving…" : locked ? "Save future preference" : "Save changes"),
+            h("button", { type: "button", className: "ps-mini-button", disabled: busy || !dirty,
+                onClick: () => controller.discardFeatureDraft(flag.featureKey) }, "Discard changes"),
+            conflict ? h("button", { type: "button", className: "ps-mini-button", disabled: busy || conflictNeedsRefresh,
+                onClick: () => controller.reviewFeatureDraft(flag.featureKey) }, "Review latest settings") : null),
+        isAdmin ? h("p", { className: "ps-feature-delivery", role: "status" }, deliveryText(status, workersError)) : null,
+        h("details", { className: "ps-feature-details" }, h("summary", null, "Technical details"),
+            h("p", null, h("code", null, flag.featureKey), ` · Saved revision ${flag.revision}`),
+            h("p", null, "Workers normally check for settings changes within 20 seconds. Settings delivery does not confirm that each session has refreshed its tools."),
+            isNative ? h("p", null, "After a worker receives On, native tasks become available on the next turn. After it receives Off, new native tasks are blocked. Tasks already running can finish.") : null,
+            isAdmin && isNative ? h("p", null, workersError || !status.eligible || status.capabilityUnknown === status.eligible
+                ? "Native task support: status unavailable."
+                : `Native task support: ${status.capable} of ${status.eligible} reporting workers configured; ${status.incapable} configured Off; ${status.capabilityUnknown} unknown.`) : null,
+            isAdmin && (status.stale || status.draining || status.other) ? h("p", null, `Excluded from current delivery counts: ${status.stale} stale or undated reports; ${status.draining} draining workers; ${status.other} other worker reports.`) : null,
+            isAdmin ? h("ul", { className: "ps-feature-worker-list" }, status.reports.map(report => h("li", { key: report.workerNodeId },
+                `${report.workerNodeId}: ${report.eligible ? ({ updated: "settings received", pending: "waiting for latest settings", loading: "loading settings", unsupported: "feature unsupported", unknown: "status unavailable" })[report.delivery] : report.phase === "draining" ? "draining; excluded" : !report.recent ? "stale or undated report; status unavailable" : "not reporting ready; excluded"}${report.eligible && report.revision ? `; revision ${report.revision}` : ""}${report.eligible && isNative ? `; native task configuration ${report.capability === "sync" ? "On" : report.capability === "off" ? "Off" : "unknown"}` : ""}${report.refreshError ? "; settings refresh problem" : ""}`))) : null,
+            mode === "cluster" ? h("div", { className: "ps-feature-defaults" },
+                h("p", null, `Default policy: ${clusterSummary(flag.defaultEnabled, flag.defaultAllowUserOverride)}`),
+                h("button", { type: "button", className: "ps-mini-button", disabled: editDisabled || !flag.cluster,
+                    onClick: () => controller.setFeatureDraft(flag.featureKey, null) }, "Preview default policy"),
+                h("p", { className: "ps-feature-explanation" }, "Preview stages removal of the cluster override. Save changes to use the code-defined defaults; personal choices are kept.")) : null));
+}
+
+export function FeatureFlagsPanel({ controller, features = {}, isAdmin, workers = [], workersError = null }) {
+    const mode = features.mode || "mine";
+    const [userQuery, setUserQuery] = React.useState(features.userQuery || "");
+    const user = features.users?.find(entry => entry.userId === features.userId);
+    const userName = user?.displayName || user?.email || user?.subject || (features.userId ? `user ${features.userId}` : "this user");
+    const busy = features.saving || features.loading;
+    return h("section", { className: "ps-feature-flags-panel", "aria-label": "Feature flags" },
+        h("header", { className: "ps-feature-flag-heading" }, h("h2", null, "Feature flags"),
+            h("button", { type: "button", className: "ps-mini-button", disabled: busy, onClick: () => controller.refreshFeatureFlags() }, "Refresh settings")),
+        h("div", { role: "tablist", "aria-label": "Feature settings scope", className: "ps-feature-tabs" },
+            [{ mode: "mine", label: "My settings" }, ...(isAdmin ? [{ mode: "cluster", label: "Cluster settings" }, { mode: "users", label: "User settings" }] : [])].map(tab => {
+                const count = controller.getFeatureDraftCount?.(tab.mode) || 0;
+                return h("button", { type: "button", key: tab.mode, role: "tab", "aria-selected": mode === tab.mode, disabled: features.saving,
+                    className: "ps-mini-button", onClick: () => controller.selectFeatureScope(tab.mode) }, tab.label,
+                count ? h("span", { className: "ps-feature-unsaved" }, `${count} unsaved`) : null);
+            })),
+        mode === "users" && isAdmin ? h("div", { className: "ps-feature-user" },
+            h("form", { onSubmit: event => { event.preventDefault(); void controller.searchFeatureUsers(userQuery); } },
+                h("label", null, "Find user ", h("input", { type: "search", value: userQuery,
+                    "aria-label": "Find feature settings user", placeholder: "Name, email or identity", onChange: event => setUserQuery(event.target.value) })),
+                h("button", { className: "ps-mini-button", disabled: features.usersLoading || features.saving }, "Search")),
+            h("label", null, "User ", h("select", { "aria-label": "Feature settings user", value: features.userId ?? "", disabled: features.saving,
+                onChange: event => controller.selectFeatureScope("users", event.target.value ? Number(event.target.value) : null) },
+            h("option", { value: "" }, "Select a user"),
+            (features.users || []).map(entry => h("option", { key: entry.userId, value: entry.userId }, `${entry.displayName || entry.email || entry.subject}${entry.displayName && entry.email ? ` — ${entry.email}` : ""}${features.selectedUserOutsideResults && entry.userId === features.userId ? " (current selection)" : ""}`)))),
+            features.selectedUserOutsideResults ? h("p", { className: "ps-feature-explanation" }, "Current selection kept while you search.") : null,
+            user ? h("p", { className: "ps-feature-user-identity" }, h("strong", null, userName), user.email ? h("span", null, user.email) : null)
+                : features.userId ? h("p", null, `Selected user ID: ${features.userId}`) : null,
+            features.users?.length >= 500 ? h("p", null, "Showing the first 500 users. Refine your search to find another user.") : null) : null,
+        features.error ? h("p", { role: "alert" }, features.error) : null,
+        features.metadataError ? h("p", { role: "status" }, features.metadataError) : null,
+        isAdmin && workersError ? h("p", { role: "status" }, "Worker reports could not be refreshed. Settings delivery status is unavailable.") : null,
+        features.notice ? h("p", { role: "status" }, features.notice) : null,
+        features.loading ? h("p", { role: "status" }, "Loading feature settings…") : null,
+        (mode === "mine" || isAdmin ? features.data?.flags || [] : []).map(flag => h(FeatureFlagRow, { key: `${mode}:${features.userId}:${flag.featureKey}`,
+            flag, mode, busy, saving: features.saving, controller, workers, workersError, isAdmin, userName })),
+        !features.loading && features.data?.flags?.length === 0 ? h("p", null, "No feature definitions are published.") : null);
+}

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

@@ -0,0 +1,59 @@
+import React from "react";
+import { NATIVE_TASK_LABELS } from "../../core/src/native-tasks.js";
+
+const TERMINAL = new Set(["completed", "failed", "cancelled", "interrupted"]);
+const MARKS = { starting: "◷", running: "◷", waiting: "Ⅱ", completed: "✓", failed: "!", cancelled: "■", interrupted: "↯" };
+function duration(task, now) {
+    const ms = task.durationMs ?? (task.startedAt ? (task.completedAt || now) - task.startedAt : null);
+    if (!Number.isFinite(ms) || ms < 0) return "";
+    const seconds = Math.floor(ms / 1000);
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+
+export const NativeTaskCard = React.memo(function NativeTaskCard({ group, colors }) {
+    const [showAll, setShowAll] = React.useState(false);
+    const [now, setNow] = React.useState(Date.now);
+    const active = group.tasks.some(task => !TERMINAL.has(task.status));
+    React.useEffect(() => {
+        if (!active) return undefined;
+        const timer = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(timer);
+    }, [active]);
+    const counts = group.tasks.reduce((acc, task) => {
+        const label = NATIVE_TASK_LABELS[task.status] || "Unknown";
+        acc[label] = (acc[label] || 0) + 1;
+        return acc;
+    }, {});
+    const countLabel = Object.entries(counts).map(([label, count]) => `${count} ${label.toLowerCase()}`).join(" · ");
+    const tasks = showAll ? group.tasks : group.tasks.slice(0, 3);
+    return React.createElement("section", { className: "ps-native-tasks", "aria-label": "Native tasks", "data-task-group": group.id },
+        React.createElement("header", { className: "ps-native-tasks-header" },
+            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));
+        }),
+        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);
+});