@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/controllers/conversation-request-hydration.js

@@ -0,0 +1,88 @@
+import { isStoppedRequest, restoreStoppedResponses } from "../lib/request-stop-state.js";
+import { isApprovalPresentation, rememberRequestLifecycle } from "../lib/request-lifecycle-view.js";
+import { textOf } from "../lib/text-format.js";
+import { canRestoreSnapshotQueue } from "./history-pagination.js";
+
+function isBindableResponse(message) {
+  if (message.role !== "assistant" || !message.requestId) return false;
+  return !isApprovalPresentation(message);
+}
+function isStreamingRequest(request) {
+  if (!request.requestId) return false;
+  return request.status === "streaming";
+}
+function isQueuedTerminalRequest(request, queued) {
+  if (textOf(request.requestId) !== queued?.waitForRequestId) return false;
+  return request.status === "completed" || request.status === "failed";
+}
+function requestsForEventRestoration(requests, streamingRequestIds, appendEvents) {
+  if (!appendEvents) return requests;
+  // Existing live rows already contain received tokens. Resume their events only after lastSeq.
+  return requests.map((request) => streamingRequestIds.has(request.requestId) ? { ...request, events: [] } : request);
+}
+
+/** Shared snapshot lifecycle restoration; the caller owns the visible history window. */
+export function createConversationRequestHydration({
+  state, client, selectedEnvironmentId, sessionQueue, applyConversationChrome, renderSessions,
+  updateComposerSendState, reportQueueFailure, activeAssistantForRequest, restoreSessionEventState,
+  subscribeSession, subscribeRequest, replayRequestEvents, resumeRequest, recoverBlockedQueue, drainQueuedMessage, renderMessages,
+}) {
+  function isCurrentHydration(scope, viewVersion) {
+    if (scope.environmentId !== selectedEnvironmentId()) return false;
+    if (scope.sessionId !== state.currentSessionId) return false;
+    return viewVersion === state.sessionViewVersion;
+  }
+  async function restore(requests, { appendEvents = false } = {}) {
+    const scope = { environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId };
+    const viewVersion = state.sessionViewVersion;
+    for (const message of state.messages) {
+      if (!isBindableResponse(message)) continue;
+      state.requestMessages.set(message.requestId, message.id);
+    }
+    for (const request of requests) rememberRequestLifecycle(state, request.lifecycle);
+    applyConversationChrome();
+    renderSessions();
+    const streamingRequestIds = new Set(requests
+      .filter(isStreamingRequest)
+      .map((request) => textOf(request.requestId)));
+    if (streamingRequestIds.size === 1) {
+      const [streamingRequestId] = streamingRequestIds;
+      try { sessionQueue.rebindBlocked(scope, streamingRequestId); }
+      catch (error) {
+        reportQueueFailure(scope, `The active request was restored, but the remaining Send next queue is paused: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    state.activeRequestId = [...streamingRequestIds][0] || "";
+    updateComposerSendState();
+    for (const requestId of streamingRequestIds) activeAssistantForRequest(requestId);
+    restoreStoppedResponses(state.messages, requests);
+    restoreSessionEventState(requestsForEventRestoration(requests, streamingRequestIds, appendEvents), streamingRequestIds, appendEvents);
+    for (const requestId of streamingRequestIds) {
+      subscribeRequest(requestId);
+      await replayRequestEvents(requestId, viewVersion);
+      if (!isCurrentHydration(scope, viewVersion)) return false;
+      resumeRequest(requestId);
+    }
+    if (state.activeRequestId) { renderMessages(); return true; }
+    recoverBlockedQueue(scope);
+    const queued = sessionQueue.peek(scope);
+    const terminal = requests.find((request) => isQueuedTerminalRequest(request, queued));
+    if (terminal) await drainQueuedMessage({ ...scope, terminalRequestId: terminal.requestId, cancelled: isStoppedRequest(terminal) });
+    if (!isCurrentHydration(scope, viewVersion)) return false;
+    renderMessages();
+    return true;
+  }
+  async function rehydrate(requests) {
+    const scope = { environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId };
+    const viewVersion = state.sessionViewVersion;
+    const waitingRequestId = sessionQueue.peek(scope)?.waitForRequestId;
+    if (!canRestoreSnapshotQueue({ requests }, waitingRequestId)) {
+      const snapshot = await client.loadSession(scope.sessionId, scope.environmentId, { waitingRequestId });
+      if (!isCurrentHydration(scope, viewVersion)) return false;
+      requests = snapshot.requests || [];
+    }
+    subscribeSession(scope.sessionId);
+    return restore(requests, { appendEvents: true });
+  }
+  return { restore, rehydrate };
+}

package/dist/src/web-ui/app/controllers/conversation-session-controller.d.ts

@@ -47,10 +47,11 @@ export interface ConversationSessionClient {
     readThroughMessageId: number | string | null;
     readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
-  listSessions(environmentId: string): Promise<Record<string, unknown>>;
+  listSessions(environmentId: string, page?: Record<string, unknown>): Promise<Record<string, unknown>>;
   loadSession(
     sessionId: string,
     environmentId: string,
+    page?: Record<string, unknown>,
   ): Promise<Record<string, unknown>>;
   fetchRequestEvents(options: {
     requestId: string;
@@ -125,6 +126,7 @@ export declare function normalizeConversationMessage(
 export declare function createConversationSessionController(
   options: ConversationSessionControllerOptions,
 ): {
+  history: { load(direction?: "older" | "newer"): Promise<void>; latest(): Promise<void>; hasNewer(): boolean };
   activateRequestForScope(
     scope: { environmentId: string; sessionId: string },
     requestId: string,
@@ -150,12 +152,16 @@ export declare function createConversationSessionController(
   invalidateEnvironmentLoads(): void;
   loadSessions(): Promise<ConversationSession[]>;
   markCurrentSessionReadSoon(): void;
+  rehydrateRequests(requests: Record<string, unknown>[]): Promise<boolean>;
   normalizeMessage(raw: unknown): ConversationMessage;
   openSession(
     sessionId: string,
     options?: {
-      isRouteCurrent(): boolean;
-      commitRouteNavigation(): boolean;
+      isRouteCurrent?(): boolean;
+      commitRouteNavigation?(): boolean;
+      snapshot?: Record<string, unknown>;
+      page?: Record<string, unknown>;
+      preserveCurrentWindow?: boolean;
     },
   ): Promise<void>;
   requestBelongsToCurrentView(requestId: string): boolean;

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

@@ -1,19 +1,27 @@
-import { mergeSessionListReadState } from "../lib/session-read-state.js";
+import {
+  captureContextReplayScope,
+  bindContextReplayEvents,
+  isContextReplayCurrent,
+} from "../lib/context-window-replay.js";
+import { synchronizeContextRequestLifecycle } from "../lib/context-window-state.js";
+import { createSessionListPagination } from "./session-list-pagination.js";
+import { createHistoryPagination, canRestoreSnapshotQueue } from "./history-pagination.js";
 import { createConversationReadStateController } from "./conversation-read-state-controller.js";
+import { createConversationRequestHydration } from "./conversation-request-hydration.js";
 import { normalizeScheduleReference } from "../lib/schedule-message.js";
-import { createWebSessionId, escapeHtml, textOf } from "../lib/text-format.js";
+import { createWebSessionId, textOf } from "../lib/text-format.js";
 import { insertRequestUserMessageBeforeAssistant } from "../ui-behavior.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
-import { sparkProposalId } from "../lib/spark-proposal-message.js";
 import {
-  isStoppedRequest,
-  restoreStoppedResponses,
-} from "../lib/request-stop-state.js";
+  sparkProposalId,
+  sparkHandoffAvailable,
+} from "../lib/spark-proposal-message.js";
 import {
   isApprovalPresentation,
   requestLifecycles,
   rememberRequestLifecycle,
   sameConversationMessage,
+  mergeConversationMessage,
 } from "../lib/request-lifecycle-view.js";
 
 export function normalizeConversationMessage(raw, fallbackIndex = 0) {
@@ -31,6 +39,7 @@ export function normalizeConversationMessage(raw, fallbackIndex = 0) {
     streaming: false,
     schedule: normalizeScheduleReference(message?.schedule),
     sparkProposalId: sparkProposalId(message),
+    sparkHandoffAvailable: sparkHandoffAvailable(message),
     events: Array.isArray(message?.events)
       ? message.events.map((event) => textOf(event)).filter(Boolean)
       : [],
@@ -72,12 +81,19 @@ export function createConversationSessionController({
   onSessionCreated = () => {},
 }) {
   let environmentLoadRevision = 0;
-  let sessionListRevision = 0;
+  const listPagination = createSessionListPagination({ state, dom, client, sessions, selectedEnvironmentId, renderSessions, onSessionListState });
+  const history = createHistoryPagination({ state, dom, client, selectedEnvironmentId,
+    normalizeMessage: normalizeConversationMessage, renderMessages, conversationView, applyReadState: sessions.applyReadState,
+    onRequests: (requests) => restoreSessionEventState(requests, new Set(), true),
+    loadLatest: () => openSession(state.currentSessionId, { preserveCurrentWindow: true }),
+    onNewerPage: (messages) => markDisplayedMessagesReadSoon(messages),
+  });
   let sessionRestoreRevision = 0;
 
   function invalidateEnvironmentLoads() {
     environmentLoadRevision += 1;
-    sessionListRevision += 1;
+    listPagination.invalidate();
+    history.reset();
     sessionRestoreRevision += 1;
     state.sessions = [];
     onSessionListState({ status: "loading", sessions: [] });
@@ -88,7 +104,7 @@ export function createConversationSessionController({
     return normalizeConversationMessage(raw, state.messages.length);
   }
 
-  const { markCurrentSessionReadSoon } = createConversationReadStateController({
+  const { markCurrentSessionReadSoon, markDisplayedMessagesReadSoon } = createConversationReadStateController({
     state,
     client,
     selectedEnvironmentId,
@@ -97,6 +113,11 @@ export function createConversationSessionController({
     isConversationVisible,
     scheduleTask,
   });
+  const requestHydration = createConversationRequestHydration({
+    state, client, selectedEnvironmentId, sessionQueue, applyConversationChrome, renderSessions,
+    updateComposerSendState, reportQueueFailure, activeAssistantForRequest, restoreSessionEventState,
+    subscribeSession, subscribeRequest, replayRequestEvents, resumeRequest, recoverBlockedQueue, drainQueuedMessage, renderMessages,
+  });
 
   function addOrMergeMessage(message) {
     const id = textOf(message.id);
@@ -105,13 +126,7 @@ export function createConversationSessionController({
       sameConversationMessage(item, message),
     );
     if (existingIndex >= 0) {
-      state.messages[existingIndex] = {
-        ...state.messages[existingIndex],
-        ...message,
-        text: message.text || state.messages[existingIndex].text,
-        thinkingText:
-          message.thinkingText || state.messages[existingIndex].thinkingText,
-      };
+      state.messages[existingIndex] = mergeConversationMessage(state.messages[existingIndex], message);
     } else {
       state.messages.push(message);
     }
@@ -146,6 +161,7 @@ export function createConversationSessionController({
   }
 
   function resetLiveRequestView() {
+    history.reset();
     state.events = [];
     state.taskProgressByRequest.clear();
     state.contextWindowByRequest.clear();
@@ -189,11 +205,7 @@ export function createConversationSessionController({
 
   function shouldAcceptRealtimeMessage(message) {
     const sessionId = textOf(message.sessionId);
-    if (
-      sessionId &&
-      state.currentSessionId &&
-      sessionId !== state.currentSessionId
-    ) {
+    if (sessionId && sessionId !== state.currentSessionId) {
       return false;
     }
     const requestId = textOf(message.requestId);
@@ -247,21 +259,26 @@ export function createConversationSessionController({
   function restoreSessionEventState(
     requests = [],
     hydrateRequestIds = new Set(),
+    append = false,
   ) {
-    state.events = [];
-    state.taskProgressByRequest.clear();
-    state.contextWindowByRequest.clear();
+    if (!append) {
+      state.events = [];
+      state.taskProgressByRequest.clear();
+      state.contextWindowByRequest.clear();
+    }
     const requestEvents = [];
     for (const request of requests) {
+      rememberRequestLifecycle(state, request.lifecycle);
       if (!Array.isArray(request.events)) continue;
-      const normalizedEvents = request.events.map(normalizeRealtimeMessage);
-      normalizedEvents.sort((left, right) => {
-        const leftTime =
-          typeof left.timestamp === "number" ? left.timestamp : 0;
-        const rightTime =
-          typeof right.timestamp === "number" ? right.timestamp : 0;
-        return (left.seqNo || 0) - (right.seqNo || 0) || leftTime - rightTime;
-      });
+      const replayScope = captureContextReplayScope(
+        state,
+        selectedEnvironmentId(),
+        request.requestId,
+      );
+      const normalizedEvents = bindContextReplayEvents(
+        request.events,
+        replayScope,
+      );
       requestEvents.push(...normalizedEvents);
     }
     hydrateThinkingTextFromEvents(requestEvents, hydrateRequestIds);
@@ -269,6 +286,14 @@ export function createConversationSessionController({
       if (hydrateRequestIds.has(event.requestId)) handleRealtimeMessage(event);
       else recordEvent(event);
     }
+    for (const request of requests) {
+      if (!request.lifecycle) continue;
+      synchronizeContextRequestLifecycle(
+        state,
+        { name: "request.lifecycle.changed", lifecycle: request.lifecycle },
+        selectedEnvironmentId(),
+      );
+    }
     if (requestEvents.length === 0) {
       for (const message of state.messages) {
         for (const marker of message.events || []) {
@@ -324,6 +349,11 @@ export function createConversationSessionController({
   }
 
   async function replayRequestEvents(requestId, viewVersion) {
+    const replayScope = captureContextReplayScope(
+      state,
+      selectedEnvironmentId(),
+      requestId,
+    );
     const afterSeq = state.lastSeqByRequest.get(requestId) || 0;
     let events = [];
     try {
@@ -345,50 +375,14 @@ export function createConversationSessionController({
     ) {
       return;
     }
+    if (!isContextReplayCurrent(replayScope, state, selectedEnvironmentId()))
+      return;
     if (afterSeq === 0) resetAssistantForReplay(requestId);
-    for (const event of events) handleRealtimeMessage(event);
+    for (const event of bindContextReplayEvents(events, replayScope))
+      handleRealtimeMessage(event);
   }
 
-  async function loadSessions() {
-    const environmentRevision = environmentLoadRevision;
-    const requestRevision = ++sessionListRevision;
-    const environmentId = selectedEnvironmentId();
-    onSessionListState({ status: "loading", sessions: state.sessions });
-    try {
-      const payload = await client.listSessions(environmentId);
-      if (
-        environmentRevision !== environmentLoadRevision ||
-        requestRevision !== sessionListRevision ||
-        environmentId !== selectedEnvironmentId()
-      ) {
-        return [];
-      }
-      state.sessions = mergeSessionListReadState(
-        Array.isArray(payload.sessions) ? payload.sessions : [],
-        state.sessions,
-      );
-      onSessionListState({ status: "ready", sessions: state.sessions });
-      renderSessions();
-      return state.sessions;
-    } catch (error) {
-      if (
-        environmentRevision !== environmentLoadRevision ||
-        requestRevision !== sessionListRevision ||
-        environmentId !== selectedEnvironmentId()
-      ) {
-        return [];
-      }
-      onSessionListState({
-        status: "error",
-        sessions: state.sessions,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      dom.sessionsList.innerHTML = `<div class="empty-state error-text">${escapeHtml(
-        error instanceof Error ? error.message : String(error),
-      )}</div>`;
-      return [];
-    }
-  }
+  const loadSessions = () => listPagination.load();
 
   async function restoreLastSession() {
     const environmentRevision = environmentLoadRevision;
@@ -399,33 +393,38 @@ export function createConversationSessionController({
       environmentRevision !== environmentLoadRevision ||
       restoreRevision !== sessionRestoreRevision ||
       environmentId !== selectedEnvironmentId() ||
-      availableSessions.length === 0 ||
       state.currentSessionId
     ) {
       return;
     }
     const savedSessionId = preferences.sessionIdForEnvironment(environmentId);
-    const targetSession =
-      availableSessions.find((session) => session.id === savedSessionId) ||
-      availableSessions[0];
-    if (targetSession?.id) await openSession(targetSession.id);
+    const targetId = savedSessionId || availableSessions[0]?.id;
+    if (!targetId) return;
+    try { await openSession(targetId); }
+    catch (error) {
+      if (error.code !== "session_not_found") throw error;
+      if (availableSessions[0]?.id && availableSessions[0].id !== targetId) await openSession(availableSessions[0].id);
+    }
   }
 
   async function openSession(
     sessionId,
-    { isRouteCurrent, commitRouteNavigation } = {},
+    { isRouteCurrent, commitRouteNavigation, snapshot, page, preserveCurrentWindow = false } = {},
   ) {
     const routeOwned = typeof commitRouteNavigation === "function";
+    const loadBeforeReset = routeOwned || preserveCurrentWindow;
     let payload;
-    if (routeOwned) {
+    const pageOptions = { ...page, waitingRequestId: sessionQueue.peek({ environmentId: selectedEnvironmentId(), sessionId })?.waitForRequestId };
+    const prefetched = canRestoreSnapshotQueue(snapshot, pageOptions.waitingRequestId) ? snapshot : undefined;
+    if (loadBeforeReset) {
       const environmentId = selectedEnvironmentId();
       const viewVersion = state.sessionViewVersion;
       const currentSessionId = state.currentSessionId;
-      payload = await client.loadSession(sessionId, environmentId);
+      payload = prefetched ?? await client.loadSession(sessionId, environmentId, pageOptions);
       if (environmentId !== selectedEnvironmentId()) return;
       if (viewVersion !== state.sessionViewVersion) return;
       if (currentSessionId !== state.currentSessionId) return;
-      if (isRouteCurrent?.() !== true) return;
+      if (routeOwned && isRouteCurrent?.() !== true) return;
     }
     if (
       state.currentSessionId &&
@@ -451,8 +450,8 @@ export function createConversationSessionController({
     renderMessages();
     subscribeSession(sessionId);
 
-    if (!routeOwned) {
-      payload = await client.loadSession(sessionId, selectedEnvironmentId());
+    if (!loadBeforeReset) {
+      payload = prefetched ?? await client.loadSession(sessionId, selectedEnvironmentId(), pageOptions);
     }
     if (
       state.currentSessionId !== sessionId ||
@@ -460,87 +459,17 @@ export function createConversationSessionController({
     ) {
       return;
     }
+    history.adopt(payload);
     const rawMessages = Array.isArray(payload.messages) ? payload.messages : [];
-    const scope = { environmentId: selectedEnvironmentId(), sessionId };
     state.messages = rawMessages.map((message, index) =>
       normalizeConversationMessage(message, index),
     );
+    const displayedPage = [...state.messages];
     sessions.applyTitle(sessionId, payload.title);
     sessions.applyReadState(sessionId, payload.readState);
-    for (const message of state.messages) {
-      if (
-        message.role === "assistant" &&
-        message.requestId &&
-        !isApprovalPresentation(message)
-      ) {
-        state.requestMessages.set(message.requestId, message.id);
-      }
-    }
     const requests = Array.isArray(payload.requests) ? payload.requests : [];
-    for (const request of requests)
-      rememberRequestLifecycle(state, request.lifecycle);
-    applyConversationChrome();
-    renderSessions();
-    const streamingRequestIds = new Set(
-      requests
-        .filter(
-          (request) => request.status === "streaming" && request.requestId,
-        )
-        .map((request) => textOf(request.requestId)),
-    );
-    if (streamingRequestIds.size === 1) {
-      const [streamingRequestId] = streamingRequestIds;
-      try {
-        sessionQueue.rebindBlocked(scope, streamingRequestId);
-      } catch (error) {
-        reportQueueFailure(
-          scope,
-          `The active request was restored, but the remaining Send next queue is paused: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-    state.activeRequestId = [...streamingRequestIds][0] || "";
-    updateComposerSendState();
-    for (const requestId of streamingRequestIds) {
-      activeAssistantForRequest(requestId);
-    }
-    restoreStoppedResponses(state.messages, requests);
-    restoreSessionEventState(requests, streamingRequestIds);
-    for (const request of requests) {
-      if (request.status === "streaming" && request.requestId) {
-        subscribeRequest(request.requestId);
-        await replayRequestEvents(request.requestId, viewVersion);
-        if (
-          state.currentSessionId !== sessionId ||
-          state.sessionViewVersion !== viewVersion
-        ) {
-          return;
-        }
-        resumeRequest(request.requestId);
-      }
-    }
-    if (!state.activeRequestId) {
-      recoverBlockedQueue(scope);
-      const queued = sessionQueue.peek(scope);
-      const terminal = queued
-        ? requests.find(
-            (request) =>
-              textOf(request.requestId) === queued.waitForRequestId &&
-              (request.status === "completed" || request.status === "failed"),
-          )
-        : null;
-      if (terminal) {
-        await drainQueuedMessage({
-          ...scope,
-          terminalRequestId: terminal.requestId,
-          cancelled: isStoppedRequest(terminal),
-        });
-      }
-    }
-    renderMessages();
-    markCurrentSessionReadSoon();
+    if (!await requestHydration.restore(requests)) return;
+    markDisplayedMessagesReadSoon(displayedPage);
   }
 
   function ensureSession() {
@@ -605,6 +534,7 @@ export function createConversationSessionController({
   }
 
   return {
+    history,
     activateRequestForScope,
     activeAssistantForRequest,
     addOrMergeMessage,
@@ -619,6 +549,7 @@ export function createConversationSessionController({
     invalidateEnvironmentLoads,
     loadSessions,
     markCurrentSessionReadSoon,
+    rehydrateRequests: requestHydration.rehydrate,
     normalizeMessage,
     openSession,
     requestBelongsToCurrentView,

package/dist/src/web-ui/app/controllers/conversation-view-feature.js

@@ -1,14 +1,11 @@
 import { createConversationView } from "../components/conversation-view.js";
 import { createConversationFilePreviewFeature } from "./conversation-file-preview-feature.js";
-import { createSparkConversationActions } from "../components/spark-conversation-actions.js";
 
 export function createConversationViewFeature({
   filePreviewClient,
   getFileEnvironmentId,
   getFileSessionId,
-  preferences,
-  archiveSession,
-  onSparkArchived,
+  sparkActions = { createNode: () => null },
   ...viewOptions
 }) {
   const {
@@ -28,15 +25,5 @@ export function createConversationViewFeature({
     documentRoot,
     viewport,
   });
-  const sparkActions = createSparkConversationActions({
-    getScope: () => ({ environmentId: getFileEnvironmentId?.(), sessionId: getFileSessionId?.() }),
-    getMessages: viewOptions.getMessages,
-    getActiveRequestId,
-    preferences,
-    archiveSession,
-    onArchived: onSparkArchived,
-    notify: viewOptions.notify,
-    documentRoot,
-  });
   return createConversationView({ ...viewOptions, filePreview, sparkActions });
 }

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

@@ -19,6 +19,8 @@ export function createDashboardController({
     activityError: "",
     loadingSessions: true,
     sessionsError: "",
+    activeAutomations: [],
+    automationStatusUnavailable: false,
   };
   let active = false;
   let ready = false;
@@ -26,6 +28,7 @@ export function createDashboardController({
   let environmentId = "";
   let sessionsEnvironmentId = "";
   let revision = 0;
+  let automationRevision = 0;
   const pendingResources = new Set();
   const eventRefresh = createEventRefresh({
     canRefresh,
@@ -41,6 +44,7 @@ export function createDashboardController({
     return {
       ...state,
       sessions,
+      environmentId: getEnvironmentId(),
       supportsSchedules: client.supportsSchedules(),
       ...approvalData?.snapshot(),
     };
@@ -50,6 +54,14 @@ export function createDashboardController({
     if (readRevision !== revision) return false;
     return readEnvironmentId === getEnvironmentId();
   }
+  function hasCurrentAutomationRead(readRevision, readEnvironmentId) {
+    if (readRevision !== automationRevision) return false;
+    return readEnvironmentId === getEnvironmentId();
+  }
+  function hasActiveAutomationRun(item) {
+    if (!item.latestRunId) return false;
+    return ["pending", "running", "stopping"].includes(item.latestRunStatus);
+  }
   function canRefresh() {
     if (!isRuntimeReady()) return false;
     if (!ready) return false;
@@ -99,19 +111,40 @@ export function createDashboardController({
       }
     }
   }
+  async function refreshAutomations() {
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++automationRevision;
+    if (!client.supportsAutomations?.()) {
+      state.activeAutomations = [];
+      state.automationStatusUnavailable = false;
+      publish();
+      return;
+    }
+    try {
+      const result = await client.listAutomations(readEnvironmentId);
+      if (!hasCurrentAutomationRead(readRevision, readEnvironmentId)) return;
+      state.activeAutomations = (result.automations || []).filter(hasActiveAutomationRun);
+      state.automationStatusUnavailable = false;
+    } catch {
+      if (!hasCurrentAutomationRead(readRevision, readEnvironmentId)) return;
+      state.automationStatusUnavailable = true;
+    }
+    publish();
+  }
   async function readPendingResources() {
     const resources = [...pendingResources];
     pendingResources.clear();
     const readers = {
       sessions: loadSessions,
       activity: refreshActivity,
+      automations: refreshAutomations,
       approvals: () => approvalData?.refresh(),
     };
     await Promise.allSettled(resources.map((resource) => readers[resource]()));
   }
   function refresh() {
     if (!canRefresh()) return Promise.resolve();
-    for (const resource of ["sessions", "activity", "approvals"])
+    for (const resource of ["sessions", "activity", "automations", "approvals"])
       pendingResources.add(resource);
     return eventRefresh.run();
   }
@@ -135,10 +168,15 @@ export function createDashboardController({
       }
       runtimeReady = available;
       revision += 1;
+      automationRevision += 1;
       if (!available) approvalData?.invalidate();
       cancelRefresh();
       state.activityError = "";
       state.sessionsError = "";
+      if (!available) {
+        state.activeAutomations = [];
+        state.automationStatusUnavailable = false;
+      }
       publish();
       if (available) void refresh();
     },
@@ -165,6 +203,7 @@ export function createDashboardController({
     environmentChanged() {
       cancelRefresh();
       revision += 1;
+      automationRevision += 1;
       approvalData?.invalidate();
       sessionsEnvironmentId = "";
       activitySettled = false;
@@ -174,6 +213,8 @@ export function createDashboardController({
         sessionsError: "",
         loadingActivity: true,
         loadingSessions: true,
+        activeAutomations: [],
+        automationStatusUnavailable: false,
       });
       publish();
       void refresh();