@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/web-ui/app/components/passive-learning/macos-collection-restart-notice.js

@@ -0,0 +1,52 @@
+const permissionReasons = new Set([
+  "macos_accessibility_permission_required",
+  "macos_accessibility_permission_timeout",
+  "macos_accessibility_permission_revoked",
+]);
+
+function hasEnabledMacCollection(snapshot) {
+  if (snapshot.hostConnection?.identity?.os !== "macos") return false;
+  return snapshot.status?.preferences?.enabled === true;
+}
+
+export function hasMacCollectionPermissionBlock(snapshot) {
+  if (!hasEnabledMacCollection(snapshot)) return false;
+  if (snapshot.status.collectionState !== "permission_required") return false;
+  return permissionReasons.has(snapshot.status.collectionReason);
+}
+
+function canRestartMacCollection(snapshot, actions) {
+  if (!hasMacCollectionPermissionBlock(snapshot)) return false;
+  if (snapshot.saving || snapshot.loadingStatus) return false;
+  if (snapshot.restartingCollection) return false;
+  return typeof actions.restartCollection === "function";
+}
+
+export function macCollectionRestartNoticeMarkup() {
+  return `<div class="co-worker-computer-update" data-learning-mac-restart hidden role="status">
+    <span class="co-worker-computer-update-icon" aria-hidden="true">↻</span>
+    <div class="co-worker-computer-update-copy"><p class="co-worker-computer-update-title">Spark needs Accessibility access</p>
+      <p>Already granted access? Restart collection to check again.</p></div>
+    <button type="button" data-learning-restart-collection>Restart collection</button>
+  </div>`;
+}
+
+export function renderMacCollectionRestartNotice(root, snapshot) {
+  const notice = root.querySelector("[data-learning-mac-restart]");
+  const blocked = hasMacCollectionPermissionBlock(snapshot);
+  const restartingMacCollection = hasEnabledMacCollection(snapshot) && snapshot.restartingCollection;
+  notice.hidden = !blocked && !restartingMacCollection;
+  notice.setAttribute("aria-busy", String(Boolean(snapshot.restartingCollection)));
+  const button = notice.querySelector("[data-learning-restart-collection]");
+  button.disabled = Boolean(snapshot.saving || snapshot.loadingStatus || snapshot.restartingCollection || !blocked);
+  button.textContent = snapshot.restartingCollection ? "Restarting collection…" : "Restart collection";
+}
+
+export function handleMacCollectionRestartClick(root, event, actions) {
+  const button = event.target.closest("[data-learning-restart-collection]");
+  if (!button || !root.contains(button)) return false;
+  if (button.disabled) return true;
+  if (!canRestartMacCollection(actions.snapshot(), actions)) return true;
+  void actions.restartCollection();
+  return true;
+}

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

@@ -0,0 +1,232 @@
+import { renderAgent } from "./agent-view.js";
+import { renderComputerUpdateNotice } from "./computer-update-notice.js";
+import { renderMacCollectionRestartNotice, handleMacCollectionRestartClick } from "./macos-collection-restart-notice.js";
+import { learningCadenceLabel } from "./agent-state.js";
+import { renderLearningDiagnostics } from "./diagnostics-view.js";
+import { isObservationReviewActive } from "./processing-state.js";
+import { createAgentMotion } from "./agent-motion.js";
+import { createLearningSettings } from "./settings.js";
+import { handleActivityControlClick, renderActivityControls } from "./activity-controls.js";
+import { createLearningApplications } from "./applications-view.js";
+import { renderResourceUsage } from "./usage-view.js";
+import { renderLearningKnowledge, handleKnowledgeClick } from "./knowledge-view.js";
+import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+import { learningBatchStatusLabel, renderLearningBatchDetail } from "./batch-detail.js";
+import { learningWorkspaceMarkup, navigateLearningTabs, selectLearningView } from "./workspace-view.js";
+import {
+  learningCoveragePresentation,
+  learningFailurePresentation,
+  learningProcessingLabel,
+  learningRetentionText,
+  hasUnprocessedLearningActivity,
+  learningTimeLabel,
+} from "./presentation.js";
+
+const defaultTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+
+export function createPassiveLearningMemory({
+  actions, showActivityMemories, openComputerAccess,
+  confirmDelete = (message) => window.confirm(message),
+}) {
+  let root = null;
+  let settings;
+  let applications;
+  let motion;
+  let displayedBatch = null;
+  let displayedBatchId = "";
+  let displayedDetailError = "";
+  let displayedDetailLoading = false;
+  let lastBatchMarkup = "";
+
+  function mount(nextRoot) {
+    if (root === nextRoot) return;
+    motion?.dispose();
+    root?.removeEventListener("click", handleClick);
+    root?.removeEventListener("submit", handleSubmit);
+    root?.removeEventListener("change", handleChange);
+    root?.removeEventListener("input", handleChange);
+    root?.removeEventListener("keydown", handleKeyDown);
+    root = nextRoot;
+    if (!root) return;
+    displayedBatch = null;
+    displayedBatchId = "";
+    lastBatchMarkup = "";
+    root.innerHTML = learningWorkspaceMarkup(defaultTimeZone());
+    settings = createLearningSettings({ root, actions, openSettings: () => selectLearningView(root, "settings") });
+    applications = createLearningApplications({ root, actions });
+    motion = createAgentMotion(root);
+    root.addEventListener("click", handleClick);
+    root.addEventListener("submit", handleSubmit);
+    root.addEventListener("change", handleChange);
+    root.addEventListener("input", handleChange);
+    root.addEventListener("keydown", handleKeyDown);
+    render(actions.snapshot());
+  }
+
+  function handleChange(event) {
+    if (applications.handleChange(event)) return;
+    settings.handleChange(event); renderControls(actions.snapshot());
+  }
+  function handleSubmit(event) { settings.handleSubmit(event); }
+
+  function handleKeyDown(event) {
+    navigateLearningTabs(root, event);
+  }
+
+  function handleClick(event) {
+    if (handleActivityControlClick(root, event, actions, () => selectLearningView(root, "settings"))) return;
+    if (handleMacCollectionRestartClick(root, event, actions)) return;
+    if (handleKnowledgeClick(root, event)) return;
+    if (event.target.closest("[data-learning-open-settings]")) {
+      selectLearningView(root, "settings", true);
+      return;
+    }
+    const tab = event.target.closest("button[data-learning-tab]");
+    if (tab && root.contains(tab)) {
+      selectLearningView(root, tab.dataset.learningTab);
+      return;
+    }
+    const clearPending = event.target.closest("button[data-learning-clear-pending]");
+    if (clearPending && root.contains(clearPending)) {
+      deletePending();
+      return;
+    }
+    const setupButton = event.target.closest("button[data-learning-open-setup]") ??
+      event.target.closest("button[data-learning-open-update]") ??
+      event.target.closest("button[data-learning-computer-access]");
+    if (setupButton && root.contains(setupButton)) {
+      openComputerAccess();
+      return;
+    }
+    const button = event.target.closest("button[data-learning-refresh], button[data-learning-batch], button[data-learning-memories]");
+    if (!button || !root.contains(button)) return;
+    if (button.hasAttribute("data-learning-refresh")) void actions.refresh();
+    if (button.hasAttribute("data-learning-batch")) {
+      const previousId = actions.snapshot().selectedBatchId;
+      const nextId = button.dataset.learningBatch;
+      void actions.selectBatch(nextId);
+      if (!nextId) {
+        const previousButton = [...root.querySelectorAll("[data-learning-batches] button")]
+          .find((item) => item.dataset.learningBatch === previousId);
+        previousButton?.focus({ preventScroll: true });
+      }
+    }
+    if (button.hasAttribute("data-learning-memories"))
+      showActivityMemories();
+  }
+
+  function deletePending() {
+    const snapshot = actions.snapshot();
+    if (!snapshot.status || snapshot.saving) return;
+    if (!hasUnprocessedLearningActivity(snapshot.status)) return;
+    if (!confirmDelete("Delete all pending activity, including any review in progress? Saved insights are kept. This cannot be undone.")) return;
+    void actions.clearPending();
+  }
+
+
+  function renderControls(snapshot) {
+    const status = snapshot.status;
+    const disabled = snapshot.saving || !status;
+    renderActivityControls(root, snapshot);
+    root.querySelector("[data-learning-clear-pending]").disabled = disabled || !hasUnprocessedLearningActivity(status);
+  }
+
+  function renderStatus(snapshot) {
+    const status = snapshot.status;
+    const companion = snapshot.hostConnection?.companion;
+    renderComputerUpdateNotice(root, snapshot);
+    renderMacCollectionRestartNotice(root, snapshot);
+    root.querySelector("[data-learning-companion-version]").textContent = companion
+      ? `Installed version: ${companion.installedVersion ?? "unversioned"} · Available: ${companion.availableVersion}` : "Connect your computer to check its companion version.";
+    const attention = learningFailurePresentation(status);
+    const coverage = learningCoveragePresentation(status);
+    root.querySelector("[data-learning-attention]").hidden = !attention;
+    root.querySelector("[data-learning-attention-text]").textContent = attention?.message || "";
+    root.querySelector("[data-learning-open-setup]").hidden = !attention?.connectComputer;
+    root.querySelector("[data-learning-processing-status]").textContent = learningProcessingLabel(status);
+    root.querySelector("[data-learning-retention]").textContent = learningRetentionText(status);
+    const modelId = status?.preferences?.modelProfileId;
+    const model = snapshot.models.find((profile) => profile.id === modelId);
+    root.querySelector("[data-learning-schedule-summary]").textContent = modelId
+      ? `${model?.label || modelId} · ${learningCadenceLabel(status.preferences)}`
+      : "Choose a model in Settings to get started.";
+    root.querySelector("[data-learning-device]").textContent = status?.deviceId || "Not connected now";
+    root.querySelector("[data-learning-coverage]").textContent = coverage.label;
+    root.querySelector("[data-learning-coverage-detail]").textContent = coverage.detail;
+    const reasons = [status?.collectionReason, status?.processingReason, status?.reason, status?.proactive?.reason, status?.reassessment?.reason, status?.maintenanceReason].filter(Boolean);
+    root.querySelector("[data-learning-diagnostics]").hidden = !reasons.length;
+    renderLearningDiagnostics(root.querySelector("[data-learning-reason]"), reasons);
+    root.querySelector("[data-learning-observation]").textContent =
+      learningTimeLabel(status?.lastObservationAt);
+    root.querySelector("[data-learning-pending]").textContent = status
+      ? `${status.pendingObservations || 0} waiting${status.droppedObservations ? ` · ${status.droppedObservations} dropped` : ""}`
+      : "—";
+    const processingActive = !snapshot.statusError && isObservationReviewActive(status);
+    root.querySelector("[data-learning-pending-fact]").setAttribute("data-processing-active", String(processingActive));
+    root.querySelector("[data-learning-processing-badge]").hidden = !processingActive;
+    root.querySelector("[data-learning-analysis]").textContent = status
+      ? `${status.activeBatches ?? 0} active · ${status.effectiveConcurrency ?? 1} parallel${status.nextAnalysisAt ? ` · next ${learningTimeLabel(status.nextAnalysisAt)}` : ""}`
+      : "—";
+    const feedback = snapshot.statusError || snapshot.modelsError || snapshot.batchError;
+    root.querySelector("[data-learning-feedback]").textContent = feedback ||
+      (snapshot.loadingStatus ? "Loading learning status…" : "");
+  }
+
+  function renderBatches(snapshot) {
+    const list = root.querySelector("[data-learning-batches]");
+    if (snapshot.loadingBatches && !snapshot.batches.length) {
+      lastBatchMarkup = "";
+      list.textContent = "Loading reviews…";
+      return;
+    }
+    if (!snapshot.batches.length) {
+      lastBatchMarkup = "";
+      list.textContent = "No activity has been reviewed yet.";
+      return;
+    }
+    const markup = snapshot.batches.map((batch) =>
+      `<button type="button" class="passive-learning-batch" data-learning-batch="${escapeAttribute(batch.id)}" aria-pressed="${batch.id === snapshot.selectedBatchId}">
+        <span class="passive-learning-batch-heading"><time datetime="${escapeAttribute(batch.createdAt)}">${escapeHtml(learningTimeLabel(batch.createdAt))}</time><span>${escapeHtml(learningBatchStatusLabel(batch.status))}</span></span>
+        <small>${Number(batch.observationCount) || 0} observations · ${batch.recordIds?.length || 0} saved · ${batch.candidateIds?.length || 0} candidates</small>
+      </button>`).join("");
+    if (lastBatchMarkup !== markup) {
+      lastBatchMarkup = markup;
+      list.innerHTML = markup;
+    }
+  }
+
+  function renderBatchDetail(snapshot) {
+    const container = root.querySelector("[data-learning-detail]");
+    const batch = snapshot.selectedBatch;
+    if (snapshot.selectedBatchId === displayedBatchId &&
+        batch === displayedBatch &&
+        snapshot.detailError === displayedDetailError &&
+        snapshot.loadingDetail === displayedDetailLoading) return;
+    displayedBatchId = snapshot.selectedBatchId;
+    displayedBatch = batch;
+    displayedDetailError = snapshot.detailError;
+    displayedDetailLoading = snapshot.loadingDetail;
+    renderLearningBatchDetail(container, snapshot);
+  }
+
+  function render(snapshot) {
+    if (!root) return;
+    settings.render(snapshot);
+    applications.render(snapshot);
+    renderControls(snapshot);
+    renderAgent(root, snapshot);
+    motion.update(snapshot);
+    renderStatus(snapshot);
+    renderBatches(snapshot);
+    renderBatchDetail(snapshot);
+    renderLearningKnowledge(root, snapshot);
+    renderResourceUsage(root, snapshot);
+  }
+
+  function focus() {
+    root?.querySelector("[data-learning-heading]")?.focus({ preventScroll: true });
+    root?.scrollIntoView({ block: "start", behavior: "smooth" });
+  }
+
+  return Object.freeze({ mount, render, focus });
+}

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

@@ -0,0 +1,183 @@
+import { learningFailureCopy } from "./failure-copy.js";
+
+const setupRequiredReasons = new Set([
+  "host_not_paired",
+  "host_observations_unsupported",
+  "learning_host_unavailable",
+]);
+
+const connectReasons = new Set([
+  ...setupRequiredReasons,
+  "host_disconnected",
+  "host_broker_unavailable",
+  "host_observation_connect_timeout",
+  "learning_device_changed",
+  "macos_accessibility_permission_required",
+  "macos_accessibility_permission_timeout",
+  "macos_accessibility_permission_revoked",
+]);
+
+const failureStates = new Set([
+  "failed", "unavailable", "disconnected", "permission_required",
+]);
+
+const collectionFailureReasons = new Set([
+  ...connectReasons,
+  "host_observations_already_owned",
+  "host_observation_cancelled",
+  "platform_unsupported",
+  "macos_swift_tools_unavailable",
+  "collector_output_limit",
+  "collector_protocol_invalid",
+  "collector_dependency_unavailable",
+  "collector_start_failed",
+]);
+
+export function learningCollectionStatus(status) {
+  if (!status || status.collectionState === undefined) return status;
+  return { ...status, state: status.collectionState, reason: status.collectionReason };
+}
+
+export function hasLearningProcessingFailure(status) {
+  if (status?.processingReason) return true;
+  if (status?.collectionState !== undefined) return false;
+  if (status?.state !== "failed") return false;
+  return !collectionFailureReasons.has(status.reason);
+}
+
+const visibleAccessibilityReasons = new Set([
+  "uia_application_coverage",
+  "ax_application_coverage",
+  "atspi_application_coverage",
+  "wayland_atspi_coverage",
+  "x11_atspi_coverage",
+]);
+
+export function learningFailurePresentation(status) {
+  if (!status) return null;
+  const processingFailure = hasLearningProcessingFailure(status);
+  status = processingFailure ? { ...status, state: "failed", reason: status.processingReason || status.reason } : learningCollectionStatus(status);
+  if (!failureStates.has(status.state)) return null;
+  if (!status.preferences?.enabled && !processingFailure) return null;
+  const connectComputer = connectReasons.has(status.reason);
+  const explanation = learningFailureCopy(status.reason);
+  const fallback = status.state === "permission_required"
+    ? "Computer access needs permission before learning can collect activity."
+    : "Learning cannot collect activity right now. See Activity for technical details.";
+  const message = explanation.code || processingFailure ? explanation.message : fallback;
+  return { message, connectComputer };
+}
+
+export function learningIntroText(status) {
+  status = learningCollectionStatus(status);
+  if (status?.preferences?.enabled && status.reason === "continuous_activity")
+    return "Continuous screen changes are muted. Collection resumes after switching windows, editing, or 30 quiet seconds.";
+  if (!status) return "Checking collection status…";
+  if (!status.preferences?.enabled)
+    return "No activity is being collected. Your saved insights are kept.";
+  if (failureStates.has(status.state))
+    return "Collection needs attention. Your saved insights are still available.";
+  if (status.state === "paused")
+    return "Collection is paused. Your saved insights are still available.";
+  if (status.reason === "accessibility_read_unavailable")
+    return "The current app is not providing readable content.";
+  if (status.state === "partial" || status.state === "collecting")
+    return "Learning from visible computer activity.";
+  return "Connecting to your computer.";
+}
+
+export function learningProcessingLabel(status) {
+  if (!status) return "";
+  if (status.preferences?.processingPaused)
+    return "Processing paused. Pending activity is kept until its retention limit.";
+  if (status.processing || status.activeBatches > 0) return "Processing collected activity.";
+  if (!status.preferences?.modelProfileId)
+    return "Choose a model in Settings to process collected activity.";
+  if (hasLearningProcessingFailure(status))
+    return "Processing needs attention before pending activity can be reviewed.";
+  if (status.pendingObservations > 0)
+    return "Pending activity will be processed on the existing schedule.";
+  return "Processing is ready when activity is available.";
+}
+
+export function learningRetentionText(status) {
+  const hours = status?.retentionHours;
+  if (typeof hours === "number" && Number.isFinite(hours) && hours > 0)
+    return `Pending activity expires ${hours} hours after collection, including while processing is paused. Saved insights are kept.`;
+  return "Pending activity is kept within the configured retention period, including while processing is paused. Saved insights are kept.";
+}
+
+export function hasVisibleLearningWork(status) {
+  if (!status) return false;
+  if (status.preferences?.enabled) return true;
+  return hasUnprocessedLearningActivity(status);
+}
+
+export function hasUnprocessedLearningActivity(status) {
+  if (!status) return false;
+  if (status.blockedObservations > 0) return true;
+  if (status.pendingObservations > 0) return true;
+  if (status.activeBatches > 0) return true;
+  return status.processing === true;
+}
+
+export function learningCoveragePresentation(status) {
+  status = learningCollectionStatus(status);
+  if (!status) return { label: "Checking access", detail: "" };
+  if (!status.preferences?.enabled)
+    return { label: "Not collecting", detail: "" };
+  if (status.state === "partial" && status.reason === "accessibility_read_unavailable")
+    return { label: "Some content unreadable", detail: "The active app did not expose readable content." };
+  if (status.state === "partial" && visibleAccessibilityReasons.has(status.reason))
+    return { label: "Visible app content", detail: "Some content is not exposed by apps." };
+  if (status.state === "partial")
+    return { label: "Limited app visibility", detail: "Some content may be unavailable." };
+  if (status.state === "collecting")
+    return { label: "App content available", detail: "Coverage varies by app." };
+  if (status.state === "starting")
+    return { label: "Checking access", detail: "" };
+  return { label: "Not collecting", detail: "" };
+}
+
+export function learningStateLabel(status) {
+  status = learningCollectionStatus(status);
+  if (!status) return "Loading";
+  if (!status.preferences?.enabled) return "Collection stopped";
+  if (status.state === "partial" && status.reason === "accessibility_read_unavailable")
+    return "Limited access";
+  if (failureStates.has(status.state) && setupRequiredReasons.has(status.reason))
+    return "Setup required";
+  const labels = {
+    starting: "Connecting",
+    collecting: "Collecting",
+    partial: "Collecting",
+    unavailable: "Unavailable",
+    permission_required: "Permission required",
+    paused: "Paused",
+    stopped: "Stopped",
+    disconnected: "Disconnected",
+    failed: "Failed",
+    off: "Waiting to start",
+  };
+  return labels[status.state] || "Status unavailable";
+}
+
+export function learningTimeLabel(value) {
+  const timestamp = Date.parse(String(value || ""));
+  if (!Number.isFinite(timestamp)) return "Not yet";
+  return new Intl.DateTimeFormat(undefined, {
+    dateStyle: "medium",
+    timeStyle: "short",
+  }).format(timestamp);
+}
+
+export function learningModelLabel(profile) {
+  const name = profile.label || profile.id;
+  const provider = profile.providerId || profile.provider || "Provider unavailable";
+  return `${name} · ${provider}`;
+}
+
+export function learningPreview(value, limit = 110) {
+  const text = String(value || "").replaceAll(/\s+/gu, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit).trimEnd()}…` : text;
+}

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

@@ -0,0 +1,13 @@
+/** Queue totals exclude the batches already being processed. */
+export function isObservationReviewActive(status) {
+  if (status?.processing) return true;
+  return status?.activeBatches > 0;
+}
+
+export function observationReviewSummary(status) {
+  const batches = status?.activeBatches || 0;
+  const waiting = status?.pendingObservations || 0;
+  const running = batches > 0 ? `${batches} ${batches === 1 ? "batch" : "batches"} in progress` : "Review in progress";
+  const queue = waiting > 0 ? `${waiting} waiting` : "No observations waiting";
+  return `${running} · ${queue}`;
+}

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

@@ -0,0 +1,82 @@
+import { escapeAttribute } from "../../lib/text-format.js";
+
+function field(key, label, { type = "number", value = "", min = 1, max, legacy = "", step = "1", options } = {}) {
+  const attrs = `data-learning-setting="${key}" ${legacy ? `data-learning-${legacy}` : ""}`;
+  const control = type === "select"
+    ? `<select ${attrs} aria-label="${label}">${options || '<option value="">Choose a model</option>'}</select>`
+    : `<input ${attrs} type="${type}" value="${escapeAttribute(value)}" ${type === "number" ? `min="${min}" step="${step}" ${max ? `max="${max}"` : ""}` : ""} ${type === "text" ? 'autocomplete="off" maxlength="100"' : ""} required />`;
+  return `<label class="co-worker-setting-field">${label}${control}</label>`;
+}
+
+function toggle(key, label, legacy = "", small = false) {
+  return `<label class="${small ? "co-worker-hours-toggle" : "co-worker-setting-switch"}"><input type="checkbox" data-learning-setting="${key}" ${legacy ? `data-learning-${legacy}` : ""} /><span>${label}</span></label>`;
+}
+
+function windowFields(axis, timeZone) {
+  const legacy = axis === "processing" ? "" : `${axis}-`;
+  return `${toggle(`${axis}Hours`, "Set activity hours", `${legacy}hours`, true)}
+    <div class="co-worker-window-fields" data-learning-window-for="${axis}" data-learning-${legacy}window hidden>
+      <div class="co-worker-setting-pair">${field(`${axis}Start`, "From", { type: "time", value: "09:00", legacy: `${legacy}start` })}
+      ${field(`${axis}End`, "Until", { type: "time", value: "17:00", legacy: `${legacy}end` })}</div>
+      ${field(`${axis}TimeZone`, "Time zone", { type: "text", value: timeZone, legacy: `${legacy}time-zone` })}
+    </div>`;
+}
+
+export function learningSettingsMarkup(timeZone = "UTC") {
+  return `<form class="passive-learning-settings co-worker-settings" data-learning-settings>
+    <div class="co-worker-settings-header">
+      <div class="co-worker-settings-intro"><h4>Activity permissions</h4><p>Choose what Spark may do. Saving permission does not start an activity; use its Start button when you are ready.</p></div>
+      <button type="submit" data-learning-save disabled>Save settings</button>
+    </div>
+    <div class="co-worker-settings-grid">
+      <section class="co-worker-settings-card" data-learning-settings-axis="collection">
+        <h4>Collection</h4><p>Notice changes in your active applications.</p>
+        ${toggle("collectionEnabled", "Allow collection", "collection-enabled")}
+        ${windowFields("collection", timeZone)}
+        <p class="co-worker-setting-note">Revoking permission stops collection. Pending observations keep their existing retention limit.</p>
+      </section>
+      <section class="co-worker-settings-card" data-learning-settings-axis="processing">
+        <h4>Learning</h4><p>Review activity and refine what ABot Spark knows.</p>
+        ${toggle("processingEnabled", "Allow learning", "processing-enabled")}
+        ${field("modelProfileId", "Learning model", { type: "select", legacy: "model" })}
+        ${field("analysisTrigger", "Start a review", { type: "select", options: '<option value="interval">By time</option><option value="observations">By observation count</option>' })}
+        <div data-learning-trigger-for="interval">${field("analysisIntervalMinutes", "Review interval (minutes)", { value: 15, max: 1440, legacy: "interval" })}</div>
+        <div data-learning-trigger-for="observations" hidden>${field("analysisObservationCount", "Eligible observations waiting", { value: 100, max: 256 })}
+          <p class="co-worker-setting-note">Reviews waiting observations in small batches. Starts earlier if eligible activity nears the storage limit. New observations wait for the next review; blocked apps do not count. Hours, budgets and retention still apply.</p></div>
+        ${windowFields("processing", timeZone)}
+        <p class="co-worker-setting-note">Runs only when there is eligible work. Pausing keeps pending observations within their retention limit.</p>
+      </section>
+      <section class="co-worker-settings-card" data-learning-settings-axis="proactive">
+        <h4>Proactive mode</h4><p>Send a message in SPARK chat when there is something useful to offer.</p>
+        ${toggle("proactiveEnabled", "Allow proactive mode", "proactive-enabled")}
+        ${field("proactiveModelProfileId", "Chat and proactive model", { type: "select", legacy: "proactive-model" })}
+        ${field("proactiveIntervalMinutes", "Check interval (minutes)", { value: 60, max: 1440, legacy: "proactive-interval" })}
+        ${windowFields("proactive", timeZone)}
+        <p class="co-worker-setting-note">Can use existing knowledge while collection is off. Messages only; actions need your approval.</p>
+      </section>
+    </div>
+    <section class="co-worker-settings-limits">
+      <div class="co-worker-settings-intro"><h4>Shared limits</h4><p>Learning and proactive reviews share this daily budget. Failed attempts count too.</p></div>
+      <div class="co-worker-limits-grid">
+        ${field("modelCallsPerDay", "Model calls per day", { value: 24 })}
+        ${field("proactiveMessagesPerDay", "Proactive messages per day", { value: 2, max: 100 })}
+        ${field("maxConcurrentBatches", "Concurrent cloud calls", { value: 1, max: 8, legacy: "concurrency" })}
+        ${field("embeddingCallsPerDay", "Embedding calls per day", { value: 96 })}
+        ${field("embeddingCharactersPerDay", "Embedding input characters per day", { value: 1048576 })}
+        ${field("budgetTimeZone", "Daily budget time zone", { type: "text", value: "UTC" })}
+      </div>
+      <p class="co-worker-setting-note">Local models run one call at a time. A time-zone change does not reset the current budget.</p>
+    </section>
+    <details class="co-worker-settings-limits co-worker-memory-policy">
+      <summary>When a candidate becomes memory</summary>
+      <p class="co-worker-setting-note">Applies to automatic learning from conversations and computer activity. Promotion needs your chosen score and two independent reinforcements. Scores express model judgment, not probability.</p>
+      <div class="co-worker-limits-grid">
+        ${field("promotionScore", "Promotion score (out of 100)", { value: 90, min: 0, max: 100 })}
+        ${field("retentionDays", "Days without reinforcement", { value: 30, max: 365 })}
+        ${field("maxCandidates", "Maximum candidates", { value: 500, max: 5000 })}
+        ${field("candidateMiB", "Candidate storage limit (MiB)", { value: 2, min: 0.0009765625, max: 20, step: "any" })}
+      </div>
+    </details>
+    <div class="co-worker-settings-footer"><span data-learning-settings-feedback role="status" aria-live="polite"></span><button type="submit" data-learning-save disabled>Save settings</button></div>
+  </form>`;
+}