@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -0,0 +1,145 @@
+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 {
+    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,151 @@
+import { normalizeConversationMessage } from "./conversation-session-controller.js";
+import { rememberRequestLifecycle, sameConversationMessage } from "../lib/request-lifecycle-view.js";
+
+export function mergeSparkSnapshotMessages(snapshot, current) {
+  const canonical = (snapshot.messages || []).map(normalizeConversationMessage);
+  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));
+  });
+  return [...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;
+  }
+  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)) {
+        initialized = false; hydrating = true;
+        await conversation.session.openSession(result.sessionId);
+        hydrating = false;
+        if (!isCurrentRead(environmentId, readRevision)) return;
+        initialized = true;
+      } else {
+        state.messages = mergeSparkSnapshotMessages(snapshot, state.messages);
+        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(),
       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,6 +130,7 @@ export function createWorkspaceRouteController({
     routeActivationIsCurrent,
     commitLinkedConversationRoute,
   ) {
+    if (route.workspace === "chat" && route.automationRun) return true;
     if (!routeCarriesConversation(route)) {
       if (initial) await restoreLastSession();
       return true;
@@ -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;
@@ -215,6 +226,12 @@ export function createWorkspaceRouteController({
     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 +249,8 @@ export function createWorkspaceRouteController({
         route.environment = getEnvironmentId();
         route.session = "";
         route.job = "";
+        route.automation = "";
+        route.run = "";
       }
       await applyRoute(route, { initial: true });
     } catch (error) {
@@ -313,6 +332,7 @@ function canReturnToAcceptedHistoryEntry(targetIndex, currentIndex) {
 
 function routeCarriesConversation(route) {
   if (route.workspace !== "chat") return false;
+  if (route.automationRun) return false;
   return Boolean(route.session);
 }
 

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

@@ -32,7 +32,6 @@ 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() });

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

@@ -77,12 +77,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"
@@ -490,6 +490,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 +508,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 +533,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 +557,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
@@ -638,7 +641,6 @@
           <div class="workspace-page-heading config-workspace-heading">
             <p class="eyebrow">Runtime workspace</p>
             <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;
+}

package/dist/src/web-ui/app/lib/automation-parallel-depth.js

@@ -0,0 +1,19 @@
+// The runtime's nestingDepth of four permits two parallel groups on one path.
+export const VALID_PARALLEL_LEVELS = 2;
+
+function parallelAncestorCount(root, nodeId, ancestors = 0) {
+  if (!root || !nodeId) return null;
+  if (root.id === nodeId) return ancestors;
+  const isParallel = root.kind === "parallel";
+  const descendants = isParallel ? root.branches : root.children;
+  for (const child of Array.isArray(descendants) ? descendants : []) {
+    const found = parallelAncestorCount(child, nodeId, ancestors + Number(isParallel));
+    if (found !== null) return found;
+  }
+  return null;
+}
+
+export function canWrapAutomationSequence(root, sequenceId) {
+  const ancestors = parallelAncestorCount(root, sequenceId);
+  return ancestors !== null && ancestors < VALID_PARALLEL_LEVELS;
+}

package/dist/src/web-ui/app/lib/configuration-pages.js

@@ -1,7 +1,7 @@
 const pages = Object.freeze({
-  models: { category: "models", title: "Models", description: "Choose and configure the models available to your agents." },
-  plugins: { category: "plugins", title: "Plugins", description: "Manage the capabilities available to your agents." },
-  config: { category: "operations", title: "System", description: "Inspect runtime status, logs and health, and apply saved settings." },
+  models: { category: "models", title: "Models" },
+  plugins: { category: "plugins", title: "Plugins" },
+  config: { category: "operations", title: "System" },
 });
 
 export function isConfigurationWorkspace(workspace) {
@@ -25,7 +25,5 @@ export function renderConfigurationPageHeading(panel, workspace) {
   const page = pages[workspace];
   if (!panel || !page) return;
   const title = panel.querySelector("#configWorkspaceTitle");
-  const description = panel.querySelector("#configWorkspaceDescription");
   if (title) title.textContent = page.title;
-  if (description) description.textContent = page.description;
 }

package/dist/src/web-ui/app/lib/context-compaction-state.d.ts

@@ -0,0 +1,41 @@
+export type ContextCompactionCycle = Readonly<{
+  requestId: string;
+  generation: string;
+  invocationId: string;
+  modelStep: string;
+  profileId: string;
+  status: "pending" | "completed" | "failed" | "interrupted" | "conflicted";
+  started: Record<string, unknown> | null;
+  terminals: ReadonlyArray<{
+    event: Record<string, unknown>;
+    fingerprint: string;
+  }>;
+  interruptedAt: Record<string, unknown> | null;
+}>;
+export type ContextCompactionArrow = Readonly<{
+  requestId: string;
+  generation: string;
+  invocationId: string;
+  modelStep: string;
+  profileId: string;
+  beforePercent: number;
+  afterPercent: number;
+  event: Record<string, unknown>;
+}>;
+export declare function reduceContextCompaction(
+  cycles: Map<string, ContextCompactionCycle>,
+  event: Record<string, unknown>,
+  requestTerminal?: Record<string, unknown> | null,
+): Map<string, ContextCompactionCycle>;
+export declare function interruptContextCompactions(
+  cycles: Map<string, ContextCompactionCycle>,
+  terminal: Record<string, unknown>,
+): Map<string, ContextCompactionCycle>;
+export declare function projectContextCompactions(
+  cycles: Map<string, ContextCompactionCycle>,
+): {
+  pendingCompaction: ContextCompactionCycle | null;
+  lastCompaction: ContextCompactionArrow | null;
+  lastCompactionEvent: Record<string, unknown> | null;
+  openCompactionCount: number;
+};