@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/web-ui/app/components/notifications/presentation.js

@@ -0,0 +1,123 @@
+import { escapeHtml, escapeAttribute, formatTime } from "../../lib/text-format.js";
+
+export const NOTIFICATION_KIND_LABELS = Object.freeze({
+  reply: "Assistant replies",
+  failure: "Failures",
+  approval: "Approval requests",
+  proposal: "Co-worker suggestions",
+});
+
+const DELIVERY_LABELS = Object.freeze({
+  pending: "Waiting to send",
+  submitted: "Sent to computer",
+  disabled: "Desktop alerts off",
+  unavailable: "Computer unavailable",
+  failed: "Desktop alert failed",
+  unknown: "Delivery not confirmed",
+});
+
+const NOTIFICATION_KIND_ICONS = Object.freeze({
+  reply: '<path d="M5 4h14v11H9l-4 4V4Z" /><path d="M9 8h6M9 11h4" />',
+  failure: '<path d="m12 3 10 18H2L12 3Z" /><path d="M12 9v5M12 17h.01" />',
+  approval: '<path d="M12 3 4 6v6c0 5 8 9 8 9s8-4 8-9V6l-8-3Z" /><path d="m8 12 3 3 5-6" />',
+  proposal: '<path d="m12 3 2.5 6.5L21 12l-6.5 2.5L12 21l-2.5-6.5L3 12l6.5-2.5L12 3Z" />',
+});
+
+function renderNotificationTimestamp(createdAt) {
+  const date = new Date(createdAt);
+  const full = escapeAttribute(formatTime(createdAt));
+  const short = date.toLocaleString(undefined, {
+    month: "short", day: "numeric", hour: "2-digit", minute: "2-digit",
+  });
+  return `<time datetime="${escapeAttribute(date.toISOString())}" title="${full}" aria-label="${full}">${escapeHtml(short)}</time>`;
+}
+
+function notificationBodyRepeatsTitle(item) {
+  return item.body.trim() === item.title.trim();
+}
+
+export function notificationSourceUrl(item) {
+  if (typeof item?.sourceUrl !== "string") return "";
+  if (!item.sourceUrl.startsWith("/")) return "";
+  let url;
+  try {
+    url = new URL(item.sourceUrl, "https://abot.invalid");
+  } catch {
+    return "";
+  }
+  if (url.origin !== "https://abot.invalid") return "";
+  if (!["/chat", "/learning", "/home", "/notifications"].includes(url.pathname)) return "";
+  if (url.searchParams.get("environment") !== item.environmentId) return "";
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+function renderNotificationDeliveryError(delivery) {
+  if (!["failed", "unknown", "unavailable"].includes(delivery?.status)) return "";
+  if (typeof delivery.error !== "string") return "";
+  const error = delivery.error.trim();
+  if (!error) return "";
+  const message = error.includes("#< CLIXML")
+    ? "The computer returned an unreadable error."
+    : error;
+  return `<p class="notification-delivery-error" dir="auto">${escapeHtml(message)}</p>`;
+}
+
+export function renderNotificationItem(item, busy) {
+  const read = item.readAt != null;
+  const source = notificationSourceUrl(item);
+  const label = NOTIFICATION_KIND_LABELS[item.kind] || "Notification";
+  const delivery = DELIVERY_LABELS[item.delivery?.status] || "Delivery not confirmed";
+  const attributes = `data-notification-id="${escapeAttribute(item.id)}"`;
+  const readAction = read ? "Mark unread" : "Mark read";
+  const icon = NOTIFICATION_KIND_ICONS[item.kind] || NOTIFICATION_KIND_ICONS.reply;
+  const preview = notificationBodyRepeatsTitle(item) ? ""
+    : `<span class="notification-item-preview" dir="auto">${escapeHtml(item.body)}</span>`;
+  return `<li class="notification-item ${read ? "" : "is-unread"}" ${attributes}>
+    <span class="notification-kind-icon" role="img" aria-label="${escapeAttribute(label)}" title="${escapeAttribute(label)}"><svg viewBox="0 0 24 24" aria-hidden="true">${icon}</svg></span>
+    <details class="notification-item-details" ${attributes}>
+      <summary data-notification-detail="${escapeAttribute(item.id)}">
+        <span class="notification-item-heading">
+          <span class="notification-item-title" role="heading" aria-level="3" dir="auto">${escapeHtml(item.title)}</span>
+          ${read ? "" : '<span class="notification-read-state" aria-label="Unread">Unread</span>'}
+          <svg class="notification-expand-icon" viewBox="0 0 16 16" aria-hidden="true"><path d="m5 3 5 5-5 5" /></svg>
+        </span>
+        ${preview}
+      </summary>
+      <div class="notification-item-expanded">
+        <p dir="auto">${escapeHtml(item.body)}</p>
+        <div class="notification-item-meta"><span>${escapeHtml(label)}</span><span>${escapeHtml(delivery)}</span></div>
+        ${renderNotificationDeliveryError(item.delivery)}
+      </div>
+    </details>
+    <div class="notification-item-footer">
+      ${renderNotificationTimestamp(item.createdAt)}
+      <div class="notification-item-actions">
+        <button type="button" data-notification-action="read" ${attributes} aria-label="${readAction}" ${busy ? "disabled" : ""}>${readAction}</button>
+        ${source ? `<a href="${escapeAttribute(source)}" data-notification-action="open" ${attributes}>Open <span aria-hidden="true">↗</span></a>` : ""}
+      </div>
+    </div>
+  </li>`;
+}
+
+export function renderNotificationSettings(snapshot) {
+  const preferences = snapshot.preferences;
+  if (!preferences) return "";
+  const disabled = snapshot.busy ? "disabled" : "";
+  const desktop = snapshot.desktop || {};
+  const status = desktop.message || (desktop.available
+    ? "Computer access is connected. Alerts can arrive while your browser is closed."
+    : "Connect Computer access to receive desktop alerts.");
+  return `<details class="notification-settings"><summary>Notification settings</summary>
+    <div class="notification-settings-body">
+      <label class="notification-setting"><span><strong>Desktop notifications</strong>
+        <small>Show ABot alerts on this computer.</small></span>
+        <input type="checkbox" data-notification-preference="desktopEnabled" ${preferences.desktopEnabled ? "checked" : ""} ${disabled}></label>
+      <p class="notification-computer-status" role="status">${escapeHtml(status)}</p>
+      <div class="notification-kind-settings"><p>Notify me about</p><div class="notification-kind-options">
+        ${Object.entries(NOTIFICATION_KIND_LABELS).map(([kind, label]) =>
+          `<label class="notification-setting"><span>${label}</span><input type="checkbox" data-notification-kind="${kind}" ${preferences.kinds?.[kind] ? "checked" : ""} ${disabled}></label>`
+        ).join("")}
+      </div></div>
+      <p class="notification-settings-note">History is always saved. Replies in the active conversation stay silent. System notification settings apply.</p>
+    </div></details>`;
+}

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

@@ -0,0 +1,115 @@
+import { createNotificationFocus } from "./focus.js";
+import {
+  renderNotificationItem,
+  renderNotificationSettings,
+} from "./presentation.js";
+
+export function createNotificationsWorkspace({ root, button, badge, actions }) {
+  let snapshot;
+  const focus = createNotificationFocus(root);
+  root.innerHTML = `<div class="notifications-content">
+    <div class="notifications-toolbar">
+      <div class="notification-filters" role="group" aria-label="Filter notifications">
+        <button type="button" data-notification-filter="all" aria-pressed="true">All</button>
+        <button type="button" data-notification-filter="unread" aria-pressed="false">Unread</button>
+      </div>
+      <div class="notification-toolbar-actions">
+        <button type="button" data-notification-action="refresh">Refresh</button>
+        <button type="button" data-notification-action="read-all">Mark all read</button>
+      </div>
+    </div>
+    <p class="notification-feedback" role="status" aria-live="polite"></p>
+    <ul class="notification-list" aria-label="Notification history"></ul>
+    <button type="button" class="notification-load-more" data-notification-action="more" hidden>Load older notifications</button>
+    <div class="notification-settings-root"></div>
+  </div>`;
+  const list = root.querySelector(".notification-list");
+  const feedback = root.querySelector(".notification-feedback");
+  const settings = root.querySelector(".notification-settings-root");
+  const more = root.querySelector(".notification-load-more");
+
+  async function handleAction(event) {
+    const target = event.target.closest("[data-notification-action], [data-notification-filter]");
+    if (!target || !root.contains(target) || target.disabled) return;
+    const filter = target.dataset.notificationFilter;
+    if (filter) {
+      actions.setFilter(filter);
+      return;
+    }
+    const action = target.dataset.notificationAction;
+    if (action === "refresh") return actions.refresh();
+    if (action === "read-all") return actions.markAllRead();
+    if (action === "more") return actions.loadMore();
+    const item = snapshot?.items.find((candidate) => candidate.id === target.dataset.notificationId);
+    if (!item) return;
+    if (action === "read") return actions.markRead(item.id, item.readAt != null ? false : true);
+    if (action !== "open") return;
+    event.preventDefault();
+    return actions.openSource(item);
+  }
+
+  root.addEventListener("click", (event) => { void handleAction(event); });
+  root.addEventListener("change", (event) => {
+    const input = event.target;
+    if (!input.matches("input[type=checkbox]")) return;
+    if (!snapshot?.preferences || snapshot.busy) return;
+    const preferences = {
+      ...snapshot.preferences,
+      kinds: { ...snapshot.preferences.kinds },
+    };
+    if (input.dataset.notificationPreference === "desktopEnabled")
+      preferences.desktopEnabled = input.checked;
+    const kind = input.dataset.notificationKind;
+    if (kind) preferences.kinds[kind] = input.checked;
+    void actions.savePreferences(preferences);
+  });
+
+  function render(next) {
+    focus.remember();
+    const expandedItems = new Set([...list.querySelectorAll("details[open]")]
+      .map((item) => item.dataset.notificationId));
+    snapshot = next;
+    const count = next.unreadCount;
+    badge.hidden = count === 0;
+    badge.textContent = count > 99 ? "99+" : String(count);
+    button.setAttribute("aria-label", count ? `Open notifications, ${count} unread` : "Open notifications");
+    for (const filter of root.querySelectorAll("[data-notification-filter]"))
+      filter.setAttribute("aria-pressed", String(filter.dataset.notificationFilter === next.filter));
+    for (const control of root.querySelectorAll("button[data-notification-action]"))
+      control.disabled = next.busy || next.loading || !next.supported;
+    root.querySelector('[data-notification-action="read-all"]').disabled = next.busy || count === 0;
+    const items = next.filter === "unread"
+      ? next.items.filter((item) => item.readAt == null)
+      : next.items;
+    list.innerHTML = items.map((item) => renderNotificationItem(item, next.busy)).join("");
+    for (const details of list.querySelectorAll("details"))
+      details.open = expandedItems.has(details.dataset.notificationId);
+    list.setAttribute("aria-busy", String(next.loading));
+    feedback.textContent = notificationFeedback(next, items);
+    feedback.classList.toggle("is-error", Boolean(next.error));
+    more.hidden = !next.nextCursor;
+    const expanded = settings.querySelector("details")?.open;
+    settings.innerHTML = renderNotificationSettings(next);
+    const disclosure = settings.querySelector("details");
+    if (disclosure) disclosure.open = Boolean(expanded);
+    focus.restore(next.busy || next.loading);
+  }
+  return { render };
+}
+
+export function notificationFeedback(snapshot, items) {
+  if (snapshot.error) return snapshot.error;
+  if (!snapshot.supported) return "Notifications are unavailable with this backend.";
+  if (items.length) return "";
+  if (snapshot.loading) return "Loading notifications…";
+  if (hasOlderUnreadNotifications(snapshot))
+    return "Unread notifications are in older history. Load older notifications to view them.";
+  if (snapshot.filter === "unread") return "You're all caught up.";
+  return "No notifications yet.";
+}
+
+function hasOlderUnreadNotifications(snapshot) {
+  if (snapshot.filter !== "unread") return false;
+  if (snapshot.unreadCount <= 0) return false;
+  return Boolean(snapshot.nextCursor);
+}

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

@@ -0,0 +1,53 @@
+const navigation = Object.freeze({
+  home: "homeWorkspaceButton", chat: "chatWorkspaceButton", learning: "learningWorkspaceButton",
+  memory: "memoryWorkspaceButton", schedules: "schedulesWorkspaceButton", models: "modelsWorkspaceButton",
+  plugins: "pluginsWorkspaceButton", notifications: "notificationsWorkspaceButton", config: "configWorkspaceButton",
+});
+
+function requiresInitialSetup(availability, previous, observed) {
+  if (!availability) return false;
+  if (availability.recovery === "configuration") return false;
+  if (availability.status === "ready") return false;
+  if (["loading", "setup_required"].includes(availability.status)) return true;
+  // A refresh or network failure does not turn an already configured app into onboarding.
+  return observed ? previous : true;
+}
+
+/** Project onboarding readiness onto navigation without changing feature/backend support. */
+export function createOnboardingWorkspaceAccess({ dom, backendAllows }) {
+  let initialSetup = false;
+  let observed = false;
+
+  function isAvailable(workspace) {
+    if (workspace === "home") return true;
+    if (initialSetup) return false;
+    return backendAllows(workspace);
+  }
+
+  function render() {
+    for (const [workspace, key] of Object.entries(navigation)) {
+      const button = dom[key];
+      if (!button) continue;
+      const blocked = initialSetup && workspace !== "home";
+      button.disabled = !isAvailable(workspace);
+      button.setAttribute("aria-disabled", String(button.disabled));
+      button.dataset.onboardingBlocked = String(blocked);
+      if (blocked) button.setAttribute("aria-description", "Complete initial setup on Home to open this page.");
+      else button.removeAttribute("aria-description");
+    }
+    if (dom.learningWorkspaceButton) dom.learningWorkspaceButton.hidden = initialSetup;
+  }
+
+  function update(availability) {
+    initialSetup = requiresInitialSetup(availability, initialSetup, observed);
+    observed = true;
+    render();
+  }
+
+  function unavailableMessage() {
+    if (initialSetup) return "Complete initial setup on Home to open this page.";
+    return "This workspace is unavailable with the current backend.";
+  }
+
+  return { isAvailable, render, update, unavailableMessage };
+}

package/dist/src/web-ui/app/components/operations-section.js

@@ -1,7 +1,12 @@
 import { wrappedIndex } from "../ui-behavior.js";
 import { textOf } from "../lib/text-format.js";
 
-export function createOperationsSection({ buttons, pages }) {
+export function createOperationsSection({
+  buttons,
+  pages,
+  onNavigationChange = () => {},
+}) {
+  let currentTab = "runtime";
   const availableTabs = new Set(
     buttons.map((button) => textOf(button.dataset.tab)),
   );
@@ -9,6 +14,7 @@ export function createOperationsSection({ buttons, pages }) {
   function activateTab(tabName) {
     const normalized = textOf(tabName, "runtime") || "runtime";
     const nextTab = availableTabs.has(normalized) ? normalized : "runtime";
+    currentTab = nextTab;
     for (const button of buttons) {
       const active = button.dataset.tab === nextTab;
       button.classList.toggle("active", active);
@@ -21,6 +27,7 @@ export function createOperationsSection({ buttons, pages }) {
       page.hidden = !active;
       page.inert = !active;
     }
+    onNavigationChange();
   }
 
   function navigateTab(event, button) {
@@ -42,5 +49,5 @@ export function createOperationsSection({ buttons, pages }) {
     }
   }
 
-  return { activateTab, bind };
+  return { activateTab, activeTab: () => currentTab, bind };
 }

package/dist/src/web-ui/app/components/passive-learning/activity-controls.js

@@ -0,0 +1,91 @@
+const activities = Object.freeze({
+  collection: { label: "collection", permissionField: "collectionEnabled", selector: "[data-learning-toggle]" },
+  learning: { label: "learning", permissionField: "processingEnabled", selector: "[data-learning-processing-toggle]" },
+  proactive: { label: "proactive mode", permissionField: "proactiveEnabled", selector: "[data-learning-proactive-toggle]" },
+});
+
+export function readActivityPermissions(preferences = {}) {
+  if (preferences.activityPermissions) return {
+    collection: preferences.activityPermissions.collection === true,
+    learning: preferences.activityPermissions.learning === true,
+    proactive: preferences.activityPermissions.proactive === true,
+  };
+  return {
+    collection: preferences.enabled === true,
+    learning: Boolean(preferences.modelProfileId) && !preferences.processingPaused,
+    proactive: preferences.proactiveEnabled === true,
+  };
+}
+
+export function hasActivityModel(activity, preferences, models) {
+  const profile = activity === "proactive"
+    ? preferences.proactiveModelProfileId || preferences.modelProfileId
+    : preferences.modelProfileId;
+  if (!profile) return false;
+  if (!models) return true;
+  return models.some((model) => model.id === profile);
+}
+
+function isActivityRunning(activity, preferences) {
+  if (activity === "collection") return preferences.enabled === true;
+  if (activity === "proactive") return preferences.proactiveEnabled === true;
+  return Boolean(preferences.modelProfileId) && !preferences.processingPaused;
+}
+
+export function activityStatePatch(activity, preferences, running) {
+  const keys = { collection: "enabled", learning: "processingPaused", proactive: "proactiveEnabled" };
+  const patch = { [keys[activity]]: activity === "learning" ? !running : running };
+  if (!preferences.activityPermissions) patch.activityPermissions = readActivityPermissions(preferences);
+  return patch;
+}
+
+export function activityControl(activity, snapshot) {
+  const definition = activities[activity];
+  const preferences = snapshot.status?.preferences || {};
+  if (isActivityRunning(activity, preferences))
+    return { action: "stop", label: `Stop ${definition.label}`, tone: "danger" };
+  if (!hasActivityModel(activity, preferences, snapshot.models))
+    return { action: "setup", label: `Set up ${definition.label}`, tone: "setup",
+      field: activity === "proactive" ? "proactiveModelProfileId" : "modelProfileId" };
+  if (!readActivityPermissions(preferences)[activity])
+    return { action: "setup", label: `Set up ${definition.label}`, tone: "setup", field: definition.permissionField };
+  return { action: "start", label: `Start ${definition.label}`, tone: "default" };
+}
+
+export function homeActivityStartPatch(snapshot) {
+  const preferences = snapshot.status?.preferences || {};
+  const permissions = readActivityPermissions(preferences);
+  const approved = Object.keys(activities).filter((activity) => permissions[activity]);
+  if (!approved.length) return null;
+  // Home does not load model choices; saved profiles are validated by configure.
+  if (approved.some((activity) => !hasActivityModel(activity, preferences))) return null;
+  return Object.assign({}, ...approved.map((activity) => activityStatePatch(activity, preferences, true)));
+}
+
+export function handleActivityControlClick(root, event, actions, openSettings) {
+  for (const [activity, definition] of Object.entries(activities)) {
+    const button = event.target.closest(definition.selector);
+    if (!button || !root.contains(button)) continue;
+    const snapshot = actions.snapshot();
+    if (button.disabled || snapshot.saving || snapshot.loadingStatus || !snapshot.status) return true;
+    const control = activityControl(activity, snapshot);
+    if (control.action === "setup") {
+      openSettings();
+      root.querySelector(`[data-learning-setting="${control.field}"]`)?.focus();
+      return true;
+    }
+    void actions.configure(activityStatePatch(activity, snapshot.status.preferences, control.action === "start"));
+    return true;
+  }
+  return false;
+}
+
+export function renderActivityControls(root, snapshot) {
+  for (const [activity, definition] of Object.entries(activities)) {
+    const button = root.querySelector(definition.selector);
+    const control = activityControl(activity, snapshot);
+    button.disabled = Boolean(snapshot.saving || snapshot.loadingStatus || !snapshot.status);
+    button.textContent = control.label;
+    button.dataset.actionTone = control.tone;
+  }
+}

package/dist/src/web-ui/app/components/passive-learning/agent-motion.js

@@ -0,0 +1,37 @@
+/** Event-driven motion gate. No frame loop, model request or refresh timer. */
+export function createAgentMotion(root) {
+  const doc = root.ownerDocument;
+  const agent = root.querySelector("[data-coworker-agent]");
+  const Observer = doc.defaultView?.IntersectionObserver;
+  let inViewport = true;
+  let workspaceVisible = true;
+  let previousObservation;
+  let pulse = false;
+  function sync() {
+    const visible = doc.visibilityState !== "hidden" && workspaceVisible && inViewport;
+    agent?.setAttribute("data-motion", visible ? "on" : "off");
+  }
+  const observer = Observer && agent ? new Observer((entries) => {
+    inViewport = entries.some((entry) => entry.isIntersecting);
+    sync();
+  }) : null;
+  if (agent) observer?.observe(agent);
+  doc.addEventListener?.("visibilitychange", sync);
+  return {
+    update(snapshot) {
+      workspaceVisible = snapshot.learningActive !== false || snapshot.homeActive === true;
+      const observation = snapshot.status?.lastObservationAt;
+      if (previousObservation && observation && previousObservation !== observation) {
+        pulse = !pulse;
+        agent?.setAttribute("data-observation-pulse", pulse ? "a" : "b");
+      }
+      previousObservation = observation;
+      sync();
+    },
+    dispose() {
+      observer?.disconnect();
+      doc.removeEventListener?.("visibilitychange", sync);
+      agent?.setAttribute("data-motion", "off");
+    },
+  };
+}

package/dist/src/web-ui/app/components/passive-learning/agent-state.js

@@ -0,0 +1,131 @@
+import { hasLearningProcessingFailure, learningCollectionStatus, learningStateLabel, learningTimeLabel } from "./presentation.js";
+import { isObservationReviewActive, observationReviewSummary } from "./processing-state.js";
+
+const failures = new Set(["failed", "unavailable", "disconnected", "permission_required"]);
+
+export function latestVisibleProposal(status) {
+  return [...(status?.proactive?.proposals ?? [])].reverse().find((item) => item.status === "delivered");
+}
+
+function isReviewing(status) {
+  if (isObservationReviewActive(status)) return true;
+  if (status.reassessment?.state === "reviewing") return true;
+  return status.proactive?.state === "reviewing";
+}
+function isCollecting(status) {
+  status = learningCollectionStatus(status);
+  if (!status.preferences?.enabled) return false;
+  return status.state === "collecting" || status.state === "partial";
+}
+function hasActivityFailure(status) {
+  if (hasLearningProcessingFailure(status)) return true;
+  if (status.proactive?.state === "failed") return true;
+  if (status.reassessment?.state === "failed" || status.maintenanceReason) return true;
+  status = learningCollectionStatus(status);
+  if (!failures.has(status.state)) return false;
+  if (status.preferences?.enabled) return true;
+  return status.state === "failed";
+}
+function isBudgetLimited(status) {
+  if (status.proactive?.state === "budget_limited") return true;
+  if (status.reassessment?.state === "budget_limited") return true;
+  return String(status.reason || "").includes("budget_exhausted");
+}
+function isCompletelyPaused(status) {
+  if (status.preferences?.enabled || status.preferences?.proactiveEnabled) return false;
+  return status.preferences?.processingPaused || !status.preferences?.modelProfileId;
+}
+
+/** Presentation of committed runtime state only; this never advances a schedule. */
+export function coWorkerAgentState(snapshot) {
+  const status = snapshot.status;
+  if (!status) return { mode: "quiet", label: "Connecting", title: "ABot Spark", description: "Checking the current activity…" };
+  if (snapshot.statusError) return { mode: "attention", label: "Connection interrupted", title: "Waiting to reconnect.", description: "The last known activity is shown below. Refresh to check the connection." };
+  if (isReviewing(status)) return { mode: "reviewing", label: "Working now", title: "Finding what matters.", description: status.proactive?.state === "reviewing" ? "Considering whether there’s something useful to offer you." : "Reviewing activity and refining what’s worth remembering." };
+  if (latestVisibleProposal(status)) return { mode: "suggestion", label: "Something to share", title: "A thought for your next step.", description: "A conversation is ready. Read it when it suits you." };
+  if (hasActivityFailure(status)) return { mode: "attention", label: "Needs attention",
+    title: (status.processingReason || status.reason) === "learning_model_request_failed" ? "Let’s check the learning model." : "One activity needs attention.",
+    description: hasLearningProcessingFailure(status) ? "Learning could not finish its review. Check learning settings; saved knowledge is still here." : "Your saved knowledge is still here. Check the activity details below." };
+  if (isBudgetLimited(status)) return { mode: "quiet", label: "Taking a break", title: "Within your limits.", description: "The current budget is used up. Eligible work can continue after the limit resets." };
+  if (isCollecting(status)) return { mode: "collecting", label: "Noticing activity", title: "Getting to know your rhythm.", description: "Collecting changes in your active apps. Only useful patterns should become lasting knowledge." };
+  if (isCompletelyPaused(status)) return { mode: "quiet", label: "Taking a pause", title: "Ready when you are.", description: "Your saved knowledge is here. Each activity has its own controls." };
+  return { mode: "waiting", label: "Ready in the background", title: "Room for the next idea.", description: "Waiting for eligible work. No model runs just to keep this screen alive." };
+}
+
+function nextLabel(value, window) {
+  if (!value) return window ? `${window.start}–${window.end} · ${window.timeZone}` : "No hours restriction";
+  return `Next ${learningTimeLabel(value)}${window ? ` · ${window.timeZone}` : ""}`;
+}
+export function coWorkerActivityStates(status) {
+  if (!status) return { collection: ["—", ""], processing: ["—", ""], proactive: ["—", ""] };
+  const p = status.preferences;
+  const processing = processingLabel(status);
+  const proactive = proactiveLabel(status);
+  return {
+    collection: [learningStateLabel(status), p.enabled ? nextLabel(status.nextCollectionAt, p.collectionWindow) : "No new activity collected"],
+    processing: [processing, processingDetail(status)],
+    proactive: [proactive, p.proactiveEnabled ? nextLabel(status.proactive?.nextReviewAt, p.proactiveWindow) : "No unsolicited messages"],
+  };
+}
+function processingDetail(status) {
+  if (isObservationReviewActive(status)) return observationReviewSummary(status);
+  if (status.preferences.processingPaused) return "Pending activity stays within its retention limit";
+  if (status.reviewPassRemaining > 0) {
+    const remaining = `${status.reviewPassRemaining} observations left in this review`;
+    if (status.nextAnalysisAt) return `${remaining} · ${nextLabel(status.nextAnalysisAt, status.preferences.analysisWindow)}`;
+    return remaining;
+  }
+  if (status.preferences.analysisTrigger === "observations") {
+    const progress = `${status.pendingObservations} / ${status.preferences.analysisObservationCount ?? 100} eligible observations`;
+    if (status.nextAnalysisAt) return `${progress} · ${nextLabel(status.nextAnalysisAt, status.preferences.analysisWindow)}`;
+    return progress;
+  }
+  return nextLabel(status.nextAnalysisAt || status.reassessment?.nextReviewAt, status.preferences.analysisWindow);
+}
+
+export function learningCadenceLabel(preferences) {
+  if (preferences.analysisTrigger === "observations") return `Review at ${preferences.analysisObservationCount ?? 100} observations`;
+  return `Every ${preferences.analysisIntervalMinutes ?? 15} min`;
+}
+function processingLabel(status) {
+  if (isObservationReviewActive(status)) return "Processing now";
+  if (!status.preferences.modelProfileId) return "Choose a model";
+  if (status.preferences.processingPaused) return "Paused";
+  if (status.reassessment?.state === "reviewing") return "Reviewing knowledge";
+  if (hasLearningProcessingFailure(status)) return "Needs attention";
+  if (status.reassessment?.state === "failed") return "Needs attention";
+  if (status.reassessment?.state === "budget_limited") return "Budget reached";
+  if (status.pendingObservations > 0) return `${status.pendingObservations} observations waiting`;
+  return "Waiting for useful activity";
+}
+function proactiveLabel(status) {
+  if (!status.preferences.proactiveEnabled) return "Off";
+  if (status.proactive?.state === "reviewing") return "Considering an idea";
+  if (status.proactive?.state === "budget_limited") return "Budget reached";
+  if (status.proactive?.state === "failed") return "Needs attention";
+  return "Enabled · waiting";
+}
+
+export function coWorkerActivityTones(status) {
+  if (!status) return { collection: "off", processing: "off", proactive: "off" };
+  const p = status.preferences;
+  let collection = "off", processing = "off", proactive = "off";
+  if (p.enabled) {
+    collection = "waiting";
+    if (isCollecting(status)) collection = "active";
+    if (failures.has(learningCollectionStatus(status).state)) collection = "attention";
+  }
+  if (!p.processingPaused && p.modelProfileId) {
+    processing = "ready";
+    if (status.pendingObservations > 0) processing = "waiting";
+    if (status.reassessment?.state === "reviewing") processing = "active";
+    if (hasLearningProcessingFailure(status) || status.reassessment?.state === "failed" || status.reassessment?.state === "budget_limited") processing = "attention";
+  }
+  if (isObservationReviewActive(status)) processing = "active";
+  if (p.proactiveEnabled) {
+    proactive = "ready";
+    if (status.proactive?.state === "reviewing") proactive = "active";
+    if (status.proactive?.state === "failed" || status.proactive?.state === "budget_limited") proactive = "attention";
+  }
+  return { collection, processing, proactive };
+}

package/dist/src/web-ui/app/components/passive-learning/agent-view.js

@@ -0,0 +1,40 @@
+import { coWorkerActivityStates, coWorkerActivityTones, coWorkerAgentState } from "./agent-state.js";
+import { isObservationReviewActive } from "./processing-state.js";
+
+const glyph = `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 3c0 6-3 9-9 9 6 0 9 3 9 9 0-6 3-9 9-9-6 0-9-3-9-9Z"/><path d="M18 3v4m-2-2h4"/></svg>`;
+
+export function agentMarkup({ compact = false, actionMarkup = "" } = {}) {
+  return `<section class="co-worker-agent${compact ? " co-worker-agent-compact" : ""}" data-coworker-agent data-agent-mode="quiet" data-motion="off" aria-label="ABot Spark activity">
+    <div class="co-worker-agent-main">
+      <div class="co-worker-art" aria-hidden="true"><div class="co-worker-wave"></div><div class="co-worker-orbit"><i data-orbit-phase="collection"></i><i data-orbit-phase="processing"></i><i data-orbit-phase="proactive"></i></div><div class="co-worker-core">${glyph}</div><div class="co-worker-spark"></div></div>
+      <div class="co-worker-agent-copy"><span class="co-worker-agent-label" data-agent-status>Connecting</span><h3 data-agent-title tabindex="-1" data-learning-heading>ABot Spark</h3><p data-agent-description></p></div>
+      ${actionMarkup}
+    </div>
+    <div class="co-worker-phases">
+      <div class="co-worker-phase" data-agent-phase="collection"><span>Collection</span><p data-agent-collection data-learning-state>—</p><small data-agent-collection-time></small></div>
+      <div class="co-worker-phase" data-agent-phase="processing" data-agent-processing-phase><span>Learning</span><p data-agent-processing role="status">—</p><small data-agent-processing-time></small></div>
+      <div class="co-worker-phase" data-agent-phase="proactive"><span>Proactive</span><p data-agent-proactive>—</p><small data-agent-proactive-time></small></div>
+    </div>
+  </section>`;
+}
+
+export function renderAgent(root, snapshot) {
+  const agent = root.querySelector("[data-coworker-agent]");
+  if (!agent) return;
+  const state = coWorkerAgentState(snapshot);
+  agent.setAttribute("data-agent-mode", state.mode);
+  agent.querySelector("[data-agent-processing-phase]").setAttribute("data-processing-active", String(!snapshot.statusError && isObservationReviewActive(snapshot.status)));
+  const setText = (selector, value) => { const node = agent.querySelector(selector); if (node.textContent !== value) node.textContent = value; };
+  setText("[data-agent-status]", state.label);
+  setText("[data-agent-title]", state.title);
+  setText("[data-agent-description]", state.description);
+  const tones = coWorkerActivityTones(snapshot.status);
+  for (const [key, [label, time]] of Object.entries(coWorkerActivityStates(snapshot.status))) {
+    const tone = snapshot.statusError ? "attention" : tones[key];
+    setText(`[data-agent-${key}]`, label);
+    agent.querySelector(`[data-agent-${key}]`).setAttribute("data-phase-state", tone);
+    agent.querySelector(`[data-agent-phase="${key}"]`).setAttribute("data-phase-state", tone);
+    agent.querySelector(`[data-orbit-phase="${key}"]`).setAttribute("data-phase-state", tone);
+    setText(`[data-agent-${key}-time]`, time);
+  }
+}

package/dist/src/web-ui/app/components/passive-learning/application-actions.js

@@ -0,0 +1,22 @@
+const exclusionFields = Object.freeze({ collection: "excludedApplications", processing: "processingExcludedApplications" });
+const applicationKey = app => app.trim().toLowerCase();
+
+/** Change one permission using current server preferences; other activity rules stay untouched. */
+export function learningApplicationPreferenceChange(snapshot, { app, axis, allowed, environmentId }) {
+  if (!canChangeApplicationPreferences(snapshot, environmentId)) return null;
+  if (!Object.hasOwn(exclusionFields, axis) || typeof allowed !== "boolean") return null;
+  if (typeof app !== "string" || !app.trim()) return null;
+  const application = snapshot.status.applications.find(item => applicationKey(item.app) === applicationKey(app));
+  if (!application) return null;
+  const field = exclusionFields[axis];
+  const excluded = snapshot.status.preferences[field] ?? [];
+  const remaining = excluded.filter(value => applicationKey(value) !== applicationKey(application.app));
+  return { [field]: allowed ? remaining : [...remaining, application.app] };
+}
+
+function canChangeApplicationPreferences(snapshot, environmentId) {
+  if (snapshot.environmentId !== environmentId) return false;
+  if (snapshot.saving || snapshot.statusError) return false;
+  if (!snapshot.status?.preferences) return false;
+  return Array.isArray(snapshot.status.applications);
+}