@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -28,6 +28,13 @@ export function createWorkspaceShell({
     bound: false,
   };
   let navigationRevision = 0;
+  const workspaceListeners = new Set();
+  const runtimeAvailabilityListeners = new Set();
+  const workspaceGuards = new Set();
+  function notifyWorkspaceListeners(workspace) {
+    onWorkspaceChange(workspace);
+    for (const listener of workspaceListeners) listener(workspace);
+  }
   function noteShellNavigation() {
     navigationRevision += 1;
     onNavigationChange();
@@ -64,6 +71,7 @@ export function createWorkspaceShell({
     const chatWorkspace = shellState.workspace === "chat";
     const configWorkspace = isConfigurationWorkspace(shellState.workspace);
     const schedulesWorkspace = shellState.workspace === "schedules";
+    const automationsWorkspace = shellState.workspace === "automations";
     const learningWorkspace = shellState.workspace === "learning";
     const memoryWorkspace = shellState.workspace === "memory";
     const notificationsWorkspace = shellState.workspace === "notifications";
@@ -81,6 +89,7 @@ export function createWorkspaceShell({
       );
     }
     dom.app.classList.toggle("schedules-workspace", schedulesWorkspace);
+    dom.app.classList.toggle("automations-workspace", automationsWorkspace);
     dom.app.classList.toggle("sessions-open", sessions.drawerOpen);
     dom.app.classList.toggle("sessions-docked", sessions.docked);
 
@@ -102,6 +111,11 @@ export function createWorkspaceShell({
         String(!schedulesWorkspace),
       );
     }
+    if (dom.automationsWorkspacePanel) {
+      dom.automationsWorkspacePanel.hidden = !automationsWorkspace;
+      dom.automationsWorkspacePanel.inert = !automationsWorkspace;
+      dom.automationsWorkspacePanel.setAttribute("aria-hidden", String(!automationsWorkspace));
+    }
     dom.learningWorkspacePanel.hidden = !learningWorkspace;
     dom.learningWorkspacePanel.inert = !learningWorkspace;
     dom.learningWorkspacePanel.setAttribute(
@@ -143,6 +157,7 @@ export function createWorkspaceShell({
     setCurrentPage(dom.modelsWorkspaceButton, shellState.workspace === "models");
     setCurrentPage(dom.pluginsWorkspaceButton, shellState.workspace === "plugins");
     setCurrentPage(dom.schedulesWorkspaceButton, schedulesWorkspace);
+    setCurrentPage(dom.automationsWorkspaceButton, automationsWorkspace);
     setCurrentPage(dom.learningWorkspaceButton, learningWorkspace);
     setCurrentPage(dom.memoryWorkspaceButton, memoryWorkspace);
 
@@ -183,7 +198,7 @@ export function createWorkspaceShell({
     const wasSessionsDrawerOpen = shellState.activeSheet === "sessions";
     shellState.activeSheet = "";
     syncShell();
-    if (wasSessionsDrawerOpen) onWorkspaceChange(shellState.workspace);
+    if (wasSessionsDrawerOpen) notifyWorkspaceListeners(shellState.workspace);
     const sessions = sidebarLayout();
     if (!sidebarFocusNeedsRestoration(activeElement, sessions)) return;
     if (sessions.docked) {
@@ -207,10 +222,18 @@ export function createWorkspaceShell({
       to: nextWorkspace,
     });
     if (preparedChange === false || preparedChange === null) return null;
+    const additionalChanges = [];
+    for (const guard of workspaceGuards) {
+      const change = guard({ from: shellState.workspace, to: nextWorkspace });
+      if (change === false || change === null) return null;
+      if (typeof change === "function") additionalChanges.push(change);
+    }
     return {
       nextWorkspace,
-      commitBeforeChange:
-        typeof preparedChange === "function" ? preparedChange : () => {},
+      commitBeforeChange() {
+        if (typeof preparedChange === "function") preparedChange();
+        for (const change of additionalChanges) change();
+      },
     };
   }
 
@@ -223,7 +246,7 @@ export function createWorkspaceShell({
     shellState.workspace = nextWorkspace;
     shellState.activeSheet = "";
     syncShell();
-    onWorkspaceChange(nextWorkspace);
+    notifyWorkspaceListeners(nextWorkspace);
     noteShellNavigation();
 
     if (options.focus === false) return true;
@@ -237,6 +260,7 @@ export function createWorkspaceShell({
         const closeButtons = {
           notifications: dom.closeNotificationsWorkspaceButton,
           schedules: dom.closeSchedulesWorkspaceButton,
+          automations: dom.closeAutomationsWorkspaceButton,
           learning: dom.closeLearningWorkspaceButton,
           memory: dom.closeMemoryWorkspaceButton,
           config: dom.closeConfigWorkspaceButton,
@@ -279,7 +303,7 @@ export function createWorkspaceShell({
     const useDrawer = open && sidebarViewport?.matches !== true;
     shellState.activeSheet = useDrawer ? "sessions" : "";
     syncShell();
-    onWorkspaceChange("chat");
+    notifyWorkspaceListeners("chat");
     noteShellNavigation();
 
     if (options.focus === false) return true;
@@ -318,7 +342,7 @@ export function createWorkspaceShell({
       setSessionsDrawerOpen(false, { restoreFocus: true });
       return true;
     }
-    if (["config", "models", "plugins", "schedules", "learning", "memory", "notifications"].includes(shellState.workspace)) {
+    if (["config", "models", "plugins", "schedules", "automations", "learning", "memory", "notifications"].includes(shellState.workspace)) {
       return activateWorkspace("chat");
     }
     return false;
@@ -343,6 +367,8 @@ export function createWorkspaceShell({
     dom.schedulesWorkspaceButton?.addEventListener("click", () =>
       activateWorkspace("schedules"),
     );
+    dom.automationsWorkspaceButton?.addEventListener("click", () => activateWorkspace("automations"));
+    dom.closeAutomationsWorkspaceButton?.addEventListener("click", () => activateWorkspace("chat"));
     dom.learningWorkspaceButton.addEventListener("click", () =>
       activateWorkspace("learning"),
     );
@@ -381,6 +407,7 @@ export function createWorkspaceShell({
     workspaceAccess.update(availability);
     if (!workspaceAccess.isAvailable(shellState.workspace))
       activateWorkspace("home", { focus: false });
+    for (const listener of runtimeAvailabilityListeners) listener();
   }
 
   function load() {
@@ -396,6 +423,18 @@ export function createWorkspaceShell({
     runtimeAvailabilityChanged,
     workspaceUnavailableMessage: workspaceAccess.unavailableMessage,
     navigationRevision: () => navigationRevision,
+    subscribeRuntimeAvailabilityChange(listener) {
+      runtimeAvailabilityListeners.add(listener);
+      return () => runtimeAvailabilityListeners.delete(listener);
+    },
+    subscribeWorkspaceChange(listener) {
+      workspaceListeners.add(listener);
+      return () => workspaceListeners.delete(listener);
+    },
+    addWorkspaceGuard(guard) {
+      workspaceGuards.add(guard);
+      return () => workspaceGuards.delete(guard);
+    },
     activeOperationsTab: operationsSection.activeTab,
     activateOperationsTab: operationsSection.activateTab,
     activateWorkspace,

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

@@ -1,10 +1,12 @@
 import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
 import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
 
-/** One connection owner, always first on Home and shared with the chat notice. */
+/** One connection owner for configured Home and its shared chat notice. */
 export function createComputerAccessFeature({
   dom,
   runtimeClient,
+  getEnvironmentId = () => "",
+  isComputerAccessAvailable = () => true,
   onChange = () => {},
 }) {
   const documentRoot = dom.homeDashboardRoot?.ownerDocument;
@@ -13,9 +15,12 @@ export function createComputerAccessFeature({
   const connection = createSystemHostConnectionManager({
     documentRoot,
     compact: true,
+    getEnvironmentId,
     loadConnection: () => runtimeClient.getSystemHostConnection(),
     connectLocal: () => runtimeClient.connectLocalSystemHost(),
     createPairing: () => runtimeClient.createSystemHostPairing(),
+    requestStoreConnection: () => runtimeClient.requestSystemHostStoreConnection(),
+    requestPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
     downloadSetup: (platform) =>
       runtimeClient.downloadSystemHostSetup(platform),
     revokeConnection: () => runtimeClient.revokeSystemHostConnection(),
@@ -27,6 +32,7 @@ export function createComputerAccessFeature({
   });
 
   function open() {
+    if (!isComputerAccessAvailable()) return false;
     dom.homeWorkspaceButton?.click();
     if (dom.homeWorkspacePanel?.hidden !== false || !root) return false;
     connection.openManagement();
@@ -35,16 +41,29 @@ export function createComputerAccessFeature({
     return true;
   }
 
+  function runtimeAvailabilityChanged() {
+    const ready = isComputerAccessAvailable();
+    if (root) root.hidden = !ready;
+    connection.setActive(ready);
+    notice?.render();
+  }
+
+  function load(background) {
+    if (!isComputerAccessAvailable()) return Promise.resolve(false);
+    return connection.load(background);
+  }
+
   notice = createSystemHostSetupNotice({
     container: dom.chatPanel?.querySelector(".composer-dock"),
     conversationRegion: dom.messagesList,
     getConnectionState: () => connection.state,
-    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
-    refreshConnection: () => connection.load(true),
+    supportsConnection: () => isComputerAccessAvailable() && runtimeClient.supportsSystemHostConnection(),
+    refreshConnection: () => load(true),
     onOpen: open,
   });
   if (root) {
     root.className = "home-computer-access";
+    root.hidden = !isComputerAccessAvailable();
     root.setAttribute("tabindex", "-1");
     root.setAttribute("aria-label", "Computer access");
     dom.homeDashboardRoot.parentElement?.insertBefore(
@@ -52,13 +71,16 @@ export function createComputerAccessFeature({
       dom.homeDashboardRoot,
     );
     connection.mount(root);
-    connection.setActive(true);
+    runtimeAvailabilityChanged();
   }
+  dom.environmentSelect?.addEventListener("change", connection.environmentChanged);
   return {
     state: connection.state,
-    load: connection.load,
+    load,
     open,
+    runtimeAvailabilityChanged,
     dispose() {
+      dom.environmentSelect?.removeEventListener("change", connection.environmentChanged);
       notice.dispose();
       connection.dispose();
       root?.remove();

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

@@ -15,11 +15,13 @@ export function createConfigurationFeature({
   runtimeClient,
   selectedEnvironmentId,
   recordControlEvent,
+  getOperationsSummary,
   onNavigationChange = () => {},
   onConfigurationApplied = async () => {},
   onConfigurationSettled = () => true,
   getLearningSnapshot = () => null,
   isRuntimeReady = () => true,
+  isComputerAccessAvailable = () => true,
 }) {
   let configWorkspace;
   let activation;
@@ -72,9 +74,26 @@ export function createConfigurationFeature({
   });
 
   const pluginManager = createPluginManager({
+    onSummaryChange: () => configWorkspace?.syncSummary(),
     getEnvironmentId: selectedEnvironmentId,
+    loadConfiguration: (id, environment) =>
+      runtimeClient.getPluginConfiguration(id, environment),
+    saveConfiguration: (id, input, environment) =>
+      runtimeClient.savePluginConfiguration(id, input, environment),
     onConfigurationSaved: () => activation?.markPending(),
+    onConfigurationSettled,
     loadPlugins: () => runtimeClient.getRuntimePlugins(),
+    inspectPlugin: (input, environment) =>
+      runtimeClient.inspectRuntimePlugin(input, environment),
+    removePlugin: (input, environment) =>
+      runtimeClient.removeRuntimePlugin(input, environment),
+    onConfigurationApplied: async () => {
+      activation?.markApplied();
+      await onConfigurationApplied();
+    },
+    installPlugin: (input, environment) =>
+      runtimeClient.installRuntimePlugin(input, environment),
+    onNavigationChange,
     setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
     beginRuntimeMutation: (subject) =>
       configWorkspace?.beginExternalRuntimeMutation(subject) ?? false,
@@ -89,6 +108,8 @@ export function createConfigurationFeature({
   const computerAccess = createComputerAccessFeature({
     dom,
     runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    isComputerAccessAvailable,
     onChange: () => homeSetupSuggestion?.render(),
   });
   homeSetupSuggestion = createHomeGuidance({
@@ -98,7 +119,7 @@ export function createConfigurationFeature({
     getEnvironmentId: selectedEnvironmentId,
     getLearningSnapshot,
     isRuntimeReady,
-    // Computer access is permanently visible above the Home suggestions.
+    // Configured Home owns computer access above the suggestions.
     getConnectionState: () => null,
     supportsConnection: () => false,
     refreshConnection: () => {},
@@ -114,6 +135,7 @@ export function createConfigurationFeature({
     },
   });
   configWorkspace = createConfigWorkspace({
+    getOperationsSummary,
     onNavigationChange,
     onRemoveModel: (model) => {
       if (modelSetup?.isOpen()) return;
@@ -126,6 +148,8 @@ export function createConfigurationFeature({
     },
     loadDashboard: () =>
       runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
+    loadModelPlugins: () =>
+      runtimeClient.getRuntimePlugins(selectedEnvironmentId()),
     saveFile: async ({ kind, id, config, expectedRevision }) => {
       const result = await runtimeClient.saveConfigFile({
         environmentId: selectedEnvironmentId(),
@@ -230,15 +254,25 @@ export function createConfigurationFeature({
   const prepareDiscardChanges = configWorkspace.prepareDiscardChanges;
   return {
     ...configWorkspace,
+    activePluginTab: pluginManager.activeTab,
+    openPluginRoute: pluginManager.openRoute,
     openComputerSetup: computerAccess.open,
     refreshComputerAccess: computerAccess.load,
-    renderHomeGuidance: () => homeSetupSuggestion.render(),
+    renderHomeGuidance: () => {
+      computerAccess.runtimeAvailabilityChanged();
+      homeSetupSuggestion.render();
+    },
     showActivityMemories: () => {
       memoryWorkspace.activate("memories");
       void longTermMemoryController.setOriginFilter("passive_observation");
       longTermMemoryManager.focus();
     },
     prepareDiscardChanges: (...args) => {
+      if (pluginManager.hasConfigurationDraft()) {
+        dom.configStatus.textContent =
+          "Finish or cancel plugin configuration before leaving.";
+        return null;
+      }
       if (modelSetup.isOpen()) {
         dom.configStatus.textContent =
           "Finish or cancel model setup before leaving configuration.";

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

@@ -17,6 +17,19 @@ export function createAppEventBindings({
 }) {
   let environmentChangeRevision = 0;
   let environmentChanging = false;
+  let prepareAdditionalEnvironmentChange = () => true;
+
+  function prepareQueueRecovery() {
+    if (actions.prepareQueueRecovery) return actions.prepareQueueRecovery();
+    return actions.suspendQueueRecovery();
+  }
+
+  function suspendQueueRecovery() {
+    const prepared = prepareQueueRecovery();
+    if (environmentChangeWasDeclined(prepared)) return false;
+    if (typeof prepared === "function") prepared();
+    return true;
+  }
 
   async function changeEnvironment(
     nextEnvironmentId,
@@ -47,12 +60,20 @@ export function createAppEventBindings({
       restoreEnvironmentSelection();
       return false;
     }
-    if (!actions.suspendQueueRecovery()) {
+    const preparedAdditionalChange = prepareAdditionalEnvironmentChange();
+    if (environmentChangeWasDeclined(preparedAdditionalChange)) {
+      restoreEnvironmentSelection();
+      return false;
+    }
+    const preparedQueueRecovery = prepareQueueRecovery();
+    if (environmentChangeWasDeclined(preparedQueueRecovery)) {
       restoreEnvironmentSelection();
       return false;
     }
     const revision = ++environmentChangeRevision;
     environmentChanging = true;
+    if (typeof preparedAdditionalChange === "function") preparedAdditionalChange();
+    if (typeof preparedQueueRecovery === "function") preparedQueueRecovery();
     if (typeof preparedEnvironmentChange === "function")
       preparedEnvironmentChange();
     actions.invalidateSessionLoads?.();
@@ -94,9 +115,12 @@ export function createAppEventBindings({
   }
 
   function bind() {
+    let searchTimer;
     dom.sessionSearchInput.addEventListener("input", () => {
       state.sessionQuery = dom.sessionSearchInput.value;
       actions.renderSessions();
+      clearTimeout(searchTimer);
+      searchTimer = setTimeout(() => void actions.loadSessions(), 200);
     });
     dom.refreshSessionsButton.addEventListener(
       "click",
@@ -108,7 +132,7 @@ export function createAppEventBindings({
         { focus: false },
       );
       if (!preparedWorkspaceActivation) return;
-      if (!actions.suspendQueueRecovery()) return;
+      if (!suspendQueueRecovery()) return;
       if (preparedWorkspaceActivation() === false) return;
       state.currentSessionId = createWebSessionId();
       onSessionCreated(state.currentSessionId);
@@ -132,7 +156,7 @@ export function createAppEventBindings({
       void changeEnvironment(dom.environmentSelect.value, {
         notifyEnvironmentChange: false,
       });
-    });
+    }, true);
     dom.agentPickerButton.addEventListener("click", (event) => {
       event.stopPropagation();
       state.agentPickerOpen = !state.agentPickerOpen;
@@ -343,6 +367,7 @@ export function createAppEventBindings({
   return {
     bind,
     changeEnvironment,
+    setEnvironmentChangePreparation(prepare) { prepareAdditionalEnvironmentChange = prepare; },
     isEnvironmentChanging: () => environmentChanging,
   };
 }

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

@@ -0,0 +1,153 @@
+import { findAutomationNode } from "../components/automations/timeline.js";
+import { findAutomationPosition } from "../lib/automation-graph-position.js";
+
+const MAX_UNDO_MOVES = 20;
+
+function inverseMove(before, after, change) {
+  if (change.kind !== "move_node") return null;
+  const previous = findAutomationPosition(before.body, change.nodeId);
+  const current = findAutomationPosition(after.body, change.nodeId);
+  if (!previous || !current) return null;
+  const sameParent = previous.parentSequenceId === current.parentSequenceId;
+  if (sameParent && previous.index === current.index) return null;
+  // move_node indexes refer to the destination before removing the source.
+  const removalOffset = sameParent && current.index < previous.index ? 1 : 0;
+  return { kind: "move_node", nodeId: change.nodeId,
+    parentSequenceId: previous.parentSequenceId, index: previous.index + removalOffset };
+}
+
+/** Session-only inverse moves; every write still uses the revisioned draft API. */
+export function createAutomationDraftActions({ state, client, mutation, publish,
+  loadList, currentEnvironment, captureView }) {
+  const history = [];
+
+  function currentUndo() {
+    const latest = history.at(-1);
+    if (!latest) return null;
+    if (!currentEnvironment(latest.environmentId)) { history.length = 0; return null; }
+    if (state.selectedAutomationId !== latest.automationId || !state.draft) return null;
+    if (state.draft.revision !== latest.expectedRevision) { history.length = 0; return null; }
+    return latest;
+  }
+
+  function undoState() {
+    const latest = currentUndo();
+    if (!latest) return null;
+    return { count: history.length, title: latest.title };
+  }
+
+  function captureScope() {
+    return { ...captureView(), revision: state.draft?.revision };
+  }
+
+  function ownsView(scope) {
+    return scope.isCurrent();
+  }
+
+  function recordMutation(before, after, change, scope, undo) {
+    if (undo) {
+      history.pop();
+      const next = history.at(-1);
+      if (next) next.expectedRevision = after.revision;
+      return;
+    }
+    const inverse = inverseMove(before, after.definition, change);
+    if (!inverse) { history.length = 0; return; }
+    const latest = history.at(-1);
+    const continuesHistory = latest && latest.automationId === scope.automationId &&
+      latest.environmentId === scope.environmentId && latest.expectedRevision === scope.revision;
+    if (!continuesHistory) history.length = 0;
+    history.push({ ...scope, expectedRevision: after.revision, inverse,
+      title: findAutomationNode(before.body, change.nodeId)?.title || "Step" });
+    if (history.length > MAX_UNDO_MOVES) history.shift();
+  }
+
+  async function commit(change, { scope = captureScope(), undo = false,
+    feedback = "Draft saved." } = {}) {
+    if (!scope.automationId || !Number.isInteger(scope.revision) || !ownsView(scope)) return false;
+    if (state.draft?.revision !== scope.revision) return false;
+    currentUndo();
+    const before = state.draft.definition;
+    const response = await mutation("Draft", () => client.mutateAutomationDraft(
+      scope.automationId, scope.revision, change, scope.environmentId), feedback, () => ownsView(scope));
+    if (!response?.draft || !ownsView(scope)) return false;
+    const continuation = scope.captureContinuation();
+    state.draft = response.draft;
+    recordMutation(before, response.draft, change, scope, undo);
+    if (change.kind === "add_node") {
+      const parent = findAutomationNode(response.draft.definition?.body, change.parentSequenceId);
+      const added = parent?.children?.[change.index];
+      if (added?.kind === "agent" || added?.kind === "tool") state.selectedNodeId = added.id;
+    }
+    if (change.kind === "restore_published") state.selectedNodeId = "";
+    state.validation = null;
+    state.validationVisible = false;
+    await loadList(continuation.isCurrent);
+    if (!continuation.isCurrent()) return false;
+    publish();
+    return true;
+  }
+
+  function mutateDraft(change) {
+    const feedback = change.kind === "move_node"
+      ? "Step order saved to the draft. Use Undo move to reverse it. Publishing is separate."
+      : "Draft saved.";
+    return commit(change, { feedback });
+  }
+
+  async function undoDraftMove() {
+    if (state.mutation) return false;
+    const latest = currentUndo();
+    if (!latest) return false;
+    return commit(latest.inverse, { undo: true,
+      feedback: "Previous step order restored in the draft. Publishing is separate." });
+  }
+
+  async function restorePublishedDraft(confirm) {
+    if (state.mutation) return false;
+    const scope = captureScope();
+    const published = state.publishedDefinition;
+    if (!scope.automationId || !Number.isSafeInteger(scope.revision) || !published ||
+        published.automationId !== scope.automationId || !Number.isSafeInteger(published.revision) ||
+        typeof confirm !== "function") return false;
+    const confirmed = await confirm({ title: state.draft.definition.title, publishedRevision: published.revision });
+    if (confirmed !== true || !ownsView(scope)) return false;
+    const unchanged = state.draft?.revision === scope.revision &&
+      state.publishedDefinition?.revision === published.revision;
+    if (!unchanged) {
+      state.error = "The draft or published revision changed. Review it before resetting the draft.";
+      publish();
+      return false;
+    }
+    return commit({ kind: "restore_published", publishedRevision: published.revision }, {
+      scope, feedback: "The draft now matches the published version. The published automation is unchanged.",
+    });
+  }
+
+  async function saveDefinition(patch) {
+    const definition = state.draft?.definition;
+    if (!definition) return false;
+    if (Object.keys(patch).every((key) => JSON.stringify(patch[key]) === JSON.stringify(definition[key]))) {
+      state.feedback = "Draft is already up to date.";
+      publish();
+      return true;
+    }
+    return mutateDraft({ kind: "update_definition", patch });
+  }
+
+  async function saveNode(nodeId, patch) {
+    const node = findAutomationNode(state.draft?.definition?.body, nodeId);
+    if (!node) return false;
+    const changed = Object.fromEntries(Object.entries(patch).filter(([key, value]) =>
+      JSON.stringify(value) !== JSON.stringify(node[key])));
+    if (!Object.keys(changed).length) {
+      state.feedback = "Step is already up to date.";
+      publish();
+      return true;
+    }
+    return mutateDraft({ kind: "update_node", nodeId, patch: changed });
+  }
+
+  return { mutateDraft, saveDefinition, saveNode, undoDraftMove, restorePublishedDraft, undoState,
+    clearUndo: () => { history.length = 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();
+      }
+    }
+  };
+}