@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/web-ui/app/controllers/spark-chat-reading.js

@@ -0,0 +1,146 @@
+export function visibleSparkMessageIds({ messages, rows, bounds }) {
+  const eligible = new Set(messages
+    .filter((message) => message.role === "assistant" && !message.streaming && message.persistedMessageId != null)
+    .map((message) => String(message.id)));
+  return rows.filter((row) => eligible.has(row.id) && row.bottom > bounds.top && row.top < bounds.bottom)
+    .map((row) => row.id);
+}
+
+export function createSparkChatReading({
+  dom, getMessages, getEnvironmentId, isOpen, client, onReadState,
+  documentRoot = document, viewport = window, onError = () => {},
+}) {
+  let unread = [];
+  let readGeneration;
+  let readAvailable = false;
+  let anchor;
+  let opening = false;
+  let readReady = false;
+  let follow = true;
+  let top = 0;
+  let scheduled = false;
+  let revision = 0;
+  const inFlight = new Set();
+
+  function isActive() {
+    if (!isOpen()) return false;
+    if (documentRoot.visibilityState !== "visible") return false;
+    return documentRoot.hasFocus();
+  }
+  function updateJump() {
+    dom.jumpToLatestButton.hidden = follow || dom.messagesList.scrollHeight <= dom.messagesList.clientHeight + 24;
+  }
+  function nearEnd() {
+    return dom.messagesList.scrollHeight - dom.messagesList.scrollTop - dom.messagesList.clientHeight < 32;
+  }
+  async function markVisible() {
+    if (!readReady || !isActive()) return;
+    if (!readAvailable) return;
+    const bounds = dom.messagesList.getBoundingClientRect();
+    const rows = [...dom.messagesList.querySelectorAll("[data-message-id]")].map((node) => ({
+      id: node.dataset.messageId, ...rectangle(node.getBoundingClientRect()),
+    }));
+    const ids = visibleSparkMessageIds({ messages: getMessages(), rows, bounds })
+      .filter((id) => unread.includes(id) && !inFlight.has(id));
+    if (!ids.length) return;
+    const environmentId = getEnvironmentId();
+    const savedRevision = revision;
+    const observedUnreadIds = [...unread];
+    const visibleMessages = getMessages().filter((message) => ids.includes(String(message.id)))
+      .map((message) => ({ id: message.persistedMessageId, createdAt: message.createdAt, requestId: message.requestId || null }));
+    ids.forEach((id) => inFlight.add(id));
+    try {
+      const result = await client.markSparkMessagesRead({ visibleMessageIds: ids, visibleMessages, readGeneration }, environmentId);
+      if (savedRevision !== revision || environmentId !== getEnvironmentId()) return;
+      onReadState(result.readState, { acknowledgedIds: ids, observedUnreadIds });
+    } catch (error) {
+      if (savedRevision === revision) onError(error);
+    } finally {
+      if (savedRevision === revision) ids.forEach((id) => inFlight.delete(id));
+    }
+  }
+  function rectangle(bounds) { return { top: bounds.top, bottom: bounds.bottom }; }
+  function scheduleRead() {
+    if (scheduled) return;
+    scheduled = true;
+    viewport.requestAnimationFrame(() => { scheduled = false; void markVisible(); });
+  }
+  function messageNode(id) {
+    return [...dom.messagesList.querySelectorAll("[data-message-id]")].find((node) => node.dataset.messageId === id);
+  }
+  function applyAnchorSpace() {
+    const node = anchor && messageNode(anchor);
+    if (!node) return;
+    const bounds = dom.messagesList.getBoundingClientRect();
+    const nodeBounds = node.getBoundingClientRect();
+    const remaining = dom.messagesList.scrollHeight - (dom.messagesList.scrollTop + nodeBounds.top - bounds.top);
+    const spacer = documentRoot.createElement("div");
+    spacer.className = "spark-reading-spacer";
+    spacer.setAttribute("aria-hidden", "true");
+    spacer.style.height = `${Math.max(0, dom.messagesList.clientHeight - remaining)}px`;
+    dom.messagesList.append(spacer);
+    return { nodeBounds, bounds };
+  }
+  function applyOpeningAnchor() {
+    const position = applyAnchorSpace();
+    if (!position) {
+      dom.messagesList.scrollTop = dom.messagesList.scrollHeight;
+      follow = true;
+      return;
+    }
+    const { nodeBounds, bounds } = position;
+    dom.messagesList.scrollTop += nodeBounds.top - bounds.top;
+    follow = false;
+  }
+  function renderDivider() {
+    const node = anchor && messageNode(anchor);
+    if (!node) return;
+    const divider = documentRoot.createElement("div");
+    divider.className = "spark-new-messages";
+    divider.textContent = "New messages";
+    node.before(divider);
+  }
+  function afterRender() {
+    renderDivider();
+    if (!isOpen()) return;
+    if (opening) {
+      opening = false;
+      applyOpeningAnchor();
+    } else if (follow) {
+      dom.messagesList.scrollTop = dom.messagesList.scrollHeight;
+    } else {
+      applyAnchorSpace();
+      dom.messagesList.scrollTop = top;
+    }
+    top = dom.messagesList.scrollTop;
+    readReady = true;
+    updateJump();
+    scheduleRead();
+  }
+  dom.messagesList.addEventListener("scroll", () => {
+    top = dom.messagesList.scrollTop;
+    follow = nearEnd();
+    updateJump(); scheduleRead();
+  }, { passive: true });
+  documentRoot.addEventListener("visibilitychange", scheduleRead);
+  viewport.addEventListener("focus", scheduleRead);
+  return {
+    preservePosition() { follow = false; top = dom.messagesList.scrollTop; },
+    afterRender,
+    onLayoutChange() {
+      if (!isOpen()) return;
+      if (follow) dom.messagesList.scrollTop = dom.messagesList.scrollHeight;
+      else dom.messagesList.scrollTop = top;
+      updateJump(); scheduleRead();
+    },
+    toEnd() { follow = true; anchor = undefined; dom.messagesList.scrollTop = dom.messagesList.scrollHeight; top = dom.messagesList.scrollTop; updateJump(); scheduleRead(); },
+    open(targetId) { anchor = targetId || unread[0]; opening = true; readReady = false; },
+    setReadState(readState) {
+      readAvailable = readState?.readStateStatus !== "unavailable";
+      if (readGeneration !== readState?.readGeneration) { revision += 1; inFlight.clear(); }
+      unread = (readState?.unreadMessageIds || []).map(String); readGeneration = readState?.readGeneration;
+    },
+    scheduleRead,
+    reset() { revision += 1; unread = []; inFlight.clear(); anchor = undefined; opening = false; readReady = false; follow = true; top = 0; },
+  };
+}

package/dist/src/web-ui/app/controllers/spark-chat-sync.js

@@ -0,0 +1,170 @@
+import { normalizeConversationMessage } from "./conversation-session-controller.js";
+import { rememberRequestLifecycle, sameConversationMessage } from "../lib/request-lifecycle-view.js";
+
+export function mergeSparkSnapshotMessages(snapshot, current, hasNewer = false) {
+  const canonical = (snapshot.messages || []).map(normalizeConversationMessage);
+  if (hasNewer) return current.map((message) => canonical.find((entry) => sameConversationMessage(message, entry)) || message);
+  const activeRequestIds = new Set((snapshot.requests || []).filter((request) => request.status === "streaming").map((request) => request.requestId));
+  const unsettled = current.filter((message) => {
+    if (!message.streaming) return false;
+    if (activeRequestIds.has(message.requestId)) return true;
+    return !canonical.some((entry) => sameConversationMessage(message, entry));
+  });
+  if (snapshot.newerCursor === undefined) return [...canonical, ...unsettled];
+  const settled = current.filter((message) => !message.streaming);
+  const firstIndex = canonical.length ? settled.findIndex((message) => sameConversationMessage(message, canonical[0])) : -1;
+  const older = firstIndex >= 0 ? settled.slice(0, firstIndex) : [];
+  return [...older, ...canonical, ...unsettled];
+}
+
+function needsRequestLifecycleHydration(snapshot, state) {
+  const requests = snapshot.requests || [];
+  const unknownActive = requests.some((request) => request.status === "streaming" && request.requestId !== state.activeRequestId);
+  if (unknownActive) return true;
+  const current = requests.find((request) => request.requestId === state.activeRequestId);
+  if (current && current.status !== "streaming") return true;
+  return requests.some((request) => request.lifecycle?.status === "awaiting_approval"
+    && !state.requestLifecycles.has(request.requestId));
+}
+function shouldHydrateSparkConversation(initialized, rehydrate, snapshot, state) {
+  if (!initialized) return true;
+  if (rehydrate) return true;
+  return needsRequestLifecycleHydration(snapshot, state);
+}
+function hasReadableGeneration(readState) {
+  if (readState?.readStateStatus === "unavailable") return false;
+  return typeof readState?.readGeneration === "string";
+}
+function hasComposerAdvancedSinceRead(state, requestId) {
+  if (state.composerSending) return true;
+  return state.activeRequestId !== requestId;
+}
+
+/** Reconcile durable snapshots without changing drafts or replaying model requests. */
+export function createSparkChatSync({
+  client, getEnvironmentId, conversation, onConfiguration, onReadState, onSnapshot,
+  onError, isAvailable,
+  onHistoryReset = () => {},
+}) {
+  let loading = false;
+  let queued = false;
+  let initialized = false;
+  let revision = 0;
+  let consolidateNext = true;
+  let pendingWaiters = [];
+  let modelProfiles = [];
+  let modelCatalogEnvironment = "";
+  let readGeneration;
+  let rehydrateNext = false;
+  let hydrating = false;
+  const state = conversation.state;
+
+  function canRefresh() {
+    if (!isAvailable()) return false;
+    if (!getEnvironmentId()) return false;
+    if (state.composerSending) return false;
+    return !loading;
+  }
+  function isCurrentRead(environmentId, readRevision) {
+    if (environmentId !== getEnvironmentId()) return false;
+    return readRevision === revision;
+  }
+  function canRetainTargetWindow(sessionId) {
+    if (!initialized || state.currentSessionId !== sessionId) return false;
+    return conversation.session.history?.hasNewer() === true;
+  }
+  async function hydrateConversation(result) {
+    if (!canRetainTargetWindow(result.sessionId)) {
+      await conversation.session.openSession(result.sessionId, { snapshot: { ...result.snapshot, readState: result.readState } });
+      return true;
+    }
+    state.messages = mergeSparkSnapshotMessages(result.snapshot, state.messages, true);
+    return conversation.session.rehydrateRequests(result.snapshot.requests || []);
+  }
+  async function drain() {
+    if (!canRefresh()) return;
+    queued = false;
+    loading = true;
+    const environmentId = getEnvironmentId();
+    const readRevision = revision;
+    const requestAtReadStart = state.activeRequestId;
+    const rehydrate = rehydrateNext;
+    rehydrateNext = false;
+    const waiters = pendingWaiters;
+    pendingWaiters = [];
+    try {
+      const result = await client.loadSparkChat(environmentId);
+      if (!isCurrentRead(environmentId, readRevision)) return;
+      if (modelCatalogEnvironment !== environmentId || !modelProfiles.some((profile) => profile.id === result.modelProfileId)) {
+        const catalog = await client.listModels(environmentId);
+        if (!isCurrentRead(environmentId, readRevision)) return;
+        modelProfiles = catalog.profiles || catalog.models || [];
+        modelCatalogEnvironment = environmentId;
+      }
+      const profile = modelProfiles.find((item) => item.id === result.modelProfileId);
+      if (hasComposerAdvancedSinceRead(state, requestAtReadStart)) {
+        queued = true; pendingWaiters.push(...waiters.splice(0)); return;
+      }
+      const supportsImageInput = profile?.supportsImageInput === true || profile?.capabilities?.inputModalities?.includes("image") === true;
+      if (hasReadableGeneration(result.readState) && readGeneration !== undefined && readGeneration !== result.readState.readGeneration) {
+        initialized = false;
+        onHistoryReset();
+      }
+      if (hasReadableGeneration(result.readState)) readGeneration = result.readState.readGeneration;
+      onConfiguration({ ...result, supportsImageInput, modelAvailable: Boolean(profile) });
+      onReadState(result.readState);
+      const snapshot = result.snapshot;
+      if (shouldHydrateSparkConversation(initialized, rehydrate, snapshot, state)) {
+        hydrating = true;
+        const restored = await hydrateConversation(result);
+        hydrating = false;
+        if (!restored) return;
+        if (!isCurrentRead(environmentId, readRevision)) return;
+        initialized = true;
+      } else {
+        conversation.session.history?.refresh(snapshot);
+        state.messages = mergeSparkSnapshotMessages(snapshot, state.messages, conversation.session.history?.hasNewer());
+        for (const request of snapshot.requests || []) rememberRequestLifecycle(state, request.lifecycle);
+        for (const message of state.messages) {
+          if (message.role !== "assistant" || !message.requestId) continue;
+          state.requestMessages.set(message.requestId, message.id);
+        }
+        conversation.render();
+      }
+      onSnapshot(snapshot, result.readState, { consolidated: consolidateNext });
+      consolidateNext = false;
+      conversation.update();
+      waiters.forEach((waiter) => waiter.resolve(result));
+    } catch (error) {
+      if (isCurrentRead(environmentId, readRevision)) onError(error);
+      waiters.forEach((waiter) => waiter.reject(error));
+    } finally {
+      hydrating = false;
+      waiters.forEach((waiter) => waiter.resolve(undefined));
+      loading = false;
+      if (queued) void drain();
+    }
+  }
+  function refresh({ consolidated = false, wait = false, rehydrate = false } = {}) {
+    if (!isAvailable() || !getEnvironmentId()) return Promise.resolve(undefined);
+    queued = true;
+    consolidateNext ||= consolidated;
+    rehydrateNext ||= rehydrate;
+    const promise = wait ? new Promise((resolve, reject) => pendingWaiters.push({ resolve, reject })) : Promise.resolve();
+    void drain();
+    return promise;
+  }
+  return {
+    refresh,
+    isReady: () => initialized && !hydrating,
+    composerChanged(sending) { if (!sending && queued) void drain(); },
+    reset() {
+      revision += 1; initialized = false; queued = false; consolidateNext = true;
+      modelCatalogEnvironment = ""; modelProfiles = [];
+      readGeneration = undefined;
+      rehydrateNext = false;
+      pendingWaiters.forEach((waiter) => waiter.resolve(undefined)); pendingWaiters = [];
+    },
+    modelChanged() { modelCatalogEnvironment = ""; void refresh(); },
+  };
+}

package/dist/src/web-ui/app/controllers/spark-handoff-navigation.js

@@ -0,0 +1,32 @@
+/** Capture ordinary navigation before creating the handoff; never submit a user turn. */
+export function createSparkHandoffNavigation({ state, getEnvironmentId, shell, conversation, onNavigationChange }) {
+  return function captureNavigation() {
+    const environmentId = getEnvironmentId();
+    const sessionId = state.currentSessionId;
+    const viewVersion = state.sessionViewVersion;
+    const workspace = shell.activeWorkspace();
+    function navigationIsCurrent() {
+      if (environmentId !== getEnvironmentId()) return false;
+      if (sessionId !== state.currentSessionId || viewVersion !== state.sessionViewVersion) return false;
+      return workspace === shell.activeWorkspace();
+    }
+    return async function openHandoffSession(targetSessionId) {
+      if (!targetSessionId || !navigationIsCurrent()) return false;
+      await conversation.loadSessions();
+      if (!navigationIsCurrent()) return false;
+      let committed = false;
+      await conversation.openSession(targetSessionId, {
+        isRouteCurrent: navigationIsCurrent,
+        commitRouteNavigation() {
+          if (!navigationIsCurrent()) return false;
+          committed = shell.activateWorkspace("chat") !== false;
+          return committed;
+        },
+      });
+      if (!committed || environmentId !== getEnvironmentId()) return false;
+      if (state.currentSessionId !== targetSessionId) return false;
+      onNavigationChange();
+      return true;
+    };
+  };
+}

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

@@ -18,6 +18,7 @@ export function createWorkspaceRouteController({
   openSession,
   restoreLastSession,
   schedules,
+  automations,
 }) {
   let initialRoute = readWorkspaceRoute(viewport.location);
   let pendingInitialHistory = null;
@@ -34,9 +35,12 @@ export function createWorkspaceRouteController({
       workspace: shell.activeWorkspace(),
       environment: getEnvironmentId(),
       session: getSessionId(),
+      automationRun: automations?.chatRunId() || "",
       category: configurationCategoryForWorkspace(shell.activeWorkspace()),
-      tab: shell.activeOperationsTab(),
+      tab: shell.activeWorkspace() === "plugins" ? configuration.activePluginTab?.() || "installed" : shell.activeOperationsTab(),
       job: schedules.selectedJobId(),
+      automation: automations?.selectedAutomationId() || "",
+      run: automations?.selectedRunId() || "",
     };
   }
 
@@ -96,6 +100,9 @@ export function createWorkspaceRouteController({
   }
 
   function routeBackendIsAvailable(route) {
+    if (route.workspace === "automations") return automations.isWorkspaceAvailable(route.workspace);
+    if (route.workspace === "chat" && route.automationRun)
+      return automations?.isWorkspaceAvailable("automations") === true;
     return shell.isWorkspaceSupportedByBackend(route.workspace);
   }
 
@@ -104,6 +111,7 @@ export function createWorkspaceRouteController({
       shell: shell.navigationRevision(),
       configuration: configuration.navigationRevision(),
       schedules: schedules.navigationRevision(),
+      automations: automations?.navigationRevision() || 0,
     };
   }
 
@@ -111,7 +119,8 @@ export function createWorkspaceRouteController({
     if (shell.navigationRevision() !== revisions.shell) return false;
     if (configuration.navigationRevision() !== revisions.configuration)
       return false;
-    return schedules.navigationRevision() === revisions.schedules;
+    if (schedules.navigationRevision() !== revisions.schedules) return false;
+    return (automations?.navigationRevision() || 0) === revisions.automations;
   }
 
   async function restoreSession(
@@ -121,29 +130,30 @@ export function createWorkspaceRouteController({
     routeActivationIsCurrent,
     commitLinkedConversationRoute,
   ) {
+    if (route.workspace === "chat" && route.automationRun) return true;
     if (!routeCarriesConversation(route)) {
       if (initial) await restoreLastSession();
       return true;
     }
     if (route.session === getSessionId()) return true;
-    const sessions = await loadSessions();
+    await loadSessions();
     if (!routeActivationIsCurrent()) return false;
     if (environmentId !== getEnvironmentId()) return false;
-    if (!routeSessionIsListed(route, sessions)) {
-      shell.showToast(
-        "This conversation is unavailable in the selected environment.",
-        "failed",
-      );
+    let routeCommitted = false;
+    try {
+      await openSession(route.session, {
+        isRouteCurrent: routeActivationIsCurrent,
+        commitRouteNavigation: () => {
+          routeCommitted = commitLinkedConversationRoute();
+          return routeCommitted;
+        },
+      });
+    } catch (error) {
+      if (error.code !== "session_not_found") throw error;
+      if (!routeActivationIsCurrent()) return false;
+      shell.showToast("This conversation is unavailable in the selected environment.", "failed");
       return false;
     }
-    let routeCommitted = false;
-    await openSession(route.session, {
-      isRouteCurrent: routeActivationIsCurrent,
-      commitRouteNavigation: () => {
-        routeCommitted = commitLinkedConversationRoute();
-        return routeCommitted;
-      },
-    });
     if (!routeCommitted) return false;
     if (!routeActivationIsCurrent()) return false;
     if (environmentId !== getEnvironmentId()) return false;
@@ -151,6 +161,7 @@ export function createWorkspaceRouteController({
   }
 
   async function applyRoute(route, { initial = false } = {}) {
+    if (automations?.prepareRouteChange?.(route) === false) return false;
     if (!routeEnvironmentIsAvailable(route)) {
       shell.showToast("This environment is no longer available.", "failed");
       return false;
@@ -212,9 +223,18 @@ export function createWorkspaceRouteController({
     if (route.workspace === "config") {
       shell.activateOperationsTab(route.tab || "runtime");
     }
+    if (route.workspace === "plugins") {
+      return configuration.openPluginRoute?.(route) ?? true;
+    }
     if (route.workspace === "schedules") {
       return await schedules.openJob(route.job || "");
     }
+    if (route.workspace === "automations") {
+      return await automations.openRoute(route.automation || "", route.run || "");
+    }
+    if (route.workspace === "chat") {
+      return await automations?.openChatRun(route.automationRun || "") ?? true;
+    }
     return true;
   }
 
@@ -232,6 +252,11 @@ export function createWorkspaceRouteController({
         route.environment = getEnvironmentId();
         route.session = "";
         route.job = "";
+        route.automation = "";
+        route.run = "";
+        route.pluginSource = "";
+        route.pluginRef = "";
+        route.pluginPath = "";
       }
       await applyRoute(route, { initial: true });
     } catch (error) {
@@ -313,6 +338,7 @@ function canReturnToAcceptedHistoryEntry(targetIndex, currentIndex) {
 
 function routeCarriesConversation(route) {
   if (route.workspace !== "chat") return false;
+  if (route.automationRun) return false;
   return Boolean(route.session);
 }
 
@@ -326,10 +352,6 @@ function routeChangesEnvironment(route, selectedEnvironment) {
   return route.environment !== selectedEnvironment;
 }
 
-function routeSessionIsListed(route, sessions) {
-  return sessions.some((session) => session.id === route.session);
-}
-
 function initialRouteWasSuperseded(initial, pendingHistory) {
   if (!initial) return false;
   return Boolean(pendingHistory);

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

@@ -32,10 +32,9 @@ export function createDashboardFeature({
     isRuntimeReady: isComposerAvailable,
     approvalData: approvals,
     render: (snapshot) => {
-      passiveLearning?.updateSessions?.({ environmentId: selectedEnvironmentId(), sessions: snapshot.sessions });
       const sessions = filterSessionsByArchiveState(snapshot.sessions,
         preferences?.loadSessionSidebar?.(selectedEnvironmentId())?.archivedSessionIds);
-      view?.render({ ...snapshot, sessions, composerAvailable: isComposerAvailable() });
+      view?.render({ ...snapshot, sessions, sessionOverview: state.sessionOverview, composerAvailable: isComposerAvailable() });
     },
   });
   view = createDashboardWorkspace({
@@ -53,7 +52,7 @@ export function createDashboardFeature({
       openConversation: async (sessionId, requestId) => {
         if (!shell.activateWorkspace("chat")) return;
         try {
-          await openSession(sessionId);
+          await openSession(sessionId, { page: { targetRequestId: requestId } });
           if (state.currentSessionId !== sessionId) return;
           if (!requestId) return;
           requestAnimationFrame(() => {

package/dist/src/web-ui/app/index.html

@@ -25,7 +25,10 @@
     </section>
     <div id="app" class="app-shell" data-startup-pending aria-busy="true" inert>
       <nav class="workspace-rail" aria-label="Workspace navigation">
-        <div class="workspace-brand"><img src="/favicon.svg" width="28" height="28" alt="ABot" /></div>
+        <div class="workspace-brand">
+          <img src="/favicon.svg" width="28" height="28" alt="ABot" />
+          <a class="product-site-link" href="https://abot-ai.com/" target="_blank" rel="noopener noreferrer" aria-label="abot-ai.com — ABot website (opens in a new tab)">abot-ai.com <span aria-hidden="true">↗</span></a>
+        </div>
         <button
           id="sessionsToggleButton"
           class="rail-button rail-history-button"
@@ -77,12 +80,12 @@
             aria-controls="learningWorkspacePanel"
             title="ABot Spark"
           >
-            <span class="rail-icon rail-icon-coworker" aria-hidden="true"><svg viewBox="0 0 24 24">
-              <path d="M12 3c0 6-3 9-9 9 6 0 9 3 9 9 0-6 3-9 9-9-6 0-9-3-9-9Z" />
-              <path d="M18 3v4m-2-2h4" />
-            </svg></span>
+            <span class="rail-icon rail-icon-coworker" aria-hidden="true"><img src="/spark-mascot.svg" width="23" height="23" alt="" /></span>
             <span class="rail-button-label">ABot Spark</span>
           </button>
+          <button
+            id="automationsWorkspaceButton" class="rail-button" type="button" aria-label="Open ABot Studio" aria-controls="automationsWorkspacePanel" title="ABot Studio"
+          ><span class="rail-icon rail-icon-studio" aria-hidden="true"><svg viewBox="0 0 24 24"><path d="M4 6h6v5H4zM14 3h6v5h-6zM14 16h6v5h-6zM10 8h3m1 0v10m-4-7h3m0 7h1" /></svg></span><span class="rail-button-label">ABot Studio</span></button>
           <button
             id="memoryWorkspaceButton"
             class="rail-button"
@@ -314,6 +317,7 @@
           id="messagesList"
           class="messages-list"
           aria-label="Conversation messages"
+          tabindex="0"
         ></section>
         <div
           id="messageStatusRegion"
@@ -490,6 +494,14 @@
         </div>
       </main>
 
+      <main id="automationChatRunPanel" class="chat-panel automation-chat-run-panel" aria-label="Read-only automation run" hidden></main>
+
+      <section id="automationsWorkspacePanel" class="workspace-page-panel automations-workspace-panel" aria-labelledby="automationsWorkspaceTitle" hidden>
+        <header class="workspace-page-header"><div class="workspace-page-heading"><p class="eyebrow">Build and run</p><h2 id="automationsWorkspaceTitle">ABot Studio</h2></div>
+          <button id="closeAutomationsWorkspaceButton" class="workspace-page-back" type="button">Back to chat</button></header>
+        <div id="automationsRoot" class="workspace-page-body automations-workspace-body"></div>
+      </section>
+
       <section
         id="schedulesWorkspacePanel"
         class="workspace-page-panel schedules-workspace-panel"
@@ -500,7 +512,6 @@
           <div class="workspace-page-heading">
             <p class="eyebrow">Automations</p>
             <h2 id="schedulesWorkspaceTitle">Schedules</h2>
-            <p>Tasks that return to the conversation, right on time.</p>
           </div>
           <button
             id="closeSchedulesWorkspaceButton"
@@ -526,7 +537,6 @@
           <div class="workspace-page-heading">
             <p class="eyebrow">Computer activity</p>
             <h2 id="learningWorkspaceTitle">ABot Spark</h2>
-            <p>What ABot learns from your computer activity.</p>
           </div>
           <button
             id="closeLearningWorkspaceButton"
@@ -551,9 +561,6 @@
           <div class="workspace-page-heading config-workspace-heading">
             <p class="eyebrow">Long-term memory</p>
             <h2 id="memoryWorkspaceTitle">Memory</h2>
-            <p>
-              Review and manage what ABot can remember across conversations.
-            </p>
           </div>
           <div class="toolbar-actions">
             <button
@@ -636,9 +643,8 @@
       >
         <header class="workspace-page-header config-workspace-header">
           <div class="workspace-page-heading config-workspace-heading">
-            <p class="eyebrow">Runtime workspace</p>
+            <a class="product-site-link" href="https://abot-ai.com/" target="_blank" rel="noopener noreferrer" aria-label="abot-ai.com — ABot website (opens in a new tab)">abot-ai.com <span aria-hidden="true">↗</span></a>
             <h2 id="configWorkspaceTitle">System</h2>
-            <p id="configWorkspaceDescription">Inspect runtime status, logs and health, and apply saved settings.</p>
           </div>
           <div class="toolbar-actions">
             <button

package/dist/src/web-ui/app/lib/automation-binding-producers.js

@@ -0,0 +1,47 @@
+/** Lists only steps guaranteed to settle before the selected step. */
+export function listAvailableAutomationProducers(body, selectedNodeId) {
+  if (!body || !selectedNodeId) return [];
+
+  function visitSequence(node, available) {
+    let current = available;
+    for (const child of Array.isArray(node.children) ? node.children : []) {
+      const result = visit(child, current);
+      if (result.found) return result;
+      current = result.available;
+    }
+    return { found: false, available: current };
+  }
+
+  function visitParallel(node, available) {
+    const joined = new Map(available);
+    for (const branch of Array.isArray(node.branches) ? node.branches : []) {
+      const result = visit(branch, available);
+      if (result.found) return result;
+      for (const [id, producer] of result.available) joined.set(id, producer);
+    }
+    joined.set(node.id, {
+      id: node.id, kind: "parallel",
+      title: `Parallel · ${node.branches?.length || 0} branches`,
+    });
+    return { found: false, available: joined };
+  }
+
+  function visit(node, available) {
+    if (node?.kind === "sequence") return visitSequence(node, available);
+    if (node?.kind === "parallel") return visitParallel(node, available);
+    if (node?.id === selectedNodeId) return { found: true, available };
+    if (node?.kind !== "agent" && node?.kind !== "tool")
+      return { found: false, available };
+    const settled = new Map(available);
+    settled.set(node.id, { id: node.id, title: node.title, kind: node.kind });
+    return { found: false, available: settled };
+  }
+
+  const result = visit(body, new Map());
+  return result.found ? [...result.available.values()] : [];
+}
+
+export function hasConnectedAutomationResultInput(node) {
+  return Object.values(node?.inputs || {}).some((binding) =>
+    binding?.kind === "node_result" || binding?.kind === "branch_results");
+}

package/dist/src/web-ui/app/lib/automation-graph-position.js

@@ -0,0 +1,19 @@
+export function findAutomationPosition(root, nodeId) {
+  if (!root || !nodeId) return null;
+  if (root.kind === "sequence") {
+    const children = Array.isArray(root.children) ? root.children : [];
+    const index = children.findIndex((item) => item.id === nodeId);
+    if (index >= 0) return { parentSequenceId: root.id, index, next: children[index + 1] || null, count: children.length };
+    for (const child of children) {
+      const found = findAutomationPosition(child, nodeId);
+      if (found) return found;
+    }
+  }
+  if (root.kind === "parallel") {
+    for (const branch of Array.isArray(root.branches) ? root.branches : []) {
+      const found = findAutomationPosition(branch, nodeId);
+      if (found) return found;
+    }
+  }
+  return null;
+}