@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -0,0 +1,17 @@
+import type { SessionRecord, SessionSnapshot, SessionSnapshotMessage } from "./types.js";
+export type SessionMessageIdentity = Pick<SessionSnapshotMessage, "id" | "role" | "createdAt" | "requestId">;
+export type SessionSnapshotOptions = {
+    afterMessageId?: string | number | null;
+    includeRequests?: boolean;
+    /** Web read receipts need identities, never message bodies or request events. */
+    identitiesOnly?: boolean;
+    page?: {
+        limit: number;
+        cursor?: string | null;
+        targetMessageId?: string;
+        targetCreatedAt?: number;
+        targetRequestId?: string;
+        waitingRequestId?: string;
+    };
+};
+export declare function projectSessionSnapshot(session: SessionRecord, options?: SessionSnapshotOptions): SessionSnapshot;

package/dist/src/sessions/snapshot.js

@@ -0,0 +1,105 @@
+import { clientVisibleMessages, filterMessagesAfter, createMessageRequestIdResolver, toEpochMs, toMessageIdForUi, toSnapshotMessage, toSnapshotRequest } from "./record/projection.js";
+function encodeAnchor(sessionId, message, direction) {
+    return Buffer.from(JSON.stringify({ sessionId, id: message.id, createdAt: message.createdAt, direction })).toString("base64url");
+}
+function decodeAnchor(cursor, sessionId) {
+    try {
+        const anchor = JSON.parse(Buffer.from(cursor, "base64url").toString());
+        if (anchor.sessionId !== sessionId)
+            throw new Error();
+        if (typeof anchor.id !== "string" || typeof anchor.createdAt !== "string")
+            throw new Error();
+        if (!["older", "newer"].includes(anchor.direction))
+            throw new Error();
+        return anchor;
+    }
+    catch {
+        throw new Error("history_cursor_stale");
+    }
+}
+function messageWindow(sessionId, messages, page, resolveRequestId) {
+    const limit = page.limit;
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        throw new Error("history_page_size_invalid");
+    let start = Math.max(0, messages.length - limit);
+    let end = messages.length;
+    if (page.targetMessageId != null) {
+        const target = messages.findIndex((message) => {
+            if (String(toMessageIdForUi(message.id)) !== page.targetMessageId)
+                return false;
+            if (page.targetCreatedAt == null)
+                return true;
+            if (toEpochMs(message.createdAt) !== page.targetCreatedAt)
+                return false;
+            return (resolveRequestId(message) || "") === (page.targetRequestId || "");
+        });
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    else if (page.targetRequestId) {
+        const target = messages.findIndex((message) => resolveRequestId(message) === page.targetRequestId);
+        if (target >= 0) {
+            start = target;
+            end = Math.min(messages.length, start + limit);
+        }
+    }
+    if (page.cursor) {
+        const anchor = decodeAnchor(page.cursor, sessionId);
+        const index = messages.findIndex((message) => message.id === anchor.id && message.createdAt === anchor.createdAt);
+        if (index < 0)
+            throw new Error("history_cursor_stale");
+        start = anchor.direction === "older" ? Math.max(0, index - limit) : index + 1;
+        end = anchor.direction === "older" ? index : Math.min(messages.length, start + limit);
+    }
+    const selected = messages.slice(start, end);
+    return {
+        selected,
+        nextCursor: start > 0 && selected.length ? encodeAnchor(sessionId, selected[0], "older") : null,
+        newerCursor: end < messages.length && selected.length ? encodeAnchor(sessionId, selected.at(-1), "newer") : null,
+    };
+}
+function isRequiredPageRequest(request, ids, waitingRequestId, continuation = false) {
+    if (ids.has(request.requestId))
+        return true;
+    if (continuation)
+        return false;
+    if (request.requestId === waitingRequestId)
+        return true;
+    if (request.status === "streaming")
+        return true;
+    return request.status === "awaiting_approval";
+}
+export function projectSessionSnapshot(session, options = {}) {
+    const visible = clientVisibleMessages(session.messages);
+    const requests = session.requests ?? [];
+    const resolveRequestId = createMessageRequestIdResolver(requests);
+    const base = {
+        sessionId: session.id, title: session.title,
+        ...(session.kind ? { kind: session.kind } : {}),
+        ...(session.project ? { project: session.project } : {}),
+    };
+    // The default projection is kept intact for existing session consumers.
+    if (!options.page && !options.identitiesOnly)
+        return {
+            ...base,
+            messages: filterMessagesAfter(visible, options.afterMessageId).map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId)),
+            requests: options.includeRequests === false ? [] : requests.map(toSnapshotRequest),
+            nextCursor: null,
+        };
+    const messageIndex = visible.map((message) => ({
+        id: toMessageIdForUi(message.id), role: message.role, createdAt: toEpochMs(message.createdAt),
+        requestId: resolveRequestId(message),
+    }));
+    if (options.identitiesOnly)
+        return { ...base, messages: [], requests: [], nextCursor: null, messageIndex };
+    const page = messageWindow(session.id, visible, options.page, resolveRequestId);
+    const messages = page.selected.map((message) => toSnapshotMessage(session.id, message, requests, resolveRequestId));
+    const ids = new Set(messages.map((message) => message.requestId));
+    return {
+        ...base, messages, messageIndex, nextCursor: page.nextCursor, newerCursor: page.newerCursor,
+        requests: options.includeRequests === false ? [] : requests
+            .filter((request) => isRequiredPageRequest(request, ids, options.page?.waitingRequestId, Boolean(options.page?.cursor))).map(toSnapshotRequest),
+    };
+}

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,12 +123,15 @@ export type SessionSnapshotRequest = {
     finalState: SessionRequestFinalState | null;
 };
 export type SessionSnapshot = {
+    kind?: import("./spark-session.js").SessionKind;
     project?: SessionProject;
     sessionId: string;
     title: string;
     messages: SessionSnapshotMessage[];
     requests: SessionSnapshotRequest[];
     nextCursor: string | null;
+    newerCursor?: string | null;
+    messageIndex?: import("./snapshot.js").SessionMessageIdentity[];
 };
 export type SessionDeleteResult = {
     sessionId: string;
@@ -172,7 +176,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/shared/tool-selection.d.ts

@@ -0,0 +1,2 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export declare function matchesToolSelectionId(ownerId: string, toolName: string, configuredId: string): boolean;

package/dist/src/shared/tool-selection.js

@@ -0,0 +1,7 @@
+/** Matches the existing wildcard, owner, tool, and qualified tool selectors. */
+export function matchesToolSelectionId(ownerId, toolName, configuredId) {
+    return (configuredId === "*" ||
+        configuredId === ownerId ||
+        configuredId === toolName ||
+        configuredId === `${ownerId}.${toolName}`);
+}

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

@@ -216,6 +216,20 @@ The server checks synchronous owner admission, refuses busy or externally owned
 environments, and refreshes its gateway through the owning lifecycle callback.
 Browser reload and saved selection are not evidence of live activation.
 
+Plugin configuration uses the existing manifest defaults and secret declarations.
+`components/plugins/configuration-fields.js` owns the shared install/edit form;
+`configuration-editor.js` keeps an editing dialog outside dashboard replacement.
+Installation drafts move their existing controls during rendering rather than
+serializing password values. Environment/workspace navigation respects unfinished
+configuration, and writes keep the existing external mutation guard.
+
+`plugin-configuration-service.ts` owns saved-value validation and the redacted
+projection. Its private store is installation-scoped, outside plugin packages,
+and survives removal. Saves and Apply acquire the canonical Runtime-file lock
+then the private-store lock. The plugin loader captures local values once per
+compiled configuration lifetime, preserving previous-owner rollback without
+changing plugin SDK or manifest contracts. No process environment is mutated.
+
 ### Additive model setup
 
 Configuration composes a separate Provider / Model / Ready dialog in
@@ -282,3 +296,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

@@ -68,6 +68,7 @@ let projectsFeature;
 let workspaceRoutes;
 let notifications;
 const operationsController = createOperationsController({
+  onSummaryChange: () => configWorkspace?.syncSummary(),
   dom,
   client: runtimeClient,
   getEnvironmentId: selectedEnvironmentId,
@@ -100,7 +101,7 @@ const steerController = createSteerController({
 
 const shell = createWorkspaceShell({
   dom,
-  onNavigationChange: () => workspaceRoutes?.sync(),
+  onNavigationChange: () => { configWorkspace?.syncSummary(); workspaceRoutes?.sync(); },
   isWorkspaceAvailable: (destination) => {
     if (!notifications?.isWorkspaceAvailable(destination)) return false;
     return schedulesFeature?.isWorkspaceAvailable(destination) ?? false;
@@ -147,6 +148,8 @@ const { guide: runtimeSetupGuide, controller: runtimeOnboarding } =
       renderAttachmentComposer();
       dashboardFeature?.runtimeAvailabilityChanged();
       schedulesFeature?.runtimeAvailabilityChanged();
+      projectsFeature?.runtimeAvailabilityChanged();
+      passiveLearning?.runtimeAvailabilityChanged();
       configWorkspace?.renderHomeGuidance();
     },
   });
@@ -164,13 +167,12 @@ schedulesFeature = createSchedulesFeature({
   getCurrentSessionId: () => state.currentSessionId,
   getAgentModes: () => state.supportedAgentModes,
   isRuntimeReady: runtimeOnboarding.isReady,
-  openSession: (sessionId) => conversationSession.openSession(sessionId),
+  openSession: (sessionId, options) => conversationSession.openSession(sessionId, options),
 });
 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"),
@@ -189,7 +191,7 @@ dashboardFeature = createDashboardFeature({
   schedules: schedulesFeature,
   selectedEnvironmentId,
   loadSessions,
-  openSession: (sessionId) => conversationSession.openSession(sessionId),
+  openSession: (sessionId, options) => conversationSession.openSession(sessionId, options),
   isComposerAvailable: runtimeOnboarding.isReady,
   passiveLearning,
 });
@@ -276,9 +278,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 +337,7 @@ conversationSession = createConversationSessionController({
     composerQueueController.isCurrentScope(scope),
 });
 projectsFeature = createProjectsFeature({
+  isRuntimeReady: runtimeOnboarding.isReady,
   onSessionCreated: (sessionId) =>
     runtimeSelection.initializeSessionMode(sessionId),
   dom,
@@ -526,7 +526,7 @@ const appEventBindings = createAppEventBindings({
   actions: {
     renderSessions,
     loadSessions,
-    suspendQueueRecovery: suspendRecoveredComposerReleaseForNavigation,
+    prepareQueueRecovery: () => composerQueueController.prepareRecoveryForNavigation(),
     saveSessionId: saveSessionIdForEnvironment,
     selectedEnvironmentId,
     rememberModelSelection: rememberCurrentModelSelection,
@@ -564,8 +564,10 @@ const appEventBindings = createAppEventBindings({
 });
 
 configWorkspace = createConfigurationFeature({
+  getOperationsSummary: () => operationsController.summary(shell.activeOperationsTab()),
   getLearningSnapshot: () => passiveLearning?.snapshot(),
   isRuntimeReady: runtimeOnboarding.isReady,
+  isComputerAccessAvailable: () => shell.isWorkspaceAvailable("config"),
   onNavigationChange: () => workspaceRoutes?.sync(),
   state,
   selection: runtimeSelection,
@@ -753,10 +755,6 @@ async function loadSystemHealth() {
   await operationsController.loadSystemHealth();
 }
 
-function suspendRecoveredComposerReleaseForNavigation() {
-  return composerQueueController.suspendRecoveryForNavigation();
-}
-
 void startWebApp({
   state,
   dom,