@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -0,0 +1,51 @@
+/** Each receipt belongs to its executing process, never the browser computer. */
+export function canCheckMacPermissions(snapshot) {
+  if (snapshot?.identity?.os !== "macos") return false;
+  if (!snapshot.connected) return false;
+  if (!snapshot.hostId || !snapshot.connectionId) return false;
+  if (snapshot.readiness?.companionUpdateRequired) return false;
+  return snapshot.capabilities?.includes("macos_permission_preflight_v1") === true;
+}
+
+export function permissionsMatchConnection(receipt, snapshot) {
+  if (!receipt || !canCheckMacPermissions(snapshot)) return false;
+  if (receipt.hostId !== snapshot.hostId) return false;
+  return receipt.connectionId === snapshot.connectionId;
+}
+
+export function canCheckNativePermissions(snapshot, environmentId) {
+  const native = snapshot?.nativePermissions;
+  if (native?.available !== true) return false;
+  if (native.scope !== "native_runtime") return false;
+  if (typeof native.ownerId !== "string" || !native.ownerId) return false;
+  return native.environmentId === environmentId;
+}
+
+export function permissionsMatchNativeOwner(receipt, snapshot, environmentId) {
+  if (!receipt || !canCheckNativePermissions(snapshot, environmentId)) return false;
+  if (receipt.scope !== "native_runtime") return false;
+  if (receipt.environmentId !== environmentId) return false;
+  return receipt.ownerId === snapshot.nativePermissions.ownerId;
+}
+
+export function hasCompletePermissionReceipt(receipt) {
+  if (receipt?.ok !== true) return false;
+  if (typeof receipt.executablePath !== "string") return false;
+  if (!receipt.executablePath.startsWith("/")) return false;
+  const statuses = ["granted", "required"];
+  if (!statuses.includes(receipt.permissions?.screenRecording)) return false;
+  return statuses.includes(receipt.permissions?.accessibility);
+}
+
+export const macPermissionScopes = {
+  companion: {
+    receiptKey: "macPermissions", errorKey: "macPermissionError", selector: "mac",
+    canCheck: canCheckMacPermissions, matches: permissionsMatchConnection,
+    binding: snapshot => ({ hostId: snapshot.hostId, connectionId: snapshot.connectionId }),
+  },
+  native_runtime: {
+    receiptKey: "nativeMacPermissions", errorKey: "nativeMacPermissionError", selector: "native-mac",
+    canCheck: canCheckNativePermissions, matches: permissionsMatchNativeOwner,
+    binding: snapshot => ({ scope: "native_runtime", environmentId: snapshot.nativePermissions.environmentId, ownerId: snapshot.nativePermissions.ownerId }),
+  },
+};

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

@@ -2,12 +2,15 @@ import { downloadHostSetup } from "./download.js";
 import { hostSetupIsReady, renderSystemHostConnection } from "./rendering.js";
 import { createSystemHostVisibility } from "./visibility.js";
 import { createMacConnectionActions } from "./macos-connection-actions.js";
+import { createMacPermissionPreparation } from "./macos-permission-preparation.js";
 
 export function createSystemHostConnectionManager({
   loadConnection,
   downloadSetup,
   connectLocal,
   createPairing,
+  requestPermissions,
+  getEnvironmentId = () => "",
   getRuntimeOrigin = () => globalThis.location?.origin,
   revokeConnection,
   supportsConnection = () => true,
@@ -30,6 +33,10 @@ export function createSystemHostConnectionManager({
     downloaded: null,
     manualMac: null,
     managementOpen: false,
+    macPermissions: null,
+    macPermissionError: "",
+    nativeMacPermissions: null,
+    nativeMacPermissionError: "",
   };
   let revision = 0;
   let pollTimer;
@@ -56,6 +63,11 @@ export function createSystemHostConnectionManager({
     getSurfaceRevision: () => surfaceRevision,
     isVisible: () => visibility.isVisible(),
   });
+  const permissions = createMacPermissionPreparation({
+    state, requestPermissions, beginRequest, finishRequest, isCurrentResponse, getEnvironmentId,
+    getSurfaceRevision: () => surfaceRevision,
+    isVisible: () => visibility.isVisible(),
+  });
   function markup() {
     return renderSystemHostConnection({
       ...state,
@@ -65,6 +77,7 @@ export function createSystemHostConnectionManager({
     });
   }
   function afterPaint(root = state.root) {
+    permissions.afterPaint(root);
     const management = root?.querySelector("[data-system-host-management]");
     management?.addEventListener("toggle", () => {
       if (management !== state.root?.querySelector("[data-system-host-management]")) return;
@@ -124,6 +137,7 @@ export function createSystemHostConnectionManager({
     wasVisible = visible;
     if (!visible) {
       state.manualMac = null;
+      permissions.clear();
       notify();
       stopPolling();
       return;
@@ -159,10 +173,13 @@ export function createSystemHostConnectionManager({
       return false;
     }
     const operation = beginRequest(background);
+    const environment = getEnvironmentId();
     try {
       const snapshot = await loadConnection();
       if (!isCurrentResponse(operation)) return false;
+      if (environment !== getEnvironmentId()) return false;
       state.snapshot = snapshot;
+      permissions.reconcile();
       state.statusUnavailable = false;
       state.error = "";
       if (hostSetupIsReady(snapshot)) {
@@ -175,6 +192,7 @@ export function createSystemHostConnectionManager({
     } catch {
       if (!isCurrentResponse(operation)) return false;
       state.statusUnavailable = true;
+      permissions.clear();
       state.error = state.downloaded?.restartRequired
         ? "Waiting for WSL and ABot to return after setup."
         : "Could not check this computer. Refresh to try again.";
@@ -232,6 +250,7 @@ export function createSystemHostConnectionManager({
       const snapshot = await revokeConnection();
       if (!isCurrentResponse(operation)) return false;
       state.snapshot = snapshot;
+      permissions.clear();
       state.downloaded = null;
       state.manualMac = null;
       state.statusUnavailable = false;
@@ -263,6 +282,7 @@ export function createSystemHostConnectionManager({
     state.actionError = "";
     state.message = "";
     state.managementOpen = false;
+    permissions.clear();
     stopPolling();
     wasVisible = false;
     render();
@@ -272,6 +292,20 @@ export function createSystemHostConnectionManager({
     load,
     install,
     ...mac,
+    checkPermissions: permissions.checkPermissions,
+    requestPermission: permissions.requestPermission,
+    checkNativePermissions: permissions.checkNativePermissions,
+    requestNativePermission: permissions.requestNativePermission,
+    environmentChanged() {
+      revision += 1;
+      surfaceRevision += 1;
+      state.busy = false;
+      backgroundPending = false;
+      state.snapshot = null;
+      permissions.clear();
+      notify();
+      if (visibility.isVisible()) void load();
+    },
     revoke,
     markup,
     afterPaint,

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

@@ -1,5 +1,5 @@
 import { escapeHtml } from "../../lib/text-format.js";
-import { renderMacPermissionGuide } from "./macos-permissions.js";
+import { macPermissionSummary, renderMacPermissionPreparation } from "./macos-permission-rendering.js";
 import {
   renderMacSetupAction,
   renderMacSetupNotice,
@@ -20,7 +20,7 @@ function pairedCompanionIsOffline(snapshot) {
 function connectionStatus(snapshot, statusUnavailable, busy) {
   if (statusUnavailable) return "Status unavailable";
   if (busy || !snapshot) return "Checking this computer…";
-  if (hostSetupIsReady(snapshot)) return "Ready";
+  if (hostSetupIsReady(snapshot)) return snapshot.identity?.os === "macos" ? "Connected" : "Ready";
   if (pairedCompanionIsOffline(snapshot)) return "Paired · offline";
   if (hostCompanionUpdateRequired(snapshot)) return "Update needed";
   if (snapshot.connected) return "Computer access unavailable";
@@ -34,6 +34,8 @@ function hostAccessIsAvailable(snapshot, supported, statusUnavailable, busy) {
 function readyDescription(snapshot) {
   if (["native", "wsl_interop"].includes(snapshot?.readiness?.route))
     return "Direct commands are available. No extra installation is needed for direct commands.";
+  if (snapshot?.identity?.os === "macos")
+    return "Your Mac is connected. macOS permissions and tool approvals are checked separately. Background collection starts only when you enable it.";
   return "Your computer is connected for system tools and ABot Spark. Background collection starts only when you enable it.";
 }
 function renderIdentity(snapshot) {
@@ -92,14 +94,16 @@ function setupDownloadHasExpired(downloaded) {
 export function renderSystemHostConnection(input) {
   const content = renderConnectionDetails(input);
   if (!input.compact) return content;
-  const { snapshot, supported, statusUnavailable, busy, managementOpen } = input;
+  const { snapshot, supported, statusUnavailable, busy, managementOpen, macPermissions, nativeMacPermissions } = input;
   const available = hostAccessIsAvailable(snapshot, supported, statusUnavailable, busy);
   const status = supported ? connectionStatus(snapshot, statusUnavailable, busy) : "Unavailable";
+  const permissionSummary = macPermissionSummary(snapshot, macPermissions, nativeMacPermissions);
   return `<details class="system-host-compact" data-system-host-management ${managementOpen ? "open" : ""}>
     <summary class="system-host-summary">
       <span class="system-host-summary-title">Computer access</span>
       <span class="system-host-status" role="status" data-tone="${available ? "ready" : "unavailable"}"><span class="system-host-status-dot" aria-hidden="true"></span>${escapeHtml(status)}</span>
       <span class="system-host-summary-name">${escapeHtml(snapshot?.identity?.name || "")}</span>
+      ${permissionSummary ? `<span class="system-host-summary-permissions">${escapeHtml(permissionSummary)}</span>` : ""}
       <span class="system-host-summary-action" aria-hidden="true"><span>⌄</span></span>
     </summary>
     <div class="system-host-management-body">${content}</div>
@@ -115,6 +119,10 @@ function renderConnectionDetails({
   statusUnavailable,
   downloaded,
   manualMac,
+  macPermissions,
+  macPermissionError,
+  nativeMacPermissions,
+  nativeMacPermissionError,
 }) {
   const ready = hostSetupIsReady(snapshot);
   const available = hostAccessIsAvailable(
@@ -130,7 +138,7 @@ function renderConnectionDetails({
     <p class="system-host-status" role="status" data-tone="${available ? "ready" : "unavailable"}"><span class="system-host-status-dot" aria-hidden="true"></span><span>${supported ? connectionStatus(snapshot, statusUnavailable, busy) : "Computer access setup requires the local Runtime backend."}</span></p>
     ${ready && !statusUnavailable && !busy ? `<p>${readyDescription(snapshot)}</p>` : ""}
     ${renderIdentity(snapshot)}
-    ${supported ? renderMacPermissionGuide(snapshot) : ""}
+    ${supported ? renderMacPermissionPreparation({ snapshot, macPermissions, macPermissionError, nativeMacPermissions, nativeMacPermissionError, busy, statusUnavailable }) : ""}
     ${supported ? renderMacSetupNotice(snapshot) : ""}
     ${supported ? renderMacConnectionInstructions(manualMac) : ""}
     ${!ready && snapshot?.readiness?.message ? `<p class="system-host-note">${escapeHtml(snapshot.readiness.message)}</p>` : ""}

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

@@ -28,6 +28,12 @@ export function createWorkspaceShell({
     bound: false,
   };
   let navigationRevision = 0;
+  const workspaceListeners = 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 +70,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 +88,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 +110,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 +156,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 +197,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 +221,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 +245,7 @@ export function createWorkspaceShell({
     shellState.workspace = nextWorkspace;
     shellState.activeSheet = "";
     syncShell();
-    onWorkspaceChange(nextWorkspace);
+    notifyWorkspaceListeners(nextWorkspace);
     noteShellNavigation();
 
     if (options.focus === false) return true;
@@ -237,6 +259,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 +302,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 +341,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 +366,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"),
     );
@@ -396,6 +421,14 @@ export function createWorkspaceShell({
     runtimeAvailabilityChanged,
     workspaceUnavailableMessage: workspaceAccess.unavailableMessage,
     navigationRevision: () => navigationRevision,
+    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

@@ -5,6 +5,7 @@ import { createSystemHostSetupNotice } from "./components/system-host/setup-noti
 export function createComputerAccessFeature({
   dom,
   runtimeClient,
+  getEnvironmentId = () => "",
   onChange = () => {},
 }) {
   const documentRoot = dom.homeDashboardRoot?.ownerDocument;
@@ -13,9 +14,11 @@ export function createComputerAccessFeature({
   const connection = createSystemHostConnectionManager({
     documentRoot,
     compact: true,
+    getEnvironmentId,
     loadConnection: () => runtimeClient.getSystemHostConnection(),
     connectLocal: () => runtimeClient.connectLocalSystemHost(),
     createPairing: () => runtimeClient.createSystemHostPairing(),
+    requestPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
     downloadSetup: (platform) =>
       runtimeClient.downloadSystemHostSetup(platform),
     revokeConnection: () => runtimeClient.revokeSystemHostConnection(),
@@ -54,11 +57,13 @@ export function createComputerAccessFeature({
     connection.mount(root);
     connection.setActive(true);
   }
+  dom.environmentSelect?.addEventListener("change", connection.environmentChanged);
   return {
     state: connection.state,
     load: connection.load,
     open,
     dispose() {
+      dom.environmentSelect?.removeEventListener("change", connection.environmentChanged);
       notice.dispose();
       connection.dispose();
       root?.remove();

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

@@ -89,6 +89,7 @@ export function createConfigurationFeature({
   const computerAccess = createComputerAccessFeature({
     dom,
     runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
     onChange: () => homeSetupSuggestion?.render(),
   });
   homeSetupSuggestion = createHomeGuidance({

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?.();
@@ -108,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);
@@ -343,6 +364,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; } };
+}