@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/app/components/dashboard/workspace.js

@@ -1,66 +1,44 @@
+import { updateLiveRegion } from "../../lib/live-region.js";
 import { getDashboardJobTemplates } from "../../lib/dashboard-job-templates.js";
-import { dashboardIcon } from "./icons.js";
 import { renderDashboardActivity } from "./activity.js";
 import { renderDashboardConversations } from "./recent-conversations.js";
+import {
+  hasPendingDashboardApprovals,
+  renderDashboardApprovals,
+} from "./approvals.js";
 
-const shortcuts = [
-  {
-    action: "attach",
-    icon: "upload",
-    title: "Upload a file",
-    detail: "Image or document",
-  },
-  {
-    action: "create-job",
-    icon: "job",
-    title: "Create a job",
-    detail: "Schedule an agent task",
-  },
-  {
-    action: "conversations",
-    icon: "conversations",
-    title: "Continue a chat",
-    detail: "Pick up where you left off",
-  },
-  {
-    action: "configuration",
-    icon: "configuration",
-    title: "Configuration",
-    detail: "Models and tools",
-  },
-];
-
-function shortcutMarkup(shortcut) {
-  return `<button type="button" class="home-shortcut" data-dashboard-action="${shortcut.action}">${dashboardIcon(shortcut.icon)}<span><strong>${shortcut.title}</strong><small>${shortcut.detail}</small></span></button>`;
-}
-
-export function createDashboardWorkspace({ root, actions }) {
+export function createDashboardWorkspace({ root, actions, passiveLearning }) {
   root.classList.add("home-workspace");
   root.innerHTML = `<div class="home-workspace-body">
-    <div class="home-overview">
-      <section class="home-panel home-activity-panel" aria-label="Recent activity" data-dashboard-activity></section>
-      <section class="home-panel home-recent-panel" aria-label="Recent conversations" data-dashboard-conversations></section>
+    <div class="home-workspace-content">
+      <section class="home-panel home-learning-panel" data-dashboard-learning hidden><div data-dashboard-learning-content></div></section>
+      <div class="home-overview">
+        <section class="home-panel home-activity-panel" aria-label="Recent activity" data-dashboard-activity></section>
+        <section class="home-panel home-recent-panel" aria-label="Recent conversations" data-dashboard-conversations></section>
+      </div>
+      <div class="home-setup-host" data-dashboard-setup hidden></div>
+      <section class="home-panel home-approvals-panel" aria-label="Pending approvals" data-dashboard-approvals hidden></section>
     </div>
+    <div class="home-approval-dock" data-dashboard-approval-dock hidden></div>
     <section class="home-workspace-start" aria-label="Start a new conversation">
-      <div class="home-shortcuts" aria-label="Quick actions">${shortcuts.map(shortcutMarkup).join("")}</div>
-      <div class="home-setup-host" data-dashboard-setup hidden></div>
       <div class="home-composer-host" data-dashboard-composer></div>
       <p class="home-composer-note">Starts a new conversation</p>
     </section>
   </div>`;
   const overview = root.querySelector(".home-overview");
-  const shortcutRegion = root.querySelector(".home-shortcuts");
   const activity = root.querySelector("[data-dashboard-activity]");
   const conversations = root.querySelector("[data-dashboard-conversations]");
+  const approvals = root.querySelector("[data-dashboard-approvals]");
+  const approvalDock = root.querySelector("[data-dashboard-approval-dock]");
+  const content = root.querySelector(".home-workspace-content");
   const composerHost = root.querySelector("[data-dashboard-composer]");
   const setupHost = root.querySelector("[data-dashboard-setup]");
+  const learningPanel = root.querySelector("[data-dashboard-learning]");
+  passiveLearning?.mountHome(root.querySelector("[data-dashboard-learning-content]"));
   const composerNote = root.querySelector(".home-composer-note");
   const handlers = {
-    attach: () => actions.attach(),
-    "create-job": () => actions.createJob(),
     template: (button) => actions.createJob(button.dataset.templateId),
     conversations: () => actions.continueConversation(),
-    configuration: () => actions.openConfiguration(),
     jobs: () => actions.openJobs(),
     conversation: (button) =>
       actions.openConversation(
@@ -77,34 +55,51 @@ export function createDashboardWorkspace({ root, actions }) {
 
   function render(snapshot) {
     const setupRequired = snapshot.composerAvailable === false;
+    const pendingApprovals = hasPendingDashboardApprovals(snapshot);
+    approvalDock.hidden = setupRequired || !pendingApprovals;
+    // Keep pending actions beside the composer; refresh errors stay in content.
+    const approvalParent = pendingApprovals ? approvalDock : content;
+    if (approvals.parentElement !== approvalParent)
+      approvalParent.appendChild(approvals);
     root.classList.toggle("home-setup-active", setupRequired);
+    learningPanel.hidden = setupRequired || !passiveLearning;
     overview.hidden = setupRequired;
-    shortcutRegion.hidden = setupRequired;
-    root.querySelector('[data-dashboard-action="attach"]').disabled =
-      snapshot.composerAvailable === false;
-    root.querySelector('[data-dashboard-action="create-job"]').disabled =
-      snapshot.supportsSchedules === false;
+    approvals.hidden = setupRequired;
     composerHost.hidden = snapshot.composerAvailable === false;
     setupHost.hidden = snapshot.composerAvailable !== false;
     composerNote.hidden = snapshot.composerAvailable === false;
     if (setupRequired) {
       activity.innerHTML = "";
       conversations.innerHTML = "";
+      approvals.innerHTML = "";
       return;
     }
 
-    activity.innerHTML = renderDashboardActivity({
-      runs: snapshot.runs,
-      loading: snapshot.loadingActivity,
-      error: snapshot.activityError,
-      supported: snapshot.supportsSchedules,
-      templates: getDashboardJobTemplates(),
-    });
-    conversations.innerHTML = renderDashboardConversations({
-      sessions: snapshot.sessions,
-      loading: snapshot.loadingSessions,
-      error: snapshot.sessionsError,
+    renderDashboardApprovals({
+      root: approvals,
+      snapshot,
+      onDecision: actions.decideApproval,
+      documentRoot: root.ownerDocument,
     });
+
+    updateLiveRegion(
+      activity,
+      renderDashboardActivity({
+        runs: snapshot.runs,
+        loading: snapshot.loadingActivity,
+        error: snapshot.activityError,
+        supported: snapshot.supportsSchedules,
+        templates: getDashboardJobTemplates(),
+      }),
+    );
+    updateLiveRegion(
+      conversations,
+      renderDashboardConversations({
+        sessions: snapshot.sessions,
+        loading: snapshot.loadingSessions,
+        error: snapshot.sessionsError,
+      }),
+    );
     activity.setAttribute(
       "aria-busy",
       String(Boolean(snapshot.loadingActivity)),

package/dist/src/web-ui/app/components/home-guidance/daily-review-entry.js

@@ -0,0 +1,24 @@
+/** A quiet, explicit way back to the existing saved-memory review. */
+export function createDailyReviewEntry({ container, onOpen }) {
+  const root = container.ownerDocument.createElement("aside");
+  root.className = "home-guidance home-memory-review";
+  root.hidden = true;
+  root.setAttribute("aria-label", "Saved memory review");
+  root.innerHTML = `<div class="home-guidance-copy"><h3 class="home-row-title">Saved memories</h3>
+    <p class="home-row-detail"></p></div>
+    <button type="button" class="home-text-button" data-review-open>Review memories</button>`;
+  container.prepend(root);
+  const button = root.querySelector("[data-review-open]");
+  button.addEventListener("click", () => void onOpen());
+  return {
+    render({ visible, remaining, loading }) {
+      root.hidden = !visible;
+      root.querySelector("p").textContent = remaining > 0
+        ? `${remaining} saved ${remaining === 1 ? "memory" : "memories"} to review. Come back whenever you're ready.`
+        : "Review what ABot Spark has saved. Keep what fits or delete what doesn't.";
+      button.disabled = loading;
+      button.textContent = loading ? "Loading…" : "Review memories";
+    },
+    dispose() { root.remove(); },
+  };
+}

package/dist/src/web-ui/app/components/home-guidance/daily-review.js

@@ -0,0 +1,80 @@
+import { escapeHtml } from "../../lib/text-format.js";
+
+export function createDailyReviewDialog({ container, onDecision, onDismiss }) {
+  const documentRoot = container.ownerDocument;
+  const dialog = documentRoot.createElement("dialog");
+  dialog.className = "daily-memory-review";
+  dialog.setAttribute("aria-labelledby", "dailyMemoryTitle");
+  dialog.setAttribute("aria-describedby", "dailyMemoryDescription");
+  dialog.innerHTML = `<header><h2 id="dailyMemoryTitle">Review saved memories</h2>
+    <button type="button" data-review-close aria-label="Close daily memory review">×</button></header>
+    <p id="dailyMemoryDescription">Review memories saved by ABot Spark. Keep or delete each one.</p>
+    <div class="daily-review-progress"><span data-review-count></span><progress data-review-progress aria-label="Memories reviewed"></progress></div>
+    <article class="daily-review-card" data-review-card tabindex="0" aria-label="Memory review"></article>
+    <p class="daily-review-error" role="alert" data-review-error hidden></p>
+    <div class="daily-review-actions"><button type="button" data-review-delete>Delete memory</button>
+      <button type="button" data-review-keep>Keep memory</button></div>
+    <p class="daily-review-note">These memories are already saved. Keep marks them as reviewed in this browser.</p>
+    <button type="button" class="daily-review-later" data-review-later>Not now</button>`;
+  container.append(dialog);
+  let returnFocus;
+  const close = () => { dialog.close(); onDismiss(); };
+  dialog.querySelector("[data-review-close]").addEventListener("click", close);
+  dialog.querySelector("[data-review-later]").addEventListener("click", close);
+  dialog.addEventListener("cancel", (event) => { event.preventDefault(); close(); });
+  dialog.addEventListener("close", () => {
+    if (returnFocus?.isConnected && !returnFocus.closest("[hidden]")) returnFocus.focus();
+  });
+  dialog.querySelector("[data-review-delete]").addEventListener("click", () => void onDecision("delete"));
+  dialog.querySelector("[data-review-keep]").addEventListener("click", () => void onDecision("keep"));
+  function render(snapshot) {
+    const { items, index, busy, error } = snapshot;
+    const record = items[index];
+    const hasReviewLoadError = !record && Boolean(error);
+    let completionText = items.length ? "Review complete." : "No memories to review.";
+    if (hasReviewLoadError) completionText = "Review unavailable.";
+    const contentKey = record ? `${record.id}:${record.updatedAt}` : completionText;
+    const card = dialog.querySelector("[data-review-card]");
+    if (card.dataset.record !== contentKey) {
+      card.dataset.record = contentKey;
+      card.innerHTML = record
+        ? `<p dir="auto">${escapeHtml(record.content)}</p><span>Saved ${escapeHtml(new Date(record.createdAt).toLocaleDateString())}</span>`
+        : `<p>${completionText}</p>`;
+      card.scrollTop = 0;
+    }
+    const count = dialog.querySelector("[data-review-count]");
+    count.textContent = record ? `${index + 1} of ${items.length}` : `${items.length} reviewed`;
+    if (hasReviewLoadError) count.textContent = "";
+    dialog.querySelector(".daily-review-progress").hidden = hasReviewLoadError;
+    const progress = dialog.querySelector("progress");
+    progress.max = Math.max(1, items.length);
+    progress.value = hasReviewLoadError ? 0 : index;
+    dialog.querySelector("[data-review-error]").textContent = error;
+    dialog.querySelector("[data-review-error]").hidden = !error;
+    dialog.querySelector(".daily-review-actions").hidden = !record;
+    for (const button of dialog.querySelectorAll(".daily-review-actions button")) button.disabled = busy;
+    dialog.querySelector("[data-review-delete]").textContent = busy ? "Deleting…" : "Delete memory";
+    const later = dialog.querySelector("[data-review-later]");
+    later.textContent = record ? "Not now" : "Done";
+    if (hasReviewLoadError) later.textContent = "Close";
+    dialog.querySelector(".daily-review-note").hidden = hasReviewLoadError;
+    if (!record && dialog.open) dialog.querySelector("[data-review-later]").focus();
+  }
+  function canOpen() {
+    if (dialog.open || documentRoot.hidden) return false;
+    if (documentRoot.querySelector("dialog[open]")) return false;
+    const focused = documentRoot.activeElement;
+    return !focused?.matches("input, textarea, select, [contenteditable=true]");
+  }
+  return {
+    render, canOpen,
+    isOpen: () => dialog.open,
+    open() {
+      returnFocus = documentRoot.activeElement;
+      dialog.showModal();
+      dialog.querySelector("[data-review-later]").focus();
+    },
+    hide() { if (dialog.open) dialog.close(); },
+    dispose() { dialog.close(); dialog.remove(); },
+  };
+}

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

@@ -0,0 +1,160 @@
+import { createSystemHostVisibility } from "../system-host/visibility.js";
+import { hasIndependentHomeActivity } from "../passive-learning/home.js";
+import { selectHomeSuggestion } from "./suggestion-policy.js";
+import { createHomeGuidancePreferences } from "../../services/home-guidance-preferences.js";
+import { createDailyMemoryReview } from "../../controllers/daily-memory-review.js";
+import { createDailyReviewDialog } from "./daily-review.js";
+import { createDailyReviewEntry } from "./daily-review-entry.js";
+
+export function createHomeGuidance({ container, homeRegion, client, getEnvironmentId,
+  getLearningSnapshot, getConnectionState, supportsConnection, refreshConnection,
+  onOpen, isRuntimeReady = () => true, storage }) {
+  const documentRoot = container?.ownerDocument;
+  if (!documentRoot) return { render() {}, dispose() {} };
+  let preferenceStorage = storage;
+  try { preferenceStorage ??= documentRoot.defaultView?.localStorage; } catch { /* Session-only preferences. */ }
+  const preferences = createHomeGuidancePreferences(preferenceStorage);
+  const root = documentRoot.createElement("aside");
+  root.className = "home-guidance";
+  root.hidden = true;
+  root.setAttribute("aria-label", "Setup suggestion");
+  root.innerHTML = `<div class="home-guidance-copy"><h3 class="home-row-title"></h3><p class="home-row-detail"></p></div>
+    <button type="button" class="home-text-button" data-guidance-open></button>
+    <button type="button" class="home-text-button" data-guidance-dismiss aria-label="Dismiss this suggestion" title="Hide this suggestion"><svg viewBox="0 0 16 16" aria-hidden="true"><path d="m4 4 8 8m0-8-8 8" /></svg></button>`;
+  const reviewEntry = createDailyReviewEntry({ container, onOpen: openMemoryReview });
+  container.prepend(root);
+  let environment = getEnvironmentId();
+  let revision = 0;
+  let memory = null;
+  let plugins = null;
+  let visible = false;
+  let loaded = false;
+  let loading = false;
+  let disposed = false;
+  let hiddenThisVisit = false;
+  let selected = null;
+  let reviewDismissed = false;
+  let openingReview = false;
+  let review;
+  const dialog = createDailyReviewDialog({ container,
+    onDecision: (action) => review.decide(action),
+    onDismiss: () => { reviewDismissed = true; render(); },
+  });
+  review = createDailyMemoryReview({ client, getEnvironmentId, preferences, render: (snapshot) => {
+    dialog.render(snapshot);
+    if (canOfferDailyReview(snapshot) && dialog.canOpen() && review.markOffered()) dialog.open();
+    renderSuggestion();
+  } });
+  root.querySelector("[data-guidance-open]").addEventListener("click", () => {
+    if (root.hidden || !selected) return;
+    onOpen(selected.id);
+  });
+  root.querySelector("[data-guidance-dismiss]").addEventListener("click", () => {
+    if (!selected) return;
+    preferences.dismiss(environment, selected.id);
+    hiddenThisVisit = true;
+    renderSuggestion();
+  });
+  const visibility = createSystemHostVisibility({ documentRoot, getRoot: () => homeRegion,
+    isActive: () => Boolean(homeRegion), onChange: visibilityChanged });
+
+  async function loadSuggestions() {
+    if (loading || disposed || !visible || !isRuntimeReady()) return;
+    loading = true;
+    const operation = ++revision;
+    const target = getEnvironmentId();
+    const [memoryRead, pluginsRead] = await Promise.allSettled([
+      client.loadLongTermMemoryStatus(target), client.getRuntimePlugins(target),
+    ]);
+    if (operation !== revision || target !== getEnvironmentId() || disposed) return;
+    memory = memoryRead.status === "fulfilled" ? memoryRead.value?.status : null;
+    plugins = pluginsRead.status === "fulfilled" ? pluginsRead.value : null;
+    loading = false;
+    loaded = true;
+    render();
+  }
+  function renderSuggestion() {
+    reviewEntry.render({ visible: canShowMemoryReviewEntry(),
+      remaining: review?.snapshot().remaining || 0, loading: openingReview });
+    selected = selectHomeSuggestion({ memory, plugins,
+      connection: supportsConnection() ? getConnectionState() : null,
+      dismissed: preferences.dismissed(environment) });
+    root.hidden = !visible || hiddenThisVisit || dialog.isOpen() || !selected;
+    if (root.hidden) return;
+    root.querySelector("h3").textContent = selected.title;
+    root.querySelector("p").textContent = selected.description;
+    root.querySelector("[data-guidance-open]").textContent = selected.action;
+  }
+  function hasCurrentLearningActivity() {
+    const learning = getLearningSnapshot();
+    if (learning?.environmentId !== environment || learning.statusError) return false;
+    return hasIndependentHomeActivity(learning.status);
+  }
+  function canReviewSavedMemories() {
+    if (disposed || !visible || !isRuntimeReady()) return false;
+    if (memory?.enabled === false) return false;
+    if (memory?.available === false) return false;
+    if (hasCurrentLearningActivity()) return true;
+    return memory?.enabled === true && memory?.available !== false;
+  }
+  function canShowMemoryReviewEntry() {
+    if (!canReviewSavedMemories() || dialog.isOpen()) return false;
+    return review?.snapshot().remaining > 0;
+  }
+  function canOfferDailyReview(snapshot) {
+    if (!visible || reviewDismissed || !snapshot.remaining) return false;
+    return hasCurrentLearningActivity();
+  }
+  async function openMemoryReview() {
+    if (openingReview || !canReviewSavedMemories() || !dialog.canOpen()) return;
+    const operation = revision;
+    const target = environment;
+    openingReview = reviewDismissed = true;
+    renderSuggestion();
+    const loadedReview = await review.loadForReview();
+    if (disposed || operation !== revision || target !== getEnvironmentId()) return;
+    openingReview = false;
+    if (loadedReview && canReviewSavedMemories() && dialog.canOpen()) {
+      review.markOffered();
+      dialog.open();
+    }
+    renderSuggestion();
+  }
+  function syncEnvironment() {
+    const next = getEnvironmentId();
+    if (next === environment) return;
+    revision += 1;
+    environment = next;
+    memory = plugins = null;
+    loaded = loading = hiddenThisVisit = reviewDismissed = openingReview = false;
+    dialog.hide();
+    review.reset();
+  }
+  function render() {
+    if (disposed) return;
+    syncEnvironment();
+    if (visible && !loaded && !loading) void loadSuggestions();
+    const canReview = canReviewSavedMemories();
+    review.update(canReview);
+    if (!canReview) dialog.hide();
+    renderSuggestion();
+  }
+  function visibilityChanged() {
+    if (disposed) return;
+    const next = visibility.isVisible();
+    if (next === visible) return;
+    visible = next;
+    if (visible) {
+      hiddenThisVisit = reviewDismissed = false;
+      loaded = false;
+      if (supportsConnection()) void refreshConnection();
+    } else {
+      openingReview = false;
+      dialog.hide();
+    }
+    render();
+  }
+  visibility.watch();
+  visibilityChanged();
+  return { render, dispose() { disposed = true; revision += 1; review.reset(); visibility.dispose(); dialog.dispose(); reviewEntry.dispose(); root.remove(); } };
+}

package/dist/src/web-ui/app/components/home-guidance/suggestion-policy.js

@@ -0,0 +1,35 @@
+import { needsComputerSetup } from "../system-host/setup-notice.js";
+
+const suggestions = {
+  memory: {
+    id: "memory", icon: "memory", title: "Set up passive memory",
+    description: "Keep useful context between conversations. Choose an embedding model to get started.",
+    action: "Set up memory",
+  },
+  computer: {
+    id: "computer", icon: "computer", title: "Connect your computer",
+    description: "Access local apps and tools, with permissions you control.",
+    action: "Connect computer",
+  },
+  plugin: {
+    id: "plugin", icon: "memory", title: "Review your memory setup",
+    description: "Passive memory is ready. Review whether you still need the separate memory plugin.",
+    action: "Review memory plugin",
+  },
+};
+
+function hasEnabledMemoryPlugin(plugins) {
+  const plugin = plugins?.plugins?.find((item) => item.id === "memory");
+  if (!plugin || plugin.blockedByGlobalPolicy) return false;
+  if (plugin.pluginEnabled === false) return false;
+  return plugin.selectedCapabilityCount > 0;
+}
+
+export function selectHomeSuggestion({ memory, plugins, connection, dismissed = [] }) {
+  const eligible = [];
+  if (memory?.enabled === false) eligible.push("memory");
+  if (needsComputerSetup(connection)) eligible.push("computer");
+  const memoryReady = memory?.enabled === true && memory.available !== false;
+  if (memoryReady && hasEnabledMemoryPlugin(plugins)) eligible.push("plugin");
+  return suggestions[eligible.find((id) => !dismissed.includes(id))] || null;
+}

package/dist/src/web-ui/app/components/long-term-memory/manager.js

@@ -55,6 +55,8 @@ export function createLongTermMemoryManager({
     if (action === "edit") actions.beginEdit(recordId);
     if (action === "cancel-edit") actions.cancelEdit();
     if (action === "clear-search") void actions.search("");
+    if (action === "toggle-origin")
+      void actions.setOriginFilter(view.originFilter ? "" : "passive_observation");
     if (action === "previous-page") void actions.changePage(-1);
     if (action === "next-page") void actions.changePage(1);
     if (action === "delete") confirmAndDelete(recordId);
@@ -109,7 +111,11 @@ export function createLongTermMemoryManager({
     );
   }
 
-  return Object.freeze({ mount, render });
+  return Object.freeze({
+    mount,
+    render,
+    focus: () => root?.querySelector(".memory-management-heading h4")?.scrollIntoView({ block: "start" }),
+  });
 }
 
 function managerMarkup(view) {
@@ -124,6 +130,7 @@ function managerMarkup(view) {
       </div>
       ${availabilityMarkup(view)}
       <div class="memory-management-toolbar">
+        <button class="memory-origin-filter" type="button" data-memory-management-action="toggle-origin" aria-pressed="${!view.query && view.originFilter === "passive_observation"}" ${view.query ? "disabled title=\"Activity filter is paused during semantic search\"" : ""}>Computer activity${view.query && view.originFilter ? " (paused)" : ""}</button>
         <form class="memory-search" role="search" data-memory-search-form>
           <label class="sr-only" for="memoryManagementSearch">Search stored memories</label>
           <div class="memory-search-shell">

package/dist/src/web-ui/app/components/long-term-memory/record-list.js

@@ -43,6 +43,7 @@ function renderMemoryRecord(record, view) {
               Updated ${escapeHtml(formatMemoryTimestamp(record.updatedAt))}
             </time>
           </div>
+          ${renderObservationSources(record.observationSources)}
         </div>
       </div>
       <div class="memory-record-actions">
@@ -69,6 +70,12 @@ function renderMemoryRecord(record, view) {
   `;
 }
 
+function renderObservationSources(sources) {
+  if (!Array.isArray(sources) || sources.length === 0) return "";
+  return `<details class="memory-observation-sources"><summary>Activity sources (${sources.length})</summary><ul>${sources.map((source) =>
+    `<li>${escapeHtml(String(source.kind || "Observation"))} · ${escapeHtml(formatMemoryTimestamp(source.observedAt))}${source.reason ? ` · ${escapeHtml(String(source.reason))}` : ""}${source.certainty ? ` · ${escapeHtml(String(source.certainty))}` : ""}</li>`).join("")}</ul></details>`;
+}
+
 function renderContent(content) {
   const collapsible = memoryContentNeedsExpansion(content);
   return `

package/dist/src/web-ui/app/components/long-term-memory/view-model.js

@@ -12,6 +12,8 @@ export function createMemoryManagerView(snapshot) {
     status: memoryStatus(snapshot),
     emptyMessage: snapshot.query
       ? "No memories match this search."
+      : snapshot.originFilter === "passive_observation"
+        ? "No memories from computer activity yet."
       : "No long-term memories have been stored yet.",
     pageLabel: pageLabel(snapshot),
     hasPreviousPage: snapshot.offset > 0,
@@ -38,6 +40,7 @@ export function formatMemoryTimestamp(value) {
 export function memoryOriginLabel(origin) {
   const labels = {
     passive_response: "Learned from conversation",
+    passive_observation: "Learned from computer activity",
     web_ui: "Added in Web UI",
     management_api: "Added through API",
   };

package/dist/src/web-ui/app/components/long-term-memory/workspace.js

@@ -0,0 +1,48 @@
+function memoryTabIndexForKey(key, index, count) {
+  if (key === "Home") return 0;
+  if (key === "End") return count - 1;
+  if (key === "ArrowRight") return (index + 1) % count;
+  if (key === "ArrowLeft") return (index + count - 1) % count;
+  return -1;
+}
+
+export function createMemoryWorkspace({ root }) {
+  const tabs = ["memories", "setup"].map((name) => ({
+    name,
+    button: root?.querySelector('[data-memory-tab="' + name + '"]'),
+    panel: root?.querySelector('[data-memory-panel="' + name + '"]'),
+  }));
+
+  function hasMemoryTabSurface(tab) {
+    if (!tab?.button) return false;
+    return Boolean(tab.panel);
+  }
+
+  function activate(name, { focus = false } = {}) {
+    const selected = tabs.find((tab) => tab.name === name);
+    if (!hasMemoryTabSurface(selected)) return false;
+    for (const tab of tabs) {
+      if (!hasMemoryTabSurface(tab)) continue;
+      const active = tab === selected;
+      tab.panel.hidden = !active;
+      tab.button.setAttribute("aria-selected", String(active));
+      tab.button.tabIndex = active ? 0 : -1;
+      tab.button.classList.toggle("active", active);
+    }
+    if (focus) selected.button.focus();
+    return true;
+  }
+
+  tabs.forEach((tab, index) => {
+    if (!hasMemoryTabSurface(tab)) return;
+    tab.button.addEventListener("click", () => activate(tab.name));
+    tab.button.addEventListener("keydown", (event) => {
+      const nextIndex = memoryTabIndexForKey(event.key, index, tabs.length);
+      if (nextIndex < 0) return;
+      event.preventDefault();
+      activate(tabs[nextIndex].name, { focus: true });
+    });
+  });
+  activate("memories");
+  return { activate };
+}

package/dist/src/web-ui/app/components/model-setup/rendering.js

@@ -81,7 +81,7 @@ export function modelSetupFooter(state) {
           ? "Apply model"
           : "Save and apply";
   const action = state.step === 2 ? "finish" : "next";
-  return `<div class="model-setup-back-actions"><button type="button" class="runtime-setup-secondary" data-model-action="cancel" data-runtime-setup-action="model-cancel" ${disabled}>Cancel</button>${back}</div><button type="button" class="runtime-setup-action" data-model-action="${action}" data-runtime-setup-action="model-${action}" ${state.busy || !state.loaded || !state.choice ? "disabled" : ""}>${label}</button>`;
+  return `<div class="model-setup-back-actions"><button type="button" class="runtime-setup-secondary" data-model-action="cancel" data-runtime-setup-action="model-cancel" ${disabled}>${state.saved ? "Close" : "Cancel"}</button>${back}</div><button type="button" class="runtime-setup-action" data-model-action="${action}" data-runtime-setup-action="model-${action}" ${state.busy || !state.loaded || !state.choice ? "disabled" : ""}>${label}</button>`;
 }
 
 export function modelSetupMarkup(state) {

package/dist/src/web-ui/app/components/model-setup/save-flow.js

@@ -1,7 +1,8 @@
 import { selectedModelProvider } from "./validation.js";
 import {
   isDefinitiveModelSaveRejection,
-  modelSaveFailureMessage,
+  modelSaveErrorMessage,
+  deferredModelMessage,
 } from "./save-outcome.js";
 
 export function createModelSaveFlow({
@@ -18,6 +19,7 @@ export function createModelSaveFlow({
   beginRuntimeMutation,
   endRuntimeMutation,
   onSaved,
+  onDeferred,
   onComplete,
 }) {
   async function refreshModelList(operation) {
@@ -44,6 +46,7 @@ export function createModelSaveFlow({
     let completed = false;
     try {
       state.error = "";
+      state.notice = "";
       if (!state.saved) {
         const input = readRequest();
         if (!input) return false;
@@ -73,9 +76,12 @@ export function createModelSaveFlow({
         const payload = await applySetup();
         if (!isCurrent(operation)) return false;
         if (payload?.activation?.status === "restart_required") {
-          state.error =
-            payload.activation.message ||
-            "Model saved. Apply it when your agent is idle.";
+          state.notice = deferredModelMessage(payload.activation);
+          state.busy = "refreshing";
+          render();
+          const refreshed = await onDeferred(state.saved);
+          if (!isCurrent(operation)) return false;
+          if (refreshed === false) state.error = modelSaveErrorMessage(state);
           return false;
         }
         if (payload?.activation?.status !== "ready")
@@ -91,8 +97,7 @@ export function createModelSaveFlow({
       if (credentialSaved)
         state.credentialSavedFor =
           selectedModelProvider(state)?.id || state.newProviderId;
-      const fallback = modelSaveFailureMessage(state);
-      state.error = error?.payload?.message || fallback;
+      state.error = modelSaveErrorMessage(state, error);
       if (credentialSaved)
         state.error +=
           " Your API key was saved privately and will be reused on retry.";

package/dist/src/web-ui/app/components/model-setup/save-outcome.js

@@ -8,9 +8,25 @@ export function isDefinitiveModelSaveRejection(error) {
 
 export function modelSaveFailureMessage(state) {
   if (state.applied) return "Model applied. Could not refresh the model list.";
+  if (state.saved && state.busy === "refreshing")
+    return "Model saved. It is not active yet. Could not refresh the model list.";
   if (state.saved)
     return "Model saved. Could not apply the configuration. Try again when your agent is idle.";
   if (state.saveOutcomeUncertain)
     return "The model save could not be confirmed. Try again to check the saved model and apply it.";
   return "Could not save this model. Check the connection details and try again.";
 }
+
+export function modelSaveErrorMessage(state, error) {
+  const fallback = modelSaveFailureMessage(state);
+  const detail = error?.payload?.message;
+  if (!detail) return fallback;
+  if (state.saved) return `${fallback} ${detail}`;
+  return detail;
+}
+
+export function deferredModelMessage(activation) {
+  const status = "Model saved. It is not active yet.";
+  if (!activation.message) return `${status} Apply it when your agent is idle.`;
+  return `${status} ${activation.message}`;
+}