@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -1,11 +1,13 @@
 import { createModelSetupWizard } from "./components/model-setup/wizard.js";
 import { createRuntimeConfigActivation } from "./components/runtime-config-activation.js";
 import { createPluginManager } from "./components/plugins/manager.js";
-import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
-import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
+import { createComputerAccessFeature } from "./computer-access-feature.js";
+import { createHomeGuidance } from "./components/home-guidance/home-guidance.js";
 import { createConfigWorkspace } from "./components/config-workspace.js";
+import { createModelRemovalController } from "./components/config-workspace/model-removal.js";
 import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
 import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
+import { createMemoryWorkspace } from "./components/long-term-memory/workspace.js";
 import { createLongTermMemoryController } from "./controllers/long-term-memory/controller.js";
 
 export function createConfigurationFeature({
@@ -13,12 +15,16 @@ export function createConfigurationFeature({
   runtimeClient,
   selectedEnvironmentId,
   recordControlEvent,
+  onNavigationChange = () => {},
   onConfigurationApplied = async () => {},
   onConfigurationSettled = () => true,
+  getLearningSnapshot = () => null,
+  isRuntimeReady = () => true,
 }) {
   let configWorkspace;
   let activation;
   let modelSetup;
+  let modelRemoval;
   const longTermMemorySetup = createLongTermMemorySetup({
     getEnvironmentId: selectedEnvironmentId,
     loadStatus: (environmentId) =>
@@ -28,13 +34,19 @@ export function createConfigurationFeature({
         environmentId,
         providerId,
       }),
-    enableMemory: (input, environmentId) =>
-      runtimeClient.enableLongTermMemory({
+    enableMemory: async (input, environmentId) => {
+      const result = await runtimeClient.enableLongTermMemory({
         environmentId,
         ...input,
-      }),
-    disableMemory: (environmentId) =>
-      runtimeClient.disableLongTermMemory(environmentId),
+      });
+      activation?.markPending();
+      return result;
+    },
+    disableMemory: async (environmentId) => {
+      const result = await runtimeClient.disableLongTermMemory(environmentId);
+      activation?.markPending();
+      return result;
+    },
     recordControlEvent,
     beginRuntimeMutation: () =>
       configWorkspace?.beginExternalRuntimeMutation() ?? false,
@@ -53,6 +65,11 @@ export function createConfigurationFeature({
   longTermMemoryManager = createLongTermMemoryManager({
     actions: longTermMemoryController,
   });
+  longTermMemorySetup.mount(dom.memorySetupRoot);
+  longTermMemoryManager.mount(dom.memoryManagementRoot);
+  const memoryWorkspace = createMemoryWorkspace({
+    root: dom.memoryWorkspacePanel,
+  });
 
   const pluginManager = createPluginManager({
     getEnvironmentId: selectedEnvironmentId,
@@ -68,29 +85,41 @@ export function createConfigurationFeature({
     recordControlEvent,
   });
 
-  let hostSetupNotice;
-  const hostConnection = createSystemHostConnectionManager({
-    loadConnection: () => runtimeClient.getSystemHostConnection(),
-    downloadSetup: (platform) =>
-      runtimeClient.downloadSystemHostSetup(platform),
-    revokeConnection: () => runtimeClient.revokeSystemHostConnection(),
-    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
-    onChange: () => hostSetupNotice?.render(),
+  let homeSetupSuggestion;
+  const computerAccess = createComputerAccessFeature({
+    dom,
+    runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    onChange: () => homeSetupSuggestion?.render(),
   });
-  hostSetupNotice = createSystemHostSetupNotice({
-    container: dom.chatPanel?.querySelector(".composer-dock"),
-    conversationRegion: dom.messagesList,
-    getConnectionState: () => hostConnection.state,
-    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
-    refreshConnection: () => hostConnection.load(true),
-    onOpen: () => {
-      dom.configWorkspaceButton?.click();
-      if (dom.configWorkspacePanel?.hidden === false)
-        configWorkspace.activateCategory("computer");
+  homeSetupSuggestion = createHomeGuidance({
+    container: dom.homeDashboardRoot?.querySelector(".home-workspace-content"),
+    homeRegion: dom.homeWorkspacePanel,
+    client: runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    getLearningSnapshot,
+    isRuntimeReady,
+    // Computer access is permanently visible above the Home suggestions.
+    getConnectionState: () => null,
+    supportsConnection: () => false,
+    refreshConnection: () => {},
+    onOpen: (id) => {
+      if (id === "coworker") return dom.learningWorkspaceButton?.click();
+      if (id === "memory") {
+        dom.memoryWorkspaceButton?.click();
+        if (dom.memoryWorkspacePanel?.hidden === false)
+          memoryWorkspace.activate("setup");
+        return;
+      }
+      dom.pluginsWorkspaceButton?.click();
     },
   });
-
   configWorkspace = createConfigWorkspace({
+    onNavigationChange,
+    onRemoveModel: (model) => {
+      if (modelSetup?.isOpen()) return;
+      return modelRemoval.remove(model);
+    },
     dom: {
       refreshConfigButton: dom.refreshConfigButton,
       configStatus: dom.configStatus,
@@ -122,7 +151,6 @@ export function createConfigurationFeature({
     },
     memorySetup: longTermMemorySetup,
     pluginManagement: pluginManager,
-    hostConnection,
     memoryManagement: {
       load: () => longTermMemoryController.load(),
       mount: (root) => longTermMemoryManager.mount(root),
@@ -144,6 +172,20 @@ export function createConfigurationFeature({
       return refreshed;
     },
   });
+  modelRemoval = createModelRemovalController({
+    removeModel: (input, environmentId) =>
+      runtimeClient.removeRuntimeModel(input, environmentId),
+    loadDashboard: (environmentId) =>
+      runtimeClient.loadConfigDashboard(environmentId, { settled: true }),
+    getEnvironmentId: selectedEnvironmentId,
+    beginRuntimeMutation: (subject) =>
+      configWorkspace.beginExternalRuntimeMutation(subject),
+    endRuntimeMutation: () => configWorkspace.endExternalRuntimeMutation(),
+    refreshRuntimeConfig: (prefix) =>
+      configWorkspace.refreshAfterExternalRuntimeMutation(prefix),
+    onSaved: () => activation.markPending(),
+    setStatus: (...args) => configWorkspace.setStatus(...args),
+  });
   modelSetup = createModelSetupWizard({
     root: dom.configDashboard.parentElement,
     getEnvironmentId: selectedEnvironmentId,
@@ -156,6 +198,14 @@ export function createConfigurationFeature({
       configWorkspace.beginExternalRuntimeMutation("model setup"),
     endRuntimeMutation: () => configWorkspace.endExternalRuntimeMutation(),
     onSaved: () => activation.markPending(),
+    onDeferred: async (model) => {
+      const refreshed =
+        await configWorkspace.refreshAfterExternalRuntimeMutation(
+          "Model saved; refresh required",
+        );
+      if (!refreshed) return false;
+      return configWorkspace.selectModel(model.profileId);
+    },
     onComplete: async (model) => {
       activation.markApplied();
       try {
@@ -181,6 +231,14 @@ export function createConfigurationFeature({
   const prepareDiscardChanges = configWorkspace.prepareDiscardChanges;
   return {
     ...configWorkspace,
+    openComputerSetup: computerAccess.open,
+    refreshComputerAccess: computerAccess.load,
+    renderHomeGuidance: () => homeSetupSuggestion.render(),
+    showActivityMemories: () => {
+      memoryWorkspace.activate("memories");
+      void longTermMemoryController.setOriginFilter("passive_observation");
+      longTermMemoryManager.focus();
+    },
     prepareDiscardChanges: (...args) => {
       if (modelSetup.isOpen()) {
         dom.configStatus.textContent =

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

@@ -13,7 +13,107 @@ export function createAppEventBindings({
   actions,
   documentRoot = document,
   onSessionCreated = () => {},
+  onNavigationChange = () => {},
 }) {
+  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,
+    { restoreSession = true, notifyEnvironmentChange = true } = {},
+  ) {
+    const previousEnvironmentId = actions.savedEnvironmentId?.() || "";
+    const recoveryEnvironmentId =
+      state.activeComposerQueueRecovery?.scope.environmentId ?? "";
+    const restoreEnvironmentSelection = () => {
+      dom.environmentSelect.value =
+        previousEnvironmentId || recoveryEnvironmentId;
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+    };
+    if (nextEnvironmentId === previousEnvironmentId) {
+      state.agentPickerOpen = false;
+      actions.renderAgentPicker();
+      return true;
+    }
+    dom.environmentSelect.value = nextEnvironmentId;
+    const preparedEnvironmentChange = actions.beforeEnvironmentChange
+      ? actions.beforeEnvironmentChange({
+          from: previousEnvironmentId,
+          to: nextEnvironmentId,
+        })
+      : true;
+    if (environmentChangeWasDeclined(preparedEnvironmentChange)) {
+      restoreEnvironmentSelection();
+      return false;
+    }
+    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?.();
+    state.agentPickerOpen = false;
+    actions.renderAgentPicker();
+    actions.saveEnvironmentId(nextEnvironmentId);
+    state.currentSessionId = "";
+    state.messages = [];
+    actions.clearAttachments();
+    actions.resetLiveRequestView();
+    dom.sessionTitle.textContent = "New conversation";
+    actions.applyConversationChrome();
+    actions.renderMessages();
+    try {
+      const loading = Promise.allSettled([
+        actions.loadModels(),
+        actions.loadAgentMode(),
+        actions.loadRuntimeConfig({
+          protectUnsaved: false,
+          clearBeforeLoad: true,
+        }),
+      ]);
+      if (notifyEnvironmentChange) {
+        const ChangeEvent =
+          dom.environmentSelect.ownerDocument?.defaultView?.Event ?? Event;
+        dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
+      }
+      await loading;
+      if (revision !== environmentChangeRevision) return false;
+      if (dom.environmentSelect.value !== nextEnvironmentId) return false;
+      if (restoreSession) await actions.restoreLastSession();
+      return dom.environmentSelect.value === nextEnvironmentId;
+    } finally {
+      if (revision === environmentChangeRevision) {
+        environmentChanging = false;
+        onNavigationChange();
+      }
+    }
+  }
+
   function bind() {
     dom.sessionSearchInput.addEventListener("input", () => {
       state.sessionQuery = dom.sessionSearchInput.value;
@@ -29,7 +129,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);
@@ -50,63 +150,9 @@ export function createAppEventBindings({
       dom.composerInput.focus();
     });
     dom.environmentSelect.addEventListener("change", () => {
-      const previousEnvironmentId = actions.savedEnvironmentId?.() || "";
-      const nextEnvironmentId = dom.environmentSelect.value;
-      const recoveryEnvironmentId =
-        state.activeComposerQueueRecovery?.scope.environmentId ?? "";
-      const restoreEnvironmentSelection = () => {
-        dom.environmentSelect.value =
-          previousEnvironmentId || recoveryEnvironmentId;
-        state.agentPickerOpen = false;
-        actions.renderAgentPicker();
-      };
-      if (nextEnvironmentId === previousEnvironmentId) {
-        state.agentPickerOpen = false;
-        actions.renderAgentPicker();
-        return;
-      }
-      const preparedEnvironmentChange = actions.beforeEnvironmentChange
-        ? actions.beforeEnvironmentChange({
-            from: previousEnvironmentId,
-            to: nextEnvironmentId,
-          })
-        : true;
-      if (
-        preparedEnvironmentChange === false ||
-        preparedEnvironmentChange === null
-      ) {
-        restoreEnvironmentSelection();
-        return;
-      }
-      if (!actions.suspendQueueRecovery()) {
-        restoreEnvironmentSelection();
-        return;
-      }
-      if (typeof preparedEnvironmentChange === "function") {
-        preparedEnvironmentChange();
-      }
-      actions.invalidateSessionLoads?.();
-      state.agentPickerOpen = false;
-      actions.renderAgentPicker();
-      actions.saveEnvironmentId(nextEnvironmentId);
-      state.currentSessionId = "";
-      state.messages = [];
-      actions.clearAttachments();
-      actions.resetLiveRequestView();
-      dom.sessionTitle.textContent = "New conversation";
-      actions.applyConversationChrome();
-      actions.renderMessages();
-      void (async () => {
-        await Promise.allSettled([
-          actions.loadModels(),
-          actions.loadAgentMode(),
-          actions.loadRuntimeConfig({
-            protectUnsaved: false,
-            clearBeforeLoad: true,
-          }),
-        ]);
-        await actions.restoreLastSession();
-      })();
+      void changeEnvironment(dom.environmentSelect.value, {
+        notifyEnvironmentChange: false,
+      });
     });
     dom.agentPickerButton.addEventListener("click", (event) => {
       event.stopPropagation();
@@ -315,5 +361,15 @@ export function createAppEventBindings({
     );
   }
 
-  return { bind };
+  return {
+    bind,
+    changeEnvironment,
+    setEnvironmentChangePreparation(prepare) { prepareAdditionalEnvironmentChange = prepare; },
+    isEnvironmentChanging: () => environmentChanging,
+  };
+}
+
+function environmentChangeWasDeclined(preparedChange) {
+  if (preparedChange === false) return true;
+  return preparedChange === null;
 }

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();
+      }
+    }
+  };
+}