@abot-ai/runtime 1.4.0 → 1.6.0

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", automations: "automationsWorkspaceButton", 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,126 @@
+import { hasLearningProcessingFailure, learningCollectionStatus, learningStateLabel, learningTimeLabel } from "./presentation.js";
+import { isObservationReviewActive, observationReviewSummary } from "./processing-state.js";
+
+const failures = new Set(["failed", "unavailable", "disconnected", "permission_required"]);
+
+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 (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 = '<img src="/spark-mascot.svg" alt="" width="38" height="38" />';
+
+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);
+}

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

@@ -0,0 +1,126 @@
+import { learningTimeLabel } from "./presentation.js";
+import { learningApplicationPreferenceChange } from "./application-actions.js";
+
+export function learningApplicationsMarkup() {
+  return `<section class="co-worker-applications" aria-label="Application permissions">
+    <div class="passive-learning-section-heading"><div><h4>Applications</h4><p>Choose which apps ABot Spark can collect and review.</p></div><button type="button" data-learning-refresh>Refresh</button></div>
+    <p class="co-worker-applications-note">Collect activity controls future captures. Process activity controls whether retained activity can be reviewed.</p>
+    <p class="co-worker-applications-feedback" data-learning-applications-feedback role="status" aria-live="polite"></p>
+    <p class="co-worker-applications-count" data-learning-applications-count></p>
+    <div class="co-worker-applications-list" data-learning-applications></div>
+    <p class="co-worker-applications-note">Activity blocked from processing remains pending within existing expiry and storage limits. Content already sent to a model cannot be retracted. Saved memories are kept.</p>
+  </section>`;
+}
+
+export function createLearningApplications({ root, actions }) {
+  const list = root.querySelector("[data-learning-applications]");
+  const feedback = root.querySelector("[data-learning-applications-feedback]");
+  const count = root.querySelector("[data-learning-applications-count]");
+  const rows = new Map();
+  let environmentId;
+  let empty;
+
+  function element(tag, className, text) {
+    const node = root.ownerDocument.createElement(tag);
+    node.className = className;
+    if (text) node.textContent = text;
+    return node;
+  }
+
+  function createRow(app) {
+    const row = element("article", "co-worker-application");
+    row.setAttribute("data-learning-application", app);
+    const identity = element("div", "co-worker-application-identity");
+    const icon = element("span", "co-worker-application-icon", Array.from(app).slice(0, 2).join("").toUpperCase());
+    icon.setAttribute("aria-hidden", "true");
+    const text = element("div", "co-worker-application-text");
+    const title = element("h5", "", app); title.setAttribute("dir", "auto");
+    const detail = element("p", "");
+    text.append(title); text.append(detail); identity.append(icon); identity.append(text); row.append(identity);
+    const controls = {};
+    for (const [axis, label] of [["collection", "Collect activity"], ["processing", "Process activity"]]) {
+      const toggle = element("label", "co-worker-setting-switch co-worker-application-toggle");
+      const input = element("input", "");
+      input.setAttribute("type", "checkbox");
+      input.setAttribute("data-learning-application-axis", axis);
+      input.setAttribute("aria-label", `${label} · ${app}`);
+      toggle.append(input); toggle.append(element("span", "", label)); row.append(toggle);
+      controls[axis] = input;
+    }
+    list.append(row);
+    return { row, detail, controls };
+  }
+
+  function showEmpty(message) {
+    if (!empty) { empty = element("p", "co-worker-applications-empty"); list.append(empty); }
+    empty.textContent = message;
+  }
+
+  function render(snapshot) {
+    if (environmentId !== snapshot.environmentId) {
+      environmentId = snapshot.environmentId;
+      list.replaceChildren(); rows.clear(); empty = undefined;
+    }
+    const applications = Array.isArray(snapshot.status?.applications) ? snapshot.status.applications : [];
+    const available = Boolean(snapshot.status && Array.isArray(snapshot.status.applications));
+    const disabled = snapshot.saving || snapshot.statusError || !available;
+    feedback.textContent = applicationFeedback(snapshot);
+    count.textContent = available ? applicationCatalogLabel(applications.length, snapshot.status.applicationsOmitted) : "";
+    const current = new Set(applications.map(item => item.app));
+    for (const [app, value] of rows) {
+      if (current.has(app)) continue;
+      value.row.remove(); rows.delete(app);
+    }
+    if (!applications.length) {
+      showEmpty(applicationsEmptyMessage(snapshot, available));
+      return;
+    }
+    empty?.remove(); empty = undefined;
+    for (const item of applications) {
+      const value = rows.get(item.app) ?? createRow(item.app);
+      rows.set(item.app, value);
+      value.row.setAttribute("data-learning-application-environment", String(snapshot.environmentId));
+      const observations = Number.isSafeInteger(item.observationCount) ? Math.max(0, item.observationCount) : 0;
+      const observed = item.lastObservedAt ? ` · Last collected ${learningTimeLabel(item.lastObservedAt)}` : "";
+      value.detail.textContent = observations ? `${observations} retained ${observations === 1 ? "observation" : "observations"}${observed}` : "No retained activity";
+      value.controls.collection.checked = !item.collectionExcluded;
+      value.controls.processing.checked = !item.processingExcluded;
+      value.controls.collection.disabled = Boolean(disabled);
+      value.controls.processing.disabled = Boolean(disabled);
+    }
+  }
+
+  function handleChange(event) {
+    const input = event.target.closest("input[data-learning-application-axis]");
+    if (!input || !root.contains(input)) return false;
+    if (event.type === "input") return true;
+    const row = input.closest("[data-learning-application]");
+    const snapshot = actions.snapshot();
+    const patch = learningApplicationPreferenceChange(snapshot, { app: row?.dataset.learningApplication,
+      axis: input.dataset.learningApplicationAxis, allowed: input.checked,
+      environmentId: row?.dataset.learningApplicationEnvironment });
+    if (patch) void actions.configure(patch);
+    render(actions.snapshot());
+    return true;
+  }
+
+  return Object.freeze({ render, handleChange });
+}
+
+function applicationFeedback(snapshot) {
+  if (snapshot.statusError) return "Application status is unavailable. Refresh before changing permissions.";
+  if (snapshot.saving) return "Saving changes…";
+  return "";
+}
+
+function applicationsEmptyMessage(snapshot, available) {
+  if (snapshot.loadingStatus) return "Loading applications…";
+  if (available) return "Applications appear here as activity is collected. Excluded apps stay listed.";
+  return "Application history is unavailable.";
+}
+
+function applicationCatalogLabel(count, omitted) {
+  const label = `${count} ${count === 1 ? "application" : "applications"} · Retained activity`;
+  if (!Number.isSafeInteger(omitted) || omitted <= 0) return label;
+  return `${label} · ${omitted} older applications not shown`;
+}