pilotswarm 0.5.63 → 0.5.64

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

@@ -0,0 +1,197 @@
+// 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"]);
+const clip = (value, max = 240) => typeof value === "string" ? value.trim().slice(0, max) : "";
+const timeMs = value => {
+    const ms = typeof value === "number" ? value : new Date(value).getTime();
+    return Number.isFinite(ms) && ms > 0 ? ms : null;
+};
+const resultText = value => typeof value === "string" ? value
+    : value?.detailedContent || value?.content || value?.textResultForLlm || value?.message || value?.error?.message || "";
+
+export const NATIVE_TASK_LABELS = {
+    starting: "Starting", running: "Running", waiting: "Waiting", completed: "Done",
+    failed: "Failed", cancelled: "Cancelled", interrupted: "Interrupted",
+};
+
+function findTask(chat, task) {
+    for (let groupIndex = chat.length - 1; groupIndex >= 0; groupIndex--) {
+        const group = chat[groupIndex];
+        if (group.kind !== "native-task-group") continue;
+        const taskIndex = group.tasks.findLastIndex(item =>
+            (task.toolCallId && item.toolCallId === task.toolCallId)
+            || (task.agentId && item.agentId === task.agentId && (!task.toolCallId || !item.toolCallId))
+            || (task.id && item.id === task.id));
+        if (taskIndex >= 0) return { groupIndex, taskIndex };
+    }
+    return null;
+}
+
+function updateTask(chat, patch, event, { authoritative = false } = {}) {
+    const match = findTask(chat, patch);
+    const previous = match ? chat[match.groupIndex].tasks[match.taskIndex] : null;
+    if (previous?.ownerId && patch.ownerId && previous.ownerId !== patch.ownerId) return;
+    if (patch.revision != null && previous?.revision != null && patch.revision < previous.revision) return;
+    const next = {
+        id: patch.toolCallId || patch.agentId || patch.id,
+        title: "Native task", status: "starting", toolCalls: 0,
+        startedAt: timeMs(patch.startedAt) || timeMs(event.createdAt),
+        ...previous,
+        ...Object.fromEntries(Object.entries(patch).filter(([,value]) => value !== undefined)),
+        telemetryStale: false,
+    };
+    if (!next.id) return;
+    next.id = previous?.id || next.id;
+    next.startedAt = previous?.startedAt || timeMs(patch.startedAt) || timeMs(event.createdAt);
+    next.completedAt = timeMs(next.completedAt);
+    // Cleanup and late progress must not replace a confirmed outcome. A
+    // cancelled:true completion is handled before it becomes terminal.
+    if (previous && TERMINAL.has(previous.status)
+        && (!previous.inferredTerminal || !TERMINAL.has(patch.status))) {
+        next.status = previous.status;
+        next.error = previous.error;
+        next.completedAt = previous.completedAt;
+        next.durationMs = previous.durationMs;
+        if (!TERMINAL.has(patch.status) || patch.status === "cancelled") next.toolCalls = previous.toolCalls;
+        if (!patch.result && !patch.error) next.preview = previous.preview;
+    } else if (TERMINAL.has(patch.status) && !patch.inferredTerminal) {
+        next.inferredTerminal = false;
+        // A late real outcome replaces the explanatory text of an inferred
+        // interruption, rather than displaying that stale error under Done.
+        if (previous?.inferredTerminal) next.error = patch.error || "";
+    }
+    next.title = clip(next.title, 160) || "Native task";
+    next.preview = clip(next.preview);
+    next.result = clip(next.result, 4000);
+    next.error = clip(next.error, 1000);
+    next.toolCalls = Math.max(Number(previous?.toolCalls) || 0, Number(next.toolCalls) || 0);
+    next.recentActivity = Array.isArray(next.recentActivity)
+        ? next.recentActivity.slice(-5).map(a => ({ message: clip(a.message), timestamp: a.timestamp })) : [];
+    if (match) {
+        const group = chat[match.groupIndex];
+        const tasks = [...group.tasks];
+        tasks[match.taskIndex] = next;
+        chat[match.groupIndex] = { ...group, tasks };
+        return;
+    }
+    // A retained snapshot can arrive after newer chat. Insert at its original
+    // start time instead of attaching it permanently to the transcript tail.
+    const later = next.startedAt ? chat.findIndex(item => Number(item.createdAt) > next.startedAt) : -1;
+    const insertion = later < 0 ? chat.length : later;
+    const prior = chat[insertion - 1];
+    if (prior?.kind === "native-task-group" && prior.tasks.length < 32) {
+        chat[insertion - 1] = { ...prior, tasks: [...prior.tasks, next] };
+    } else {
+        chat.splice(insertion, 0, {
+            id: `native-tasks:${event.sessionId}:${next.id}`, kind: "native-task-group", role: "system",
+            createdAt: next.startedAt, tasks: [next],
+        });
+    }
+}
+
+export function appendNativeTaskEvent(chat, event) {
+    const type = event?.eventType || "";
+    const data = event?.data || {};
+    if (type === "native.task_updated") {
+        if (data.id && NATIVE_TASK_LABELS[data.status]) updateTask(chat, data, event, { authoritative: true });
+        return;
+    }
+    if (type === "session.turn_completed" || type === "session.turn_stopped") {
+        for (let i = 0; i < chat.length; i++) {
+            if (chat[i].kind !== "native-task-group") continue;
+            chat[i] = { ...chat[i], tasks: chat[i].tasks.map(task => TERMINAL.has(task.status) ? task : {
+                ...task, status: "interrupted", inferredTerminal: true, completedAt: timeMs(event.createdAt),
+                error: type === "session.turn_stopped" ? "The parent turn was stopped." : "The parent turn ended before a task result was confirmed.",
+            }) };
+        }
+        return;
+    }
+    const lifecycle = type.startsWith("subagent.");
+    const child = type.startsWith("native.");
+    const taskTool = !child && !data.nativeAgentId && (data.toolName || data.name) === "task"
+        && ["tool.execution_start", "tool.execution_complete"].includes(type);
+    if (!lifecycle && !child && !taskTool) return;
+    const args = data.arguments || data.args || {};
+    const toolCallId = child ? data.parentToolCallId : data.toolCallId;
+    const agentId = data.nativeAgentId || data.agentId;
+    const patch = { toolCallId, agentId };
+    const found = findTask(chat, patch);
+    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",
+        profile: args.agent_type || data.agentName || data.agentType,
+        model: data.model,
+    });
+    if (type === "subagent.configured") {
+        Object.assign(patch, { model: data.model, reasoningEffort: data.reasoningEffort });
+    } else if (type === "subagent.started") {
+        patch.status = "running";
+    } else if (type === "subagent.completed" || type === "subagent.failed") {
+        Object.assign(patch, {
+            status: data.cancelled ? "cancelled" : type === "subagent.failed" ? "failed" : "completed",
+            completedAt: event.createdAt, durationMs: data.durationMs, toolCalls: data.totalToolCalls,
+            ...(data.cancelled ? { error: "Task was cancelled before returning a result." }
+                : type === "subagent.failed" ? { error: clip(resultText(data.error) || data.message || "Native task failed.", 1000) } : {}),
+        });
+    } else if (type === "tool.execution_start") {
+        patch.status = "starting";
+    } else if (type === "tool.execution_complete") {
+        const failed = data.success === false || data.result?.success === false || Boolean(data.error)
+            || ["failure", "failed", "rejected", "denied"].includes(data.result?.resultType ?? data.resultType);
+        const text = resultText(data.result) || resultText(data.error);
+        Object.assign(patch, { status: failed ? "failed" : "completed", completedAt: event.createdAt,
+            ...(failed ? { error: clip(text, 1000) || "Native task request failed." } : { result: clip(text, 4000) }) });
+    } 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.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.
+        patch.preview = clip(data.content);
+    } else return;
+    updateTask(chat, patch, event);
+}
+
+export function applyNativeTaskSnapshot(history, payload, meta = {}) {
+    if (payload?.phase === "unavailable" && history) return { ...history,
+        nativeTaskSnapshot: history.nativeTaskSnapshot ? { ...history.nativeTaskSnapshot, liveSeq: undefined } : undefined,
+        chat: history.chat.map(group => group.kind !== "native-task-group" ? group : { ...group,
+            tasks: group.tasks.map(task => TERMINAL.has(task.status) ? task : { ...task, telemetryStale: true }) }) };
+    if (payload?.version !== 1 || !Array.isArray(payload.tasks) || !payload.ownerId) return history;
+    const current = history || { chat: [], activity: [], events: [], lastSeq: 0 };
+    const latest = current.nativeTaskSnapshot;
+    const newestRecordedOwner = Math.max(0, ...current.chat
+        .filter(group => group.kind === "native-task-group")
+        .flatMap(group => group.tasks.map(task => Number(task.ownerStartedAt) || 0)));
+    // The retained live row can belong to an old publisher that finished
+    // writing after a newer turn. On reconnect, durable summary owners fence
+    // that row even when this viewer has not received a live snapshot yet.
+    if (Number.isFinite(payload.ownerStartedAt) && payload.ownerStartedAt < newestRecordedOwner) {
+        if (latest?.ownerStartedAt >= newestRecordedOwner) return current;
+        return { ...current, chat: current.chat.map(group => group.kind !== "native-task-group" ? group : { ...group,
+            tasks: group.tasks.map(task => !TERMINAL.has(task.status) && task.ownerStartedAt === newestRecordedOwner
+                ? { ...task, telemetryStale: true } : task) }) };
+    }
+    if (Number.isFinite(latest?.ownerStartedAt) && Number.isFinite(payload.ownerStartedAt)
+        && payload.ownerStartedAt < latest.ownerStartedAt) return current;
+    if (latest?.ownerId === payload.ownerId && latest.revision >= payload.revision) return current;
+    if (latest?.ownerId === payload.ownerId && Number.isFinite(meta.seq)
+        && Number.isFinite(latest?.liveSeq) && meta.seq <= latest.liveSeq) return current;
+    const chat = [...current.chat];
+    for (const task of payload.tasks.slice(0, 32)) {
+        if (!task?.id || !NATIVE_TASK_LABELS[task.status]) continue;
+        const ended = current.events?.some(e => ["session.turn_completed", "session.turn_stopped"].includes(e.eventType)
+            && timeMs(e.createdAt) > timeMs(task.startedAt));
+        const patch = { ...task, ownerId: payload.ownerId, ownerStartedAt: payload.ownerStartedAt, revision: payload.revision };
+        if (ended && !TERMINAL.has(patch.status)) {
+            patch.status = "interrupted";
+            patch.inferredTerminal = true;
+            patch.error = "The parent turn ended before a task result was confirmed.";
+        }
+        updateTask(chat, patch, { sessionId: meta.sessionId, createdAt: task.startedAt }, { authoritative: true });
+    }
+    return { ...current, chat, nativeTaskSnapshot: { ownerId: payload.ownerId, ownerStartedAt: payload.ownerStartedAt,
+        revision: payload.revision, liveSeq: meta.seq } };
+}

package/ui/core/src/question-display.js

@@ -0,0 +1,13 @@
+/**
+ * Some model-authored questions contain literal newline escapes. Decode those
+ * for presentation before markdown parsing, including mixed real/escaped lines.
+ * Keep stored question/choice identity intact for answers and history matching.
+ * Code spans/fences, Windows paths, quoted escape literals and doubled slashes
+ * are literal content, not formatting. Do not run a general JSON unescape here.
+ */
+export function normalizeQuestionForDisplay(value) {
+    const source = String(value ?? "");
+    if (!source.includes("\\n")) return source;
+    const tokens = /(`+)[\s\S]*?\1(?!`)|(~{3,})[\s\S]*?\2|(["'])[A-Za-z]:\\[^\r\n]*?\3|(?<!\w)(?:[A-Za-z]:\\|\\\\)(?:(?!\\n\\n|\\r\\n\\r\\n)[^\s"'`])+|(["'])(?:\\r\\n|\\[nr])\4|\\\\|\\r\\n|\\n/g;
+    return source.replace(tokens, token => token === "\\n" || token === "\\r\\n" ? "\n" : token);
+}

package/ui/core/src/reducer.js

@@ -41,6 +41,15 @@ function packageResponseIsStale(packages, action) {
     return false;
 }
 
+function clearFeatureIdentity(features) {
+    return { mode: "mine", userId: null, data: null, users: [], drafts: {}, loading: false, saving: false,
+        error: null, generation: (features?.generation || 0) + 1, fetchedAt: null, userQuery: "" };
+}
+
+function featurePrincipalKey(principal) {
+    return JSON.stringify([principal?.provider, principal?.subject]);
+}
+
 /** A provider name, or null. Names are cluster-unique and never blank. */
 function normalizeProviderName(value) {
     const name = String(value ?? "").trim();
@@ -965,6 +974,9 @@ function baseReducer(state, action) {
         case "auth/context":
             return {
                 ...state,
+                admin: featurePrincipalKey(state.auth?.principal) !== featurePrincipalKey(action.principal)
+                    || state.auth?.authorization?.role !== action.authorization?.role
+                    ? { ...state.admin, features: clearFeatureIdentity(state.admin.features) } : state.admin,
                 auth: {
                     principal: action.principal ?? null,
                     authorization: action.authorization ?? null,
@@ -2513,6 +2525,9 @@ function baseReducer(state, action) {
                     loading: false,
                     loadError: null,
                     profile: action.profile || null,
+                    features: featurePrincipalKey(state.admin.profile) !== featurePrincipalKey(action.profile)
+                        || Boolean(state.admin.profile?.isAdmin) !== Boolean(action.profile?.isAdmin)
+                        ? clearFeatureIdentity(state.admin.features) : state.admin.features,
                     ghcpKey: {
                         ...state.admin.ghcpKey,
                         // A successful load doesn't clobber an in-progress
@@ -2964,9 +2979,11 @@ function baseReducer(state, action) {
             };
         }
         case "admin/section": {
-            const section = ["packages", "workers", "ghcp"].includes(action.section) ? action.section : "ghcp";
+            const section = ["providers", "packages", "workers", "features", "ghcp"].includes(action.section) ? action.section : "ghcp";
             return { ...state, admin: { ...state.admin, section } };
         }
+        case "admin/features":
+            return { ...state, admin: { ...state.admin, features: { ...state.admin.features, ...action.patch } } };
         case "admin/workers/attempt": {
             const workers = state.admin.workers || {};
             return { ...state, admin: { ...state.admin, workers: { ...workers, attempts: (workers.attempts || 0) + 1, lastAttemptAt: Date.now(), lastSkip: action.skip || null } } };

package/ui/core/src/selectors.js

@@ -29,6 +29,8 @@ import {
     getContextHeaderBadge,
 } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
+import { matchesSessionError } from "./session-warning.js";
+import { normalizeQuestionForDisplay } from "./question-display.js";
 import { withSessionWarnings, isActivityOnlySessionError } from "./session-errors.js";
 import {
     BUDGET_PERIODS,
@@ -1543,11 +1545,11 @@ export function canStopSessionTurn(session) {
 // raised them. They used to stamp session.updatedAt, which moves on EVERY
 // poll and status tick — so the card's clock jumped forward with each update
 // and read as flicker.
-function latestEventCreatedAtMs(events = [], eventTypes = []) {
+function latestEventCreatedAtMs(events = [], eventTypes = [], predicate = () => true) {
     const wanted = new Set(eventTypes);
     for (let index = (events || []).length - 1; index >= 0; index -= 1) {
         const event = events[index];
-        if (!event || !wanted.has(event.eventType)) continue;
+        if (!event || !wanted.has(event.eventType) || !predicate(event)) continue;
         const createdAt = event.createdAt;
         const ms = createdAt instanceof Date
             ? createdAt.getTime()
@@ -1561,7 +1563,7 @@ function buildPendingQuestionMessage(session, events = []) {
     const pendingQuestion = session?.pendingQuestion;
     if (!pendingQuestion?.question) return null;
 
-    const body = [String(pendingQuestion.question).trim()];
+    const body = [normalizeQuestionForDisplay(pendingQuestion.question).trim()];
     const choices = Array.isArray(pendingQuestion.choices)
         ? pendingQuestion.choices.filter((choice) => typeof choice === "string" && choice.trim())
         : [];
@@ -1569,7 +1571,7 @@ function buildPendingQuestionMessage(session, events = []) {
     if (choices.length > 0) {
         body.push("", "Choices:");
         for (const choice of choices) {
-            body.push(`- ${choice}`);
+            body.push(`- ${normalizeQuestionForDisplay(choice)}`);
         }
     }
 
@@ -1661,10 +1663,11 @@ function buildSessionErrorMessage(session, events = []) {
         role: "system",
         text: body,
         time: "",
-        // The error event when one was recorded, else the end of the turn
-        // that produced the error; never the session's rolling updatedAt.
-        createdAt: latestEventCreatedAtMs(events, ["session.error"])
-            ?? latestEventCreatedAtMs(events, ["session.turn_completed", "assistant.turn_end"]),
+        // Only an actual failure can anchor this card. A later successful
+        // turn must never move an earlier warning's timestamp forward.
+        createdAt: latestEventCreatedAtMs(events, ["session.error", "session.turn_completed"],
+            (event) => matchesSessionError(event.eventType === "session.error" ? event.data?.message
+                : event.data?.resultType === "error" ? event.data?.errorMessage : null, errorText)),
         cardTitle: isFailed ? "Error" : "Warning",
         cardTitleColor: isFailed ? "red" : "yellow",
         cardBorderColor: isFailed ? "red" : "yellow",
@@ -1912,8 +1915,24 @@ export function selectActiveChat(state) {
         messages.push(answeredQuestionMessage);
     }
     if (sessionErrorMessage) {
-        const index = messages.findIndex(message => sessionErrorMessage.createdAt != null && message.createdAt > sessionErrorMessage.createdAt);
-        messages.splice(index < 0 ? messages.length : index, 0, sessionErrorMessage);
+        // History owns the warning's position and identity. Status may add
+        // current retry/failure details, but must not append the same warning
+        // after the newer conversation on every poll.
+        const warningIndex = messages.findLastIndex((message) => message.kind === "session-warning"
+            && matchesSessionError(message.text, session.error));
+        if (warningIndex < 0) {
+            const index = messages.findIndex(message => sessionErrorMessage.createdAt != null && message.createdAt > sessionErrorMessage.createdAt);
+            messages.splice(index < 0 ? messages.length : index, 0, sessionErrorMessage);
+        } else if (warningIndex === messages.length - 1 || sessionErrorMessage.cardTitle === "Error") {
+            const warning = messages[warningIndex];
+            messages[warningIndex] = {
+                ...warning,
+                ...sessionErrorMessage,
+                id: warning.id,
+                createdAt: warning.createdAt,
+                time: warning.time,
+            };
+        }
     }
     return messages;
 }
@@ -2597,7 +2616,7 @@ function buildChatMessageLinesUncached(message, maxWidth, options = {}) {
                 ...(askedAndAnswered.question === "a question" ? [] : buildMessageCardLines({
                     title: "Question",
                     timestamp: formatTimestamp(message?.createdAt || message?.time),
-                    body: askedAndAnswered.question,
+                    body: normalizeQuestionForDisplay(askedAndAnswered.question),
                     width: Math.max(20, maxWidth),
                     titleColor: USER_CHAT_COLOR,
                     borderColor: USER_CHAT_COLOR,
@@ -3069,7 +3088,20 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     };
     const lines = [];
     for (const [index, message] of messages.entries()) {
-        if (message?.kind === "epoch-divider") {
+        if (message?.kind === "native-task-group") {
+            if (options.tableMode === "sentinel") {
+                lines.push({ kind: "nativeTasks", group: message });
+            } else {
+                const labels = { starting: "Starting", running: "Running", waiting: "Waiting", completed: "Done",
+                    failed: "Failed", cancelled: "Cancelled", interrupted: "Interrupted" };
+                appendChatBlockLines(lines, buildChatMessageLines({ ...message, cardTitle: "Native tasks",
+                    cardTitleColor: "cyan", cardBorderColor: "cyan",
+                    text: message.tasks.map(task => `[${labels[task.status] || task.status}] ${task.title}`
+                        + (task.toolCalls ? ` · ${task.toolCalls} calls` : "")
+                        + (task.error || task.result || task.preview ? `\n  ${String(task.error || task.result || task.preview).replace(/\s+/g, " ").slice(0, 240)}` : "")).join("\n\n"),
+                }, maxWidth, buildOptions));
+            }
+        } else if (message?.kind === "epoch-divider") {
             lines.push(buildEpochDividerLine(message, maxWidth));
         } else if (message?.kind === "regen-refused") {
             lines.push(buildRegenRefusedLine(message, maxWidth));
@@ -4422,11 +4454,12 @@ export function selectAdminConsole(state) {
     // Settings tree — the session-list-slot navigation. Rendered by both
     // hosts; `kind` drives affordances (section rows switch panes, package
     // rows select a package).
-    const section = ["providers", "packages", "workers"].includes(admin.section) ? admin.section : "providers";
+    const section = ["providers", "packages", "workers", "features"].includes(admin.section) ? admin.section : "providers";
     const settingsTree = [
         { id: "providers", kind: "section", depth: 0, label: "Model Providers", selected: false },
         { id: "myProviders", kind: "subsection", depth: 1, label: "My Providers", selected: section === "providers" && providerPage === "mine" },
         ...(isAdmin ? [{ id: "sharedProviders", kind: "subsection", depth: 1, label: "Shared Providers", selected: section === "providers" && providerPage === "shared" }] : []),
+        { id: "features", kind: "section", depth: 0, label: "Feature flags", selected: section === "features" },
         { id: "agents", kind: "section", depth: 0, label: "Agents", selected: section === "packages" && !pkgState.selectedName },
         { id: "group:shared", kind: "group", depth: 1, label: "Shared", count: sharedRows.length },
         ...sharedRows.map((row) => ({ id: `pkg:shared:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),

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

@@ -771,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: {