@abot-ai/runtime 1.7.0 → 1.8.1

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

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/95-home-widgets.css

@@ -0,0 +1,109 @@
+/* Home-only small-screen summaries. Full live components retain their owners. */
+.home-widget-grid[hidden] { display: none; }
+
+.home-widget-dialog {
+  width: min(720px, calc(100vw - 32px));
+  max-height: calc(100dvh - 40px);
+  padding: 0;
+  border: 1px solid var(--line-strong);
+  border-radius: 12px;
+  background: var(--panel);
+  color: var(--text);
+}
+.home-widget-dialog[open] { display: flex; flex-direction: column; }
+.home-widget-dialog::backdrop { background: color-mix(in srgb, var(--bg) 78%, transparent); }
+.home-widget-dialog-header {
+  display: flex; align-items: center; justify-content: space-between;
+  gap: 16px; padding: 14px 20px; border-bottom: 1px solid var(--line); flex: none;
+}
+.home-widget-dialog-header h2 { margin: 0; font-size: var(--font-size-2xl); font-weight: 500; }
+.home-widget-dialog-body { overflow: auto; min-height: 0; padding: 20px; overscroll-behavior: contain; }
+.home-widget-dialog-body > .home-widget-source { width: 100%; margin: 0; }
+.home-widget-dialog .home-panel-rows,
+.home-widget-dialog .system-host-permission-details .system-host-permissions {
+  max-height: none; overflow: visible;
+}
+.home-widget-dialog .home-panel { border: 0; border-radius: 0; }
+.home-widget-dialog .home-approval { max-height: none; }
+.home-widget-dialog .home-automation-status { display: block; }
+.home-widget-dialog .home-automation-runs { margin-top: 12px; flex-wrap: wrap; }
+
+@media (max-width: 1440px) {
+  .home-widgets-compact .home-widget-source:not(.home-widget-expanded) { display: none !important; }
+  .home-widgets-compact .home-overview { display: contents; }
+  .home-widgets-compact .home-approval-dock { display: none; }
+  .home-widgets-compact .home-workspace-body { padding-block: 16px; }
+  .home-widgets-compact .home-widget-grid {
+    display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); grid-auto-rows: 1fr; gap: 12px; order: 1;
+  }
+  .home-widgets-compact .home-widget-grid[hidden] { display: none; }
+  .home-widget {
+    display: flex; flex-direction: column; align-items: stretch; gap: 12px;
+    min-width: 0; min-height: 160px; width: 100%; padding: 15px 16px;
+    text-align: start; background: var(--panel); color: var(--text);
+    border: 1px solid var(--line); border-radius: 10px; box-shadow: none;
+  }
+  .home-widget:hover { border-color: var(--line-strong); background: var(--panel-soft); }
+  .home-widget-heading {
+    display: flex; align-items: center; gap: 9px; padding-bottom: 11px;
+    border-bottom: 1px solid var(--line); color: var(--text-strong);
+    font-size: var(--font-size-lg); font-weight: 500; line-height: 1.4;
+  }
+  .home-widget-heading-icon {
+    display: flex; align-items: center; justify-content: center; flex: none;
+    width: 27px; height: 27px; border-radius: 6px; background: var(--control-fill); color: var(--muted);
+  }
+  .home-widget-heading-icon > svg, .home-widget-heading-icon > img { width: 17px; height: 17px; }
+  .home-widget svg { fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
+  .home-widget [data-widget-label] { flex: 1; min-width: 0; }
+  .home-widget-arrow { margin-inline-start: auto; color: var(--muted-2); flex: none; }
+  .home-widget-badge { flex: none; }
+  .home-widget-badge .home-widget-symbol { font-size: var(--font-size-xs); }
+  .home-widget-preview { display: flex; flex-direction: column; justify-content: center; gap: 10px; min-width: 0; min-height: 74px; }
+  .home-widget-row { display: flex; align-items: center; gap: 10px; min-height: 31px; min-width: 0; }
+  .home-widget-copy { display: flex; flex: 1; flex-direction: column; gap: 3px; min-width: 0; }
+  .home-widget-item-title { display: block; font-size: var(--font-size-md); font-weight: 400; line-height: 1.4; }
+  .home-widget-row .home-widget-item-title { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .home-widget-meta { font-size: var(--font-size-xs); color: var(--muted-2); line-height: 1.4; overflow-wrap: anywhere; }
+  .home-widget-meta:empty { display: none; }
+  .home-widget-row .home-widget-meta { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .home-widget-automation .home-widget-item-title, .home-widget-fallback .home-widget-title, .home-widget-fallback .home-widget-detail { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; overflow: hidden; }
+  .home-widget-symbol { display: inline-flex; align-items: center; justify-content: center; gap: 5px; flex: none; color: var(--muted); font-size: var(--font-size-sm); font-weight: 400; font-variant-numeric: tabular-nums; }
+  .home-widget-symbol svg { width: 16px; height: 16px; flex: none; }
+  .home-widget-symbol[data-tone="active"] { color: var(--accent); }
+  .home-widget-symbol[data-tone="success"] { color: var(--green); }
+  .home-widget-symbol[data-tone="attention"] { color: var(--amber); }
+  .home-widget-symbol[data-tone="failed"] { color: var(--danger); }
+  .home-widget-badge .home-widget-symbol[data-tone="attention"] { padding: 2px 6px; border-radius: 5px; background: color-mix(in srgb, var(--amber) 10%, var(--panel)); }
+  .home-widget-metrics { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); align-items: center; gap: 10px; min-height: 74px; }
+  .home-widget-metric { display: flex; flex-direction: column; align-items: center; gap: 9px; min-width: 0; color: var(--muted); font-size: var(--font-size-xs); }
+  .home-widget-metric .home-widget-symbol { min-height: 23px; font-size: var(--font-size-4xl); }
+  .home-widget-metric .home-widget-symbol svg { width: 20px; height: 20px; }
+  .home-widget-automation { display: flex; align-items: center; gap: 13px; min-height: 74px; }
+  .home-widget-automation > .home-widget-symbol { flex-direction: column; gap: 5px; min-width: 33px; font-size: var(--font-size-3xl); }
+  .home-widget-automation > .home-widget-symbol svg { width: 20px; height: 20px; }
+  .home-widget-computer { display: flex; flex-direction: column; justify-content: center; gap: 14px; min-height: 74px; }
+  .home-widget-device { display: flex; align-items: baseline; justify-content: space-between; gap: 8px; min-width: 0; }
+  .home-widget-device .home-widget-item-title { overflow-wrap: anywhere; }
+  .home-widget-device .home-widget-meta { flex: none; }
+  .home-widget-checks { display: flex; flex-wrap: wrap; gap: 10px 16px; }
+  .home-widget-check { display: inline-flex; align-items: center; gap: 6px; font-size: var(--font-size-xs); color: var(--muted); }
+  .home-widget-fallback { display: flex; flex-direction: column; gap: 5px; }
+  .home-widget-title { font-size: var(--font-size-md); font-weight: 400; line-height: 1.4; }
+  .home-widget-detail { font-size: var(--font-size-xs); color: var(--muted); }
+  .home-widget-status { font-size: var(--font-size-xs); color: var(--muted-2); }
+  .home-widget-title, .home-widget-detail, .home-widget-status { overflow-wrap: anywhere; }
+  .home-widget[data-tone="success"] .home-widget-status { color: var(--green); }
+  .home-widget[data-tone="attention"] .home-widget-status { color: var(--amber); }
+  .home-widget[data-tone="failed"] .home-widget-status { color: var(--danger); }
+  .home-widget[data-tone="active"] .home-widget-status { color: var(--accent); }
+}
+@media (max-width: 1000px) {
+  .home-widgets-compact .home-widget-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .home-widgets-compact .home-widget { padding: 14px; }
+}
+@media (max-width: 520px) {
+  .home-widgets-compact .home-widget-grid { grid-template-columns: minmax(0, 1fr); }
+  .home-widget-dialog-body { padding: 12px; }
+  .home-widget-dialog-header { padding: 12px; }
+}

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,5 @@
 @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");
+@import url("./styles/95-home-widgets.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);
+}