@abot-ai/runtime 1.7.0 → 1.8.0

package/dist/src/web-ui/app/lib/session-composer-queue-ownership.js

@@ -0,0 +1,58 @@
+/** Persisted ownership has no expiry: uncertain sends require a manual handoff. */
+export function hasValidQueueOwnership(queue) {
+  const owner = queue.blockedReleaseOwner;
+  if (owner === undefined || owner === null) return true;
+  if (queue.blockedByReleaseToken === null) return false;
+  if (!owner || typeof owner !== "object" || Array.isArray(owner)) return false;
+  if (typeof owner.id !== "string" || !owner.id || owner.id.length > 128) return false;
+  return ["editing", "sending", "uncertain"].includes(owner.state);
+}
+
+export function canEditBlockedRelease(queue, ownerId) {
+  if (!queue.blockedReleaseOwner) return true;
+  if (queue.blockedReleaseOwner.id !== ownerId) return false;
+  return queue.blockedReleaseOwner.state === "editing";
+}
+
+export function canUpdateBlockedRelease(queue, ownerId) {
+  return canEditBlockedRelease(queue, ownerId);
+}
+
+export function canBindBlockedRelease(queue, ownerId) {
+  if (!queue.blockedReleaseOwner) return true;
+  if (queue.blockedReleaseOwner.id !== ownerId) return false;
+  return ["sending", "uncertain"].includes(queue.blockedReleaseOwner.state);
+}
+
+export function createQueueOwnership({ ownerId, readStore, writeStore, getQueue, createToken, projectRelease }) {
+  function claimBlockedRelease(scope, releaseToken, { takeover = false } = {}) {
+    if (!ownerId) return projectRelease(getQueue(readStore(), scope));
+    const store = readStore();
+    const queue = getQueue(store, scope);
+    if (!queue?.blockedReleaseItem || queue.blockedByReleaseToken !== releaseToken) return null;
+    const owner = queue.blockedReleaseOwner;
+    if (!takeover && owner && !canEditBlockedRelease(queue, ownerId)) return null;
+    if (takeover || !owner) queue.blockedByReleaseToken = createToken();
+    queue.blockedReleaseOwner = { id: ownerId, state: "editing" };
+    writeStore(store);
+    return projectRelease(queue);
+  }
+
+  function changeOwnedPhase(scope, releaseToken, from, to) {
+    if (!ownerId) return true;
+    const store = readStore();
+    const queue = getQueue(store, scope);
+    if (queue?.blockedByReleaseToken !== releaseToken) return false;
+    if (queue.blockedReleaseOwner?.id !== ownerId) return false;
+    if (queue.blockedReleaseOwner.state !== from) return false;
+    queue.blockedReleaseOwner.state = to;
+    writeStore(store);
+    return true;
+  }
+
+  return {
+    claimBlockedRelease,
+    beginBlockedSend: (scope, token) => changeOwnedPhase(scope, token, "editing", "sending"),
+    markBlockedUncertain: (scope, token) => changeOwnedPhase(scope, token, "sending", "uncertain"),
+  };
+}

package/dist/src/web-ui/app/lib/session-composer-queue.d.ts

@@ -32,9 +32,14 @@ export interface SessionComposerQueueStorage {
 export interface ReleasedSessionComposerQueueItem {
   item: SessionComposerQueueItem;
   releaseToken: string;
+  owner?: { id: string; state: "editing" | "sending" | "uncertain" };
 }
 
 export interface SessionComposerQueue {
+  refresh?(): Promise<void>;
+  claimBlockedRelease(scope: SessionComposerQueueScope, releaseToken: string, options?: { takeover?: boolean }): ReleasedSessionComposerQueueItem | null;
+  beginBlockedSend(scope: SessionComposerQueueScope, releaseToken: string): boolean;
+  markBlockedUncertain(scope: SessionComposerQueueScope, releaseToken: string): boolean;
   enqueue(
     scope: SessionComposerQueueScope,
     item: SessionComposerQueueItemInput,
@@ -64,12 +69,19 @@ export interface SessionComposerQueue {
   ): boolean;
 }
 
+type QueueMutation = "claimBlockedRelease" | "beginBlockedSend" | "markBlockedUncertain" | "enqueue" | "updateBlockedRelease" | "releaseForTerminal" | "bindReleasedSuccess" | "rebindBlocked";
+export type RemoteSessionComposerQueue = Omit<SessionComposerQueue, QueueMutation> & {
+  [K in QueueMutation]: (...args: Parameters<SessionComposerQueue[K]>) => Promise<ReturnType<SessionComposerQueue[K]>>;
+};
+
 export interface CreateSessionComposerQueueOptions {
+  ownerId?: string | null;
   storage?: SessionComposerQueueStorage;
   storageKey?: string;
 }
 
 export declare const SESSION_COMPOSER_QUEUE_STORAGE_KEY: string;
+export declare function isPersistedStore(value: unknown): boolean;
 
 export declare function createSessionComposerQueue(
   options?: CreateSessionComposerQueueOptions,

package/dist/src/web-ui/app/lib/session-composer-queue.js

@@ -1,3 +1,5 @@
+import { hasValidQueueOwnership, canUpdateBlockedRelease, canBindBlockedRelease, createQueueOwnership } from "./session-composer-queue-ownership.js";
+
 export const SESSION_COMPOSER_QUEUE_STORAGE_KEY =
   "abot-web.sessionComposerQueue.v1";
 
@@ -60,6 +62,7 @@ function isQueueRecord(value) {
   const blockedReleaseItem = value?.blockedReleaseItem ?? null;
   return Boolean(
     isRecord(value) &&
+    hasValidQueueOwnership(value) &&
     isNonEmptyString(value.environmentId) &&
     isNonEmptyString(value.sessionId) &&
     (value.blockedByReleaseToken === null ||
@@ -72,7 +75,7 @@ function isQueueRecord(value) {
   );
 }
 
-function isPersistedStore(value) {
+export function isPersistedStore(value) {
   if (
     !isRecord(value) ||
     value.version !== STORAGE_VERSION ||
@@ -149,7 +152,8 @@ function createReleaseToken() {
 }
 
 export function createSessionComposerQueue({
-  storage = globalThis.localStorage,
+  storage,
+  ownerId = null,
   storageKey = SESSION_COMPOSER_QUEUE_STORAGE_KEY,
 } = {}) {
   if (
@@ -210,9 +214,7 @@ export function createSessionComposerQueue({
     return list(scopeInput)[0] ?? null;
   }
 
-  function getBlockedRelease(scopeInput) {
-    const scope = validateScope(scopeInput);
-    const queue = findQueue(readStore(), scope);
+  function projectRelease(queue) {
     if (
       !queue ||
       queue.blockedByReleaseToken === null ||
@@ -223,9 +225,14 @@ export function createSessionComposerQueue({
     return {
       releaseToken: queue.blockedByReleaseToken,
       item: cloneJson(queue.blockedReleaseItem),
+      ...(queue.blockedReleaseOwner ? { owner: { ...queue.blockedReleaseOwner } } : {}),
     };
   }
 
+  function getBlockedRelease(scopeInput) {
+    return projectRelease(findQueue(readStore(), validateScope(scopeInput)));
+  }
+
   function updateBlockedRelease(scopeInput, releaseToken, itemInput) {
     const scope = validateScope(scopeInput);
     if (!isNonEmptyString(releaseToken)) return false;
@@ -239,6 +246,7 @@ export function createSessionComposerQueue({
     ) {
       return false;
     }
+    if (!canUpdateBlockedRelease(queue, ownerId)) return false;
     queue.blockedReleaseItem = item;
     writeStore(store);
     return true;
@@ -261,8 +269,9 @@ export function createSessionComposerQueue({
     const releaseToken = createReleaseToken();
     queue.blockedByReleaseToken = releaseToken;
     queue.blockedReleaseItem = item;
+    if (ownerId) queue.blockedReleaseOwner = { id: ownerId, state: "editing" };
     writeStore(store);
-    return { item: cloneJson(item), releaseToken };
+    return projectRelease(queue);
   }
 
   function bindReleasedSuccess(scopeInput, releaseToken, newRequestId) {
@@ -273,12 +282,14 @@ export function createSessionComposerQueue({
     const store = readStore();
     const queue = findQueue(store, scope);
     if (!queue || queue.blockedByReleaseToken !== releaseToken) return false;
+    if (!canBindBlockedRelease(queue, ownerId)) return false;
 
     if (queue.items[0]) {
       queue.items[0].waitForRequestId = newRequestId;
     }
     queue.blockedByReleaseToken = null;
     queue.blockedReleaseItem = null;
+    delete queue.blockedReleaseOwner;
     if (queue.items.length === 0) {
       store.queues = store.queues.filter((candidate) => candidate !== queue);
     }
@@ -292,12 +303,16 @@ export function createSessionComposerQueue({
     const store = readStore();
     const queue = findQueue(store, scope);
     if (!queue || queue.blockedByReleaseToken === null) return false;
+    // A request found in a snapshot is not proof that it belongs to this release.
+    if (queue.blockedReleaseOwner) return false;
+    if (queue.blockedReleaseItem?.waitForRequestId === newRequestId) return false;
 
     if (queue.items[0]) {
       queue.items[0].waitForRequestId = newRequestId;
     }
     queue.blockedByReleaseToken = null;
     queue.blockedReleaseItem = null;
+    delete queue.blockedReleaseOwner;
     if (queue.items.length === 0) {
       store.queues = store.queues.filter((candidate) => candidate !== queue);
     }
@@ -306,6 +321,10 @@ export function createSessionComposerQueue({
   }
 
   return {
+    ...createQueueOwnership({
+      ownerId, readStore, writeStore, createToken: createReleaseToken, projectRelease,
+      getQueue: (store, scope) => findQueue(store, validateScope(scope)),
+    }),
     enqueue,
     list,
     peek,

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,11 +34,16 @@ 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,
@@ -54,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/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, { page: { targetRequestId: requestId } });
+        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/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/system-host.js

@@ -14,6 +14,8 @@ 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: () =>

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,6 +100,7 @@ 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>>;

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 {

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("-");
+}