@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/controllers/realtime-event-controller.js

@@ -16,9 +16,15 @@ import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 import { reduceTaskProgress } from "../lib/task-progress.js";
 import { projectWebSourceEvent } from "../lib/web-source-event.js";
 import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
-import { canReplaceContextWindowEvidence } from "../lib/context-window-snapshot-order.js";
+import {
+  contextEvidenceScope,
+  contextEvidenceOrder,
+  reduceContextWindowEvidence,
+  synchronizeContextRequestLifecycle,
+} from "../lib/context-window-state.js";
 import { isWorkspaceChange } from "../lib/workspace-change.js";
 import { createRequestLifecycleController } from "./request-lifecycle-controller.js";
+import { ownsToolApprovalAcknowledgement } from "../lib/tool-approval-acknowledgement.js";
 
 export { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 export { taskStatusClass } from "../lib/task-progress.js";
@@ -75,6 +81,12 @@ export function createRealtimeEventController({
 }) {
   const lifecycleController = createRequestLifecycleController({
     state,
+    onAcceptedLifecycle: (message) =>
+      synchronizeContextRequestLifecycle(
+        state,
+        message,
+        selectedEnvironmentId(),
+      ),
     addOrMergeMessage,
     normalizeChatMessage,
     activeAssistantForRequest,
@@ -119,161 +131,17 @@ export function createRealtimeEventController({
   }
 
   function updateContextWindow(message) {
-    const eventName = textOf(message.name || message.rawType);
-    const requestId = textOf(message.requestId) || state.activeRequestId;
-    if (!requestId) return;
-    const current = state.contextWindowByRequest.get(requestId) || {
+    const requestId = textOf(message.requestId);
+    const current = state.contextWindowByRequest.get(requestId);
+    const scope = contextEvidenceScope(
+      state,
+      selectedEnvironmentId(),
       requestId,
-      snapshot: null,
-      providerUsage: null,
-      pendingCompaction: null,
-      lastCompaction: null,
-      lastCompactionEvent: null,
-    };
-    if (eventName === "context.window.snapshot") {
-      const contextWindowTokens = Number(message.contextWindowTokens);
-      const estimatedInputTokens = Number(message.estimatedInputTokens);
-      const usedContextPercent = Number(message.usedContextPercent);
-      const remainingContextTokens = Number(message.remainingContextTokens);
-      if (
-        !Number.isFinite(contextWindowTokens) ||
-        contextWindowTokens <= 0 ||
-        !Number.isFinite(estimatedInputTokens) ||
-        estimatedInputTokens < 0 ||
-        !Number.isFinite(usedContextPercent)
-      ) {
-        return;
-      }
-      const previous = current.snapshot;
-      if (!canReplaceContextWindowEvidence(previous, message)) return;
-      const snapshot = {
-        requestId,
-        eventSequence: message.eventSequence,
-        seqNo: message.seqNo,
-        invocationId: textOf(message.invocationId),
-        modelStep: textOf(message.modelStep),
-        profileId: textOf(message.profileId),
-        provider: textOf(message.provider),
-        model: textOf(message.model),
-        measurement: textOf(message.measurement, "estimated"),
-        source: textOf(message.source, "runtime_token_estimator"),
-        admissionOutcome: textOf(message.admissionOutcome),
-        contextWindowTokens,
-        estimatedInputTokens,
-        remainingContextTokens: Number.isFinite(remainingContextTokens)
-          ? remainingContextTokens
-          : Math.max(0, contextWindowTokens - estimatedInputTokens),
-        usedContextPercent,
-        remainingContextPercent: Number(message.remainingContextPercent),
-        compactionTriggerPercent: Number(message.compactionTriggerPercent),
-        outputReserveTokens: Number(message.outputReserveTokens),
-        safetyReserveTokens: Number(message.safetyReserveTokens),
-        attachmentReserveTokens: Number(message.attachmentReserveTokens),
-        formatReserveTokens: Number(message.formatReserveTokens),
-      };
-      let lastCompaction = current.lastCompaction;
-      if (
-        current.pendingCompaction &&
-        previous?.profileId === snapshot.profileId &&
-        snapshot.usedContextPercent < previous.usedContextPercent
-      ) {
-        lastCompaction = {
-          beforePercent:
-            current.pendingCompaction.beforePercent ??
-            previous.usedContextPercent,
-          afterPercent: snapshot.usedContextPercent,
-        };
-      }
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        snapshot,
-        lastCompaction,
-        pendingCompaction: lastCompaction ? null : current.pendingCompaction,
-      });
-      return true;
-    }
-    if (eventName === "context.window.provider_usage") {
-      if (!canReplaceContextWindowEvidence(current.providerUsage, message))
-        return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        providerUsage: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-          invocationId: textOf(message.invocationId),
-          modelStep: textOf(message.modelStep),
-          profileId: textOf(message.profileId),
-          source: textOf(message.source, "provider_reported"),
-          inputTokens: Number(message.inputTokens),
-          outputTokens: Number(message.outputTokens),
-          totalTokens: Number(message.totalTokens),
-        },
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.started") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      if (!canReplaceContextWindowEvidence(current.snapshot, message)) return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: {
-          beforePercent: Number.isFinite(
-            Number(message.beforeUsedContextPercent),
-          )
-            ? Number(message.beforeUsedContextPercent)
-            : current.snapshot?.usedContextPercent,
-        },
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.completed") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      const beforePercent = Number(message.beforeUsedContextPercent);
-      const afterPercent = Number(message.afterUsedContextPercent);
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: null,
-        lastCompaction:
-          Number.isFinite(beforePercent) && Number.isFinite(afterPercent)
-            ? { beforePercent, afterPercent }
-            : current.lastCompaction,
-      });
-      return true;
-    }
-    if (eventName === "context.compaction.failed") {
-      if (
-        !canReplaceContextWindowEvidence(current.lastCompactionEvent, message)
-      )
-        return;
-      state.contextWindowByRequest.set(requestId, {
-        ...current,
-        requestId,
-        lastCompactionEvent: {
-          eventSequence: message.eventSequence,
-          seqNo: message.seqNo,
-        },
-        pendingCompaction: null,
-      });
-      return true;
-    }
+    );
+    const next = reduceContextWindowEvidence(current, message, scope);
+    if (!next || next === current) return false;
+    state.contextWindowByRequest.set(requestId, next);
+    return true;
   }
 
   function recordEvent(message) {
@@ -285,16 +153,16 @@ export function createRealtimeEventController({
     const eventSequence = hasOriginalEventSequence(message.eventSequence)
       ? message.eventSequence
       : undefined;
-    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
-      trackSeq(message);
-      return;
-    }
-    updateTaskProgress(message);
     const contextWindowUpdated = updateContextWindow(message);
     if (contextWindowUpdated) {
       renderContextWindow();
       renderActivityStatus();
     }
+    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
+      trackSeq(message);
+      return;
+    }
+    updateTaskProgress(message);
     const eventName = textOf(message.name || message.rawType || message.type);
     if (isLowValueActivityEvent(message)) {
       trackSeq(message);
@@ -308,6 +176,10 @@ export function createRealtimeEventController({
     const key = eventKeyFor({ ...message, requestId }, name, tone);
     const webSources = projectWebSourceEvent(message);
     const toolActivity = projectToolActivityEvent(message);
+    const contextOrder = contextEvidenceOrder(
+      message,
+      contextEvidenceScope(state, selectedEnvironmentId(), requestId),
+    );
     const lastEvent = state.events[state.events.length - 1];
     if (
       canMergeUnsequencedActivity(
@@ -321,6 +193,7 @@ export function createRealtimeEventController({
       lastEvent.count = (lastEvent.count || 1) + 1;
       lastEvent.summary = summary;
       lastEvent.updatedAt = Date.now();
+      Object.assign(lastEvent, contextOrder);
       if (typeof message.seqNo === "number")
         lastEvent.lastSeqNo = message.seqNo;
       lastEvent.eventName = eventName || lastEvent.eventName;
@@ -334,6 +207,7 @@ export function createRealtimeEventController({
         lastSeqNo:
           typeof message.seqNo === "number" ? message.seqNo : undefined,
         eventSequence,
+        ...contextOrder,
         updatedAt: Date.now(),
         type: message.type,
         rawType: message.rawType,
@@ -415,6 +289,14 @@ export function createRealtimeEventController({
   function handle(rawMessage) {
     const message = normalizeRealtimeMessage(rawMessage);
     if (message.type === "tool_approval_ack") {
+      if (
+        !ownsToolApprovalAcknowledgement(
+          message,
+          state,
+          selectedEnvironmentId(),
+        )
+      )
+        return;
       if (!message.accepted) {
         state.submittedToolApprovalIds.delete(message.approvalId);
         recordControlEvent({

package/dist/src/web-ui/app/controllers/request-lifecycle-controller.js

@@ -6,6 +6,7 @@ import {
 export function createRequestLifecycleController(options) {
   const {
     state,
+    onAcceptedLifecycle = () => {},
     addOrMergeMessage,
     normalizeChatMessage,
     activeAssistantForRequest,
@@ -21,6 +22,7 @@ export function createRequestLifecycleController(options) {
     if (message.name !== "request.lifecycle.changed") return false;
     const lifecycle = message.lifecycle;
     if (!rememberRequestLifecycle(state, lifecycle)) return true;
+    onAcceptedLifecycle(message);
     const requestId = lifecycle.requestId;
     const waiting = lifecycle.status === "awaiting_approval";
     if (waiting) removeStreamingPlaceholder(state, requestId);

package/dist/src/web-ui/app/controllers/runtime-onboarding-controller.d.ts

@@ -9,11 +9,15 @@ export interface RuntimeOnboardingControllerDependencies {
     runtimeAvailability: RuntimeAvailability;
   };
   readonly guide: Readonly<{
-    bind(options?: { onCheckAgain?: () => void | Promise<void> }): void;
+    bind(options?: {
+      onCheckAgain?: () => void | Promise<void>;
+      onApplied?: () => void | Promise<void>;
+    }): void;
     focusAction(): void;
     render(setup: RuntimeAvailability): void;
   }>;
   readonly reloadModels: () => void | Promise<void>;
+  readonly getEnvironmentId?: () => string;
   readonly setMessageStatus: (message: string) => void;
   readonly onStateChange?: () => void;
 }

package/dist/src/web-ui/app/controllers/runtime-onboarding-controller.js

@@ -40,13 +40,16 @@ export function createRuntimeOnboardingController({
   state,
   guide,
   reloadModels,
+  getEnvironmentId = () => "",
   setMessageStatus,
   onStateChange = () => {},
 }) {
   let checkPromise = null;
+  let checkRevision = 0;
+  let catalogEnvironmentId = getEnvironmentId();
 
   function bind() {
-    guide.bind({ onCheckAgain: checkAgain });
+    guide.bind({ onCheckAgain: checkAgain, onApplied: startCatalogCheck });
     render();
   }
 
@@ -54,7 +57,16 @@ export function createRuntimeOnboardingController({
     guide.render(state.runtimeAvailability);
   }
 
+  function resetCatalogEnvironment() {
+    const environmentId = getEnvironmentId();
+    if (catalogEnvironmentId === environmentId) return;
+    catalogEnvironmentId = environmentId;
+    state.runtimeAvailability = { status: "loading" };
+    render();
+  }
+
   function beginCatalogLoad() {
+    resetCatalogEnvironment();
     state.runtimeAvailability = {
       status: "checking",
       showGuide: guideWasVisible(state.runtimeAvailability),
@@ -95,11 +107,21 @@ export function createRuntimeOnboardingController({
     if (checkPromise || state.runtimeAvailability?.status === "checking") {
       return checkPromise || Promise.resolve();
     }
+    return startCatalogCheck();
+  }
+
+  function startCatalogCheck() {
+    const revision = ++checkRevision;
+    const availability = state.runtimeAvailability;
     const run = Promise.resolve()
       .then(() => reloadModels())
-      .catch((error) => catalogUnavailable(error));
+      .catch((error) => {
+        if (revision !== checkRevision) return;
+        if (availability !== state.runtimeAvailability) return;
+        catalogUnavailable(error);
+      });
     checkPromise = run.finally(() => {
-      checkPromise = null;
+      if (revision === checkRevision) checkPromise = null;
     });
     return checkPromise;
   }

package/dist/src/web-ui/app/controllers/schedules-controller.js

@@ -1,6 +1,5 @@
 import { createEventRefresh } from "../lib/event-refresh.js";
 import {
-  canManageSchedule,
   matchesScheduleFilter,
   scheduleErrorMessage,
 } from "../lib/schedule-presentation.js";
@@ -120,8 +119,8 @@ export function createSchedulesController({
     return !historySettled;
   }
 
-  function shouldOpenEntryEditor(
-    openFirstEditor,
+  function shouldSelectEntryJob(
+    selectFirstJob,
     environmentChanged,
     targetJobId,
     readSelectionRevision,
@@ -131,7 +130,7 @@ export function createSchedulesController({
     if (state.editor) return false;
     if (state.mutation) return false;
     if (!active) return false;
-    if (openFirstEditor) return true;
+    if (selectFirstJob) return true;
     return environmentChanged;
   }
 
@@ -145,15 +144,8 @@ export function createSchedulesController({
     return readSelectionRevision === selectionRevision;
   }
 
-  function openEntryScheduleEditor() {
-    const job = firstVisibleJob();
-    selectJobIdentity(job?.id || "");
-    if (!canManageSchedule(job)) return;
-    state.editor = { job, environmentId: getEnvironmentId() };
-  }
-
   function reconcileLoadedSelection(
-    openEditor,
+    selectEntryJob,
     targetJobId,
     readSelectionRevision,
   ) {
@@ -162,8 +154,8 @@ export function createSchedulesController({
       return;
     }
     if (state.editor) return;
-    if (openEditor) {
-      openEntryScheduleEditor();
+    if (selectEntryJob) {
+      selectJobIdentity(firstVisibleJob()?.id || "");
       return;
     }
     const selected = state.jobs.find((job) => job.id === state.selectedId);
@@ -217,7 +209,7 @@ export function createSchedulesController({
 
   async function load({
     background = false,
-    openFirstEditor = false,
+    selectFirstJob = false,
     targetJobId = "",
     waitForHistory = false,
   } = {}) {
@@ -258,8 +250,8 @@ export function createSchedulesController({
       state.defaultModelProfileId = models.defaultProfileId || "";
       state.error = "";
       reconcileLoadedSelection(
-        shouldOpenEntryEditor(
-          openFirstEditor,
+        shouldSelectEntryJob(
+          selectFirstJob,
           environmentChanged,
           targetJobId,
           readSelectionRevision,
@@ -425,7 +417,7 @@ export function createSchedulesController({
     selectionRevision += 1;
     Object.assign(state, { query: "", filter: scheduleEntryFilter(jobId), editor: null });
     selectJobIdentity(jobId, { routeNavigation: true });
-    await load({ targetJobId: jobId });
+    await load({ targetJobId: jobId, selectFirstJob: !jobId });
   }
 
   async function openCreate(initialValues = {}) {
@@ -483,7 +475,7 @@ export function createSchedulesController({
       eventRefresh.cancel();
       nextRefreshOptions = null;
       if (active) {
-        void refresh({ background: !entering, openFirstEditor: entering });
+        void refresh({ background: !entering, selectFirstJob: entering });
         return;
       }
       loadRevision += 1;

package/dist/src/web-ui/app/controllers/session-controller.js

@@ -27,6 +27,7 @@ export function createSessionController({
   confirmAction = window.confirm.bind(window),
   copyText = (value) => navigator.clipboard.writeText(value),
 }) {
+  let pagination;
   const titleOf = (session) =>
     textOf(session?.displayName || session?.title || session?.id);
   const byId = (sessionId) =>
@@ -34,7 +35,8 @@ export function createSessionController({
   const isPinned = (sessionId) => state.pinnedSessionIds.includes(sessionId);
   const sidebar = createSessionSidebarController({
     state, preferences, selectedEnvironmentId, showToast: shell?.showToast,
-    render: onSidebarChange ?? render, getFilteredSessions: filtered,
+    render: () => { (onSidebarChange ?? render)(); void pagination?.load(); }, getFilteredSessions: filtered,
+    getPageInfo: () => pagination?.info(),
   });
 
   function filtered() {
@@ -51,11 +53,14 @@ export function createSessionController({
   }
 
   function render() {
+    const scrollTop = dom.sessionsList.scrollTop;
     sessionActionsMenu.reset();
     dom.sessionsList.innerHTML = "";
     const sessions = filtered();
-    dom.sessionsCount.textContent = String(sessions.length);
+    dom.sessionsCount.textContent = String(pagination?.info().total ?? sessions.length);
     sidebar.renderSections({ root: dom.sessionsList, sessions, createSessionItem, renderGroups });
+    pagination?.renderFooter();
+    dom.sessionsList.scrollTop = scrollTop;
   }
 
   function createSessionItem(session, sessionIndex) {
@@ -229,6 +234,7 @@ export function createSessionController({
       : [sessionId, ...state.pinnedSessionIds];
     preferences.savePinnedSessions(state.pinnedSessionIds);
     render();
+    void pagination?.load();
   }
 
   async function copyFilename(sessionId) {
@@ -310,6 +316,8 @@ export function createSessionController({
   }
 
   return {
+    setPagination: (value) => { pagination = value; },
+    paginationQuery: sidebar.paginationQuery,
     archiveSession: (sessionId) => sidebar.archiveSession(sessionId),
     applyReadState,
     applyTitle,

package/dist/src/web-ui/app/controllers/session-list-pagination.js

@@ -0,0 +1,71 @@
+import { mergeSessionListReadState } from "../lib/session-read-state.js";
+
+export function createSessionListPagination({ state, dom, client, sessions, selectedEnvironmentId, renderSessions, onSessionListState }) {
+  let revision = 0;
+  let pending = false;
+  let nextCursor = null;
+  let pageInfo = {};
+  let queryKey = "";
+  let errorMessage = "";
+  const query = () => ({ ...sessions.paginationQuery?.(), query: state.sessionQuery || "" });
+  function invalidate() {
+    state.sessionOverview = undefined;
+    revision += 1; pending = false; nextCursor = null; pageInfo = {}; queryKey = ""; errorMessage = "";
+  }
+  function isCurrent(environmentId, version, key) {
+    if (version !== revision) return false;
+    if (environmentId !== selectedEnvironmentId()) return false;
+    return key === JSON.stringify(query());
+  }
+  async function load(more = false) {
+    const input = query();
+    const key = JSON.stringify(input);
+    if (more && (pending || !nextCursor || key !== queryKey)) return state.sessions;
+    if (!more) nextCursor = null;
+    const environmentId = selectedEnvironmentId();
+    const version = ++revision;
+    const cursor = more ? nextCursor : null;
+    pending = true; errorMessage = ""; queryKey = key;
+    onSessionListState({ status: "loading", sessions: state.sessions });
+    renderSessions();
+    try {
+      const payload = await client.listSessions(environmentId, { ...input, cursor });
+      if (!isCurrent(environmentId, version, key)) return [];
+      const incoming = Array.isArray(payload.sessions) ? payload.sessions : [];
+      const merged = more ? [...state.sessions, ...incoming] : incoming;
+      state.sessions = mergeSessionListReadState([...new Map(merged.map((session) => [session.id, session])).values()], state.sessions);
+      nextCursor = payload.nextCursor || null;
+      pageInfo = { total: payload.total, archivedCount: payload.archivedCount };
+      if (payload.overview) state.sessionOverview = payload.overview;
+      onSessionListState({ status: "ready", sessions: state.sessions });
+      return state.sessions;
+    } catch (error) {
+      if (!isCurrent(environmentId, version, key)) return [];
+      errorMessage = error instanceof Error ? error.message : String(error);
+      onSessionListState({ status: "error", sessions: state.sessions, error: errorMessage });
+      return [];
+    } finally {
+      if (version === revision) { pending = false; renderSessions(); }
+    }
+  }
+  function renderFooter() {
+    const root = dom.sessionsList;
+    if (!root?.ownerDocument) return;
+    if (!pending && !nextCursor && !errorMessage) return;
+    const button = root.ownerDocument.createElement("button");
+    button.type = "button";
+    button.className = "session-archive-toggle";
+    button.disabled = pending;
+    button.textContent = pending ? "Loading conversations…" : errorMessage ? "Could not load conversations — retry" : "Load more conversations";
+    button.addEventListener("click", () => void load(Boolean(nextCursor)));
+    root.appendChild(button);
+  }
+  dom.sessionsList?.addEventListener?.("scroll", () => {
+    const root = dom.sessionsList;
+    if (root.scrollHeight - root.scrollTop - root.clientHeight > 100) return;
+    if (!errorMessage) void load(true);
+  }, { passive: true });
+  const controller = { load, invalidate, renderFooter, info: () => pageInfo };
+  sessions.setPagination?.(controller);
+  return controller;
+}

package/dist/src/web-ui/app/controllers/session-sidebar-controller.js

@@ -6,7 +6,7 @@ import { renderSessionSidebarSections } from "../components/session-sidebar-sect
 import { filterSessionsByArchiveState } from "../lib/session-archive-visibility.js";
 
 export function createSessionSidebarController({
-  state, preferences, selectedEnvironmentId = () => "", render, showToast, getFilteredSessions,
+  state, preferences, selectedEnvironmentId = () => "", render, showToast, getFilteredSessions, getPageInfo = () => undefined,
 }) {
   let showingArchived = false;
   let environmentId = selectedEnvironmentId();
@@ -67,8 +67,10 @@ export function createSessionSidebarController({
       return;
     }
     const saved = savedPreferences();
+    const rankedIds = new Set(saved.orderedSessionIds);
+    const unrankedIds = orderedSessions().map((session) => session.id).filter((id) => !rankedIds.has(id));
     saved.orderedSessionIds = moveSidebarSession(
-      orderedSessions().map((session) => session.id), sourceId, targetId, placement,
+      [...unrankedIds, ...saved.orderedSessionIds], sourceId, targetId, placement,
     );
     if (saveSidebar(saved)) render();
   }
@@ -143,7 +145,7 @@ export function createSessionSidebarController({
     const saved = savedPreferences();
     renderSessionSidebarSections({
       ...options,
-      archivedCount: filterSessionsByArchiveState(state.sessions, saved.archivedSessionIds, true).length,
+      archivedCount: getPageInfo()?.archivedCount ?? filterSessionsByArchiveState(state.sessions, saved.archivedSessionIds, true).length,
       showingArchived,
       onToggleArchived: () => {
         showingArchived = !showingArchived;
@@ -155,5 +157,5 @@ export function createSessionSidebarController({
     });
   }
 
-  return { archiveSession, bindItem, renderSections, visibleSessions, isArchiveView: () => showingArchived };
+  return { paginationQuery: () => ({ ...savedPreferences(), archived: showingArchived, pinnedSessionIds: state.pinnedSessionIds }), archiveSession, bindItem, renderSections, visibleSessions, isArchiveView: () => showingArchived };
 }

package/dist/src/web-ui/app/controllers/spark-chat-notices.js

@@ -0,0 +1,34 @@
+function persistedAssistantMessages(snapshot) {
+  return (snapshot?.messages || []).filter((message) => message.role === "assistant" && message.id != null);
+}
+function messageIdentity(message) { return JSON.stringify([String(message.id), message.createdAt, message.requestId || null]); }
+
+export function createSparkChatNotices({ showNotice, setUnread, isVisible = () => document.visibilityState === "visible" }) {
+  let initialized = false;
+  let seen = new Set();
+  let deferredCount = 0;
+  function reconcile(snapshot, readState, { consolidated = false } = {}) {
+    const messages = persistedAssistantMessages(snapshot);
+    const fresh = messages.filter((message) => !seen.has(messageIdentity(message)));
+    seen = new Set(messages.map(messageIdentity));
+    const count = Number(readState?.unreadCount) || 0;
+    if (Number.isFinite(readState?.unreadCount)) setUnread(count);
+    if (!isVisible()) {
+      deferredCount = count;
+      initialized = true;
+      return;
+    }
+    if (!initialized || consolidated || deferredCount) {
+      initialized = true;
+      deferredCount = 0;
+      if (count) showNotice(`${count} unread ${count === 1 ? "message" : "messages"}`);
+      return;
+    }
+    if (!fresh.length) return;
+    for (const message of fresh) showNotice(String(message.text || message.content || "").slice(0, 350));
+  }
+  return {
+    reconcile,
+    reset() { initialized = false; seen.clear(); deferredCount = 0; setUnread(0); },
+  };
+}