@abot-ai/runtime 1.3.1 → 1.5.0

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`;
+}

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

@@ -0,0 +1,143 @@
+import { learningTimeLabel } from "./presentation.js";
+import { learningFailureCopy } from "./failure-copy.js";
+import { renderLearningDiagnostics } from "./diagnostics-view.js";
+
+const batchStatusLabels = Object.freeze({
+  pending: "Waiting",
+  processing: "Reviewing",
+  saved: "Completed",
+  reviewed: "Candidates updated",
+  discarded: "Discarded",
+  failed: "Failed",
+  cancelled: "Cancelled",
+});
+
+export function learningBatchStatusLabel(status) {
+  return batchStatusLabels[status] || "Status unavailable";
+}
+
+function observationKindLabel(kind) {
+  if (kind === "edit") return "Text changed";
+  if (kind === "activity") return "Returned to this app";
+  return "Viewed";
+}
+
+function observationText(observation) {
+  if (typeof observation.content === "string" && observation.content.trim())
+    return observation.content;
+  if (observation.revisit?.contentUnchanged || observation.revisitsObservationId)
+    return "No new text since the previous view.";
+  if (observation.kind === "activity")
+    return "Activity was observed without new text.";
+  return "This app did not expose readable text for this observation.";
+}
+
+function renderObservation(container, observation) {
+  const documentRoot = container.ownerDocument;
+  const element = (tag, className, text) => {
+    const node = documentRoot.createElement(tag);
+    node.className = className;
+    if (text) node.textContent = text;
+    return node;
+  };
+  const item = documentRoot.createElement("details");
+  item.className = "passive-learning-observation";
+  const summary = documentRoot.createElement("summary");
+  const app = observation.source?.app || "Unknown app";
+  const icon = element("span", "passive-learning-observation-icon", Array.from(app).slice(0, 2).join("").toUpperCase());
+  icon.setAttribute("aria-hidden", "true");
+  const heading = element("div", "passive-learning-observation-heading");
+  const labels = element("div", "passive-learning-observation-labels");
+  labels.append(element("span", "passive-learning-observation-app", app));
+  labels.append(element("span", "passive-learning-observation-kind", observationKindLabel(observation.kind)));
+  const source = element("span", "passive-learning-observation-source", observation.source?.title || "Untitled window");
+  source.setAttribute("dir", "auto");
+  const time = element("time", "passive-learning-observation-meta", learningTimeLabel(observation.timestamp));
+  if (Number.isFinite(Date.parse(observation.timestamp || ""))) time.setAttribute("datetime", observation.timestamp);
+  heading.append(labels);
+  heading.append(source);
+  heading.append(time);
+  summary.append(icon);
+  summary.append(heading);
+
+  const body = element("div", "passive-learning-observation-body");
+  const readable = typeof observation.content === "string" && observation.content.trim();
+  if (readable) body.append(element("p", "passive-learning-observation-content-label", "Captured text"));
+  const content = documentRoot.createElement("pre");
+  content.setAttribute("dir", "auto");
+  content.setAttribute("tabindex", "0");
+  content.setAttribute("aria-label", readable ? "Captured text" : "Observation context");
+  content.textContent = observationText(observation);
+  body.append(content);
+  const diagnostics = [observation.coverage, observation.coverageReason]
+    .filter(Boolean).join(" · ");
+  if (diagnostics) {
+    const note = element("details", "passive-learning-observation-diagnostics");
+    note.append(element("summary", "", "Capture details"));
+    note.append(element("code", "", diagnostics));
+    body.append(note);
+  }
+  item.append(summary);
+  item.append(body);
+  container.append(item);
+}
+
+export function renderLearningBatchDetail(container, snapshot) {
+  container.hidden = !snapshot.selectedBatchId;
+  if (container.hidden) return;
+  container.replaceChildren();
+  if (snapshot.loadingDetail) {
+    container.textContent = "Loading review details…";
+    return;
+  }
+  if (snapshot.detailError) {
+    container.textContent = "Review details could not be loaded. Refresh to try again.";
+    return;
+  }
+  const batch = snapshot.selectedBatch;
+  if (!batch) return;
+  const observations = Array.isArray(batch.observations) ? batch.observations : [];
+  const documentRoot = container.ownerDocument;
+  const header = documentRoot.createElement("header");
+  header.className = "passive-learning-detail-header";
+  const heading = documentRoot.createElement("h5");
+  heading.textContent = "Review details";
+  const summary = documentRoot.createElement("p");
+  const observationLabel = observations.length === 1 ? "observation" : "observations";
+  summary.textContent = `${learningBatchStatusLabel(batch.status)} · ${observations.length} ${observationLabel} · ${batch.recordIds?.length || 0} saved · ${batch.candidateIds?.length || 0} candidates`;
+  header.append(heading);
+  header.append(summary);
+  const close = documentRoot.createElement("button");
+  close.setAttribute("type", "button");
+  close.setAttribute("data-learning-batch", "");
+  close.textContent = "Close details";
+  header.append(close);
+  container.append(header);
+  if (batch.reason || batch.status === "failed") {
+    const explanation = learningFailureCopy(batch.reason);
+    const reason = documentRoot.createElement("p");
+    reason.className = "passive-learning-detail-reason";
+    reason.textContent = explanation.message;
+    container.append(reason);
+    if (explanation.code) {
+      const details = documentRoot.createElement("details");
+      details.className = "passive-learning-diagnostics";
+      const label = documentRoot.createElement("summary");
+      label.textContent = "Technical details";
+      const codes = documentRoot.createElement("dl");
+      codes.className = "passive-learning-diagnostic-list";
+      renderLearningDiagnostics(codes, [explanation.code]);
+      details.append(label);
+      details.append(codes);
+      container.append(details);
+    }
+  }
+  if (!observations.length) {
+    const empty = documentRoot.createElement("p");
+    empty.textContent = "No observations were included in this batch.";
+    container.append(empty);
+    return;
+  }
+  for (const observation of observations)
+    renderObservation(container, observation);
+}

package/dist/src/web-ui/app/components/passive-learning/computer-update-notice.js

@@ -0,0 +1,13 @@
+export function computerUpdateNoticeMarkup() {
+  return `<div class="co-worker-computer-update" data-learning-update 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">Computer access update available</p>
+      <p data-learning-update-text>Update this computer to get the latest fixes and collection protections.</p></div>
+    <button type="button" data-learning-open-update>Update Computer access <span aria-hidden="true">↗</span></button>
+  </div>`;
+}
+
+export function renderComputerUpdateNotice(root, snapshot) {
+  root.querySelector("[data-learning-update]").hidden =
+    !snapshot.hostConnection?.companion?.updateAvailable;
+}

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

@@ -0,0 +1,28 @@
+import { learningFailureCopy } from "./failure-copy.js";
+
+/** Render status codes with explanations, without interpreting provider error bodies. */
+export function renderLearningDiagnostics(container, reasons) {
+  container.replaceChildren();
+  const documentRoot = container.ownerDocument;
+  for (const reason of new Set(reasons.filter(Boolean))) {
+    const copy = learningFailureCopy(reason);
+    const code = diagnosticCode(reason);
+    const row = documentRoot.createElement("div");
+    row.className = "passive-learning-diagnostic-row";
+    const key = documentRoot.createElement("dt");
+    const label = documentRoot.createElement("code");
+    label.textContent = code;
+    key.append(label);
+    const description = documentRoot.createElement("dd");
+    description.textContent = copy.code ? copy.message : "No explanation is available for this status yet.";
+    row.append(key);
+    row.append(description);
+    container.append(row);
+  }
+}
+
+function diagnosticCode(value) {
+  if (typeof value !== "string") return "unrecognized_status";
+  if (!/^[a-z][a-z0-9_]{0,100}$/u.test(value)) return "unrecognized_status";
+  return value;
+}

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

@@ -0,0 +1,141 @@
+const genericMessage = "ABot Spark could not complete this review. No specific cause is available.";
+
+// Exact content-free codes only. Never turn an arbitrary provider error into UI copy.
+const groups = [
+  ["macOS Accessibility permission is required. Open Computer access for the exact companion executable to approve. Spark waits up to two minutes for your consent.", ["macos_accessibility_permission_required"]],
+  ["macOS Accessibility permission was removed. Re-enable access for the companion in Computer access, then stop and start collection.", ["macos_accessibility_permission_revoked"]],
+  ["macOS Accessibility permission was not granted within two minutes. Complete permission setup in Computer access, then stop and start collection to check again.", ["macos_accessibility_permission_timeout"]],
+  ["Collection is working through Windows accessibility. Some apps do not expose all visible content; this is a coverage limit, not a connection failure.", ["uia_application_coverage"]],
+  ["Collection is working through macOS accessibility. Some apps do not expose all visible content; this is a coverage limit, not a connection failure.", ["ax_application_coverage"]],
+  ["Collection is working through Linux accessibility. Some apps do not expose all visible content; this is a coverage limit, not a connection failure.", ["atspi_application_coverage", "wayland_atspi_coverage", "x11_atspi_coverage"]],
+  ["The current app is not exposing readable content. Collection can continue when readable content becomes available.", ["accessibility_read_unavailable", "focused_window_unavailable"]],
+  ["Rapid screen changes are temporarily muted to avoid collecting repeated activity. Collection resumes after switching windows, editing, or a quiet period.", ["continuous_activity"]],
+  ["Collection is paused because this application is excluded in Settings.", ["application_excluded"]],
+  ["Collection is paused while the screen is locked or a secure desktop is active.", ["screen_locked_or_secure_desktop", "screen_locked"]],
+  ["ABot's own interface is excluded from collection to avoid learning from its own output.", ["runtime_interface_excluded"]],
+  ["Collection is outside its configured hours. It resumes during the next collection window.", ["learning_outside_collection_window"]],
+  ["Processing is outside its configured hours. Pending activity is kept within its retention limit.", ["learning_outside_processing_window"]],
+  ["The computer has no accessible graphical session. Sign in to a desktop session to collect activity.", ["graphical_session_unavailable"]],
+  ["The collector cannot verify whether the screen is locked, so collection is paused.", ["session_lock_state_unavailable"]],
+  ["Linux accessibility dependencies are missing. Update Computer access setup on this computer.", ["linux_atspi_python_dependencies_missing"]],
+  ["Window-change events are unavailable. Collection is using accessibility events with reduced coverage.", ["x11_events_unavailable_atspi_only"]],
+  ["The Windows accessibility collector is unavailable. Check Computer access and its permissions.", ["windows_uia_helper_unavailable", "foreground_events_unavailable"]],
+  ["The proactive model's explanation was missing or invalid. That attempt did not create a suggestion; collection and learning are separate.", ["proactive_reason_invalid"]],
+  ["The proactive model returned an unreadable response. No suggestion was created.", ["proactive_output_invalid_json"]],
+  ["The proactive model returned a decision that could not be accepted. No suggestion was created.", ["proactive_decision_invalid", "proactive_none_payload_invalid"]],
+  ["The model could not complete a step of the proactive review. No suggestion was created.", ["proactive_staged_output_invalid", "proactive_staged_output_fields_invalid", "proactive_objective_invalid"]],
+  ["The proactive suggestion needs a valid title and message before it can be shown.", ["proactive_title_invalid", "proactive_message_invalid"]],
+  ["The proactive suggestion referred to missing, changed, or invalid knowledge. It was not delivered.", ["proactive_sources_invalid", "proactive_source_invalid", "proactive_source_stale_or_unknown", "proactive_source_duplicate", "proactive_sources_required"]],
+  ["The proactive suggestion had a missing or invalid expiry or review time. It was not delivered.", ["proactive_expiry_required", "proactive_time_invalid", "proactive_time_not_future", "proactive_time_too_distant", "proactive_reference_time_invalid"]],
+  ["Choose an available proactive model in Spark Settings before allowing or starting proactive mode.", ["proactive_model_required", "proactive_model_profile_unavailable", "proactive_model_profile_overridden"]],
+  ["The proactive review reached its time limit. No suggestion was created.", ["proactive_review_timeout"]],
+  ["Proactive mode has reached its daily message limit. It can send suggestions after the daily limit resets.", ["proactive_daily_message_limit_reached"]],
+  ["Proactive mode is outside its configured hours. It resumes during the next proactive window.", ["proactive_outside_window"]],
+  ["Proactive mode is turned off.", ["proactive_disabled"]],
+  ["The proactive review yielded resources to your active conversation.", ["proactive_interactive_preempted"]],
+  ["The proactive review was superseded by changed settings or knowledge.", ["proactive_superseded", "proactive_preferences_changed", "proactive_revision_conflict"]],
+  ["The proactive review was interrupted. The same knowledge is not retried automatically to avoid repeated model costs.", ["proactive_review_interrupted"]],
+  ["The suggestion could not be delivered to a conversation. Check the runtime connection.", ["proactive_session_delivery_unavailable"]],
+  ["The proactive activity could not start. Other ABot Spark activities can continue independently.", ["proactive_start_failed"]],
+  ["Saved proactive state could not be read safely.", ["proactive_state_invalid", "proactive_state_too_large"]],
+  ["The proactive review's context is too large for its allowed limit.", ["proactive_knowledge_context_too_large"]],
+  ["Proactive mode could not complete this review. No specific cause is available.", ["proactive_failed"]],
+  ["Scheduled knowledge review could not start. Other ABot Spark activities can continue independently.", ["learning_reassessment_start_failed"]],
+  ["Scheduled knowledge review is waiting for capacity.", ["learning_reassessment_capacity"]],
+  ["Scheduled knowledge review could not finish. Existing knowledge is kept.", ["learning_reassessment_failed"]],
+  ["Learning data cleanup could not finish. Check the runtime's storage access.", ["learning_maintenance_failed"]],
+  ["No computer is paired for learning. Connect a computer to start collecting.", ["host_not_paired"]],
+  ["The paired computer is disconnected. Reconnect it or open computer setup.", ["host_disconnected"]],
+  ["The computer connection is unavailable. Connect a computer for learning.", ["host_broker_unavailable"]],
+  ["This Host Companion cannot collect learning activity. Install the current companion.", ["host_observations_unsupported"]],
+  ["The paired computer did not respond. Check that its companion is running.", ["host_observation_connect_timeout"]],
+  ["A Host Companion connection is required to collect computer activity.", ["learning_host_unavailable"]],
+  ["The connected computer changed. Connect it again for learning.", ["learning_device_changed"]],
+  ["Another runtime is already collecting activity from this computer.", ["host_observations_already_owned"]],
+  ["The computer connection request was cancelled.", ["host_observation_cancelled"]],
+  ["Allow this activity in Spark Settings before starting it.", ["learning_activity_not_allowed"]],
+  ["Choose a learning model in Spark Settings before allowing or starting collection or learning.", ["learning_model_required"]],
+  ["The selected learning model is unavailable. Choose another model.", ["learning_model_profile_unavailable"]],
+  ["The selected learning model cannot be used for background learning. Choose another model.", ["learning_model_profile_overridden"]],
+  ["The learning model could not process activity. Check its configuration in Settings.", ["learning_model_request_failed"]],
+  ["The model did not finish its response.", ["output_incomplete"]],
+  ["This review reached its time limit before finishing.", ["learning_batch_timeout"]],
+  ["Long-term memory or its embedding model is unavailable. Check Memory settings.", ["learning_memory_unavailable"]],
+  ["Learning storage is unavailable. Check Memory settings.", ["learning_storage_unavailable"]],
+  ["Review progress could not be saved. Processing stopped to avoid repeating completed model work. Earlier saved progress is kept within its retention limit.", ["learning_review_progress_storage_unavailable", "learning_review_progress_capacity"]],
+  ["Saved review progress could not be read safely. No changes from this review were applied.", ["learning_review_progress_invalid"]],
+  ["Saved review progress reached its retention limit. This review cannot continue from that checkpoint.", ["learning_review_progress_expired"]],
+  ["The staged review could not continue safely. No changes from this review were applied.", ["co_worker_review_stage_limit_invalid", "co_worker_review_stage_order_invalid"]],
+  ["Collection was turned off.", ["learning_disabled"]],
+  ["Processing was paused. Pending activity remains subject to its retention limit.", ["learning_processing_paused"]],
+  ["The pending activity was deleted.", ["learning_pending_deleted"]],
+  ["Processing stopped before this review finished.", ["learning_stopped"]],
+  ["This activity reached its retention limit before the review finished.", ["learning_batch_expired"]],
+  ["This review yielded resources to an active conversation.", ["learning_interactive_preempted"]],
+  ["This review was superseded by a newer learning state.", ["learning_generation_superseded"]],
+  ["One observation is too large for the selected model's context window.", ["learning_observation_exceeds_context"]],
+  ["The selected model's context capacity is too small for this review. Choose a model with a larger context window.", [
+    "request_context_final_envelope_exceeds_window", "request_context_required_content_exceeds_budget", "learning_review_context_exceeds_budget",
+  ]],
+  ["Waiting in smaller batches to fit the selected model.", ["learning_batch_partitioned"]],
+  ["Waiting because processing is turned off for an application. Pending activity remains subject to expiry and storage limits.", ["learning_application_processing_excluded"]],
+  ["This review is waiting for queue space to split safely. Its observations remain pending within the retention limit.", ["learning_partition_capacity"]],
+  ["The review referred to activity that could not be verified.", [
+    "learning_proposal_source_unknown", "learning_decision_source_unknown", "learning_proposal_device_mismatch", "learning_proposal_source_required",
+  ]],
+  ["The underlying knowledge changed before this review could be saved.", ["learning_knowledge_conflict"]],
+  ["Learning needs its embeddings updated before this review can be saved.", ["learning_embedding_reindex_required"]],
+  ["The review tried to change a memory protected by a manual edit.", ["learning_memory_protected"]],
+  ["The review could not be saved because its receipt storage limit was reached.", ["learning_receipt_capacity"]],
+  ["The proposed memory duplicates an existing item and needs an update instead.", ["learning_duplicate_requires_bound_update"]],
+  ["The model returned an invalid request to create a new candidate.", ["learning_create_target_invalid"]],
+  ["The model returned a learning decision with missing or unsupported fields. This review was not saved.", ["learning_review_output_contract_invalid"]],
+  ["The model returned an unreadable response format.", ["learning_output_invalid_json"]],
+  ["The model returned the wrong response structure.", ["learning_output_object_required"]],
+  ["The model's response did not include its learning decisions.", ["learning_output_decisions_missing"]],
+  ["The model returned its learning decisions in the wrong format.", ["learning_output_decisions_not_array"]],
+  ["The model returned more learning decisions than this review allows.", ["learning_output_decision_limit"]],
+  ["The model returned a decision that could not be accepted.", [
+    "learning_action_invalid", "learning_decision_invalid", "learning_decision_list_invalid",
+    "learning_decisions_invalid", "learning_target_invalid", "learning_target_kind_invalid", "learning_review_action_invalid",
+    "learning_review_cause_invalid", "learning_reason_invalid", "learning_merge_binding_invalid", "invalid_learning_proposal",
+  ]],
+  ["The review referred to an item that could not be found.", ["learning_decision_target_unknown", "learning_merge_source_unknown"]],
+  ["The review requested more than one change to the same item.", ["learning_decision_target_repeated"]],
+  ["The model returned an invalid candidate score.", ["learning_score_invalid", "learning_certainty_invalid"]],
+  ["The model returned a reinforcement decision that could not be accepted.", ["learning_reinforcement_invalid"]],
+  ["The proposed content is not valid for a memory.", ["learning_content_invalid"]],
+  ["The proposed content exceeds the memory size limit.", ["learning_content_exceeds_limit"]],
+  ["The proposed memory was blocked because it may contain sensitive information.", ["learning_content_sensitive"]],
+  ["The candidate could not be saved because its identity conflicts with an existing item.", ["learning_candidate_identity_conflict", "learning_candidate_identity_duplicate"]],
+  ["The candidate expired before this review could update it.", ["learning_candidate_expired"]],
+  ["Some saved learning data could not be read safely.", [
+    "learning_candidate_certainty_corrupt", "learning_candidate_embedding_missing", "learning_candidate_score_corrupt",
+    "learning_candidate_vector_binding_corrupt", "learning_candidate_vector_corrupt", "learning_candidates_corrupt",
+    "learning_maturation_store_corrupt", "learning_receipts_corrupt", "invalid_learning_state",
+  ]],
+  ["The learning policy contains an invalid setting.", ["learning_maturation_policy_invalid"]],
+  ["The model returned an invalid future review time.", ["learning_reconsideration_invalid", "learning_reconsideration_not_future"]],
+  ["The review requested a change that is not allowed without new supporting activity.", ["learning_review_cannot_raise_score", "learning_review_cannot_reinforce"]],
+  ["The scheduled review included activity it was not allowed to use.", ["learning_review_observations_unexpected"]],
+  ["This item is not due for another review yet.", ["learning_review_target_not_due"]],
+  ["The embedding configuration changed during this review.", ["long_term_memory_embedding_binding_changed"]],
+  ["The embedding request contained no usable text.", ["long_term_memory_embedding_input_empty"]],
+  ["The embedding provider returned data that could not be used.", ["long_term_memory_embedding_response_invalid", "long_term_memory_embedding_vector_count_invalid"]],
+  ["The collected batch could not be read safely.", ["invalid_learning_batch", "invalid_learning_batch_expiry"]],
+  ["The daily model-call limit was reached. Eligible work can continue after it resets.", ["co_worker_model_daily_budget_exhausted"]],
+  ["The daily embedding-call limit was reached. Eligible work can continue after it resets.", ["co_worker_embedding_daily_budget_exhausted"]],
+  ["The daily embedding-text limit was reached. Eligible work can continue after it resets.", ["co_worker_embedding_character_budget_exhausted"]],
+  ["The available model capacity is busy. This review must wait.", ["co_worker_resources_busy"]],
+  ["Computer activity collection is not supported on this platform.", ["platform_unsupported"]],
+  ["Computer activity collection needs a dependency that is unavailable.", ["macos_swift_tools_unavailable", "collector_dependency_unavailable"]],
+  ["The computer activity collector could not start.", ["collector_start_failed"]],
+  ["The computer activity collector returned data that could not be accepted.", ["collector_output_limit", "collector_protocol_invalid"]],
+  [genericMessage, ["learning_failed"]],
+];
+const messages = Object.freeze(Object.fromEntries(groups.flatMap(([message, codes]) => codes.map(code => [code, message]))));
+
+export function learningFailureCopy(reason) {
+  if (typeof reason === "string" && Object.hasOwn(messages, reason)) return { message: messages[reason], code: reason };
+  return { message: genericMessage, code: null };
+}

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

@@ -0,0 +1,101 @@
+import { hostSetupIsReady } from "../system-host/rendering.js";
+import { agentMarkup, renderAgent } from "./agent-view.js";
+import { createAgentMotion } from "./agent-motion.js";
+import { renderLearningProposals, handleProposalClick } from "./proposal-view.js";
+import { learningFailurePresentation } from "./presentation.js";
+import { homeActivityStartPatch, readActivityPermissions } from "./activity-controls.js";
+import { computerUpdateNoticeMarkup, renderComputerUpdateNotice } from "./computer-update-notice.js";
+import { macCollectionRestartNoticeMarkup, renderMacCollectionRestartNotice, handleMacCollectionRestartClick } from "./macos-collection-restart-notice.js";
+
+function canStartHomeLearning(snapshot) {
+  if (!homeActivityStartPatch(snapshot)) return false;
+  if (snapshot.statusError || learningFailurePresentation(snapshot.status))
+    return false;
+  if (readActivityPermissions(snapshot.status.preferences).collection)
+    return hostSetupIsReady(snapshot.hostConnection);
+  return true;
+}
+
+function homeLearningActionLabel(snapshot) {
+  if (hasIndependentHomeActivity(snapshot.status)) return "Open ABot Spark";
+  return canStartHomeLearning(snapshot)
+    ? "Start ABot Spark"
+    : "Set up ABot Spark";
+}
+
+export function hasIndependentHomeActivity(status) {
+  if (status?.preferences?.enabled) return true;
+  if (status?.preferences?.proactiveEnabled) return true;
+  if (status?.preferences?.modelProfileId && !status.preferences.processingPaused) return true;
+  return Boolean(status?.processing);
+}
+
+export function createPassiveLearningHome({
+  actions,
+  openLearning,
+  openSetup = openLearning,
+  openComputerAccess = openSetup,
+}) {
+  let root = null;
+  let renderedSnapshot = {};
+  let motion;
+
+  function mount(nextRoot) {
+    if (root === nextRoot) return;
+    motion?.dispose();
+    root?.removeEventListener("click", handleClick);
+    root = nextRoot;
+    if (!root) return;
+    root.innerHTML = `${computerUpdateNoticeMarkup()}${macCollectionRestartNoticeMarkup()}
+    <div class="home-learning-agent">${agentMarkup({
+      compact: true,
+      actionMarkup: '<button type="button" class="home-text-button" data-learning-open>Open ABot Spark</button>',
+    })}</div>
+    <div class="co-worker-proposals" data-learning-proposals></div>
+    <p class="home-learning-status" data-learning-status hidden></p>`;
+    root.addEventListener("click", handleClick);
+    motion = createAgentMotion(root);
+  }
+
+  function handleClick(event) {
+    if (handleMacCollectionRestartClick(root, event, actions)) return;
+    const update = event.target.closest("[data-learning-open-update]");
+    if (update && root.contains(update)) {
+      openComputerAccess();
+      return;
+    }
+    if (handleProposalClick(root, event, actions)) return;
+    const button = event.target.closest("[data-learning-open]");
+    if (!button || !root.contains(button) || button.disabled) return;
+    const snapshot = actions?.snapshot?.() ?? renderedSnapshot;
+    if (snapshot.saving || snapshot.loadingStatus) return;
+    if (hasIndependentHomeActivity(snapshot.status)) {
+      openLearning();
+      return;
+    }
+    if (!canStartHomeLearning(snapshot)) {
+      openSetup();
+      return;
+    }
+    void actions.configure(homeActivityStartPatch(snapshot));
+  }
+
+  function render(snapshot) {
+    renderedSnapshot = snapshot;
+    if (!root) return;
+    renderComputerUpdateNotice(root, snapshot);
+    renderMacCollectionRestartNotice(root, snapshot);
+    renderAgent(root, snapshot);
+    renderLearningProposals(root, snapshot, { limit: 1 });
+    motion?.update(snapshot);
+    root.hidden = false;
+    const action = root.querySelector("[data-learning-open]");
+    action.textContent = homeLearningActionLabel(snapshot);
+    action.disabled = Boolean(snapshot.saving || snapshot.loadingStatus);
+    const error = root.querySelector("[data-learning-status]");
+    error.textContent = snapshot.statusError || "";
+    error.hidden = !snapshot.statusError;
+  }
+
+  return Object.freeze({ mount, render });
+}