@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/app/passive-learning-feature.js

@@ -1,4 +1,5 @@
 import { createMacCollectionConsent } from "./components/passive-learning/macos-collection-consent.js";
+import { createCollectionConsentGate } from "./components/passive-learning/collection-consent-gate.js";
 import { createPassiveLearningController } from "./controllers/passive-learning-controller.js";
 import { createPassiveLearningHome } from "./components/passive-learning/home.js";
 import { createPassiveLearningMemory } from "./components/passive-learning/memory.js";
@@ -17,8 +18,10 @@ export function createPassiveLearningFeature({
   let home;
   let memory;
   let collectionConsent;
+  let macConsent;
   function renderViews(snapshot) {
     collectionConsent?.update(snapshot);
+    macConsent?.update(snapshot);
     home?.render(snapshot);
     memory?.render(snapshot);
   }
@@ -31,15 +34,19 @@ export function createPassiveLearningFeature({
       onChange();
     },
   });
-  collectionConsent = createMacCollectionConsent({
+  macConsent = createMacCollectionConsent({
     actions: controller,
     container: learningRoot,
   });
-  const actions = { ...controller, configure: collectionConsent.configure };
+  collectionConsent = createCollectionConsentGate({
+    actions: { ...controller, configure: macConsent.configure },
+    container: learningRoot, openComputerAccess,
+  });
+  const actions = { ...controller, configure: collectionConsent.configure,
+    restartCollection: collectionConsent.restartCollection };
   home = createPassiveLearningHome({
     actions,
     openLearning,
-    openComputerAccess,
     openSetup: () => {
       if (openLearning() === false) return;
       if (learningRoot) selectLearningView(learningRoot, "settings");
@@ -55,14 +62,19 @@ export function createPassiveLearningFeature({
     ...actions,
     setWorkspace(workspace) {
       collectionConsent.cancel();
+      macConsent.cancel();
       controller.setWorkspace(workspace);
     },
     handleRealtime(message) {
-      if (message?.type === "system-host.changed") collectionConsent.cancel();
+      if (message?.type === "system-host.changed") {
+        collectionConsent.cancel();
+        macConsent.cancel();
+      }
       controller.handleRealtime(message);
     },
     environmentChanged() {
       collectionConsent.cancel();
+      macConsent.cancel();
       controller.environmentChanged();
     },
     mountHome: (root) => {

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -17,6 +17,7 @@ export function createRuntimeOnboardingFeature({
   const usesBridgeBackend = () => state.config?.backend === "bridge";
   let selectedGuide = null;
   let bindings = {};
+  shell?.runtimeAvailabilityChanged(state.runtimeAvailability);
 
   function createConfiguredGuide() {
     const common = {
@@ -52,6 +53,7 @@ export function createRuntimeOnboardingFeature({
       loadHostConnection: () => runtimeClient.getSystemHostConnection(),
       connectLocalHost: () => runtimeClient.connectLocalSystemHost(),
       createHostPairing: () => runtimeClient.createSystemHostPairing(),
+      requestHostStoreConnection: () => runtimeClient.requestSystemHostStoreConnection(),
       requestHostPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
       downloadHostSetup: (platform) =>
         runtimeClient.downloadSystemHostSetup(platform),
@@ -87,6 +89,7 @@ export function createRuntimeOnboardingFeature({
   };
   const controller = createRuntimeOnboardingController({
     state,
+    getEnvironmentId: selectedEnvironmentId,
     guide,
     reloadModels: () =>
       usesBridgeBackend() ? reloadCatalog() : reloadModels(),

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

@@ -1,8 +1,10 @@
+import { createWorkspaceConversationOpener } from "./controllers/workspace-conversation-opener.js";
 import { createSchedulesController } from "./controllers/schedules-controller.js";
 import { createSchedulesWorkspace } from "./components/schedules/workspace.js";
 
 export function createSchedulesFeature({
   dom,
+  state = {},
   client,
   shell,
   selectedEnvironmentId,
@@ -13,6 +15,7 @@ export function createSchedulesFeature({
   documentRoot = globalThis.document,
   isRuntimeReady = () => true,
 }) {
+  const openConversation = createWorkspaceConversationOpener({ state, shell, openSession });
   let view;
   let active = false;
   let navigationRevision = 0;
@@ -29,10 +32,8 @@ export function createSchedulesFeature({
       onNavigationChange();
     },
     openConversation: async (sessionId, requestId) => {
-      if (!shell.activateWorkspace("chat")) return;
-      if (!sessionId) return;
       try {
-        await openSession(sessionId);
+        if (!await openConversation(sessionId, { page: { targetRequestId: requestId } })) return;
         if (!requestId) return;
         requestAnimationFrame(() => {
           const messages = [
@@ -78,6 +79,7 @@ export function createSchedulesFeature({
       return client.supportsSchedules();
     },
     prepareLeave: view.prepareLeave,
+    prepareEnvironmentChange: view.prepareEnvironmentChange,
     navigationRevision: () => navigationRevision,
     selectedJobId: () => controller.snapshot().selectedId,
     setActive(value) {

package/dist/src/web-ui/app/services/client-preferences.d.ts

@@ -6,25 +6,33 @@ type SessionSidebarPreferences = {
   archivedSessionIds: string[];
   orderedSessionIds: string[];
 };
+type PreferenceStorage = {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void | Promise<unknown>;
+  removeItem(key: string): void | Promise<unknown>;
+  subscribe?(listener: () => void): () => void;
+  flush?(): Promise<void>;
+  snapshot?(): { preferences: Record<string, string> } | null;
+};
 
-export declare function createClientPreferences(storage: Pick<
-  Storage, "getItem" | "setItem" | "removeItem"
->): {
+export declare function createClientPreferences(storage: PreferenceStorage): {
+  subscribe(listener: () => void): (() => void) | undefined;
+  flush(): Promise<void> | undefined;
   loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
-  saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void;
+  saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void | Promise<unknown>;
   loadPinnedSessions(): string[];
-  savePinnedSessions(sessionIds: readonly string[]): void;
+  savePinnedSessions(sessionIds: readonly string[]): void | Promise<unknown>;
   loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;
-  saveSessionModes(modes: SessionModeMap): void;
+  saveSessionModes(modes: SessionModeMap): void | Promise<unknown>;
   loadLastToolPermissionMode(normalize: (value: unknown) => ToolPermissionMode): ToolPermissionMode;
-  saveLastToolPermissionMode(mode: ToolPermissionMode): void;
+  saveLastToolPermissionMode(mode: ToolPermissionMode): void | Promise<unknown>;
   loadModelPreferences(): {
     sessionModels: PreferenceMap;
     lastModelByEnvironment: PreferenceMap;
   };
-  saveModelPreferences(sessionModels: PreferenceMap, lastModelByEnvironment: PreferenceMap): void;
+  saveModelPreferences(sessionModels: PreferenceMap, lastModelByEnvironment: PreferenceMap): Promise<unknown[]>;
   environmentId(): string;
-  saveEnvironmentId(environmentId: string): void;
+  saveEnvironmentId(environmentId: string): void | Promise<unknown>;
   sessionIdForEnvironment(environmentId: string): string;
-  saveSessionIdForEnvironment(environmentId: string, sessionId: string): void;
+  saveSessionIdForEnvironment(environmentId: string, sessionId: string): void | Promise<unknown>;
 };

package/dist/src/web-ui/app/services/client-preferences.js

@@ -15,10 +15,10 @@ function parseObject(storage, key) {
     const raw = storage.getItem(key);
     const value = raw ? JSON.parse(raw) : {};
     return value && typeof value === "object" && !Array.isArray(value)
-      ? value
-      : {};
+      ? Object.assign(Object.create(null), value)
+      : Object.create(null);
   } catch {
-    return {};
+    return Object.create(null);
   }
 }
 
@@ -36,10 +36,15 @@ function restoreSessionMode(value, normalizeToolPermissionMode) {
 
 export function createClientPreferences(storage) {
   return {
+    subscribe: (listener) => storage.subscribe?.(listener),
+    flush: () => storage.flush?.(),
     ...createSessionSidebarPreferences(storage),
     loadPinnedSessions() {
       try {
-        const raw = storage.getItem(storageKeys.pinnedSessions);
+        const acknowledged = storage.snapshot?.();
+        const raw = acknowledged
+          ? acknowledged.preferences[storageKeys.pinnedSessions]
+          : storage.getItem(storageKeys.pinnedSessions);
         const value = raw ? JSON.parse(raw) : [];
         return Array.isArray(value)
           ? value.map((id) => String(id || "")).filter(Boolean)
@@ -50,7 +55,7 @@ export function createClientPreferences(storage) {
     },
 
     savePinnedSessions(sessionIds) {
-      storage.setItem(storageKeys.pinnedSessions, JSON.stringify(sessionIds));
+      return storage.setItem(storageKeys.pinnedSessions, JSON.stringify(sessionIds));
     },
 
     loadSessionModes(normalizeToolPermissionMode) {
@@ -61,24 +66,25 @@ export function createClientPreferences(storage) {
           return restored ? [[sessionId, restored]] : [];
         },
       ));
-      storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
-      return modes;
+      return Object.assign(Object.create(null), modes);
     },
 
     saveSessionModes(modes) {
-      storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
+      return storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
     },
 
     loadLastToolPermissionMode(normalizeToolPermissionMode) {
       try {
-        return normalizeToolPermissionMode(storage.getItem(storageKeys.lastToolPermissionMode));
+        const mode = storage.getItem(storageKeys.lastToolPermissionMode);
+        if (!["ask", "full_access", "full_plus"].includes(mode)) return "ask";
+        return normalizeToolPermissionMode(mode);
       } catch {
-        return "full_access";
+        return "ask";
       }
     },
 
     saveLastToolPermissionMode(mode) {
-      storage.setItem(storageKeys.lastToolPermissionMode, mode);
+      return storage.setItem(storageKeys.lastToolPermissionMode, mode);
     },
 
     loadModelPreferences() {
@@ -92,11 +98,14 @@ export function createClientPreferences(storage) {
     },
 
     saveModelPreferences(sessionModels, lastModelByEnvironment) {
-      storage.setItem(storageKeys.sessionModels, JSON.stringify(sessionModels));
-      storage.setItem(
+      const sessions = storage.setItem(storageKeys.sessionModels, JSON.stringify(sessionModels));
+      const environments = storage.setItem(
         storageKeys.lastModelByEnvironment,
         JSON.stringify(lastModelByEnvironment),
       );
+      const saved = Promise.all([sessions, environments]);
+      void saved.catch(() => {});
+      return saved;
     },
 
     environmentId() {
@@ -105,8 +114,8 @@ export function createClientPreferences(storage) {
 
     saveEnvironmentId(environmentId) {
       if (environmentId)
-        storage.setItem(storageKeys.environmentId, environmentId);
-      else storage.removeItem(storageKeys.environmentId);
+        return storage.setItem(storageKeys.environmentId, environmentId);
+      return storage.removeItem(storageKeys.environmentId);
     },
 
     sessionIdForEnvironment(environmentId) {
@@ -124,7 +133,7 @@ export function createClientPreferences(storage) {
       );
       if (sessionId) sessions[environmentId] = sessionId;
       else delete sessions[environmentId];
-      storage.setItem(
+      return storage.setItem(
         storageKeys.currentSessionByEnvironment,
         JSON.stringify(sessions),
       );

package/dist/src/web-ui/app/services/home-guidance-preferences.js

@@ -1,4 +1,4 @@
-/** Browser-local review receipts only. Memory content never goes into storage. */
+/** Bounded review receipts only. Memory content is owned by the memory service. */
 export function createHomeGuidancePreferences(storage) {
   const key = (environment) => `abot-web.homeGuidance.${encodeURIComponent(environment)}`;
   const volatile = new Map();
@@ -9,35 +9,35 @@ export function createHomeGuidancePreferences(storage) {
       if (value && typeof value === "object" && !Array.isArray(value)) return {
         offeredOn: typeof value.offeredOn === "string" ? value.offeredOn : "",
         dismissed: Array.isArray(value.dismissed) ? value.dismissed.filter((id) => typeof id === "string").slice(-8) : [],
-        reviewed: Array.isArray(value.reviewed) ? value.reviewed.filter((id) => typeof id === "string").slice(-200) : [],
+        reviewed: Array.isArray(value.reviewed) ? value.reviewed.filter((item) => typeof item?.id === "string" && typeof item.updatedAt === "string").slice(-200) : [],
       };
-    } catch { /* Browser preferences may be unavailable. */ }
+    } catch { /* A malformed projection does not count as a review receipt. */ }
     return volatile.get(environment) || {};
   }
   function save(environment, patch) {
     const value = { ...read(environment), ...patch };
-    try {
-      if (!storage) throw new Error("Storage unavailable");
-      storage.setItem(key(environment), JSON.stringify(value));
-      volatile.delete(environment);
-    } catch { volatile.set(environment, value); }
+    if (!storage) { volatile.set(environment, value); return; }
+    return storage.setItem(key(environment), JSON.stringify(value));
   }
   return {
     dismissed: (environment) => read(environment).dismissed || [],
     dismiss(environment, id) {
       const dismissed = new Set(read(environment).dismissed || []);
       dismissed.add(id);
-      save(environment, { dismissed: [...dismissed].slice(-8) });
+      return save(environment, { dismissed: [...dismissed].slice(-8) });
     },
     wasOffered: (environment, day) => read(environment).offeredOn === day,
     markOffered: (environment, day) => save(environment, { offeredOn: day }),
     hasReviewed(environment, record) {
-      return (read(environment).reviewed || []).includes(`${record.id}:${record.updatedAt}`);
+      return (read(environment).reviewed || []).some((item) => item.id === record.id && item.updatedAt === record.updatedAt);
     },
     markReviewed(environment, record) {
-      const receipt = `${record.id}:${record.updatedAt}`;
-      const reviewed = (read(environment).reviewed || []).filter((id) => id !== receipt);
-      save(environment, { reviewed: [...reviewed, receipt].slice(-200) });
+      const reviewed = (read(environment).reviewed || []).filter((item) => item.id !== record.id);
+      return save(environment, { reviewed: [...reviewed, { id: record.id, updatedAt: record.updatedAt }].slice(-200) });
+    },
+    forgetReviewed(environment, id) {
+      const reviewed = (read(environment).reviewed || []).filter((item) => item.id !== id);
+      return save(environment, { reviewed });
     },
   };
 }

package/dist/src/web-ui/app/services/reasoning-override.js

@@ -0,0 +1,12 @@
+/** Save only the selected profile flag through the revision-checked config service. */
+export async function enableModelReasoning(client, profileId, environmentId) {
+  const payload = await client.loadConfigDashboard(environmentId, { settled: true });
+  const file = payload?.dashboard?.files?.models?.find((item) => item.id === profileId && item.registered === true);
+  if (!file || file.invalidJson || !file.revision)
+    throw new Error("This model cannot be updated here. Open Models to review its configuration.");
+  if (file.config?.supportsThinking === true) return;
+  await client.saveConfigFile({
+    environmentId, kind: "model", id: profileId,
+    config: { ...file.config, supportsThinking: true }, expectedRevision: file.revision,
+  });
+}

package/dist/src/web-ui/app/services/runtime-web-client/automations.js

@@ -47,8 +47,16 @@ export function createAutomationRequests({ requestApi, getEnvironmentId, getConf
       requestAutomation(path(`/${encodeURIComponent(automationId)}/permission`, environmentId), {
         method: "PUT", body: JSON.stringify(permission),
       }),
-    getAutomationCatalog: (automationId, environmentId) =>
-      requestAutomation(`${path("/catalog", environmentId)}&automation=${encodeURIComponent(automationId)}`),
+    async getAutomationCatalog(automationId, environmentId = getEnvironmentId()) {
+      const [catalog, modelCatalog] = await Promise.all([
+        requestAutomation(`${path("/catalog", environmentId)}&automation=${encodeURIComponent(automationId)}`),
+        requestAutomation(`/chat/models?environment=${encodeURIComponent(environmentId)}`),
+      ]);
+      return { ...catalog, models: (catalog.models || []).map((model) => ({
+        ...model,
+        supportsThinking: modelCatalog.profiles?.find((profile) => profile.id === model.id)?.supportsThinking === true,
+      })) };
+    },
     startAutomationRun: (automationId, idempotencyKey, environmentId) =>
       post(path(`/${encodeURIComponent(automationId)}/run`, environmentId), { idempotencyKey }),
     listAutomationRuns: (automationId, environmentId) =>

package/dist/src/web-ui/app/services/runtime-web-client/configuration.js

@@ -1,8 +1,10 @@
+import { createPluginConfigurationRequests } from "./plugin-configuration.js";
 /** Configuration transport; credentials are sent once and never retained here. */
 export function createConfigurationRequests({ requestApi, environmentQuery }) {
   const scoped = (path, environmentId) =>
     path + "?environment=" + environmentQuery(environmentId);
   return {
+    ...createPluginConfigurationRequests({ requestApi, environmentQuery }),
     getRuntimeSetup(environmentId) {
       return requestApi(scoped("/runtime/setup", environmentId));
     },
@@ -42,6 +44,24 @@ export function createConfigurationRequests({ requestApi, environmentQuery }) {
         body: JSON.stringify(input),
       });
     },
+    inspectRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/inspect", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    installRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/install", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    removeRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins/remove", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
     applyRuntimeConfiguration(environmentId) {
       return requestApi(scoped("/runtime/config/apply", environmentId), {
         method: "POST",

package/dist/src/web-ui/app/services/runtime-web-client/memory.js

@@ -2,6 +2,7 @@ export function createLongTermMemoryRequests({
   requestApi,
   getEnvironmentId,
   environmentQuery,
+  onMemoryDeleted = async () => {},
 }) {
   return Object.freeze({
     loadLongTermMemoryStatus(environmentId = getEnvironmentId()) {
@@ -102,13 +103,17 @@ export function createLongTermMemoryRequests({
       });
     },
 
-    deleteLongTermMemory({ environmentId = getEnvironmentId(), id }) {
-      return requestApi(
+    async deleteLongTermMemory({ environmentId = getEnvironmentId(), id }) {
+      const result = await requestApi(
         `/runtime/memory/records/${encodeURIComponent(
           id,
         )}?environment=${environmentQuery(environmentId)}`,
         { method: "DELETE" },
       );
+      if (result?.deleted !== true) return result;
+      try { await onMemoryDeleted(environmentId, id); }
+      catch { /* Receipt storage reports its failure separately; DELETE already succeeded. */ }
+      return result;
     },
   });
 }

package/dist/src/web-ui/app/services/runtime-web-client/plugin-configuration.js

@@ -0,0 +1,19 @@
+/** Plugin configuration transport never retains entered credentials. */
+export function createPluginConfigurationRequests({
+  requestApi,
+  environmentQuery,
+}) {
+  const path = (pluginId, environmentId) =>
+    `/runtime/plugins/configuration/${encodeURIComponent(pluginId)}?environment=${environmentQuery(environmentId)}`;
+  return {
+    getPluginConfiguration(pluginId, environmentId) {
+      return requestApi(path(pluginId, environmentId));
+    },
+    savePluginConfiguration(pluginId, input, environmentId) {
+      return requestApi(path(pluginId, environmentId), {
+        method: "PUT",
+        body: JSON.stringify(input),
+      });
+    },
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client/spark-chat.js

@@ -1,16 +1,16 @@
 export function createSparkChatRequests({ requestApi, getEnvironmentId, getConfig }) {
   const supportsSparkChat = () => getConfig()?.backend === "runtime";
-  function path(environmentId) {
+  function path(environmentId, paged = false) {
     if (!supportsSparkChat()) throw new Error("SPARK chat is unavailable with this backend.");
-    return `/runtime/spark/chat?${new URLSearchParams({ environment: environmentId })}`;
+    return `/runtime/spark/chat?${new URLSearchParams({ environment: environmentId, ...(paged ? { page: "1" } : {}) })}`;
   }
   return {
     supportsSparkChat,
     loadSparkChat(environmentId = getEnvironmentId()) {
-      return requestApi(path(environmentId));
+      return requestApi(path(environmentId, true));
     },
     configureSparkChat(input, environmentId = getEnvironmentId()) {
-      return requestApi(path(environmentId), {
+      return requestApi(path(environmentId, true), {
         method: "PUT", body: JSON.stringify(input),
       });
     },

package/dist/src/web-ui/app/services/runtime-web-client/system-host.js

@@ -14,10 +14,14 @@ export function createSystemHostRequests({ requestApi, getConfig, getEnvironment
   return {
     supportsSystemHostConnection,
     getSystemHostConnection: () => requestSystemHost(`?environment=${encodeURIComponent(getEnvironmentId())}`),
+    acceptSystemHostCollectionConsent: () =>
+      requestSystemHost("/collection-consent", { method: "POST", body: JSON.stringify({ acknowledged: true }) }),
     requestSystemHostPermissions: (input) =>
       requestSystemHost("/permissions", { method: "POST", body: JSON.stringify(input) }),
     connectLocalSystemHost: () =>
       requestSystemHost("/connect-local", { method: "POST", body: "{}" }),
+    requestSystemHostStoreConnection: () =>
+      requestSystemHost("/store-connect", { method: "POST", body: "{}" }),
     downloadSystemHostSetup: (platform, options = {}) =>
       requestSystemHost("/setup", {
         method: "POST",

package/dist/src/web-ui/app/services/runtime-web-client.d.ts

@@ -84,6 +84,7 @@ export declare function createRuntimeWebClient(options: {
   getEnvironmentId: () => string;
   fetchImpl?: typeof fetch;
   origin?: string;
+  onMemoryDeleted?: (environmentId: string, id: string) => Promise<unknown> | void;
 }): {
   supportsSparkChat: SparkChatRequests["supportsSparkChat"];
   loadSparkChat: SparkChatRequests["loadSparkChat"];
@@ -99,8 +100,10 @@ export declare function createRuntimeWebClient(options: {
   decideToolApproval: ToolApprovalRequests["decideToolApproval"];
   supportsSystemHostConnection(): boolean;
   getSystemHostConnection(): Promise<Record<string, unknown>>;
+  acceptSystemHostCollectionConsent(): Promise<Record<string, unknown>>;
   requestSystemHostPermissions(input: Record<string, unknown>): Promise<Record<string, unknown>>;
   connectLocalSystemHost(): Promise<Record<string, unknown>>;
+  requestSystemHostStoreConnection(): Promise<Record<string, unknown>>;
   downloadSystemHostSetup(
     platform: "windows" | "macos" | "linux",
     options?: { purpose?: "learning" },
@@ -128,6 +131,9 @@ export declare function createRuntimeWebClient(options: {
     environmentId?: string,
   ): Promise<Record<string, unknown>>;
   getRuntimePlugins(environmentId?: string): Promise<Record<string, unknown>>;
+  inspectRuntimePlugin(input: Record<string, unknown>, environmentId?: string): Promise<Record<string, unknown>>;
+  installRuntimePlugin(input: Record<string, unknown>, environmentId?: string): Promise<Record<string, unknown>>;
+  removeRuntimePlugin(input: { pluginId: string }, environmentId?: string): Promise<Record<string, unknown>>;
   setRuntimePlugin(
     input: { pluginId: string; capabilityId?: string; enabled: boolean },
     environmentId?: string,
@@ -217,10 +223,11 @@ export declare function createRuntimeWebClient(options: {
     file: Blob;
   }): Promise<Record<string, unknown>>;
   loadWebConfig(): Promise<Record<string, unknown>>;
-  listSessions(environmentId?: string): Promise<Record<string, unknown>>;
+  listSessions(environmentId?: string, page?: Record<string, unknown>): Promise<Record<string, unknown>>;
   loadSession(
     sessionId: string,
     environmentId?: string,
+    page?: Record<string, unknown>,
   ): Promise<Record<string, unknown>>;
   markSessionRead(options: {
     sessionId: string;

package/dist/src/web-ui/app/services/runtime-web-client.js

@@ -36,6 +36,7 @@ export function createRuntimeWebClient({
   getEnvironmentId,
   fetchImpl = fetch,
   origin = window.location.origin,
+  onMemoryDeleted,
 }) {
   const environmentQuery = (environmentId = getEnvironmentId()) =>
     encodeURIComponent(environmentId);
@@ -98,6 +99,7 @@ export function createRuntimeWebClient({
     requestApi,
     getEnvironmentId,
     environmentQuery,
+    onMemoryDeleted,
   });
 
   return {
@@ -168,17 +170,26 @@ export function createRuntimeWebClient({
       return request("/web-config", "Web configuration");
     },
 
-    listSessions(environmentId = getEnvironmentId()) {
+    listSessions(environmentId = getEnvironmentId(), page) {
+      if (page && getConfig()?.backend === "runtime") return requestApi(
+        `/chat/sessions/page?environment=${environmentQuery(environmentId)}`,
+        { method: "POST", body: JSON.stringify(page) },
+      );
       return requestApi(
         `/chat/sessions?environment=${environmentQuery(environmentId)}`,
       );
     },
 
-    loadSession(sessionId, environmentId = getEnvironmentId()) {
+    loadSession(sessionId, environmentId = getEnvironmentId(), page = {}) {
+      const query = new URLSearchParams({ environment: environmentId });
+      if (getConfig()?.backend === "runtime") {
+        query.set("page", "1");
+        for (const [key, value] of Object.entries(page)) if (value != null) query.set(key, String(value));
+      }
       return requestApi(
         `/chat/sessions/${encodeURIComponent(
           sessionId,
-        )}/messages?environment=${environmentQuery(environmentId)}`,
+        )}/messages?${query}`,
       );
     },
 

package/dist/src/web-ui/app/services/server-composer-queue.js

@@ -0,0 +1,32 @@
+import { createSessionComposerQueue } from "../lib/session-composer-queue.js";
+
+/** Reads use the latest server projection. Mutations are serialized by the server. */
+export function createServerComposerQueue(storage) {
+  const ownerId = createWindowIdentity();
+  const view = () => createSessionComposerQueue({ storage: {
+    getItem: () => storage.snapshot()?.queue || null,
+    setItem() { throw new Error("Queue writes require server acknowledgement."); },
+  } });
+  const change = (scope, action, input = {}) =>
+    storage.execute({ kind: "queue", scope, action, ownerId, ...input });
+  return {
+    list: (scope) => view().list(scope),
+    peek: (scope) => view().peek(scope),
+    getBlockedRelease: (scope) => view().getBlockedRelease(scope),
+    claimBlockedRelease: (scope, releaseToken, options = {}) => change(scope, "claim", { releaseToken, takeover: options.takeover === true }),
+    beginBlockedSend: (scope, releaseToken) => change(scope, "begin", { releaseToken }),
+    markBlockedUncertain: (scope, releaseToken) => change(scope, "uncertain", { releaseToken }),
+    enqueue: (scope, item) => change(scope, "enqueue", { item }),
+    releaseForTerminal: (scope, requestId) => change(scope, "release", { requestId }),
+    bindReleasedSuccess: (scope, releaseToken, requestId) => change(scope, "bind", { releaseToken, requestId }),
+    rebindBlocked: (scope, requestId) => change(scope, "rebind", { requestId }),
+    updateBlockedRelease: (scope, releaseToken, item) => change(scope, "update", { releaseToken, item }),
+    refresh: () => storage.refresh(),
+  };
+}
+
+function createWindowIdentity() {
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+  // getRandomValues is also available on HTTP LAN origins, unlike randomUUID.
+  return [...globalThis.crypto.getRandomValues(new Uint32Array(4))].join("-");
+}

package/dist/src/web-ui/app/services/session-sidebar-preferences.js

@@ -8,11 +8,11 @@ function sessionIds(value) {
 function readEnvironments(storage) {
   try {
     const value = JSON.parse(storage.getItem(storageKey) || "{}");
-    if (!value || typeof value !== "object") return {};
-    if (Array.isArray(value)) return {};
-    return value;
+    if (!value || typeof value !== "object") return Object.create(null);
+    if (Array.isArray(value)) return Object.create(null);
+    return Object.assign(Object.create(null), value);
   } catch {
-    return {};
+    return Object.create(null);
   }
 }
 
@@ -36,7 +36,7 @@ export function createSessionSidebarPreferences(storage) {
         configurable: true,
         writable: true,
       });
-      storage.setItem(storageKey, JSON.stringify(environments));
+      return storage.setItem(storageKey, JSON.stringify(environments));
     },
   };
 }