@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -2,8 +2,9 @@ import type { SessionProject } from "./project-binding.js";
 import type { AgentMode } from "../shared/types.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
 import type { SessionMemoryCheckpoint } from "./memory/contracts.js";
+import type { SessionApprovalPresentation, SessionRequestLifecycleRecord, SessionRequestLifecycleSnapshot } from "./request-lifecycle/contracts.js";
 export type SessionMessageRole = "user" | "assistant";
-export type SessionMessageSource = "user" | "request" | "agent_bridge" | "cron";
+export type SessionMessageSource = "user" | "request" | "agent_bridge" | "cron" | "co_worker";
 export type SessionMessageTaskType = string;
 export type SessionMessageGrounding = "conversation" | "tool_observation";
 export type ToolObservationKind = "stable_fact" | "volatile_external" | "task_result";
@@ -40,7 +41,7 @@ export type SessionThinkingTraceEntry = {
     status: SessionThinkingTraceStatus;
     text: string;
 };
-export type SessionRequestStatus = "streaming" | "completed" | "failed";
+export type SessionRequestStatus = "streaming" | "awaiting_approval" | "completed" | "failed";
 export type SessionRuntimeEvent = {
     seqNo: number;
     type: string;
@@ -49,6 +50,7 @@ export type SessionRuntimeEvent = {
     payload: Record<string, unknown>;
 };
 export type SessionRequestRecord = {
+    lifecycle?: SessionRequestLifecycleRecord;
     requestId: string;
     sessionId: string;
     /** Absent for legacy records and records recreated by late event appends. */
@@ -69,6 +71,7 @@ export type SessionRequestFinalState = {
     completedAt: number;
 };
 export type SessionRequestReplay = {
+    lifecycle?: SessionRequestLifecycleSnapshot;
     requestId: string;
     sessionId: string;
     generation?: string;
@@ -76,6 +79,7 @@ export type SessionRequestReplay = {
     finalState: SessionRequestFinalState | null;
 };
 export type SessionListItem = {
+    kind?: import("./spark-session.js").SessionKind;
     project?: SessionProject;
     id: string;
     title: string;
@@ -91,6 +95,9 @@ export type SessionListResult = {
     nextCursor: string | null;
 };
 export type SessionSnapshotMessage = {
+    kind?: "tool_approval_request" | "terminal";
+    approvalRequest?: SessionApprovalPresentation;
+    initiative?: import("./assistant-initiative.js").AssistantInitiative;
     schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string | number;
     sessionId: string;
@@ -105,6 +112,7 @@ export type SessionSnapshotMessage = {
     attachments?: RuntimeAttachmentReference[];
 };
 export type SessionSnapshotRequest = {
+    lifecycle?: SessionRequestLifecycleSnapshot;
     requestId: string;
     sessionId: string;
     status: SessionRequestStatus;
@@ -115,6 +123,7 @@ export type SessionSnapshotRequest = {
     finalState: SessionRequestFinalState | null;
 };
 export type SessionSnapshot = {
+    kind?: import("./spark-session.js").SessionKind;
     project?: SessionProject;
     sessionId: string;
     title: string;
@@ -144,6 +153,9 @@ export type SessionMessageDeleteResult = {
     deletedRequestEvents?: number;
 };
 export type SessionMessage = {
+    kind?: "tool_approval_request" | "terminal";
+    approvalRequest?: SessionApprovalPresentation;
+    initiative?: import("./assistant-initiative.js").AssistantInitiative;
     schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string;
     role: SessionMessageRole;
@@ -162,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/shared/model-step-registry-data.json

@@ -1,5 +1,14 @@
 {
   "steps": {
+    "LEARNING_BATCH": {
+      "id": "learning.batch",
+      "owner": "runtime-core",
+      "role": "utility",
+      "lane": "utility",
+      "defaultFormat": "json",
+      "outputContract": "passive_learning_batch",
+      "attachmentPolicy": "none"
+    },
     "SUPERVISOR_DECISION": {
       "id": "supervisor.decision",
       "owner": "runtime-core",

package/dist/src/shared/model-step-registry.d.ts

@@ -2,6 +2,15 @@ import type { ModelInvocationLane, ModelInvocationStepDefinition } from "./model
 export type { ModelInvocationFormat, ModelInvocationAttachmentPolicy, ModelInvocationLane, ModelInvocationOutputTokenPolicy, ModelInvocationRole, ModelInvocationStepDefinition, ModelInvocationStepOwner, RegisteredModelInvocationStepDefinition, } from "./model-step-registry.types.js";
 export declare const CORE_DECISION_OUTPUT_TOKEN_LIMIT = 2048;
 export declare const MODEL_INVOCATION_STEP_REGISTRY: {
+    readonly LEARNING_BATCH: {
+        readonly id: "learning.batch";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "json";
+        readonly outputContract: "passive_learning_batch";
+        readonly attachmentPolicy: "none";
+    };
     readonly SUPERVISOR_DECISION: {
         readonly id: "supervisor.decision";
         readonly owner: "runtime-core";

package/dist/src/shared/model-step-registry.generated.d.ts

@@ -1,4 +1,13 @@
 export declare const GENERATED_MODEL_INVOCATION_STEP_REGISTRY: {
+    readonly LEARNING_BATCH: {
+        readonly id: "learning.batch";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "json";
+        readonly outputContract: "passive_learning_batch";
+        readonly attachmentPolicy: "none";
+    };
     readonly SUPERVISOR_DECISION: {
         readonly id: "supervisor.decision";
         readonly owner: "runtime-core";

package/dist/src/shared/model-step-registry.generated.js

@@ -1,4 +1,13 @@
 export const GENERATED_MODEL_INVOCATION_STEP_REGISTRY = {
+    LEARNING_BATCH: {
+        id: "learning.batch",
+        owner: "runtime-core",
+        role: "utility",
+        lane: "utility",
+        defaultFormat: "json",
+        outputContract: "passive_learning_batch",
+        attachmentPolicy: "none",
+    },
     SUPERVISOR_DECISION: {
         id: "supervisor.decision",
         owner: "runtime-core",

package/dist/src/shared/passive-observation.d.ts

@@ -0,0 +1,46 @@
+/** Maximum replay lifetime of collected evidence, including paused batches. */
+export declare const PASSIVE_OBSERVATION_RETENTION_MS: number;
+/** Passive desktop evidence. An edit describes a changed editable control, not authorship. */
+export type PassiveObservationSource = Readonly<{
+    app: string;
+    processId?: number;
+    windowId: string;
+    documentId?: string;
+    title?: string;
+    url?: string;
+}>;
+export type PassiveObservation = Readonly<{
+    id: string;
+    timestamp: string;
+    sequence: number;
+    source: PassiveObservationSource;
+    content: string;
+    kind: "view" | "edit" | "activity";
+    extraction: "uia" | "ax" | "atspi";
+    coverage: "complete" | "partial" | "metadata_only";
+    coverageReason?: string;
+    revisitsObservationId?: string;
+}>;
+export type PassiveCollectionState = "starting" | "collecting" | "partial" | "unavailable" | "permission_required" | "paused" | "stopped" | "disconnected" | "failed";
+export type PassiveCollectorEvent = Readonly<{
+    type: "observation";
+    observation: PassiveObservation;
+}> | Readonly<{
+    type: "status";
+    state: PassiveCollectionState;
+    reason?: string;
+}>;
+/** Device identity is attached by the authenticated broker, never trusted from screen content. */
+export type HostObservationEvent = PassiveCollectorEvent & Readonly<{
+    deviceId: string;
+    ownerId: string;
+    leaseId: string;
+}>;
+export type HostObservationSubscription = Readonly<{
+    rootDir: string;
+    ownerId: string;
+    leaseId: string;
+    abortSignal: AbortSignal;
+    excludedApplications?: readonly string[];
+    onEvent(event: HostObservationEvent): void;
+}>;

package/dist/src/shared/passive-observation.js

@@ -0,0 +1,2 @@
+/** Maximum replay lifetime of collected evidence, including paused batches. */
+export const PASSIVE_OBSERVATION_RETENTION_MS = 24 * 60 * 60 * 1000;

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

@@ -19,6 +19,17 @@ Controllers and components communicate through injected callbacks or values. The
 
 `workspace-shell.js` is the single owner of workspace navigation. It owns the active Home, Chat, Schedules or Config workspace, responsive Conversations visibility, focus restoration, Escape handling, backdrop state, and related ARIA attributes. `conversation-sidebar-layout.js` resolves the sidebar presentation policy; `operations-section.js` owns the internal Runtime, Logs, and Health tabs within Configuration. These components must not own session data, request state, or Runtime transport.
 
+`workspace-route-controller.js` owns the browser address projection and history
+restoration; `lib/workspace-route.js` owns address parsing and serialization.
+The four workspace paths reuse the existing server fallback. Environment is
+explicit, with a Chat session, Configuration category and Operations tab, or
+saved schedule Job when relevant. Bootstrap validates the URL environment before
+loading its data, then restores the addressed view. Route application uses the
+existing shell, environment, conversation and schedule controllers and respects
+their guards. Environment transitions suppress intermediate history entries;
+rejected Back or Forward navigation restores the accepted history entry. The URL
+never contains drafts, credentials, approval choices, or mutation payloads.
+
 `conversation-activity.js` owns only request-scoped activity presentation. `realtime-event-controller.js` preserves sequence authority, associates events and progress with their exact `requestId`, and injects those values into the conversation view. `realtime-transport.js` only parses and transports frames; it does not reduce application state.
 
 `composer-context-window.js` presents the existing context estimate as one compact composer indicator. It selects the active assistant request, or the newest conversation message only when it is a request-linked assistant message while idle. A pending user turn, an assistant message without a request ID, or missing metrics hides the indicator instead of falling back to an earlier request. Context metric updates refresh it independently of message tokens; session-view resets clear it. Estimated usage, provider-reported usage, and compaction remain distinct, and provider usage stays bound to the matching model invocation.
@@ -83,7 +94,7 @@ Panel resizing and persisted panel widths are intentionally not part of this arc
 
 `composer-workspace-controller.js` moves the existing composer DOM between Home and Chat and isolates their draft text and attachments. `composer-surface-controller.js` routes input, rendering and attachment actions to the active surface. Both surfaces use the same attachment and submission controllers; background Chat queue work writes to its own input surface. Home submission adopts its draft into a new conversation before invoking the ordinary Chat request controller. Home navigation alone never resets or reads the active conversation. `conversation-read-state-controller.js` rechecks visible Chat, environment, session and view revision before marking persisted assistant messages read.
 
-Dashboard Job suggestions are inert data in `dashboard-job-templates.js`. They open the ordinary schedule form with editable defaults, a selected model, device time zone and a new dedicated conversation target. Only explicit Save creates state. `schedule-job-creation.ts` adapts this Web-only target into an owner-created conversation and the existing scheduler contract; it never invokes the model. Existing-conversation creation remains supported. `configuration-feature.js` owns the composition of Configuration and its memory controls. `app-bootstrap.js` owns startup ordering, environment restoration, initial loading and Home activation.
+Dashboard Job suggestions are inert data in `dashboard-job-templates.js`. They open the ordinary schedule form with editable defaults, a selected model, device time zone and a new dedicated conversation target. Only explicit Save creates state. `schedule-job-creation.ts` adapts this Web-only target into an owner-created conversation and the existing scheduler contract; it never invokes the model. Existing-conversation creation remains supported. `configuration-feature.js` owns the composition of Configuration and its memory controls. `app-bootstrap.js` owns startup ordering, environment restoration, initial loading and route-controller composition; an unaddressed start activates Home.
 
 Read tracking belongs only to the native Web UI backend. `session-read-state/service.ts` reads canonical session snapshots and projects unread assistant replies; `store.ts` persists the UI cursors in an environment-specific sidecar under `runtimeDir/web-ui/read-state/`. Runtime session files, model context and Runtime contracts remain unchanged. A persisted initialization timestamp treats existing history as read and tracks later replies, including newly created Job conversations. Read acknowledgements resolve only the displayed persisted assistant message or its exact completed request ID. Cursors advance monotonically and survive server restarts; invalid boundaries never acknowledge unseen replies. Browser consumers retain newer read revisions when older responses arrive late.
 
@@ -143,9 +154,14 @@ Visual components may format or group events, but they never accept transport fr
 `schedules-feature.js` composes the scheduler browser feature from its controller,
 transport requests and presentation. `schedules-controller.js` owns loading and
 management actions scoped to the selected environment, guards stale reads, and
-refreshes only while the workspace is active and no editor or mutation is pending.
+refreshes from committed server changes while the workspace is active and visible.
+The event refresh queue coalesces bursts and preserves changes received during
+reads or mutations; reconnection and visibility return reconcile missed changes.
+Background updates retain the open editor and the selected run-history page.
 The full Schedules workspace shares the shell navigation and discard guards;
-its editor uses an explicit save and a saved model/mode with Full tool access.
+its editor uses an explicit save and a saved model/mode with selectable Full or
+FULL+ tool access. Full remains the default; FULL+ must be selected explicitly.
+The run history shows the permission captured for each invocation.
 Unchanged timing fields are omitted from edits, preserving the original timer or
 interval anchor when only a title, prompt or model changes.
 
@@ -215,6 +231,9 @@ external mutation lock during save, Apply and refresh. Saved model identity
 survives Apply failure; successful Apply survives refresh failure. Completion
 refreshes Memory provider choices and chat models, selects the new profile, and
 focuses it only after closing the modal and releasing the lock.
+Deferred activation refreshes the saved declaration without marking it active or
+refreshing the active chat catalog. The dialog distinguishes saved/pending status
+from save failures, and closing it does not undo the saved declaration.
 
 local-runtime/model-setup-\* owns catalog/input/credential/addition behavior.
 It uses the canonical configuration repository and shared CLI merge helper,
@@ -223,6 +242,12 @@ Only new OpenAI/Ollama connections are created here; existing provider IDs are
 resolved by adapter type. The transport exposes no secret values and requires
 the same-origin JSON mutation guard. This flow does not invoke a model.
 
+New Web additions use a model file and `configRef`; existing inline profiles
+remain supported. Declaration removal uses the canonical Runtime lock and loaded
+root revision, validates the remaining configuration for every environment, and
+keeps referenced files, providers and credentials. Discovered files without a
+declaration remain editable and are explicitly marked as not registered.
+
 ## Projects and permission modes
 
 `projects-feature.js` composes project UI; `projects-controller.js` owns project
@@ -245,3 +270,104 @@ values and server compatibility. FULL+ requires advertised server support, and
 transport rejects unsupported requests without a silent downgrade. The existing
 composer queue keeps its captured mode. Project membership never selects FULL+.
 `app-state.js` constructs the same one shared browser state identity for `app.js`.
+
+Home approvals reuse the local Web transport's live approval promises through
+`GET /chat/approvals`. An explicit decision POST binds the environment, session,
+request and approval identities and rechecks live ownership before resolving it.
+The dashboard controller discards old-environment responses; discovery and
+approval never load or mark a conversation as read. External bridge connections
+show that Home discovery is unavailable. The shared approval card keeps recorded
+execution evidence visible and places the complete rationale in a native disclosure.
+
+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,4 +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,
@@ -7,6 +13,8 @@ export async function bootstrapWebApp({
   shell,
   homeComposer,
   dashboard,
+  learning,
+  notifications,
   schedules,
   projects,
   selection,
@@ -19,18 +27,54 @@ export async function bootstrapWebApp({
   configuration,
   realtime,
   restoreLastSession,
+  navigation,
+  onNavigationReady = () => {},
 }) {
+  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,
+        isEnvironmentChanging: navigation.bindings.isEnvironmentChanging,
+        loadSessions: navigation.conversation.loadSessions,
+        openSession: navigation.conversation.openSession,
+        restoreLastSession,
+      })
+    : null;
+  onNavigationReady(routes);
+  routes?.bind();
   selection.loadPreferences();
   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();
   renderMessages();
   state.config = await client.loadWebConfig();
+  void configuration.refreshComputerAccess?.();
   schedules.refreshAvailability();
+  automations.refreshAvailability();
+  notifications?.refreshAvailability();
   projects?.refreshAvailability();
   selection.renderEnvironmentOptions();
   const options = selection.environmentOptions();
@@ -38,8 +82,15 @@ export async function bootstrapWebApp({
   const fallback =
     textOf(state.config.defaultEnvironmentId).trim() || options[0]?.value || "";
   const hasSavedEnvironment = options.some((option) => option.value === saved);
-  dom.environmentSelect.value = hasSavedEnvironment ? saved : fallback;
+  dom.environmentSelect.value = routes
+    ? routes.bootstrapEnvironment(options, saved, fallback)
+    : hasSavedEnvironment
+      ? saved
+      : fallback;
   preferences.saveEnvironmentId(dom.environmentSelect.value);
+  learning?.environmentChanged();
+  spark.environmentChanged();
+  learning?.setWorkspace(shell.activeWorkspace());
   homeComposer.environmentChanged();
   selection.renderAgentPicker();
   realtime.connect();
@@ -51,6 +102,20 @@ export async function bootstrapWebApp({
     operations.loadSystemHealth(),
     configuration.load(),
   ]);
-  await restoreLastSession();
+  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();
+}
+
+export async function startWebApp(options) {
+  const startup = createStartupScreen();
+  try {
+    await bootstrapWebApp(options);
+    startup.ready();
+  } catch (error) {
+    startup.fail(error);
+  }
 }

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",
     ),
@@ -15,8 +19,31 @@ export function findAppDom(documentRoot = document) {
       "closeSchedulesWorkspaceButton",
     ),
     schedulesRoot: documentRoot.getElementById("schedulesRoot"),
+    learningWorkspaceButton: documentRoot.getElementById(
+      "learningWorkspaceButton",
+    ),
+    learningWorkspacePanel: documentRoot.getElementById(
+      "learningWorkspacePanel",
+    ),
+    closeLearningWorkspaceButton: documentRoot.getElementById(
+      "closeLearningWorkspaceButton",
+    ),
+    learningRoot: documentRoot.getElementById("learningRoot"),
+    memoryWorkspaceButton: documentRoot.getElementById("memoryWorkspaceButton"),
+    memoryWorkspacePanel: documentRoot.getElementById("memoryWorkspacePanel"),
+    openMemoryRestartControlsButton: documentRoot.getElementById(
+      "openMemoryRestartControlsButton",
+    ),
+    closeMemoryWorkspaceButton: documentRoot.getElementById(
+      "closeMemoryWorkspaceButton",
+    ),
+    memorySetupRoot: documentRoot.getElementById("memorySetupRoot"),
+    memoryManagementRoot: documentRoot.getElementById("memoryManagementRoot"),
     configWorkspaceButton: documentRoot.getElementById("configWorkspaceButton"),
+    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(
@@ -58,6 +85,7 @@ export function findAppDom(documentRoot = document) {
     composerPlan: documentRoot.getElementById("composerPlan"),
     composerSubmitControl: documentRoot.getElementById("composerSubmitControl"),
     sendButton: documentRoot.getElementById("sendButton"),
+    stopButton: documentRoot.getElementById("stopButton"),
     sendButtonLabel: documentRoot.getElementById("sendButtonLabel"),
     sendNextMenuButton: documentRoot.getElementById("sendNextMenuButton"),
     sendNextMenu: documentRoot.getElementById("sendNextMenu"),

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

@@ -0,0 +1,46 @@
+import { bindRuntimeSetupPageLifecycle } from "./runtime-setup-page-lifecycle.js";
+
+export function bindWebAppPageLifecycle({
+  appEventBindings,
+  page,
+  documentRoot,
+  environmentSelect,
+  disposeRuntimeSetup,
+  reloadModels,
+  markSessionRead,
+  environmentChanged,
+  visibilityChanged,
+}) {
+  appEventBindings.bind();
+  bindRuntimeSetupPageLifecycle({
+    page,
+    dispose: disposeRuntimeSetup,
+    reloadModels,
+  });
+  documentRoot.addEventListener("visibilitychange", markSessionRead);
+  documentRoot.addEventListener("visibilitychange", visibilityChanged);
+  environmentSelect.addEventListener("change", environmentChanged);
+}
+
+export function bindWebAppWorkspaceLifecycle({
+  appEventBindings, dom, runtimeSetupGuide, reloadModels, conversationSession,
+  homeComposer, dashboardFeature, passiveLearning, notifications, operations,
+}) {
+  bindWebAppPageLifecycle({
+    appEventBindings,
+    page: window,
+    documentRoot: document,
+    environmentSelect: dom.environmentSelect,
+    disposeRuntimeSetup: runtimeSetupGuide.dispose,
+    reloadModels,
+    markSessionRead: conversationSession.markCurrentSessionReadSoon,
+    environmentChanged: () => {
+      homeComposer.environmentChanged();
+      dashboardFeature.environmentChanged();
+      passiveLearning.environmentChanged();
+      notifications.environmentChanged();
+      operations.environmentChanged();
+    },
+    visibilityChanged: passiveLearning.visibilityChanged,
+  });
+}

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

@@ -0,0 +1,67 @@
+import { createRealtimeTransport } from "./services/realtime-transport.js";
+
+export function createAppRealtimeTransport({
+  state,
+  getConfig,
+  onMessage,
+  setConnectionLabel,
+  rejectPendingSteers,
+  recordControlEvent,
+  onConnected,
+}) {
+  const messageListeners = new Set();
+  const connectedListeners = new Set();
+  const connectionListeners = new Set();
+  const transport = createRealtimeTransport({
+    getConfig,
+    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;
+      rejectPendingSteers(
+        "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({
+        type: "control",
+        name: "Realtime parse error",
+        tone: "failed",
+        summary: `${error instanceof Error ? error.message : String(error)}${
+          preview ? `: ${preview}` : ""
+        }`,
+      });
+    },
+  });
+  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-state.js

@@ -19,6 +19,7 @@ export function createAppState() {
     contextWindowByRequest: new Map(),
     submittedToolApprovalIds: new Set(),
     requestMessages: new Map(),
+    requestLifecycles: new Map(),
     currentSessionId: "",
     activeRequestId: "",
     sessionViewVersion: 0,