@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -0,0 +1,28 @@
+import { escapeHtml } from "../../lib/text-format.js";
+
+function runLink(automation, environmentId) {
+  const query = new URLSearchParams({
+    environment: environmentId,
+    automation: automation.id,
+    run: automation.latestRunId,
+  });
+  return `/automations?${query}`;
+}
+
+function runStatusLabel(status) {
+  return { pending: "Queued", stopping: "Stopping" }[status] || "Running";
+}
+
+export function renderDashboardAutomations(automations = [], environmentId = "", unavailable = false) {
+  if (!automations.length && !unavailable) return "";
+  const visible = automations.slice(0, 3);
+  const remaining = automations.length - visible.length;
+  const heading = unavailable ? "Automation status unavailable" :
+    `${automations.length} ${automations.length === 1 ? "automation" : "automations"} in progress`;
+  return `<div class="home-automation-heading"><span>ABot Studio</span><strong>${heading}</strong></div>
+    <div class="home-automation-runs">${visible.map((automation) => `<a class="home-automation-run" href="${escapeHtml(runLink(automation, environmentId))}">
+      ${unavailable ? "" : '<span class="home-automation-pulse" aria-hidden="true"></span>'}
+      <strong dir="auto">${escapeHtml(automation.title || "ABot Automation")}</strong>
+      <span>${unavailable ? "Last seen " : ""}${runStatusLabel(automation.latestRunStatus)} · ${unavailable ? "Open run" : "View live timeline"}</span>
+    </a>`).join("")}${remaining ? `<span class="home-automation-more">+${remaining} more in ABot Studio</span>` : ""}${unavailable ? '<button type="button" class="home-automation-retry" data-dashboard-action="refresh">Retry</button>' : ""}</div>`;
+}

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

@@ -11,29 +11,14 @@ function conversationRow(session) {
   if (session.readStateUnavailable) metadata.push("Unread status unavailable");
   if (session.unreadCount > 0)
     metadata.push(
-      `${session.unreadCount} new ${session.unreadCount === 1 ? "message" : "messages"}`,
+      `${session.unreadCount} unread ${session.unreadCount === 1 ? "message" : "messages"}`,
     );
   if (time) metadata.push(time.label);
-  const unread =
-    session.unreadCount > 0
-      ? `<span class="home-small-count" aria-label="${session.unreadCount} unread messages">${session.unreadCount}</span>`
-      : "";
   return `<button type="button" class="home-recent-row${session.unreadCount > 0 ? " has-unread" : ""}" data-dashboard-action="conversation" data-session-id="${escapeHtml(session.id)}">
-    <span class="home-row-copy"><span class="home-row-title" dir="auto">${escapeHtml(session.title)}</span><span class="home-row-detail" title="${escapeHtml(time?.title || "")}">${escapeHtml(metadata.join(" · ") || "No messages yet")}</span></span>${unread}
+    <span class="home-row-copy"><span class="home-row-title" dir="auto">${escapeHtml(session.title)}</span><span class="home-row-detail" title="${escapeHtml(time?.title || "")}">${escapeHtml(metadata.join(" · ") || "No messages yet")}</span></span>
   </button>`;
 }
 
-function conversationsSummary({
-  totalCount,
-  unreadCount,
-  hasUnavailableReadState,
-}) {
-  if (hasUnavailableReadState) return "Unread status unavailable";
-  if (unreadCount > 0)
-    return `${totalCount} ${totalCount === 1 ? "conversation" : "conversations"}`;
-  return "All clear. No unread messages.";
-}
-
 function conversationsState({ loading, error }) {
   if (loading)
     return '<p class="home-panel-state" role="status">Loading conversations…</p>';
@@ -42,23 +27,32 @@ function conversationsState({ loading, error }) {
   return `<div class="home-panel-empty" role="status">${dashboardIcon("conversations")}<strong>A fresh start.</strong><p>Your conversations will appear here.</p></div>`;
 }
 
+function unreadAvailabilityNotice({ conversations, hasUnavailableReadState }) {
+  if (!hasUnavailableReadState) return "";
+  if (conversations.some((session) => session.readStateUnavailable)) return "";
+  return '<p class="home-refresh-feedback" role="status">Unread status unavailable</p>';
+}
+
 export function renderDashboardConversations({
   sessions = [],
   loading = false,
   error = "",
 }) {
-  const projection = projectDashboardConversations(sessions);
-  const { conversations, unreadCount, hasUnavailableReadState } = projection;
+  const projection = projectDashboardConversations(sessions, 3);
+  const {
+    recentConversations: conversations,
+    unreadCount,
+    hasUnavailableReadState,
+  } = projection;
   const badge =
     unreadCount > 0 && !hasUnavailableReadState
       ? `<span class="home-unread-count" aria-label="${unreadCount} unread messages">${unreadCount}</span>`
       : "";
-  const header = `<header class="home-panel-header"><h2>Recent conversations</h2>${badge}</header>`;
+  const header = `<header class="home-panel-header"><h2>Recent conversations${badge}</h2><button type="button" class="home-text-button" data-dashboard-action="conversations">Open chats${dashboardIcon("arrow")}</button></header>`;
   if (!conversations.length)
     return header + conversationsState({ loading, error });
-  const summary = conversationsSummary(projection);
   const feedback = error
     ? '<p class="home-refresh-feedback" role="status">Conversations could not be refreshed. <button type="button" class="home-text-button" data-dashboard-action="refresh">Try again</button></p>'
     : "";
-  return `${header}<div class="home-panel-rows" aria-label="Recent conversations including unread">${conversations.map(conversationRow).join("")}</div>${feedback}<footer class="home-panel-footer"><span>${summary}</span><button type="button" class="home-text-button" data-dashboard-action="conversations">Open chats${dashboardIcon("arrow")}</button></footer>`;
+  return `${header}<div class="home-panel-rows" aria-label="Recent conversations including unread">${conversations.map(conversationRow).join("")}</div>${unreadAvailabilityNotice({ conversations, hasUnavailableReadState })}${feedback}`;
 }

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

@@ -1,66 +1,47 @@
+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 { renderDashboardAutomations } from "./automations.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>
+      <section class="home-automation-status" aria-label="Automations in progress" aria-live="polite" data-dashboard-automations hidden></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]");
+  const automationPanel = root.querySelector("[data-dashboard-automations]");
+  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 +58,57 @@ 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;
+    const automationMarkup = renderDashboardAutomations(
+      snapshot.activeAutomations, snapshot.environmentId, snapshot.automationStatusUnavailable,
+    );
+    automationPanel.hidden = setupRequired || !automationMarkup;
     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 = "";
+      automationPanel.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(automationPanel, automationMarkup);
+
+    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",
   };