@abot-ai/runtime 1.8.0 → 1.9.0

package/dist/src/web-ui/app/components/system-host/home-widget-permission-preview.js

@@ -0,0 +1,75 @@
+import { hostSetupIsReady } from "./rendering.js";
+import { hasNativePermissionSurface, permissionSummary } from "./macos-permission-rendering.js";
+import { canCheckMacPermissions, canCheckNativePermissions, permissionsMatchConnection, permissionsMatchNativeOwner } from "./macos-permission-scopes.js";
+
+function currentPermissionScopes(state) {
+  const snapshot = state.snapshot;
+  const scopes = [];
+  if (snapshot.identity?.os === "macos") {
+    scopes.push({
+      available: canCheckMacPermissions(snapshot),
+      current: permissionsMatchConnection(state.macPermissions, snapshot),
+      receipt: state.macPermissions,
+    });
+  }
+  if (hasNativePermissionSurface(snapshot)) {
+    const environmentId = snapshot.nativePermissions?.environmentId;
+    scopes.push({
+      available: canCheckNativePermissions(snapshot, environmentId),
+      current: permissionsMatchNativeOwner(state.nativeMacPermissions, snapshot, environmentId),
+      receipt: state.nativeMacPermissions,
+    });
+  }
+  return scopes;
+}
+
+function scopeRequiresPermission(scope) {
+  if (!scope.current) return false;
+  return permissionSummary(scope.receipt) === "action needed";
+}
+
+function scopeHasGrantedPermissions(scope) {
+  if (!scope.current) return false;
+  return permissionSummary(scope.receipt) === "granted";
+}
+
+function scopeCannotCheckPermissions(scope) {
+  return !scope.available;
+}
+
+function computerPermissionIndicator(state) {
+  const scopes = currentPermissionScopes(state);
+  if (scopes.some(scopeRequiresPermission))
+    return { icon: "failed", label: "Required", tone: "attention" };
+  if (!scopes.length)
+    return { icon: "neutral", label: "Unavailable", tone: "neutral" };
+  if (scopes.some(scopeCannotCheckPermissions))
+    return { icon: "paused", label: "Unavailable", tone: "neutral" };
+  if (scopes.every(scopeHasGrantedPermissions))
+    return { icon: "success", label: "Granted", tone: "success" };
+  return { icon: "unknown", label: "Not checked", tone: "neutral" };
+}
+
+function canPreviewConnectedComputer(state) {
+  if (state.snapshot?.connected !== true) return false;
+  if (!hostSetupIsReady(state.snapshot)) return false;
+  if (state.busy) return false;
+  if (state.downloaded) return false;
+  if (state.manualMac) return false;
+  return true;
+}
+
+/** Project current receipts without requesting permissions or changing connection state. */
+export function computerWidgetPreview(state, title, status) {
+  if (!canPreviewConnectedComputer(state)) return null;
+  const os = state.snapshot.identity?.os;
+  return {
+    kind: "computer",
+    title,
+    detail: { macos: "macOS", windows: "Windows", linux: "Linux" }[os] || os || "Unknown OS",
+    items: [
+      { label: "Connection", indicator: { icon: "success", label: status, tone: "success" } },
+      { label: "Permissions", indicator: computerPermissionIndicator(state) },
+    ],
+  };
+}

package/dist/src/web-ui/app/components/system-host/home-widget-summary.js

@@ -0,0 +1,93 @@
+import { connectionDescription, connectionStatus, connectionTitle, hostSetupIsReady } from "./rendering.js";
+import { isNativeWindowsLocalAccess, nativeWindowsAccessPresentation } from "./native-windows-access.js";
+import { computerWidgetPreview } from "./home-widget-permission-preview.js";
+import { macPermissionSummary, permissionSummary } from "./macos-permission-rendering.js";
+import { permissionsMatchConnection, permissionsMatchNativeOwner } from "./macos-permission-scopes.js";
+import { storeConnectionStage, storeConnectionDisplayContent, windowsStorePanelIsAvailable } from "./windows-store-setup.js";
+
+function currentMacPermissionStates(state) {
+  const snapshot = state.snapshot;
+  const states = [];
+  if (permissionsMatchConnection(state.macPermissions, snapshot))
+    states.push(permissionSummary(state.macPermissions));
+  if (permissionsMatchNativeOwner(state.nativeMacPermissions, snapshot, snapshot?.nativePermissions?.environmentId))
+    states.push(permissionSummary(state.nativeMacPermissions));
+  return states;
+}
+
+function hasComputerActionFailure(state) {
+  return Boolean(state.error || state.actionError || state.macPermissionError || state.nativeMacPermissionError);
+}
+
+function computerPermissionTone(state, permissionText) {
+  if (hasComputerActionFailure(state)) return "attention";
+  const status = connectionStatus(state.snapshot, state.statusUnavailable, state.busy);
+  if (["Paired · offline", "Update needed", "Computer access unavailable"].includes(status)) return "attention";
+  const states = currentMacPermissionStates(state);
+  if (states.includes("action needed")) return "attention";
+  // A connected Mac with unmeasured or unavailable permissions is not all-clear.
+  if (permissionText) return "neutral";
+  if (hostSetupIsReady(state.snapshot)) return "success";
+  return "neutral";
+}
+
+function windowsStoreTone(state, stage) {
+  if (hasComputerActionFailure(state)) return "attention";
+  if (state.busy) return "neutral";
+  const tones = { ready: "success", reconnect: "attention", expired: "attention", "confirm-repair": "attention", preparing: "active", repairing: "active", waiting: "active", open: "active" };
+  return tones[stage] || "neutral";
+}
+
+function nativeWindowsTone(state, status) {
+  if (hasComputerActionFailure(state)) return "attention";
+  if (status === "Check needed") return "attention";
+  return "neutral";
+}
+
+function windowsStoreSummary(state) {
+  const snapshot = state.snapshot;
+  const invitation = state.windowsStoreInvitation;
+  const stage = storeConnectionStage(snapshot, invitation, state.windowsStoreAttempt);
+  const content = storeConnectionDisplayContent(stage, snapshot, invitation, state.busy, state.statusUnavailable);
+  return {
+    title: snapshot.identity?.name || content.step,
+    detail: state.error || state.actionError || state.message || content.copy,
+    status: content.status,
+    tone: windowsStoreTone(state, stage),
+  };
+}
+
+/** Connection and process-bound permission receipts stay separate facts. */
+export function computerAccessWidgetSummary(state = {}, supported = true) {
+  const input = { ...state, supported };
+  if (!supported)
+    return { title: "Computer connection unavailable", detail: "Computer access setup requires the local Runtime backend.", status: "Unavailable", tone: "neutral" };
+  if (state.statusUnavailable)
+    return { title: "Check your computer connection", detail: "The current connection status could not be checked.", status: "Status unavailable", tone: "attention" };
+  if (!state.snapshot)
+    return { title: "Checking this computer…", detail: "", status: "Checking", tone: "neutral" };
+  if (isNativeWindowsLocalAccess(state.snapshot)) {
+    const presentation = nativeWindowsAccessPresentation(input);
+    return {
+      title: presentation.title,
+      detail: state.error || state.actionError || state.message || presentation.description,
+      status: presentation.status,
+      tone: nativeWindowsTone(state, presentation.status),
+    };
+  }
+  if (windowsStorePanelIsAvailable(state.snapshot)) return windowsStoreSummary(state);
+  const permissionText = macPermissionSummary(state.snapshot, state.macPermissions, state.nativeMacPermissions);
+  const title = state.snapshot.identity?.name || connectionTitle(input);
+  if (state.busy)
+    return { title, detail: "Waiting for the current connection status…", status: "Checking", tone: "neutral" };
+  const feedback = state.error || state.actionError || state.macPermissionError || state.nativeMacPermissionError || state.message;
+  const status = connectionStatus(state.snapshot, state.statusUnavailable, state.busy);
+  const preview = feedback ? null : computerWidgetPreview(state, title, status);
+  return {
+    title,
+    detail: feedback || permissionText || connectionDescription(input),
+    status,
+    tone: computerPermissionTone(state, permissionText),
+    ...(preview ? { preview } : {}),
+  };
+}

package/dist/src/web-ui/app/components/system-host/macos-permission-rendering.js

@@ -1,12 +1,12 @@
 import { escapeHtml } from "../../lib/text-format.js";
 import { canCheckMacPermissions, canCheckNativePermissions, permissionsMatchConnection, permissionsMatchNativeOwner } from "./macos-permission-scopes.js";
 
-function hasNativePermissionSurface(snapshot) {
+export function hasNativePermissionSurface(snapshot) {
   if (snapshot?.identity?.os === "macos") return true;
   if (!snapshot?.nativePermissions) return false;
   return snapshot.nativePermissions.reason !== "native_macos_unavailable";
 }
-function permissionSummary(receipt) {
+export function permissionSummary(receipt) {
   if (!receipt) return "not checked";
   if (receipt.permissions.screenRecording !== "granted") return "action needed";
   if (receipt.permissions.accessibility !== "granted") return "action needed";

package/dist/src/web-ui/app/components/system-host/native-windows-access.js

@@ -11,7 +11,7 @@ export function shouldRenderNativeWindowsAccess(input) {
   return isNativeWindowsLocalAccess(input.snapshot);
 }
 
-function nativeWindowsAccessPresentation(input) {
+export function nativeWindowsAccessPresentation(input) {
   if (input.statusUnavailable) return {
     title: "Check Windows access", status: "Status unavailable",
     description: "The current local access status could not be checked. Refresh to try again.",

package/dist/src/web-ui/app/components/system-host/rendering.js

@@ -23,7 +23,7 @@ function pairedCompanionIsOffline(snapshot) {
 function hasDirectAccess(snapshot) {
   return ["native", "wsl_interop"].includes(snapshot?.readiness?.route);
 }
-function connectionStatus(snapshot, statusUnavailable, busy) {
+export function connectionStatus(snapshot, statusUnavailable, busy) {
   if (statusUnavailable) return "Status unavailable";
   if (busy || !snapshot) return "Checking";
   if (hostSetupIsReady(snapshot)) return snapshot.identity?.os === "macos" ? "Connected" : "Ready";
@@ -42,7 +42,7 @@ function readyDescription(snapshot) {
     return "Direct commands are available. No extra installation is needed for direct commands.";
   return "You can use computer tools from your ABot chat. Permissions and Spark collection are managed separately.";
 }
-function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
+export function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
   if (!supported) return "Computer connection unavailable";
   if (statusUnavailable) return "Check your computer connection";
   if (busy || !snapshot) return "Checking this computer…";
@@ -55,7 +55,7 @@ function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
   if (platforms.length === 1 && platforms[0] === "linux") return "Connect your Linux computer";
   return "Connect your computer";
 }
-function connectionDescription({ snapshot, supported, statusUnavailable, busy }) {
+export function connectionDescription({ snapshot, supported, statusUnavailable, busy }) {
   if (!supported) return "Computer access setup requires the local Runtime backend.";
   if (statusUnavailable) return "The current connection status could not be checked. Refresh to try again.";
   if (busy || !snapshot) return "Waiting for the current connection status…";

package/dist/src/web-ui/app/components/system-host/windows-store-setup.js

@@ -41,7 +41,7 @@ function storeRepairConfirmationIsCurrent(snapshot, attempt) {
   return attempt?.phase === "confirm-repair";
 }
 
-function storeConnectionStage(snapshot, invitation, attempt) {
+export function storeConnectionStage(snapshot, invitation, attempt) {
   if (snapshot?.readiness?.ready === true) return "ready";
   if (attempt?.phase === "repairing") return "repairing";
   if (storeRepairConfirmationIsCurrent(snapshot, attempt)) return "confirm-repair";
@@ -111,7 +111,7 @@ function connectionStageContent(stage, snapshot, invitation, disabled) {
   };
 }
 
-function storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable) {
+export function storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable) {
   if (statusUnavailable) return {
     status: "Status unavailable", step: "Check your computer connection",
     copy: "The current connection status could not be checked. Refresh to try again.",

package/dist/src/web-ui/app/components/workspace-shell.js

@@ -74,6 +74,7 @@ export function createWorkspaceShell({
     const automationsWorkspace = shellState.workspace === "automations";
     const learningWorkspace = shellState.workspace === "learning";
     const memoryWorkspace = shellState.workspace === "memory";
+    const skillsWorkspace = shellState.workspace === "skills";
     const notificationsWorkspace = shellState.workspace === "notifications";
     const sessions = sidebarLayout();
     const showSessionsToggle = chatWorkspace && !sessions.docked;
@@ -128,6 +129,12 @@ export function createWorkspaceShell({
       "aria-hidden",
       String(!memoryWorkspace),
     );
+    if (dom.skillsWorkspacePanel) {
+      dom.skillsWorkspacePanel.hidden = !skillsWorkspace;
+      dom.skillsWorkspacePanel.inert = !skillsWorkspace;
+      dom.skillsWorkspacePanel.setAttribute("aria-hidden", String(!skillsWorkspace));
+    }
+    setCurrentPage(dom.skillsWorkspaceButton, skillsWorkspace);
     if (dom.notificationsWorkspacePanel) {
       dom.notificationsWorkspacePanel.hidden = !notificationsWorkspace;
       dom.notificationsWorkspacePanel.inert = !notificationsWorkspace;
@@ -263,6 +270,7 @@ export function createWorkspaceShell({
           automations: dom.closeAutomationsWorkspaceButton,
           learning: dom.closeLearningWorkspaceButton,
           memory: dom.closeMemoryWorkspaceButton,
+          skills: dom.closeSkillsWorkspaceButton,
           config: dom.closeConfigWorkspaceButton,
           models: dom.closeConfigWorkspaceButton,
           plugins: dom.closeConfigWorkspaceButton,
@@ -342,7 +350,7 @@ export function createWorkspaceShell({
       setSessionsDrawerOpen(false, { restoreFocus: true });
       return true;
     }
-    if (["config", "models", "plugins", "schedules", "automations", "learning", "memory", "notifications"].includes(shellState.workspace)) {
+    if (["config", "models", "plugins", "schedules", "automations", "learning", "memory", "skills", "notifications"].includes(shellState.workspace)) {
       return activateWorkspace("chat");
     }
     return false;
@@ -351,6 +359,8 @@ export function createWorkspaceShell({
   function bind() {
     if (shellState.bound) return;
     shellState.bound = true;
+    dom.skillsWorkspaceButton?.addEventListener("click", () => activateWorkspace("skills"));
+    dom.closeSkillsWorkspaceButton?.addEventListener("click", () => activateWorkspace("chat"));
     dom.notificationsWorkspaceButton?.addEventListener("click", () => activateWorkspace("notifications"));
     dom.closeNotificationsWorkspaceButton?.addEventListener("click", () => activateWorkspace("chat"));
     dom.homeWorkspaceButton?.addEventListener("click", () => {

package/dist/src/web-ui/app/computer-access-feature.js

@@ -1,5 +1,6 @@
 import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
 import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
+import { computerAccessWidgetSummary } from "./components/system-host/home-widget-summary.js";
 
 /** One connection owner for configured Home and its shared chat notice. */
 export function createComputerAccessFeature({
@@ -7,11 +8,13 @@ export function createComputerAccessFeature({
   runtimeClient,
   getEnvironmentId = () => "",
   isComputerAccessAvailable = () => true,
+  compactHomeWidgets,
   onChange = () => {},
 }) {
   const documentRoot = dom.homeDashboardRoot?.ownerDocument;
   const root = documentRoot?.createElement("section");
   let notice;
+  let unregisterWidget = () => {};
   const connection = createSystemHostConnectionManager({
     documentRoot,
     compact: true,
@@ -27,6 +30,7 @@ export function createComputerAccessFeature({
     supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
     onChange: () => {
       notice?.render();
+      compactHomeWidgets?.refresh();
       onChange();
     },
   });
@@ -35,7 +39,7 @@ export function createComputerAccessFeature({
     if (!isComputerAccessAvailable()) return false;
     dom.homeWorkspaceButton?.click();
     if (dom.homeWorkspacePanel?.hidden !== false || !root) return false;
-    connection.openManagement();
+    if (!compactHomeWidgets?.open("computer")) connection.openManagement();
     root.scrollIntoView?.({ block: "start", behavior: "smooth" });
     root.focus({ preventScroll: true });
     return true;
@@ -45,6 +49,7 @@ export function createComputerAccessFeature({
     const ready = isComputerAccessAvailable();
     if (root) root.hidden = !ready;
     connection.setActive(ready);
+    compactHomeWidgets?.refresh();
     notice?.render();
   }
 
@@ -71,6 +76,12 @@ export function createComputerAccessFeature({
       dom.homeDashboardRoot,
     );
     connection.mount(root);
+    unregisterWidget = compactHomeWidgets?.register({
+      id: "computer", label: "Computer access", icon: "computer", element: root,
+      isAvailable: isComputerAccessAvailable,
+      getSummary: () => computerAccessWidgetSummary(connection.state, runtimeClient.supportsSystemHostConnection()),
+      onOpen: connection.openManagement,
+    }) || unregisterWidget;
     runtimeAvailabilityChanged();
   }
   dom.environmentSelect?.addEventListener("change", connection.environmentChanged);
@@ -80,6 +91,7 @@ export function createComputerAccessFeature({
     open,
     runtimeAvailabilityChanged,
     dispose() {
+      unregisterWidget();
       dom.environmentSelect?.removeEventListener("change", connection.environmentChanged);
       notice.dispose();
       connection.dispose();

package/dist/src/web-ui/app/configuration-feature.js

@@ -22,6 +22,7 @@ export function createConfigurationFeature({
   getLearningSnapshot = () => null,
   isRuntimeReady = () => true,
   isComputerAccessAvailable = () => true,
+  compactHomeWidgets,
 }) {
   let configWorkspace;
   let activation;
@@ -107,6 +108,7 @@ export function createConfigurationFeature({
   let homeSetupSuggestion;
   const computerAccess = createComputerAccessFeature({
     dom,
+    compactHomeWidgets,
     runtimeClient,
     getEnvironmentId: selectedEnvironmentId,
     isComputerAccessAvailable,

package/dist/src/web-ui/app/controllers/automation-read-projection.js

@@ -1,3 +1,5 @@
+import { automationRunPage } from "./automation-run-history.js";
+
 export function validationResult(value) {
   if (Array.isArray(value)) return { issues: value };
   if (Array.isArray(value?.issues)) return value;
@@ -17,11 +19,12 @@ export async function readAutomationList(client, environmentId) {
   };
 }
 
-export async function readAutomationSelection(client, automationId, runId, environmentId) {
+export async function readAutomationSelection(client, automationId, runId, environmentId,
+  { runsQuery = { limit: 50 } } = {}) {
   const [draftResponse, catalog, runsResponse, runResponse] = await Promise.all([
     client.getAutomationDraft(automationId, environmentId),
     client.getAutomationCatalog(automationId, environmentId),
-    client.listAutomationRuns(automationId, environmentId),
+    runsQuery ? client.listAutomationRuns(automationId, environmentId, runsQuery) : Promise.resolve(null),
     runId ? client.getAutomationRun(runId, environmentId) : Promise.resolve(null),
   ]);
   if (runResponse?.run && runResponse.run.automationId !== automationId)
@@ -32,7 +35,7 @@ export async function readAutomationSelection(client, automationId, runId, envir
     grant: draftResponse.grant || null,
     validation: validationResult(draftResponse.validation),
     catalog,
-    runs: Array.isArray(runsResponse.runs) ? runsResponse.runs : [],
+    ...(runsResponse ? automationRunPage(runsResponse) : {}),
     run: runResponse?.run || null,
   };
 }
@@ -41,7 +44,8 @@ export async function readAutomationBackgroundProjection(client, identity) {
   const [list, selected, evidenceResponse] = await Promise.all([
     readAutomationList(client, identity.environmentId),
     identity.automationId
-      ? readAutomationSelection(client, identity.automationId, identity.runId, identity.environmentId)
+      ? readAutomationSelection(client, identity.automationId, identity.runId, identity.environmentId,
+        { runsQuery: identity.runsQuery })
       : Promise.resolve(null),
     identity.runId && identity.nodeId
       ? client.getAutomationStepEvidence(identity.runId, identity.nodeId,

package/dist/src/web-ui/app/controllers/automation-run-actions.js

@@ -1,5 +1,5 @@
 /** Async run commands retain the view that authorized them through every read. */
-export function createAutomationRunActions({ client, mutation, publish, loadSelected, openRun,
+export function createAutomationRunActions({ client, mutation, publish, loadSelected, refreshRunHistory, openRun,
   captureView }) {
   const pendingStarts = new Set();
   const runStartKey = (view) => JSON.stringify([view.environmentId, view.automationId]);
@@ -10,6 +10,8 @@ export function createAutomationRunActions({ client, mutation, publish, loadSele
     const continuation = view.captureContinuation();
     const refreshed = await loadSelected(view.automationId, "", continuation.isCurrent);
     if (!refreshed || !continuation.isCurrent()) return false;
+    await refreshRunHistory(continuation.isCurrent);
+    if (!continuation.isCurrent()) return false;
     return openRun(result.run.id, continuation.ownsMutation);
   }
 

package/dist/src/web-ui/app/controllers/automation-run-history.js

@@ -0,0 +1,159 @@
+const PAGE_SIZE = 50;
+const emptyFilters = () => ({ status: "", from: "", to: "" });
+
+function localDay(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(0);
+  date.setFullYear(year, month - 1, day);
+  date.setHours(0, 0, 0, 0);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day)
+    return null;
+  return date;
+}
+
+function historyQuery(filters) {
+  const query = { limit: PAGE_SIZE };
+  if (filters.status) query.status = filters.status;
+  const from = filters.from ? localDay(filters.from) : null;
+  const to = filters.to ? localDay(filters.to) : null;
+  if (filters.from && !from) throw new Error("Choose a valid start date.");
+  if (filters.to && !to) throw new Error("Choose a valid end date.");
+  if (to) to.setDate(to.getDate() + 1);
+  if (from && to && from >= to) throw new Error("The end date must be on or after the start date.");
+  if (from) query.from = from.toISOString();
+  if (to) query.to = to.toISOString();
+  return query;
+}
+
+export function automationRunPage(response) {
+  return {
+    runs: Array.isArray(response?.runs) ? response.runs : [],
+    runsNextCursor: typeof response?.nextCursor === "string" ? response.nextCursor : null,
+  };
+}
+
+function appendRunPage(runs, page) {
+  const entries = new Map(runs.map((run) => [run.id, run]));
+  for (const run of page) entries.set(run.id, run);
+  return [...entries.values()];
+}
+
+/** History belongs to an automation/environment, independently of its selected report. */
+export function createAutomationRunHistory({ state, client, getEnvironmentId, publish, errorLabel }) {
+  let revision = 0;
+  let loaded = false;
+  let pages = 0;
+  let failedRead = null;
+  let pendingFilters = null;
+
+  function resetScope() {
+    revision += 1;
+    loaded = false;
+    pages = 0;
+    failedRead = null;
+    pendingFilters = null;
+    Object.assign(state, { runs: [], runsNextCursor: null, runsLoading: false,
+      runsError: "", runsFilterError: "", runsFilters: emptyFilters() });
+  }
+
+  function captureScope() {
+    const environmentId = getEnvironmentId(), automationId = state.selectedAutomationId;
+    const capturedRevision = revision;
+    return { environmentId, automationId, isCurrent: () => capturedRevision === revision &&
+      environmentId === getEnvironmentId() && automationId === state.selectedAutomationId };
+  }
+
+  function canRefreshFirstPage(refresh) {
+    if (state.runsLoading) return false;
+    if (failedRead) return false;
+    if (!loaded) return true;
+    return refresh && pages < 2;
+  }
+
+  function captureRead({ refresh = false } = {}) {
+    const scope = captureScope();
+    const query = scope.automationId && canRefreshFirstPage(refresh) ? historyQuery(state.runsFilters) : null;
+    return { query, isCurrent: scope.isCurrent, accept(projection) {
+      if (!query || !scope.isCurrent()) return;
+      state.runs = projection.runs;
+      state.runsNextCursor = projection.runsNextCursor;
+      loaded = true;
+      pages = 1;
+    } };
+  }
+
+  async function readPage(filters, query, kind, isCurrent = () => true) {
+    revision += 1;
+    const scope = captureScope();
+    const canApplyHistoryRead = () => scope.isCurrent() && isCurrent();
+    failedRead = null;
+    pendingFilters = filters;
+    state.runsLoading = true;
+    state.runsError = "";
+    state.runsFilterError = "";
+    publish();
+    try {
+      const response = await client.listAutomationRuns(scope.automationId, scope.environmentId, query);
+      if (!canApplyHistoryRead()) return false;
+      const page = automationRunPage(response);
+      state.runs = kind === "more" ? appendRunPage(state.runs, page.runs) : page.runs;
+      state.runsNextCursor = page.runsNextCursor;
+      state.runsFilters = filters;
+      loaded = true;
+      pages = kind === "more" ? pages + 1 : 1;
+      return true;
+    } catch (error) {
+      if (!canApplyHistoryRead()) return false;
+      if (kind === "filter") {
+        state.runsFilterError = errorLabel(error);
+        return false;
+      }
+      state.runsError = errorLabel(error);
+      failedRead = { filters, query, kind };
+      return false;
+    } finally {
+      if (scope.isCurrent()) {
+        pendingFilters = null;
+        state.runsLoading = false;
+        publish();
+      }
+    }
+  }
+
+  async function setRunFilters(input) {
+    if (!state.selectedAutomationId) return false;
+    const filters = { status: input?.status || "", from: input?.from || "", to: input?.to || "" };
+    let query;
+    try { query = historyQuery(filters); }
+    catch (error) {
+      state.runsFilterError = errorLabel(error);
+      publish();
+      return false;
+    }
+    return readPage(filters, query, "filter");
+  }
+
+  function loadMoreRuns() {
+    if (!state.selectedAutomationId || !state.runsNextCursor || state.runsLoading) return false;
+    return readPage(state.runsFilters,
+      { ...historyQuery(state.runsFilters), cursor: state.runsNextCursor }, "more");
+  }
+
+  function resetRunHistory({ isCurrent = () => true, supersede = false } = {}) {
+    if (!state.selectedAutomationId || !isCurrent()) return false;
+    if (state.runsLoading && !supersede) return false;
+    const filters = pendingFilters || state.runsFilters;
+    return readPage(filters, historyQuery(filters), "reset", isCurrent);
+  }
+
+  function retryRunHistory() {
+    if (!failedRead || state.runsLoading) return false;
+    const { filters, query, kind } = failedRead;
+    return readPage(filters, query, kind);
+  }
+
+  resetScope();
+  return { resetScope, captureRead, revision: () => revision,
+    setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory };
+}