@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/sessions/session-service.d.ts

@@ -1,3 +1,4 @@
+import { type AutomationSessionHandle, type AutomationSessionOrigin } from "./automation-session-origin.js";
 import type { SessionRequestLifecycleStore } from "./request-lifecycle/contracts.js";
 import { type CreateAssistantConversationInput } from "./assistant-initiative.js";
 import { type SessionCreationOptions } from "./project-binding.js";
@@ -12,10 +13,17 @@ type SessionServiceOptions = {
 export declare class SessionService {
     readonly requestLifecycle: SessionRequestLifecycleStore;
     private readonly sessionsDir;
+    private readonly automationAccess;
+    private readonly automationSessions;
     private readonly now;
     private readonly createMessageId;
     private readonly sessionMutationQueues;
     constructor(options?: SessionServiceOptions);
+    assertInteractiveSession(sessionId: string): Promise<void>;
+    createAutomationSession(sessionId: string, origin: AutomationSessionOrigin): Promise<AutomationSessionHandle>;
+    releaseAutomationSession(handle: AutomationSessionHandle): void;
+    reconcileAutomationSessions(cleanupAttachments: (sessionId: string) => Promise<void>, onError: (sessionId: string, error: unknown) => void): Promise<void>;
+    runAsAutomationSession<T>(handle: AutomationSessionHandle, task: () => Promise<T>): Promise<T>;
     getOrCreateSession(sessionId: string, options?: SessionCreationOptions): Promise<SessionRecord>;
     getAllSessions(): Promise<SessionRecord[]>;
     listSessions(params?: {
@@ -50,6 +58,7 @@ export declare class SessionService {
         attachments?: SessionMessage["attachments"];
     }): Promise<SessionRecord>;
     createAssistantConversation(sessionId: string, input: CreateAssistantConversationInput): Promise<SessionRecord>;
+    appendAssistantInitiative(sessionId: string, input: CreateAssistantConversationInput): Promise<SessionRecord>;
     compareAndSwapSessionMemoryCheckpoint(sessionId: string, command: SessionMemoryCheckpointCommit): Promise<SessionMemoryCheckpointCommitResult>;
     appendContextEntry(sessionId: string, options: {
         kind: SessionContextEntryKind;

package/dist/src/sessions/session-service.js

@@ -1,4 +1,6 @@
 import { randomUUID } from "node:crypto";
+import { AutomationSessionLockedError, createAutomationSessionAccess, hasAutomationSessionOrigin, } from "./automation-session-origin.js";
+import { createAutomationSessionStore } from "./automation-session-store.js";
 import { saveDurableSessionFile } from "./durable-session-commit.js";
 import { cleanupSessionContinuations } from "./request-lifecycle/continuation-cleanup.js";
 import { createSessionRequestLifecycle } from "./request-lifecycle/service.js";
@@ -11,12 +13,16 @@ import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRe
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "./record/rules.js";
 import { deleteSessionFile, ensureSessionsDir, loadAllSessionFiles, loadSessionFile, saveSessionFile, } from "./session-store.js";
 import { resolveSessionMemoryCheckpointCommit } from "./memory/rules.js";
+import { assertSessionKindUnchanged, sessionKindCreationFields } from "./spark-session.js";
+import { appendAssistantInitiativeRecord } from "./assistant-initiative-append.js";
 function toIso(now) {
     return now().toISOString();
 }
 export class SessionService {
     requestLifecycle;
     sessionsDir;
+    automationAccess = createAutomationSessionAccess();
+    automationSessions;
     now;
     createMessageId;
     sessionMutationQueues = new Map();
@@ -24,6 +30,10 @@ export class SessionService {
         this.sessionsDir =
             options.sessionsDir || getDefaultSessionsDir(process.cwd());
         this.now = options.now || (() => new Date());
+        this.automationSessions = createAutomationSessionStore({
+            sessionsDir: this.sessionsDir, now: this.now, access: this.automationAccess,
+            enqueue: this.runSessionMutation.bind(this),
+        });
         this.createMessageId = options.createMessageId || defaultCreateMessageId;
         this.requestLifecycle = createSessionRequestLifecycle({
             sessionsDir: this.sessionsDir,
@@ -34,12 +44,32 @@ export class SessionService {
             list: this.getAllSessions.bind(this),
         });
     }
+    async assertInteractiveSession(sessionId) {
+        assertValidSessionId(sessionId);
+        const session = await loadSessionFile(this.sessionsDir, sessionId);
+        if (session && hasAutomationSessionOrigin(session))
+            throw new AutomationSessionLockedError();
+    }
+    async createAutomationSession(sessionId, origin) {
+        return this.automationSessions.create(sessionId, origin);
+    }
+    releaseAutomationSession(handle) {
+        this.automationSessions.release(handle);
+    }
+    reconcileAutomationSessions(cleanupAttachments, onError) {
+        return this.automationSessions.reconcile(cleanupAttachments, onError);
+    }
+    runAsAutomationSession(handle, task) {
+        return this.automationAccess.run(handle, task);
+    }
     async getOrCreateSession(sessionId, options = {}) {
         assertValidSessionId(sessionId);
         await ensureSessionsDir(this.sessionsDir);
         const existing = await loadSessionFile(this.sessionsDir, sessionId);
         if (existing) {
+            this.automationAccess.assertAccess(sessionId, existing);
             assertSessionProjectUnchanged(existing, options.project);
+            assertSessionKindUnchanged(existing, options.kind);
             return existing;
         }
         const timestamp = toIso(this.now);
@@ -48,7 +78,7 @@ export class SessionService {
             ...(options.project
                 ? { project: copySessionProject(options.project) }
                 : {}),
-            title: sessionId,
+            ...sessionKindCreationFields(sessionId, options),
             createdAt: timestamp,
             updatedAt: timestamp,
             lastAgentMode: "reasoning",
@@ -60,7 +90,9 @@ export class SessionService {
     }
     async getAllSessions() {
         const sessions = await loadAllSessionFiles(this.sessionsDir);
-        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return sessions
+            .filter((session) => this.automationAccess.canAccess(session.id, session))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async listSessions(params = {}) {
         const limit = normalizeLimit(params.limit);
@@ -76,7 +108,10 @@ export class SessionService {
     async getSessionById(sessionId) {
         assertValidSessionId(sessionId);
         await ensureSessionsDir(this.sessionsDir);
-        return loadSessionFile(this.sessionsDir, sessionId);
+        const session = await loadSessionFile(this.sessionsDir, sessionId);
+        return session && this.automationAccess.canAccess(sessionId, session)
+            ? session
+            : null;
     }
     async getSessionSnapshot(sessionId, options = {}) {
         const session = await this.getSessionById(sessionId);
@@ -85,6 +120,7 @@ export class SessionService {
         }
         return {
             sessionId,
+            ...(session.kind ? { kind: session.kind } : {}),
             ...(session.project ? { project: session.project } : {}),
             title: session.title,
             messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
@@ -99,6 +135,8 @@ export class SessionService {
         const normalizedAfterSeq = normalizeAfterSeq(afterSeq);
         const sessions = await loadAllSessionFiles(this.sessionsDir);
         for (const session of sessions) {
+            if (!this.automationAccess.canAccess(session.id, session))
+                continue;
             const request = getSessionRequest(session, requestId);
             if (!request) {
                 continue;
@@ -259,6 +297,12 @@ export class SessionService {
             now: this.now(),
         }));
     }
+    async appendAssistantInitiative(sessionId, input) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, () => appendAssistantInitiativeRecord({
+            directory: this.sessionsDir, sessionId, input, now: this.now(),
+        }));
+    }
     async compareAndSwapSessionMemoryCheckpoint(sessionId, command) {
         assertValidSessionId(sessionId);
         return this.runSessionMutation(sessionId, async () => {
@@ -472,7 +516,12 @@ export class SessionService {
     }
     async runSessionMutation(sessionId, mutation) {
         const previous = this.sessionMutationQueues.get(sessionId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(mutation);
+        const current = previous.catch(() => undefined).then(async () => {
+            const existing = await loadSessionFile(this.sessionsDir, sessionId);
+            if (existing)
+                this.automationAccess.assertAccess(sessionId, existing);
+            return mutation();
+        });
         const queued = current.then(() => undefined, () => undefined);
         this.sessionMutationQueues.set(sessionId, queued);
         try {

package/dist/src/sessions/spark-handoff-brief.d.ts

@@ -0,0 +1,3 @@
+/** Fits the existing assistant conversation content bound without truncation. */
+export declare const MAX_SPARK_HANDOFF_BRIEF_CHARACTERS = 4000;
+export declare function isSparkHandoffBrief(value: unknown): value is string;

package/dist/src/sessions/spark-handoff-brief.js

@@ -0,0 +1,9 @@
+/** Fits the existing assistant conversation content bound without truncation. */
+export const MAX_SPARK_HANDOFF_BRIEF_CHARACTERS = 4000;
+export function isSparkHandoffBrief(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.trim())
+        return false;
+    return value.length <= MAX_SPARK_HANDOFF_BRIEF_CHARACTERS;
+}

package/dist/src/sessions/spark-session.d.ts

@@ -0,0 +1,13 @@
+import type { SessionCreationOptions } from "./project-binding.js";
+import type { SessionRecord } from "./types.js";
+/** The environment's session directory owns the namespace, not the display name. */
+export declare const SPARK_SESSION_ID = "spark-companion";
+export type SessionKind = "spark";
+export declare function isSparkSession(session: {
+    kind?: SessionKind;
+}): boolean;
+export declare function assertSessionKindUnchanged(session: SessionRecord, requested?: SessionKind): void;
+export declare function sessionKindCreationFields(sessionId: string, options: SessionCreationOptions): Pick<SessionRecord, "kind" | "title">;
+export declare function ensureSparkSession(sessions: {
+    getOrCreateSession(id: string, options?: SessionCreationOptions): Promise<SessionRecord>;
+}): Promise<SessionRecord>;

package/dist/src/sessions/spark-session.js

@@ -0,0 +1,25 @@
+/** The environment's session directory owns the namespace, not the display name. */
+export const SPARK_SESSION_ID = "spark-companion";
+export function isSparkSession(session) {
+    return session.kind === "spark";
+}
+export function assertSessionKindUnchanged(session, requested) {
+    if (requested === undefined)
+        return;
+    if (session.kind !== requested)
+        throw new Error("session_kind_binding_immutable");
+}
+export function sessionKindCreationFields(sessionId, options) {
+    if (options.kind === undefined)
+        return { title: sessionId };
+    if (options.kind !== "spark")
+        throw new Error("session_kind_invalid");
+    if (sessionId !== SPARK_SESSION_ID)
+        throw new Error("spark_session_identity_invalid");
+    if (options.project)
+        throw new Error("spark_session_project_binding_unsupported");
+    return { kind: "spark", title: "ABot SPARK" };
+}
+export function ensureSparkSession(sessions) {
+    return sessions.getOrCreateSession(SPARK_SESSION_ID, { kind: "spark" });
+}

package/dist/src/sessions/types.d.ts

@@ -79,6 +79,7 @@ export type SessionRequestReplay = {
     finalState: SessionRequestFinalState | null;
 };
 export type SessionListItem = {
+    kind?: import("./spark-session.js").SessionKind;
     project?: SessionProject;
     id: string;
     title: string;
@@ -122,6 +123,7 @@ export type SessionSnapshotRequest = {
     finalState: SessionRequestFinalState | null;
 };
 export type SessionSnapshot = {
+    kind?: import("./spark-session.js").SessionKind;
     project?: SessionProject;
     sessionId: string;
     title: string;
@@ -172,7 +174,10 @@ export type SessionMessage = {
     attachments?: RuntimeAttachmentReference[];
 };
 export type SessionRecord = {
+    kind?: import("./spark-session.js").SessionKind;
+    assistantInitiativeReceipts?: readonly string[];
     project?: SessionProject;
+    automationOrigin?: import("./automation-session-origin.js").AutomationSessionOrigin;
     id: string;
     title: string;
     createdAt: string;

package/dist/src/web-ui/app/ARCHITECTURE.md

@@ -282,3 +282,92 @@ execution evidence visible and places the complete rationale in a native disclos
 Startup keeps the app inert and hidden from the initial HTML until workspace
 restoration finishes. The branded startup screen reveals the app once ready;
 failed bootstrap reads remain on an error with an explicit Reload action.
+
+## Persistent SPARK popup
+
+`spark-chat-feature.js` is composed by `app-bootstrap.js` outside the exclusive
+workspace panels. It owns separate conversation state and DOM while reusing the
+ordinary session, submit/queue, steering, approval, attachment, replay and rendering
+controllers. Opening the popup does not replace the main selected session or draft.
+The launcher defaults to the sidebar above the environment picker. Its drag position
+is a browser preference shared across environments, with keyboard movement and a
+settings action to return it to the sidebar. The popup anchors above or below the
+launcher and stays inside the viewport.
+The external launcher remains visible and toggles the popup even while it is open;
+the header mascot also minimizes the chat. Free placement and anchor geometry stay intact.
+Drag release gently aligns to a nearby 16px grid and settles into the saved position.
+The popup fades and moves in from its launcher-facing edge without scaling message
+geometry; placement motion respects reduced-motion preferences.
+The marked permanent conversation is omitted from ordinary session listings.
+Initiatives are presented only in the popup. Home and the SPARK page have no
+proposal cards, card read filtering, dismissal actions or legacy suggestion toasts;
+their status views show the actual collection, learning and proactive activity.
+Popup notifications and read tracking belong to the companion alone. Desktop
+notification records derive the SPARK kind from the canonical persisted session.
+Their validated `/home` destination binds the environment, companion and exact
+message/request reference; ordinary conversation and automation destinations keep
+their existing contracts. The retired
+manual proposal-dismissal HTTP/RPC path and browser preference facade are removed;
+learning status no longer transports the card-only list of proposal contents.
+Durable engine receipts, delivery events and deletion-derived settlement remain
+owned by the proactive engine. Historical work sessions remain accessible through
+the ordinary session list.
+
+The native `/runtime/spark/chat` contract supplies the canonical session snapshot,
+shared proactive model selection and persisted tool permission preference. Changes
+live in SPARK's Chat tab; the shared model selector remains under Proactive mode
+in Settings. Chat also hosts the existing Fast / Reasoning / Deep selector, backed
+by the companion view state and used by ordinary send/queue capture. The compact
+composer keeps attachment, stop and send actions inside one input row; permissions
+remain in Chat settings. The popup settings button opens Chat directly. Clear uses the
+ordinary session-history cleanup route and
+keeps the session identity and preferences. The owner rejects clearing while a
+request or saved approval is active, reserves admission during cleanup, and removes
+only captured transcript attachment references so a concurrent new upload survives.
+Exact cleanup references are committed before history removal and retained on deletion
+failure for an explicit retry, including after restart. Proactive delivery shares the
+same admission boundary through message persistence, delivery receipt and notification.
+
+`spark-chat-reading.js` captures the first unread anchor before acknowledging any
+visible rows. SPARK read tracking uses exact persisted message identities rather
+than the ordinary cumulative read cursor; offscreen messages remain unread. Each
+receipt binds the observed message ID, timestamp and request identity plus the
+read generation. Initiative request identity remains null even if a later ordinary
+answer repeats its text. A delayed acknowledgement cannot mark a reused post-clear ID.
+Unread availability failures preserve the last known state and draft.
+The initial/reconnected snapshot produces one summary indication. Later new
+persisted assistant messages produce one indication each while the popup is closed,
+independent of streaming deltas and replay. An open popup suppresses the extra
+floating preview. View state, reads and realtime events remain environment scoped.
+
+`spark-chat-sync.js` reconciles durable snapshots and restores ordinary request
+replay after reconnect. Environment navigation first prepares both ordinary and SPARK
+queue recovery. Recovered drafts and their files are released only after every
+navigation guard accepts; failed saves leave the current composer intact.
+Shared rendering delegates popup scroll and asynchronous
+layout changes to its reading controller, keeping the ordinary view unchanged.
+The companion presents a friendly empty state and working indicator. Its canonical
+SPARK policy keeps replies in the current user's language unless another is requested,
+without announcing a language switch. It treats earlier assistant messages as its
+own conversation and distinguishes an empty long-term recall from available history.
+Its result view
+retains canonical file actions, web sources, failures and partial-result warnings;
+session event inspection, raw reasoning, context controls and routine completion
+status stay out of the companion. Approval and execution mechanisms remain shared.
+
+SPARK initiatives enter ordinary conversation history once as assistant messages in
+canonical order. They form settled assistant-only units without inventing a user
+request and follow the same checkpoint/compaction policy as other settled turns:
+older units are summarized while the latest ten remain exact. The saved transcript
+is retained for display and handoff. There is no separate initiative context block;
+saved reasons, source metadata and handoff briefs are not projected into chat model
+inputs. Request snapshots keep the existing exact source validation contract.
+
+Persisted initiatives expose an explicit handoff action when canonical metadata
+includes a saved title and brief. The client sends only the exact source message
+reference to `/runtime/spark/chat/sessions`; it never invents or submits the brief.
+`spark-handoff-navigation.js` captures the ordinary workspace and environment,
+then opens the returned ordinary session through its existing session controller.
+It submits no chat message or model request. Old suggestions without saved context
+show a disabled action and explanation. Legacy Keep/Not interested and Not now
+controls are removed; their stored historical preferences and statuses remain.

package/dist/src/web-ui/app/app-bootstrap.js

@@ -1,6 +1,10 @@
 import { createStartupScreen } from "./components/startup-screen.js";
 import { createWorkspaceRouteController } from "./controllers/workspace-route-controller.js";
 import { textOf } from "./lib/text-format.js";
+import { createAutomationsFeature } from "./automations-feature.js";
+import { createSparkChatFeature } from "./spark-chat-feature.js";
+import { canRestoreSparkAddress, sparkNotificationReference } from "./lib/spark-chat-address.js";
+import { createSparkHandoffNavigation } from "./controllers/spark-handoff-navigation.js";
 
 export async function bootstrapWebApp({
   state,
@@ -26,12 +30,26 @@ export async function bootstrapWebApp({
   navigation,
   onNavigationReady = () => {},
 }) {
-  const routes = navigation
+  let routes = null;
+  const initialAddress = new URL(window.location.href);
+  const spark = createSparkChatFeature({ dom, state, client, shell, realtime, getEnvironmentId: () => dom.environmentSelect.value,
+    captureHandoffNavigation: createSparkHandoffNavigation({ state, getEnvironmentId: () => dom.environmentSelect.value,
+      shell, conversation: navigation?.conversation, onNavigationChange: () => routes?.sync() }),
+    onOpenSchedule: (jobId) => schedules.openJob(jobId) });
+  navigation?.bindings.setEnvironmentChangePreparation(spark.prepareEnvironmentChange);
+  notifications?.setCompanionChat?.(spark);
+  const automations = createAutomationsFeature({
+    dom, client, shell, realtime,
+    getEnvironmentId: () => dom.environmentSelect.value,
+    onNavigationChange: () => routes?.sync(),
+  });
+  routes = navigation
     ? createWorkspaceRouteController({
         shell,
         configuration,
         selection,
         schedules,
+        automations,
         getEnvironmentId: () => dom.environmentSelect.value,
         getSessionId: () => state.currentSessionId,
         changeEnvironment: navigation.bindings.changeEnvironment,
@@ -47,7 +65,7 @@ export async function bootstrapWebApp({
   shell.load();
   homeComposer.setWorkspace(shell.activeWorkspace());
   dashboard.setActive(true);
-  for (const control of [shell, ...bindables]) control.bind();
+  for (const control of [shell, ...bindables, spark]) control.bind();
   bindEvents();
   renderComposer();
   selection.renderPermissionMode();
@@ -55,6 +73,7 @@ export async function bootstrapWebApp({
   state.config = await client.loadWebConfig();
   void configuration.refreshComputerAccess?.();
   schedules.refreshAvailability();
+  automations.refreshAvailability();
   notifications?.refreshAvailability();
   projects?.refreshAvailability();
   selection.renderEnvironmentOptions();
@@ -70,6 +89,7 @@ export async function bootstrapWebApp({
       : fallback;
   preferences.saveEnvironmentId(dom.environmentSelect.value);
   learning?.environmentChanged();
+  spark.environmentChanged();
   learning?.setWorkspace(shell.activeWorkspace());
   homeComposer.environmentChanged();
   selection.renderAgentPicker();
@@ -84,6 +104,8 @@ export async function bootstrapWebApp({
   ]);
   if (routes) await routes.restoreInitial();
   else await restoreLastSession();
+  if (canRestoreSparkAddress(initialAddress, dom.environmentSelect.value))
+    await spark.open(initialAddress.searchParams.get("message") || undefined, sparkNotificationReference(initialAddress));
   dashboard.setReady();
   notifications?.setReady();
 }

package/dist/src/web-ui/app/app-dom.js

@@ -5,6 +5,10 @@ export function findAppDom(documentRoot = document) {
     homeWorkspacePanel: documentRoot.getElementById("homeWorkspacePanel"),
     homeDashboardRoot: documentRoot.getElementById("homeDashboardRoot"),
     chatWorkspaceButton: documentRoot.getElementById("chatWorkspaceButton"),
+    automationsWorkspaceButton: documentRoot.getElementById("automationsWorkspaceButton"),
+    automationsWorkspacePanel: documentRoot.getElementById("automationsWorkspacePanel"),
+    closeAutomationsWorkspaceButton: documentRoot.getElementById("closeAutomationsWorkspaceButton"),
+    automationsRoot: documentRoot.getElementById("automationsRoot"),
     schedulesWorkspaceButton: documentRoot.getElementById(
       "schedulesWorkspaceButton",
     ),
@@ -39,6 +43,7 @@ export function findAppDom(documentRoot = document) {
     modelsWorkspaceButton: documentRoot.getElementById("modelsWorkspaceButton"),
     pluginsWorkspaceButton: documentRoot.getElementById("pluginsWorkspaceButton"),
     chatPanel: documentRoot.querySelector(".chat-panel"),
+    automationChatRunPanel: documentRoot.getElementById("automationChatRunPanel"),
     sessionsPanel: documentRoot.querySelector(".sessions-panel"),
     configWorkspacePanel: documentRoot.getElementById("configWorkspacePanel"),
     closeConfigWorkspaceButton: documentRoot.getElementById(

package/dist/src/web-ui/app/app-realtime-transport.js

@@ -9,13 +9,21 @@ export function createAppRealtimeTransport({
   recordControlEvent,
   onConnected,
 }) {
-  return createRealtimeTransport({
+  const messageListeners = new Set();
+  const connectedListeners = new Set();
+  const connectionListeners = new Set();
+  const transport = createRealtimeTransport({
     getConfig,
-    onMessage,
+    onMessage: (message) => {
+      onMessage(message);
+      for (const listener of messageListeners) listener(message);
+    },
     onOpen: () => {
       state.connected = true;
       setConnectionLabel("Connected");
       onConnected();
+      for (const listener of connectedListeners) listener();
+      for (const listener of connectionListeners) listener();
     },
     onClose: () => {
       state.connected = false;
@@ -23,10 +31,12 @@ export function createAppRealtimeTransport({
         "Realtime connection closed before steer was accepted.",
       );
       setConnectionLabel("Reconnecting", true);
+      for (const listener of connectionListeners) listener();
     },
     onError: () => {
       state.connected = false;
       setConnectionLabel("Connection issue", true);
+      for (const listener of connectionListeners) listener();
     },
     onParseError: (error, preview) => {
       recordControlEvent({
@@ -39,4 +49,19 @@ export function createAppRealtimeTransport({
       });
     },
   });
+  return {
+    ...transport,
+    subscribeMessages(listener) {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    subscribeConnectionChanged(listener) {
+      connectionListeners.add(listener);
+      return () => connectionListeners.delete(listener);
+    },
+    subscribeConnected(listener) {
+      connectedListeners.add(listener);
+      return () => connectedListeners.delete(listener);
+    },
+  };
 }

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

@@ -147,6 +147,8 @@ const { guide: runtimeSetupGuide, controller: runtimeOnboarding } =
       renderAttachmentComposer();
       dashboardFeature?.runtimeAvailabilityChanged();
       schedulesFeature?.runtimeAvailabilityChanged();
+      projectsFeature?.runtimeAvailabilityChanged();
+      passiveLearning?.runtimeAvailabilityChanged();
       configWorkspace?.renderHomeGuidance();
     },
   });
@@ -167,10 +169,9 @@ schedulesFeature = createSchedulesFeature({
   openSession: (sessionId) => conversationSession.openSession(sessionId),
 });
 passiveLearning = createPassiveLearningFeature({
+  isRuntimeReady: runtimeOnboarding.isReady,
   onChange: () => configWorkspace?.renderHomeGuidance(),
   client: runtimeClient,
-  openSession: (sessionId) => conversationSession.openSession(sessionId),
-  activateChat: () => shell.activateWorkspace("chat"),
   getEnvironmentId: selectedEnvironmentId,
   learningRoot: dom.learningRoot,
   openLearning: () => shell.activateWorkspace("learning"),
@@ -276,9 +277,6 @@ const toolApprovalController = createToolApprovalController({
 conversationView = createConversationView({
   dom,
   filePreviewClient: runtimeClient,
-  preferences,
-  archiveSession: (sessionId) => sessionController.archiveSession(sessionId),
-  onSparkArchived: () => shell.activateWorkspace("home"),
   getFileEnvironmentId: selectedEnvironmentId,
   getFileSessionId: () => state.currentSessionId,
   getMessages: () => state.messages,
@@ -338,6 +336,7 @@ conversationSession = createConversationSessionController({
     composerQueueController.isCurrentScope(scope),
 });
 projectsFeature = createProjectsFeature({
+  isRuntimeReady: runtimeOnboarding.isReady,
   onSessionCreated: (sessionId) =>
     runtimeSelection.initializeSessionMode(sessionId),
   dom,
@@ -526,7 +525,7 @@ const appEventBindings = createAppEventBindings({
   actions: {
     renderSessions,
     loadSessions,
-    suspendQueueRecovery: suspendRecoveredComposerReleaseForNavigation,
+    prepareQueueRecovery: () => composerQueueController.prepareRecoveryForNavigation(),
     saveSessionId: saveSessionIdForEnvironment,
     selectedEnvironmentId,
     rememberModelSelection: rememberCurrentModelSelection,
@@ -753,10 +752,6 @@ async function loadSystemHealth() {
   await operationsController.loadSystemHealth();
 }
 
-function suspendRecoveredComposerReleaseForNavigation() {
-  return composerQueueController.suspendRecoveryForNavigation();
-}
-
 void startWebApp({
   state,
   dom,

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

@@ -0,0 +1,103 @@
+import { createAutomationsController } from "./controllers/automations-controller.js";
+import { createAutomationsWorkspace } from "./components/automations/workspace.js";
+import { createAutomationChatRunProjection } from "./components/automations/chat-run-projection.js";
+import { openAutomationAuthoringChat } from "./components/automations/authoring-entry.js";
+
+export function createAutomationsFeature({
+  dom, client, shell, realtime, getEnvironmentId, onNavigationChange,
+  documentRoot = document,
+}) {
+  if (!dom.automationsRoot || !dom.automationsWorkspaceButton || !dom.automationChatRunPanel) {
+    return {
+      refreshAvailability() {},
+      isWorkspaceAvailable: (destination) => destination !== "automations",
+      selectedAutomationId: () => "", selectedRunId: () => "",
+      navigationRevision: () => 0, openRoute: async () => false,
+      prepareRouteChange: () => true,
+      chatRunId: () => "", openChatRun: async () => false,
+    };
+  }
+  let view;
+  const controller = createAutomationsController({
+    client, getEnvironmentId, onNavigationChange,
+    isEditingDirty: () => view?.isDirty() || false,
+    render: (snapshot) => view?.render(snapshot),
+  });
+  const chatRun = createAutomationChatRunProjection({
+    dom, client, getEnvironmentId, onNavigationChange,
+    returnToStudio: (run) => {
+      chatRun.clear();
+      if (!shell.activateWorkspace("automations")) return;
+      void controller.openRoute(run?.automationId || "", run?.id || "");
+    },
+  });
+  view = createAutomationsWorkspace({
+    root: dom.automationsRoot,
+    actions: {
+      ...controller,
+      openAuthoringChat(automationId, revision) {
+        return openAutomationAuthoringChat({ dom, shell, automationId, revision });
+      },
+      showChatRun(runId) {
+        if (!shell.activateWorkspace("chat")) return false;
+        return chatRun.open(runId);
+      },
+    },
+    documentRoot,
+  });
+  shell.addWorkspaceGuard(({ from, to }) => {
+    if (from !== "automations" || to === "automations") return true;
+    return view.prepareLeave();
+  });
+  dom.chatWorkspaceButton.addEventListener("click", () => chatRun.clear());
+  shell.subscribeWorkspaceChange((workspace) => {
+    controller.setWorkspaceActive(workspace === "automations");
+    chatRun.workspaceChanged(workspace);
+  });
+  dom.environmentSelect.addEventListener("change", () => queueMicrotask(() => {
+    controller.environmentChanged();
+    chatRun.clear();
+  }));
+  documentRoot.addEventListener("visibilitychange", () => {
+    controller.visibilityChanged();
+    chatRun.visibilityChanged();
+  });
+  realtime.subscribeMessages?.((message) => {
+    controller.handleRealtime(message);
+    chatRun.handleRealtime(message);
+  });
+  realtime.subscribeConnected?.(() => {
+    controller.reconnect();
+    chatRun.reconnect();
+  });
+  return {
+    refreshAvailability() {
+      const available = client.supportsAutomations();
+      dom.automationsWorkspaceButton.hidden = !available;
+      dom.automationsWorkspaceButton.disabled = !available || dom.automationsWorkspaceButton.dataset.onboardingBlocked === "true";
+      if (!available) controller.setWorkspaceActive(false);
+      if (!available) chatRun.clear();
+    },
+    isWorkspaceAvailable(destination) {
+      return destination !== "automations" || client.supportsAutomations();
+    },
+    selectedAutomationId: controller.selectedAutomationId,
+    selectedRunId: controller.selectedRunId,
+    chatRunId: chatRun.runId,
+    navigationRevision: controller.navigationRevision,
+    openRoute: controller.openRoute,
+    async openChatRun(runId) {
+      if (runId) shell.setSessionsDrawerOpen(false, { focus: false });
+      await chatRun.open(runId);
+      return true;
+    },
+    prepareRouteChange(route) {
+      if (shell.activeWorkspace() !== "automations") return true;
+      const changesIdentity = route.workspace !== "automations" ||
+        route.automation !== controller.selectedAutomationId() ||
+        route.run !== controller.selectedRunId() ||
+        route.environment !== getEnvironmentId();
+      return !changesIdentity || view.prepareLeave();
+    },
+  };
+}