@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -0,0 +1,75 @@
+/** Management writes and their follow-up reads belong to the initiating view. */
+export function createAutomationManagementActions({ state, client, mutation,
+  captureView, loadList, loadSelected, refresh, openRoute }) {
+  async function create(templateId = "") {
+    const view = captureView();
+    const label = templateId ? "Template" : "Draft";
+    const result = await mutation(label, () => client.createAutomation(
+      view.environmentId, templateId || undefined), `${label} saved.`, view.isCurrent);
+    if (!result?.draft?.automationId || !view.isCurrent()) return false;
+    const continuation = view.captureContinuation();
+    const refreshed = await loadList(continuation.isCurrent);
+    if (!refreshed || !continuation.isCurrent()) return false;
+    return openRoute(result.draft.automationId, "", continuation.ownsMutation);
+  }
+
+  async function deleteDraft() {
+    const view = captureView();
+    const revision = state.draft?.revision;
+    if (!view.automationId || !Number.isInteger(revision) || state.publishedDefinition) return false;
+    const result = await mutation("Draft deletion", () => client.deleteAutomationDraft(
+      view.automationId, revision, view.environmentId), "Draft deleted.", view.isCurrent);
+    if (!result?.ok || !view.isCurrent()) return false;
+    const continuation = view.captureContinuation();
+    state.automations = state.automations.filter((item) => item.id !== view.automationId);
+    const refreshed = await loadList(continuation.isCurrent);
+    if (!refreshed || !continuation.isCurrent()) return false;
+    return openRoute("", "", continuation.ownsMutation);
+  }
+
+  async function publishDefinition() {
+    const view = captureView();
+    const expectedRevision = state.draft?.revision;
+    if (!view.automationId || !Number.isInteger(expectedRevision)) return false;
+    const response = await mutation("Publication", () => client.publishAutomation(
+      view.automationId, expectedRevision, view.environmentId), "Publication saved.", view.isCurrent);
+    if (!response || !view.isCurrent()) return false;
+    return refresh(view.captureContinuation().isCurrent);
+  }
+
+  async function setActive(activeValue) {
+    const view = captureView();
+    if (!view.automationId) return false;
+    const label = activeValue ? "Activation" : "Pause";
+    const response = await mutation(label, () => client.setAutomationActive(
+      view.automationId, activeValue, view.environmentId), `${label} saved.`, view.isCurrent);
+    if (!response || !view.isCurrent()) return false;
+    return refresh(view.captureContinuation().isCurrent);
+  }
+
+  async function changeArchiveState(archive) {
+    const view = captureView();
+    const expectedRevision = state.draft?.revision;
+    const selected = state.automations.find((item) => item.id === view.automationId);
+    const canChangeArchiveState = archive ? selected?.status !== "archived" : selected?.status === "archived";
+    if (!Number.isInteger(expectedRevision) || !selected?.publishedRevision || !canChangeArchiveState) return false;
+    const label = archive ? "Archive" : "Restore";
+    const response = await mutation(label, () => archive
+      ? client.archiveAutomation(view.automationId, expectedRevision, view.environmentId)
+      : client.restoreAutomation(view.automationId, expectedRevision, view.environmentId), `${label} saved.`, view.isCurrent);
+    if (!response || !view.isCurrent()) return false;
+    return refresh(view.captureContinuation().isCurrent);
+  }
+
+  async function setPermission(mode, operations) {
+    const view = captureView();
+    if (!view.automationId) return false;
+    const input = { expectedGrantRevision: state.grant?.grantRevision || 0, mode, operations };
+    const response = await mutation("Permission", () => client.setAutomationPermission(
+      view.automationId, input, view.environmentId), "Permission saved.", view.isCurrent);
+    if (!response || !view.isCurrent()) return false;
+    return loadSelected(view.automationId, view.runId, view.captureContinuation().isCurrent);
+  }
+
+  return { create, deleteDraft, publishDefinition, setActive, changeArchiveState, setPermission };
+}

package/dist/src/web-ui/app/controllers/automation-mutation-lifecycle.js

@@ -0,0 +1,32 @@
+/** Keep the busy lock through settlement; obsolete views receive no result feedback. */
+export function createAutomationMutationRunner({ state, publish, errorLabel, onStart,
+  captureCurrentView = () => () => true }) {
+  let activeInvocation;
+  return async function mutation(label, operation, successFeedback = `${label} saved.`, isCurrent = () => true) {
+    if (state.mutation) return false;
+    const invocation = {};
+    activeInvocation = invocation;
+    const isCurrentView = captureCurrentView();
+    const ownsMutationInvocation = () => activeInvocation === invocation;
+    const canPublishMutationOutcome = () => ownsMutationInvocation() && isCurrentView() && isCurrent();
+    onStart();
+    state.mutation = label;
+    state.error = "";
+    publish();
+    try {
+      const value = await operation();
+      if (!canPublishMutationOutcome()) return false;
+      state.feedback = successFeedback;
+      return value;
+    } catch (error) {
+      if (canPublishMutationOutcome()) state.error = errorLabel(error);
+      return false;
+    } finally {
+      if (ownsMutationInvocation()) {
+        activeInvocation = undefined;
+        state.mutation = "";
+        publish();
+      }
+    }
+  };
+}

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

@@ -0,0 +1,63 @@
+export function validationResult(value) {
+  if (Array.isArray(value)) return { issues: value };
+  if (Array.isArray(value?.issues)) return value;
+  return null;
+}
+
+export async function readAutomationList(client, environmentId) {
+  const [listed, catalog] = await Promise.allSettled([
+    client.listAutomations(environmentId), client.getAutomationCatalog("", environmentId),
+  ]);
+  if (listed.status === "rejected") throw listed.reason;
+  return {
+    automations: Array.isArray(listed.value.automations) ? listed.value.automations : [],
+    templateCatalog: catalog.status === "fulfilled" ? catalog.value : null,
+    templateCatalogError: catalog.status === "rejected"
+      ? "Templates are unavailable right now. Refresh to try again." : "",
+  };
+}
+
+export async function readAutomationSelection(client, automationId, runId, environmentId) {
+  const [draftResponse, catalog, runsResponse, runResponse] = await Promise.all([
+    client.getAutomationDraft(automationId, environmentId),
+    client.getAutomationCatalog(automationId, environmentId),
+    client.listAutomationRuns(automationId, environmentId),
+    runId ? client.getAutomationRun(runId, environmentId) : Promise.resolve(null),
+  ]);
+  if (runResponse?.run && runResponse.run.automationId !== automationId)
+    throw new Error("This run belongs to another automation.");
+  return {
+    draft: draftResponse.draft || null,
+    publishedDefinition: draftResponse.publishedDefinition || null,
+    grant: draftResponse.grant || null,
+    validation: validationResult(draftResponse.validation),
+    catalog,
+    runs: Array.isArray(runsResponse.runs) ? runsResponse.runs : [],
+    run: runResponse?.run || null,
+  };
+}
+
+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)
+      : Promise.resolve(null),
+    identity.runId && identity.nodeId
+      ? client.getAutomationStepEvidence(identity.runId, identity.nodeId,
+        identity.environmentId, identity.full)
+      : Promise.resolve(null),
+  ]);
+  const projection = { ...list, ...(selected || {}) };
+  const evidence = evidenceResponse?.evidence;
+  if (evidence?.runId === identity.runId && evidence.nodeId === identity.nodeId) {
+    projection.stepEvidence = evidence;
+    projection.stepEvidenceError = "";
+  }
+  return projection;
+}
+
+export function automationProjectionChanged(state, projection) {
+  return Object.entries(projection).some(([key, value]) =>
+    JSON.stringify(state[key]) !== JSON.stringify(value));
+}

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

@@ -0,0 +1,54 @@
+/** Async run commands retain the view that authorized them through every read. */
+export function createAutomationRunActions({ client, mutation, publish, loadSelected, openRun,
+  captureView }) {
+  const pendingStarts = new Set();
+  const runStartKey = (view) => JSON.stringify([view.environmentId, view.automationId]);
+  const isStartingRun = (view = captureView()) => pendingStarts.has(runStartKey(view));
+
+  async function openCreatedRun(result, view) {
+    if (!result?.run?.id || !view.isCurrent()) return false;
+    const continuation = view.captureContinuation();
+    const refreshed = await loadSelected(view.automationId, "", continuation.isCurrent);
+    if (!refreshed || !continuation.isCurrent()) return false;
+    return openRun(result.run.id, continuation.ownsMutation);
+  }
+
+  async function startRun() {
+    const view = captureView();
+    if (!view.automationId) return false;
+    return createRun(view, "Run", () => client.startAutomationRun(
+      view.automationId, crypto.randomUUID(), view.environmentId), "Run saved.");
+  }
+
+  async function createRun(view, label, operation, feedback) {
+    if (isStartingRun(view)) return false;
+    const key = runStartKey(view);
+    pendingStarts.add(key);
+    publish();
+    try {
+      const result = await mutation(label, operation, feedback, view.isCurrent);
+      return await openCreatedRun(result, view);
+    } finally {
+      pendingStarts.delete(key);
+      publish();
+    }
+  }
+
+  async function stopRun() {
+    const view = captureView();
+    if (!view.automationId || !view.runId) return false;
+    const result = await mutation("Stop request", () => client.stopAutomationRun(
+      view.runId, view.environmentId), "Stop request saved.", view.isCurrent);
+    if (!result || !view.isCurrent()) return false;
+    return openRun(view.runId, view.captureContinuation().ownsMutation);
+  }
+
+  async function rerun() {
+    const view = captureView();
+    if (!view.automationId || !view.runId) return false;
+    return createRun(view, "New run", () => client.rerunAutomationRun(
+      view.runId, crypto.randomUUID(), view.environmentId), "New run saved.");
+  }
+
+  return { startRun, stopRun, rerun, isStartingRun };
+}

package/dist/src/web-ui/app/controllers/automation-view-scope.js

@@ -0,0 +1,19 @@
+/** Capture user navigation intent separately from its eventual loaded selection. */
+export function createAutomationViewCapture({ state, getEnvironmentId,
+  getNavigationRevision, getNavigationRequestRevision, getMutationRevision }) {
+  return function captureView() {
+    const automationId = state.selectedAutomationId, runId = state.selectedRunId;
+    const environmentId = getEnvironmentId();
+    const navigationRevision = getNavigationRevision();
+    const intentRevision = getNavigationRequestRevision();
+    const isCurrent = () => environmentId === getEnvironmentId() &&
+      navigationRevision === getNavigationRevision() && intentRevision === getNavigationRequestRevision() &&
+      automationId === state.selectedAutomationId && runId === state.selectedRunId;
+    function captureContinuation() {
+      const mutationRevision = getMutationRevision();
+      const ownsMutation = () => mutationRevision === getMutationRevision();
+      return { ownsMutation, isCurrent: () => isCurrent() && ownsMutation() };
+    }
+    return { automationId, runId, environmentId, isCurrent, captureContinuation };
+  };
+}

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

@@ -0,0 +1,395 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { findAutomationNode } from "../components/automations/timeline.js";
+import { selectedAutomationRunStepId } from "../components/automations/run-step-selection.js";
+import { createAutomationMutationRunner } from "./automation-mutation-lifecycle.js";
+import { createAutomationDraftActions } from "./automation-draft-actions.js";
+import { createAutomationRunActions } from "./automation-run-actions.js";
+import { createAutomationViewCapture } from "./automation-view-scope.js";
+import { createAutomationManagementActions } from "./automation-management-actions.js";
+import {
+  automationProjectionChanged, readAutomationBackgroundProjection,
+  readAutomationList, readAutomationSelection, validationResult,
+} from "./automation-read-projection.js";
+
+function errorLabel(error) {
+  const code = typeof error?.code === "string" ? error.code : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return code ? `${code} · ${message}` : message;
+}
+
+function isAutomationChange(message) {
+  if (message?.type === "event")
+    return typeof message.name === "string" &&
+      (message.name.startsWith("automation.") || message.name === "scheduler.changed");
+  return message?.type === "workspace_changed" &&
+    Array.isArray(message.resources) && message.resources.includes("automations");
+}
+
+export function createAutomationsController({
+  client, getEnvironmentId, render, onNavigationChange = () => {},
+  isVisible = () => globalThis.document?.visibilityState !== "hidden",
+  isEditingDirty = () => false,
+}) {
+  const state = {
+    automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+    draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
+    catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
+    loading: false, mutation: "", error: "", feedback: "",
+    stepEvidence: null, stepEvidenceLoading: false, stepEvidenceError: "",
+  };
+  let active = false;
+  let loaded = false;
+  let navigationRevision = 0;
+  let readRevision = 0;
+  let navigationRequestRevision = 0;
+  let evidenceReadRevision = 0;
+  let mutationRevision = 0;
+  let stepEvidenceFull = false;
+  let draftActions;
+  let runActions;
+  const snapshot = () => ({ ...state, draftUndo: draftActions?.undoState() || null,
+    runStartPending: runActions?.isStartingRun() || false });
+  const publish = () => render(snapshot());
+  const currentEnvironment = (environmentId) => environmentId === getEnvironmentId();
+  const captureView = createAutomationViewCapture({ state, getEnvironmentId,
+    getNavigationRevision: () => navigationRevision, getNavigationRequestRevision: () => navigationRequestRevision,
+    getMutationRevision: () => mutationRevision });
+  const mutation = createAutomationMutationRunner({ state, publish, errorLabel,
+    captureCurrentView: () => captureView().isCurrent,
+    onStart: () => { mutationRevision += 1; } });
+  draftActions = createAutomationDraftActions({ state, client, mutation, publish, loadList,
+    currentEnvironment, captureView });
+  const { mutateDraft, saveDefinition, saveNode, undoDraftMove, restorePublishedDraft } = draftActions;
+  runActions = createAutomationRunActions({ client, mutation, publish,
+    loadSelected, openRun, captureView });
+  const { startRun, stopRun, rerun } = runActions;
+  const { create, deleteDraft, publishDefinition, setActive, changeArchiveState, setPermission } =
+    createAutomationManagementActions({ state, client, mutation, captureView,
+      loadList, loadSelected, refresh, openRoute });
+  const eventRefresh = createEventRefresh({
+    canRefresh: () => active && loaded && isVisible() && !state.loading &&
+      !state.stepEvidenceLoading && !state.mutation && !isEditingDirty(),
+    refresh: () => backgroundRefresh(),
+  });
+
+  function selectIdentity(automationId, runId = "") {
+    if (state.selectedAutomationId === automationId && state.selectedRunId === runId) return;
+    eventRefresh.cancel();
+    const automationChanged = state.selectedAutomationId !== automationId;
+    state.selectedAutomationId = automationId;
+    state.selectedRunId = runId;
+    state.selectedNodeId = "";
+    state.run = null;
+    evidenceReadRevision += 1;
+    stepEvidenceFull = false;
+    state.stepEvidence = null;
+    state.stepEvidenceLoading = false;
+    state.stepEvidenceError = "";
+    if (automationChanged) {
+      state.draft = null;
+      state.publishedDefinition = null;
+      state.grant = null;
+      state.validation = null;
+      state.validationVisible = false;
+      state.catalog = null;
+      state.runs = [];
+    }
+    navigationRevision += 1;
+    onNavigationChange();
+  }
+
+  async function loadList(isCurrent = () => true) {
+    if (!isCurrent()) return false;
+    const environmentId = getEnvironmentId();
+    const revision = ++readRevision;
+    state.loading = true;
+    state.error = "";
+    publish();
+    try {
+      const projection = await readAutomationList(client, environmentId);
+      if (!isCurrent()) return false;
+      if (revision !== readRevision || !currentEnvironment(environmentId)) return false;
+      Object.assign(state, projection);
+      loaded = true;
+      return true;
+    } catch (error) {
+      if (revision === readRevision && currentEnvironment(environmentId) && isCurrent()) state.error = errorLabel(error);
+      return false;
+    } finally {
+      if (revision === readRevision) {
+        state.loading = false;
+        publish();
+      }
+    }
+  }
+
+  async function loadSelected(automationId, runId = "", isCurrent = () => true) {
+    if (!isCurrent()) return false;
+    const environmentId = getEnvironmentId();
+    const revision = ++readRevision;
+    state.loading = true;
+    state.error = "";
+    publish();
+    try {
+      const projection = await readAutomationSelection(client, automationId, runId, environmentId);
+      if (!isCurrent()) return false;
+      if (revision !== readRevision || !currentEnvironment(environmentId)) return false;
+      if (state.selectedAutomationId !== automationId) return false;
+      Object.assign(state, projection);
+      const selectedNodeId = selectedAutomationRunStepId(state.run, state.selectedNodeId);
+      const initialStepSelected = selectedNodeId !== state.selectedNodeId;
+      state.selectedNodeId = selectedNodeId;
+      if (initialStepSelected) await loadStepEvidence(runId, selectedNodeId, false, isCurrent);
+      return true;
+    } catch (error) {
+      if (revision === readRevision && currentEnvironment(environmentId) && isCurrent()) state.error = errorLabel(error);
+      return false;
+    } finally {
+      if (revision === readRevision) {
+        state.loading = false;
+        publish();
+      }
+    }
+  }
+
+  async function openRoute(automationId = "", runId = "", ownsMutation = () => true) {
+    if (!ownsMutation()) return false;
+    const revision = ++navigationRequestRevision;
+    const environmentId = getEnvironmentId();
+    const isCurrentRoute = () => revision === navigationRequestRevision &&
+      currentEnvironment(environmentId) && ownsMutation();
+    if (!client.supportsAutomations()) return false;
+    if (!loaded || !automationId) await loadList(isCurrentRoute);
+    if (!isCurrentRoute()) return false;
+    selectIdentity(automationId, runId);
+    if (!automationId) {
+      state.draft = null;
+      state.publishedDefinition = null;
+      state.run = null;
+      state.catalog = null;
+      state.runs = [];
+      publish();
+      return true;
+    }
+    return loadSelected(automationId, runId, isCurrentRoute);
+  }
+
+  async function refresh(isCurrent = captureView().captureContinuation().isCurrent) {
+    if (!isCurrent()) return false;
+    const selected = state.selectedAutomationId;
+    const runId = state.selectedRunId;
+    const loadedList = await loadList(isCurrent);
+    if (!loadedList || !isCurrent()) return false;
+    if (!selected) return true;
+    const selectedLoaded = await loadSelected(selected, runId, isCurrent);
+    if (!selectedLoaded || !isCurrent()) return false;
+    if (selectedLoaded && runId && state.selectedNodeId)
+      await loadStepEvidence(runId, state.selectedNodeId, stepEvidenceFull, isCurrent);
+    return isCurrent();
+  }
+
+  function backgroundIdentityMatches(identity) {
+    if (!active || !loaded || !isVisible() || state.loading || state.stepEvidenceLoading ||
+        state.mutation || isEditingDirty()) return false;
+    if (!currentEnvironment(identity.environmentId) || identity.readRevision !== readRevision ||
+        identity.navigationRevision !== navigationRevision || identity.mutationRevision !== mutationRevision ||
+        identity.evidenceRevision !== evidenceReadRevision) return false;
+    return state.selectedAutomationId === identity.automationId &&
+      state.selectedRunId === identity.runId && state.selectedNodeId === identity.nodeId;
+  }
+
+  async function backgroundRefresh() {
+    const identity = {
+      environmentId: getEnvironmentId(), automationId: state.selectedAutomationId,
+      runId: state.selectedRunId, nodeId: state.selectedNodeId,
+      readRevision, navigationRevision, mutationRevision,
+      evidenceRevision: evidenceReadRevision, full: stepEvidenceFull,
+    };
+    if (!backgroundIdentityMatches(identity)) return false;
+    try {
+      const projection = await readAutomationBackgroundProjection(client, identity);
+      if (!backgroundIdentityMatches(identity)) return false;
+      if (!automationProjectionChanged(state, projection)) return true;
+      Object.assign(state, projection);
+      publish();
+      return true;
+    } catch {
+      // A background read leaves the visible state intact; explicit reads surface errors.
+      return false;
+    }
+  }
+
+  async function loadStepEvidence(runId, nodeId, full = false, isCurrent = () => true) {
+    if (!isCurrent()) return false;
+    const revision = ++evidenceReadRevision;
+    if (full) stepEvidenceFull = true;
+    const environmentId = getEnvironmentId();
+    if (state.stepEvidence?.runId !== runId || state.stepEvidence?.nodeId !== nodeId)
+      state.stepEvidence = null;
+    state.stepEvidenceError = "";
+    state.stepEvidenceLoading = true;
+    publish();
+    try {
+      const response = await client.getAutomationStepEvidence(runId, nodeId, environmentId, full);
+      if (!isCurrent()) return false;
+      if (revision !== evidenceReadRevision || !currentEnvironment(environmentId) ||
+          state.selectedRunId !== runId || state.selectedNodeId !== nodeId) return false;
+      if (response?.evidence?.runId !== runId || response.evidence.nodeId !== nodeId)
+        throw new Error("The selected step evidence is unavailable.");
+      state.stepEvidence = response.evidence;
+      return true;
+    } catch (error) {
+      if (revision === evidenceReadRevision && currentEnvironment(environmentId) && isCurrent())
+        state.stepEvidenceError = errorLabel(error);
+      return false;
+    } finally {
+      if (revision === evidenceReadRevision) {
+        state.stepEvidenceLoading = false;
+        publish();
+      }
+    }
+  }
+
+  async function saveAgent() {
+    const view = captureView();
+    const automationId = state.selectedAutomationId;
+    const node = findAutomationNode(state.draft?.definition?.body, state.selectedNodeId);
+    const expectedRevision = state.draft?.revision;
+    const environmentId = getEnvironmentId();
+    const identityRevision = navigationRevision;
+    let savedAgentMutationRevision = mutationRevision;
+    if (!automationId || node?.kind !== "agent" || !Number.isInteger(expectedRevision)) return false;
+    function isCurrentSavedAgentMutation() {
+      if (!view.isCurrent()) return false;
+      if (!currentEnvironment(environmentId)) return false;
+      if (identityRevision !== navigationRevision) return false;
+      if (savedAgentMutationRevision !== mutationRevision) return false;
+      return state.selectedAutomationId === automationId;
+    }
+    const result = await mutation("Agent template", () => {
+      savedAgentMutationRevision = mutationRevision;
+      return client.saveAutomationAgent(automationId, node.id, expectedRevision, environmentId);
+    }, "", isCurrentSavedAgentMutation);
+    if (!result?.agent?.agentId || !isCurrentSavedAgentMutation()) return false;
+    try {
+      const catalog = await client.getAutomationCatalog(automationId, environmentId);
+      if (!isCurrentSavedAgentMutation()) return false;
+      state.catalog = catalog;
+    } catch (error) {
+      if (!isCurrentSavedAgentMutation()) return false;
+      state.error = `Agent saved, but the palette could not refresh: ${errorLabel(error)}`;
+    }
+    state.feedback = `Saved agent · revision ${result.agent.revision}.`;
+    publish();
+    return true;
+  }
+
+  async function validate() {
+    const automationId = state.selectedAutomationId, environmentId = getEnvironmentId();
+    const identityRevision = navigationRevision, draftRevision = state.draft?.revision;
+    if (!automationId) return false;
+    const isCurrentValidation = () => currentEnvironment(environmentId) &&
+      identityRevision === navigationRevision && state.selectedAutomationId === automationId &&
+      state.draft?.revision === draftRevision;
+    const response = await mutation("Validation", () =>
+      client.validateAutomation(automationId, environmentId), "", isCurrentValidation);
+    if (!response || !isCurrentValidation()) return false;
+    state.validation = validationResult(response.validation || response);
+    state.validationVisible = true;
+    state.feedback = state.validation?.issues?.length
+      ? "Review the items below before publishing." : "Check complete. Ready to publish.";
+    publish();
+    return true;
+  }
+
+  async function openRun(runId, ownsMutation = () => true) {
+    if (!ownsMutation()) return false;
+    const revision = ++navigationRequestRevision;
+    const automationId = state.selectedAutomationId;
+    const environmentId = getEnvironmentId();
+    const identityRevision = navigationRevision;
+    try {
+      const response = await client.getAutomationRun(runId, environmentId);
+      if (!ownsMutation()) return false;
+      if (revision !== navigationRequestRevision || identityRevision !== navigationRevision ||
+          automationId !== state.selectedAutomationId ||
+          !currentEnvironment(environmentId)) return false;
+      if (!response?.run) return false;
+      if (response.run.automationId !== automationId)
+        throw new Error("This run belongs to another automation.");
+      selectIdentity(automationId, runId);
+      state.run = response.run;
+      state.selectedNodeId = selectedAutomationRunStepId(state.run, state.selectedNodeId);
+      publish();
+      if (state.selectedNodeId) void loadStepEvidence(runId, state.selectedNodeId);
+      return true;
+    } catch (error) {
+      if (!ownsMutation()) return false;
+      if (revision !== navigationRequestRevision || identityRevision !== navigationRevision ||
+          automationId !== state.selectedAutomationId ||
+          !currentEnvironment(environmentId)) return false;
+      state.error = errorLabel(error);
+      publish();
+      return false;
+    }
+  }
+
+  function environmentChanged() {
+    eventRefresh.cancel();
+    draftActions.clearUndo();
+    readRevision += 1;
+    loaded = false;
+    stepEvidenceFull = false;
+    Object.assign(state, {
+      automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+      draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
+      catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
+      loading: false, error: "", feedback: "",
+      stepEvidence: null, stepEvidenceLoading: false, stepEvidenceError: "",
+    });
+    evidenceReadRevision += 1;
+    navigationRevision += 1;
+    publish();
+    if (active) void loadList();
+  }
+
+  function setWorkspaceActive(value) {
+    active = value;
+    if (active && !loaded) void loadList();
+  }
+
+  function handleRealtime(message) {
+    if (!isAutomationChange(message)) return;
+    if (message.environment !== getEnvironmentId()) return;
+    eventRefresh.schedule();
+  }
+
+  return {
+    snapshot, openRoute, refresh, create,
+    createTemplate: (templateId) => create(templateId), deleteDraft, mutateDraft, saveDefinition,
+    saveNode, saveAgent, validate, publishDefinition, setActive, undoDraftMove, restorePublishedDraft,
+    archive: () => changeArchiveState(true), restore: () => changeArchiveState(false),
+    setPermission, openRun,
+    startRun, stopRun, rerun, environmentChanged, setWorkspaceActive, handleRealtime,
+    showFullStepOutput() {
+      if (!state.selectedRunId || !state.selectedNodeId) return false;
+      return loadStepEvidence(state.selectedRunId, state.selectedNodeId, true);
+    },
+    reconnect: () => { if (active) eventRefresh.schedule(); },
+    visibilityChanged: () => { if (active && isVisible()) eventRefresh.schedule(); },
+    selectNode(nodeId) {
+      eventRefresh.cancel();
+      evidenceReadRevision += 1;
+      stepEvidenceFull = false;
+      state.selectedNodeId = nodeId;
+      state.stepEvidence = null;
+      state.stepEvidenceError = "";
+      state.stepEvidenceLoading = false;
+      publish();
+      if (nodeId && state.selectedRunId) void loadStepEvidence(state.selectedRunId, nodeId);
+    },
+    selectedAutomationId: () => state.selectedAutomationId,
+    selectedRunId: () => state.selectedRunId,
+    navigationRevision: () => navigationRevision,
+  };
+}

package/dist/src/web-ui/app/controllers/composer-queue-controller.d.ts

@@ -96,6 +96,7 @@ export interface ComposerQueueController {
   enqueue(text: string): Promise<void>;
   isCurrentDraining(): boolean;
   isCurrentScope(scope: ComposerScope): boolean;
+  prepareRecoveryForNavigation(): false | (() => void);
   queuedCount(): number;
   recoverForManualSend(scope: ComposerScope): boolean;
   reportFailure(scope: ComposerScope, summary: string): void;