@abot-ai/runtime 1.7.0 → 1.8.0

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));
     },
   };
 }

package/dist/src/web-ui/app/services/workspace-state-storage.js

@@ -0,0 +1,116 @@
+/** The in-memory view is a projection; only the server acknowledges persistence. */
+export function createWorkspaceStateStorage({ fetchImpl = fetch, onError = () => {} } = {}) {
+  let snapshot = null;
+  const lanes = new Map();
+  const failures = new Map();
+  const pending = [];
+  const listeners = new Set();
+
+  async function request(input) {
+    let response;
+    let result;
+    try {
+      response = await fetchImpl("/web-ui-state", input ? {
+        method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(input),
+      } : { cache: "no-store" });
+      result = await response.json();
+    } catch (error) { throw uncertainMutationError(error, input); }
+    if (!response.ok) throw workspaceResponseFailure(response, result, input);
+    if (result.state?.version !== 1 || !Number.isSafeInteger(result.state.revision) ||
+        !result.state.preferences || typeof result.state.queue !== "string")
+      throw uncertainMutationError(new Error("The server returned invalid workspace state."), input);
+    if (!snapshot || result.state.revision >= snapshot.revision) snapshot = result.state;
+    return result.result;
+  }
+  function laneFor(input) {
+    if (input.kind === "preference") return `preference:${input.key}`;
+    if (input.kind === "queue") return `queue:${JSON.stringify([input.scope.environmentId, input.scope.sessionId])}`;
+    return input.kind;
+  }
+  function report(error, lane) {
+    failures.set(lane, error);
+    onError(error);
+  }
+  function execute(input, completed = () => {}) {
+    const lane = laneFor(input);
+    const result = (lanes.get(lane) || Promise.resolve()).then(async () => {
+      if (failures.has(lane)) throw failures.get(lane);
+      const previousPreferences = JSON.stringify(snapshot?.preferences);
+      const value = await request(input);
+      try {
+        completed();
+        if (JSON.stringify(snapshot.preferences) !== previousPreferences)
+          for (const listener of listeners) listener();
+      } catch (error) { throw uncertainMutationError(error, input); }
+      return value;
+    });
+    // Ordering/failure belongs to this preference or queue scope. The acknowledged
+    // server snapshot remains shared; an unrelated failure is never permission to retry.
+    lanes.set(lane, result.then(() => undefined, (error) => report(error, lane)));
+    return result;
+  }
+  function getItem(key) {
+    const queued = pending.findLast((entry) => entry.key === key);
+    if (queued) return queued.value;
+    return snapshot?.preferences[key] ?? null;
+  }
+  function write(key, value) {
+    if (!snapshot) throw new Error("Workspace settings have not loaded.");
+    if (failures.has(`preference:${key}`)) {
+      const rejected = Promise.reject(failures.get(`preference:${key}`));
+      void rejected.catch(() => {});
+      return rejected;
+    }
+    const before = getItem(key);
+    if (before === value) return Promise.resolve();
+    const entry = { key, before, value };
+    pending.push(entry);
+    const discardPending = () => {
+      const index = pending.indexOf(entry);
+      if (index >= 0) pending.splice(index, 1);
+    };
+    const result = execute({ kind: "preference", ...entry }, discardPending);
+    void result.catch(() => {
+      discardPending();
+      for (const listener of listeners) listener();
+    });
+    return result;
+  }
+  return {
+    getItem,
+    setItem: (key, value) => write(key, String(value)),
+    removeItem: (key) => write(key, null),
+    execute,
+    async flush() {
+      await Promise.all(lanes.values());
+      if (failures.size) throw failures.values().next().value;
+    },
+    async refresh() {
+      try {
+        const previous = snapshot?.revision;
+        await request();
+        if (snapshot.revision !== previous) for (const listener of listeners) listener();
+      } catch (error) { report(error, "refresh"); throw error; }
+    },
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    snapshot: () => snapshot,
+    error: () => failures.values().next().value ?? null,
+  };
+}
+
+function uncertainMutationError(error, input) {
+  if (!input) return error;
+  const failure = error instanceof Error ? error : new Error(String(error));
+  // An absent acknowledgement cannot prove a POST had no durable effect.
+  failure.workspaceMutationMayHaveCommitted = true;
+  return failure;
+}
+
+function workspaceResponseFailure(response, result, input) {
+  const error = new Error(result.message || "Workspace state is unavailable.");
+  error.status = response.status;
+  error.code = result.error;
+  if (response.status < 500) return error;
+  // A server failure may follow durable publication, such as lock cleanup failure.
+  return uncertainMutationError(error, input);
+}

package/dist/src/web-ui/app/services/workspace-state.js

@@ -0,0 +1,27 @@
+import { createWorkspaceStateStorage } from "./workspace-state-storage.js";
+import { createServerComposerQueue } from "./server-composer-queue.js";
+import { acknowledgeWorkspaceStorage, showWorkspaceStorageFailure } from "../components/workspace-storage-notice.js";
+import { createStartupScreen } from "../components/startup-screen.js";
+
+let storage;
+let queue;
+export const workspaceStorage = () => storage;
+export const workspaceQueue = () => queue;
+export function observeWorkspaceStateChange(message) {
+  if (message.type !== "workspace_changed" || !message.resources?.includes("client-state")) return;
+  void storage?.refresh().catch(showWorkspaceStorageFailure);
+}
+
+export async function initializeWorkspaceState() {
+  storage = createWorkspaceStateStorage({ onError: showWorkspaceStorageFailure });
+  try {
+    await storage.refresh();
+    await acknowledgeWorkspaceStorage(storage);
+    queue = createServerComposerQueue(storage);
+    window.addEventListener("focus", () => void storage.refresh().catch(showWorkspaceStorageFailure));
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") void storage.refresh().catch(showWorkspaceStorageFailure);
+    });
+    return storage;
+  } catch (error) { createStartupScreen().fail(error); throw error; }
+}

package/dist/src/web-ui/app/spark-chat-conversation.js

@@ -1,16 +1,16 @@
+import { canChooseReasoning } from "./lib/reasoning-controls.js";
+import { createComposerFeature } from "./controllers/composer-feature.js";
+import { createComposerDrafts } from "./controllers/composer-drafts.js";
+import { createComposerDraftView } from "./controllers/composer-draft-view.js";
+import { workspaceQueue } from "./services/workspace-state.js";
 import { createAppState } from "./app-state.js";
 import { createConversationViewFeature } from "./controllers/conversation-view-feature.js";
 import { createConversationSessionController } from "./controllers/conversation-session-controller.js";
-import { createChatRequestController } from "./controllers/chat-request-controller.js";
-import { createComposerQueueController } from "./controllers/composer-queue-controller.js";
-import { createComposerSubmitController } from "./controllers/composer-submit-controller.js";
-import { createComposerAttachmentsController } from "./controllers/composer-attachments-controller.js";
 import { createRealtimeEventController } from "./controllers/realtime-event-controller.js";
 import { createSteerController } from "./controllers/steer-controller.js";
 import { createToolApprovalController } from "./controllers/tool-approval-controller.js";
 import { createToolApprovalCard } from "./components/tool-approval-card.js";
 import { createComposerActions } from "./components/composer-actions.js";
-import { createSessionComposerQueue } from "./lib/session-composer-queue.js";
 import { normalizeRealtimeMessage } from "./lib/realtime-message.js";
 import { createSparkChatResults } from "./components/spark-chat/results.js";
 import { sparkMessageStatus, sparkWorkingStatus } from "./lib/spark-chat-presentation.js";
@@ -23,24 +23,29 @@ export function createSparkChatConversation({
   dom, client, shell, getEnvironmentId, getConfiguration, isOpen, isConnected,
   getSubmissionBlock, scrollBehavior, refresh, onReadState, onRender,
   onOpenSchedule = () => {}, onOpenModelSettings = () => {},
-  sendRealtime, onComposerStateChange = () => {}, storage = localStorage,
+  sendRealtime, onComposerStateChange = () => {}, sessionQueue = workspaceQueue(),
   captureHandoffNavigation, onHandoffOpened,
 }) {
   const state = createAppState();
-  const sessionQueue = createSessionComposerQueue({ storage });
+  const drafts = createComposerDrafts();
+  const draftView = createComposerDraftView({ input: dom.composerInput,
+    getDraft: () => drafts.open({ environmentId: getEnvironmentId(), sessionId: state.currentSessionId }), isVisible: isOpen });
+  drafts.subscribe(draftView.refresh);
+  draftView.display();
   const mascotActivity = createSparkMascotActivity({ state, dom, isConnected });
   let session;
   let view;
   let realtime;
   let queue;
   let submit;
+  let attachments;
   const status = (text, busy = false) => {
     dom.messagesList.setAttribute("aria-busy", String(busy));
     dom.messageStatusRegion.textContent = sparkMessageStatus(text);
   };
   const render = () => { view?.render(); mascotActivity.render(); onRender?.(); };
   const renderActivityStatus = () => { view?.renderActivityStatus(); mascotActivity.render(); };
-  const updateSendState = () => { submit?.updateSendState(); mascotActivity.render(); onComposerStateChange(state.composerSending); };
+  const updateSendState = () => { draftView.display(); submit?.updateSendState(); mascotActivity.render(); onComposerStateChange(state.composerSending); };
   const recordControlEvent = (event) => realtime?.recordControlEvent(event);
   const getToolPermissionMode = () => getConfiguration()?.toolPermissionMode || "ask";
   const getModelPreference = () => {
@@ -56,13 +61,6 @@ export function createSparkChatConversation({
     onAccepted: (message) => session.insertSteerMessage(message),
   });
   const actions = createComposerActions({ dom, onSendNext: () => submit.dispatch("send_next") });
-  const attachments = createComposerAttachmentsController({
-    state, dom, shell, client, selectedEnvironmentId: getEnvironmentId,
-    selectedModelSupportsImageInput: () => getConfiguration()?.supportsImageInput === true,
-    ensureSession: () => session.ensureSession(), onSendStateChange: updateSendState,
-    onControlEvent: recordControlEvent,
-    isComposerAvailable: () => !getSubmissionBlock(), isComposerVisible: isOpen,
-  });
   const approvals = createToolApprovalController({
     state, selectedEnvironmentId: getEnvironmentId, sendRealtime,
     renderMessages: render, recordControlEvent, createCard: createToolApprovalCard,
@@ -88,7 +86,7 @@ export function createSparkChatConversation({
     getPendingApproval: approvals.pendingEvent, getPendingApprovals: approvals.pendingEvents,
     createApprovalCard: approvals.createCard,
     copyText: (text) => navigator.clipboard.writeText(text),
-    notify: shell.showToast, resolveAttachmentUrl: attachments.previewUrl,
+    notify: shell.showToast, resolveAttachmentUrl: (file) => attachments.previewUrl(file),
     onOpenSchedule, canOpenSchedule: () => client.supportsSchedules?.() === true,
     scrollBehavior,
     sparkActions: createSparkHandoffActions({
@@ -113,41 +111,32 @@ export function createSparkChatConversation({
     sessionQueue, conversationView: view, selectedEnvironmentId: getEnvironmentId,
     // Reading belongs to actual visible rows in the popup, never to session activation.
     isConversationVisible: () => false,
-    clearPendingAttachments() {}, applyConversationChrome() {}, applyModelSelection() {}, renderSessions() {},
+    applyConversationChrome() {}, applyModelSelection() {}, renderSessions() {},
     renderMessages: render, updateComposerSendState: updateSendState, setMessageStatus: status,
     sendRealtime, handleRealtimeMessage: (message) => realtime.handle(message),
     recordEvent: (message) => realtime.recordEvent(message), recordControlEvent,
     reportQueueFailure: (...args) => queue.reportFailure(...args),
     drainQueuedMessage: (...args) => queue.drain(...args),
-    suspendQueueRecovery: () => queue.suspendRecoveryForNavigation(),
+    suspendQueueRecovery: (canNavigate) => queue.suspendRecoveryForNavigation(canNavigate),
     recoverBlockedQueue: (...args) => queue.recoverForManualSend(...args),
     isCurrentComposerScope: isScopeCurrent,
     createSessionId() { throw new Error("SPARK conversation is not ready yet."); },
   });
-  const requests = createChatRequestController({
-    state, client, sessionQueue, conversationView: view, conversationSession: session,
-    attachments, currentComposerScope: scope, isCurrentComposerScope: isScopeCurrent,
-    rememberModelSelection() {}, applyConversationChrome() {}, renderSessions() {},
-    renderAttachments: attachments.render, getToolPermissionMode, getModelPreference,
-    clearQueueRecovery: (...args) => queue.clearRecovery(...args),
-    reportQueueFailure: (...args) => queue.reportFailure(...args),
-  });
-  queue = createComposerQueueController({
-    state, dom, queue: sessionQueue, selectedEnvironmentId: getEnvironmentId,
-    getToolPermissionMode, getModelPreference, rememberModelSelection() {}, attachments,
-    updateSendState, postChatMessage: requests.postChatMessage,
-    appendLocalUserMessage: session.appendLocalUserMessage,
-    activateRequestForScope: session.activateRequestForScope,
-    renderMessages: render, setMessageStatus: status, recordControlEvent,
-    resizeComposer: () => submit.resize(),
-  });
-  submit = createComposerSubmitController({
-    state, dom, composerActions: actions, attachments, queue, steer: steer.steer,
-    chatRequests: requests, conversationSession: session,
-    selectedEnvironmentId: getEnvironmentId, setMessageStatus: status,
-    getSubmissionBlock, onSubmissionBlocked: (block) => shell.showToast(block.message || "SPARK is not ready.", "failed"),
-    isComposerVisible: isOpen,
+  const composer = createComposerFeature({
+    state, dom: { ...dom, composerInput: draftView.surface }, shell, client, sessionQueue,
+    drafts, getDraft: draftView.current, conversationSession: session, conversationView: view,
+    getEnvironmentId, ensureSession: () => session.ensureSession(),
+    getSettings: () => ({ agentMode: state.agentMode, toolPermissionMode: getToolPermissionMode(), modelPreference: getModelPreference() }),
+    steer: steer.steer, composerActions: actions,
+    selectedModelSupportsImageInput: () => getConfiguration()?.supportsImageInput === true,
+    isComposerAvailable: () => !getSubmissionBlock(), getSubmissionBlock,
+    onSubmissionBlocked: (block) => shell.showToast(block.message || "SPARK is not ready.", "failed"),
+    isVisible: isOpen, renderSessions() {}, renderMessages: render, applyConversationChrome() {},
+    setMessageStatus: status, recordControlEvent, onChange: () => onComposerStateChange(state.composerSending),
   });
+  attachments = composer.attachments;
+  queue = composer.queue;
+  submit = composer.submit;
   realtime = createRealtimeEventController({
     state, shell, selectedEnvironmentId: getEnvironmentId,
     handleSteerAcknowledgement: steer.handleAcknowledgement,
@@ -201,16 +190,16 @@ export function createSparkChatConversation({
   return {
     state, session, view, attachments, render, handleRealtime, bind, queue,
     prepareEnvironmentChange: () => queue.prepareRecoveryForNavigation(),
-    setAgentMode(mode) { state.agentMode = mode; },
+    setAgentMode(mode) { if (canChooseReasoning(getConfiguration())) state.agentMode = mode; },
     update() {
       state.connected = isConnected();
-      attachments.render(); updateSendState(); renderActivityStatus();
+      draftView.display(); composer.changed(); updateSendState(); renderActivityStatus();
       if (!state.messages.length) render();
     },
     reset() {
       steer.rejectAll("SPARK environment changed.");
-      attachments.clear(); session.invalidateEnvironmentLoads(); session.clearCurrentSessionView();
-      dom.composerInput.value = "";
+      draftView.saveDisplayed(); session.invalidateEnvironmentLoads(); session.clearCurrentSessionView();
+      draftView.display();
     },
     status,
   };

package/dist/src/web-ui/app/spark-chat-feature.js

@@ -122,7 +122,11 @@ export function createSparkChatFeature({ dom, state: appState, client, shell, re
   });
   panel.dom.settingsButton.addEventListener("click", openSettings);
   panel.onToggle((opened) => {
-    if (!opened) { conversation.view.closeFilePreview(); return; }
+    if (!opened) {
+      accessRevision += 1;
+      conversation.view.closeFilePreview();
+      return;
+    }
     if (!isSparkAvailable()) { panel.setOpen(false, { focus: false }); return; }
     if (!restoringOpen) void open();
   });
@@ -131,7 +135,7 @@ export function createSparkChatFeature({ dom, state: appState, client, shell, re
     if (!isSparkAvailable()) return false;
     const scope = getEnvironmentId();
     const revision = accessRevision;
-    try { await sync.refresh({ wait: true }); }
+    try { await sync.refresh({ wait: true, consolidated: true }); }
     catch (error) {
       if (!canCompleteSparkOpening(scope, revision)) return false;
       shell.showToast(`SPARK could not be opened: ${error.message}`, "failed");
@@ -219,13 +223,15 @@ export function createSparkChatFeature({ dom, state: appState, client, shell, re
       const revision = accessRevision;
       try { if (!configuration) await sync.refresh({ wait: true }); }
       catch (error) {
-        if (!canCompleteSparkOpening(scope, revision)) return false;
+        if (!canCompleteSparkOpening(scope, revision)) return true;
         shell.showToast(`SPARK could not be opened: ${error.message}`, "failed");
         return true;
       }
       if (!canCompleteSparkOpening(scope, revision)) return true;
       if (sessionId !== configuration?.sessionId) return false;
-      return open(messageId, reference);
+      const opened = await open(messageId, reference);
+      if (!canCompleteSparkOpening(scope, revision)) return true;
+      return opened;
     },
     bind() {
       conversation.bind();

package/dist/src/web-ui/app/styles/21-composer-controls.css

@@ -366,3 +366,19 @@
     display: none;
   }
 }
+
+/* The reasoning permission prompt shares the composer's anchored menu surface. */
+.agent-mode-menu.reasoning-override-menu {
+  width: min(340px, calc(100vw - 32px));
+  padding: 16px;
+}
+.reasoning-override-prompt { display: grid; gap: 12px; }
+.reasoning-override-prompt p { margin: 0; color: var(--muted); font-size: 12px; line-height: 1.55; }
+.reasoning-override-prompt strong { font-size: 13px; }
+.reasoning-override-prompt small { color: var(--muted); font-size: 11px; line-height: 1.5; }
+.reasoning-override-actions { display: grid; gap: 8px; }
+.reasoning-override-actions button { padding: 8px 12px; text-align: left; border: 1px solid var(--line); border-radius: 7px; background: transparent; color: var(--text); font: inherit; font-size: 12px; }
+.reasoning-override-actions button:first-child { color: var(--accent); }
+.reasoning-override-actions button:hover:not(:disabled) { background: var(--panel); }
+.reasoning-override-actions button:disabled { opacity: .5; cursor: default; }
+.reasoning-override-prompt .error-text { color: var(--danger); }

package/dist/src/web-ui/app/styles/41-plugin-management.css

@@ -381,3 +381,11 @@
   gap: 8px;
   flex-wrap: wrap;
 }
+
+.plugin-platform-notice {
+  margin: 8px 0;
+  color: var(--amber);
+  font-size: var(--font-size-xs);
+  line-height: 1.5;
+  overflow-wrap: anywhere;
+}

package/dist/src/web-ui/app/styles/42-model-plugin-permissions.css

@@ -37,6 +37,7 @@
 }
 
 .model-plugin-summary-count,
+.model-plugin-platform-note,
 .model-plugin-global-note {
   color: var(--muted);
   font-size: var(--font-size-xs);

package/dist/src/web-ui/app/styles/49-collection-consent.css

@@ -0,0 +1,30 @@
+.collection-consent-dialog .collection-consent-acknowledgment {
+  display: flex;
+  align-items: flex-start;
+  gap: 10px;
+  margin-top: 18px;
+  color: var(--text);
+  font-size: 13px;
+  line-height: 1.5;
+  cursor: pointer;
+}
+.collection-consent-acknowledgment input[type="checkbox"] {
+  appearance: auto;
+  flex: 0 0 16px;
+  width: 16px;
+  height: 16px;
+  min-height: 16px;
+  margin: 2px 0 0;
+  border-radius: 2px;
+  accent-color: var(--accent);
+  cursor: pointer;
+}
+.collection-consent-acknowledgment span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+.collection-consent-acknowledgment a {
+  color: var(--accent);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}

package/dist/src/web-ui/app/styles/64-workspace-storage.css

@@ -0,0 +1,23 @@
+.workspace-storage-notice {
+  color: var(--text); background: var(--bg); border: 1px solid var(--line);
+  border-radius: 12px; padding: 24px; max-width: min(540px, calc(100vw - 40px));
+  line-height: 1.6;
+}
+.workspace-storage-notice::backdrop { background: #0009; }
+.workspace-storage-notice h2 { margin-top: 0; }
+.workspace-storage-notice button { margin-top: 8px; }
+.workspace-storage-failure {
+  position: fixed; z-index: 10000; bottom: 16px; left: 16px; right: 16px;
+  padding: 12px 16px; color: var(--text); background: var(--panel);
+  border: 1px solid #ed9b91; border-radius: 8px;
+}
+
+.composer-submission-notice {
+  grid-column: 1 / -1; width: 100%; color: var(--text-muted); font-size: 12px;
+}
+.composer-submission-notice[hidden] { display: none; }
+.composer-submission-notice > div {
+  display: flex; align-items: center; gap: 12px; justify-content: space-between;
+  padding: 8px 12px; border: 1px solid var(--line); border-radius: 8px;
+}
+.composer-submission-notice button { flex-shrink: 0; }

package/dist/src/web-ui/app/styles.css

@@ -53,6 +53,7 @@
 @import url("./styles/43-co-worker-applications.css");
 @import url("./styles/48-notifications.css");
 @import url("./styles/49-macos-permission.css");
+@import url("./styles/49-collection-consent.css");
 @import url("./styles/50-automations.css");
 @import url("./styles/51-automation-editor-actions.css");
 @import url("./styles/51-automation-templates.css");
@@ -61,3 +62,4 @@
 @import url("./styles/53-automation-schema-inputs.css");
 @import url("./styles/54-spark-chat.css");
 @import url("./styles/94-automations-responsive.css");
+@import url("./styles/64-workspace-storage.css");

package/dist/src/web-ui/client-state/contracts.d.ts

@@ -0,0 +1,15 @@
+/** Installation-owned UI state. These records never become model context. */
+export type ClientPreferences = Record<string, string>;
+export type ClientState = {
+    version: 1;
+    revision: number;
+    introductionSeen: boolean;
+    preferences: ClientPreferences;
+    queue: string;
+};
+export declare function emptyClientState(): ClientState;
+export declare class ClientStateError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status?: number);
+}

package/dist/src/web-ui/client-state/contracts.js

@@ -0,0 +1,13 @@
+export function emptyClientState() {
+    return { version: 1, revision: 0, introductionSeen: false,
+        preferences: { "abot-web.lastToolPermissionMode": "ask" }, queue: "" };
+}
+export class ClientStateError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/src/web-ui/client-state/preference-shapes.d.ts

@@ -0,0 +1,2 @@
+export declare function isPreferenceObject(value: unknown): value is Record<string, unknown>;
+export declare function assertPreferenceShape(key: string, value: unknown): void;

package/dist/src/web-ui/client-state/preference-shapes.js

@@ -0,0 +1,80 @@
+import { ClientStateError } from "./contracts.js";
+const modes = new Set(["ask", "full_access", "full_plus"]);
+export function isPreferenceObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasOnlyFields(value, fields) {
+    return Object.keys(value).every((key) => fields.includes(key));
+}
+function isSessionMode(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["toolPermissionMode", "savedAt"]))
+        return false;
+    if (typeof value.toolPermissionMode !== "string" || !modes.has(value.toolPermissionMode))
+        return false;
+    return Number.isFinite(value.savedAt);
+}
+function isSidebarPreference(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["archivedSessionIds", "orderedSessionIds"]))
+        return false;
+    return isStringList(value.archivedSessionIds) && isStringList(value.orderedSessionIds);
+}
+function isLauncherPosition(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["x", "y"]))
+        return false;
+    return Number.isFinite(value.x) && Number.isFinite(value.y);
+}
+function isGuidancePreference(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["offeredOn", "dismissed", "reviewed"]))
+        return false;
+    if (value.offeredOn !== undefined && typeof value.offeredOn !== "string")
+        return false;
+    if (value.dismissed !== undefined && (!isStringList(value.dismissed) || value.dismissed.length > 8))
+        return false;
+    if (value.reviewed === undefined)
+        return true;
+    if (!Array.isArray(value.reviewed) || value.reviewed.length > 200)
+        return false;
+    const seen = new Set();
+    for (const item of value.reviewed) {
+        if (!isPreferenceObject(item))
+            return false;
+        if (!hasOnlyFields(item, ["id", "updatedAt"]))
+            return false;
+        if (typeof item.id !== "string" || typeof item.updatedAt !== "string")
+            return false;
+        if (seen.has(item.id))
+            return false;
+        seen.add(item.id);
+    }
+    return true;
+}
+function hasPreferenceShape(key, value) {
+    if (key === "abot-web.pinnedSessions")
+        return isStringList(value);
+    if (key === "abot.spark.launcher.position.v1")
+        return isLauncherPosition(value);
+    if (key.startsWith("abot-web.homeGuidance."))
+        return isGuidancePreference(value);
+    if (!isPreferenceObject(value))
+        return false;
+    if (key === "abot-web.sessionModes")
+        return Object.values(value).every(isSessionMode);
+    if (key === "abot-web.sessionSidebarByEnvironment")
+        return Object.values(value).every(isSidebarPreference);
+    return Object.values(value).every((item) => typeof item === "string");
+}
+export function assertPreferenceShape(key, value) {
+    if (!hasPreferenceShape(key, value))
+        throw new ClientStateError("invalid_preferences", "Invalid workspace preferences or unbounded memory review receipts.");
+}

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

@@ -0,0 +1,3 @@
+import { type ClientPreferences } from "./contracts.js";
+export declare function decodePreference(key: string, value: unknown): unknown;
+export declare function updatePreference(preferences: ClientPreferences, input: Record<string, unknown>): void;