@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/web-ui/app/components/composer-actions.js

@@ -8,6 +8,7 @@ export function createComposerActions({
   let menuOpen = false;
   let primaryAction = "send";
   let splitAvailable = false;
+  let stopCurrent = () => {};
 
   function closeMenu({ restoreFocus = false } = {}) {
     if (!menuOpen) return false;
@@ -29,12 +30,28 @@ export function createComposerActions({
 
   function render({
     activeRequestId,
+    waitingRequestId,
     attachmentCount = 0,
     busy = false,
     disabled = false,
     queuedCount = 0,
+    stopping = false,
+    onStop = () => {},
   }) {
     const requestActive = Boolean(String(activeRequestId || "").trim());
+    stopCurrent = onStop;
+    if (dom.stopButton) {
+      const stoppable = requestActive || Boolean(waitingRequestId);
+      dom.stopButton.hidden = !stoppable;
+      dom.stopButton.disabled = !stoppable || stopping;
+      dom.stopButton.title = stopping
+        ? "Stopping…"
+        : waitingRequestId
+          ? "Cancel waiting request"
+          : "Stop response";
+      dom.stopButton.setAttribute("aria-label", dom.stopButton.title);
+      dom.stopButton.setAttribute("aria-busy", String(stopping));
+    }
     const hasAttachments = Number(attachmentCount) > 0;
     primaryAction = resolveComposerPrimaryAction(
       activeRequestId,
@@ -80,6 +97,9 @@ export function createComposerActions({
   }
 
   function bind() {
+    dom.stopButton?.addEventListener("click", () => {
+      if (!dom.stopButton.disabled) stopCurrent();
+    });
     dom.sendNextMenuButton.addEventListener("click", () => {
       if (!splitAvailable || dom.sendNextMenuButton.disabled) return;
       menuOpen = !menuOpen;

package/dist/src/web-ui/app/components/composer-context-window.js

@@ -28,7 +28,19 @@ export function buildComposerContextWindowModel({
 }
 
 function compactNumber(value) {
-  return new Intl.NumberFormat("en", { notation: "compact" }).format(value);
+  return new Intl.NumberFormat("en", {
+    notation: "compact",
+    maximumFractionDigits: 1,
+  }).format(value);
+}
+
+function providerUsageText(usage) {
+  if (!usage) return "";
+  const parts = ["input", "output", "total"].flatMap((kind) => {
+    const value = usage[`${kind}Tokens`];
+    return value === undefined ? [] : [`${compactNumber(value)} ${kind}`];
+  });
+  return parts.length ? `Provider reported ${parts.join(" · ")} tokens` : "";
 }
 
 function formatPercent(value) {
@@ -58,7 +70,7 @@ export function createComposerContextWindow({
   const header = documentRoot.createElement("div");
   header.className = "composer-context-window-header";
   const title = documentRoot.createElement("span");
-  title.textContent = "Context window";
+  title.textContent = "Latest measured model attempt";
   const percentage = documentRoot.createElement("span");
   percentage.className = "composer-context-window-percentage";
   header.append(title, percentage);
@@ -114,7 +126,9 @@ export function createComposerContextWindow({
     percentage.textContent = "";
     detail.textContent = "";
     compaction.textContent = "";
+    compaction.hidden = true;
     provider.textContent = "";
+    provider.hidden = true;
   }
 
   function render(model) {
@@ -129,25 +143,22 @@ export function createComposerContextWindow({
       model.admissionOutcome === "rejected",
     );
     const usedPercent = formatPercent(model.usedContextPercent);
-    button.setAttribute("aria-label", `Context window: ${usedPercent} used`);
+    button.setAttribute(
+      "aria-label",
+      `Latest measured model attempt: ${model.inputTokens.toLocaleString("en")} / ${model.contextWindowTokens.toLocaleString("en")} ${model.measurementKind} input tokens, ${usedPercent} used, ${formatPercent(model.remainingContextPercent)} left, ${model.modelStep}, ${model.profileId}`,
+    );
     ring.style.setProperty(
       "--context-used",
       `${Math.max(0, Math.min(100, model.usedContextPercent))}%`,
     );
     percentage.textContent = usedPercent;
-    detail.textContent = `${compactNumber(model.estimatedInputTokens)} / ${compactNumber(
-      model.contextWindowTokens,
-    )} estimated input tokens · ${formatPercent(model.remainingContextPercent)} left · ${
-      model.modelStep || model.profileId
-    }`;
+    detail.textContent = `${compactNumber(model.inputTokens)} / ${compactNumber(model.contextWindowTokens)} ${model.measurementKind} input tokens · ${formatPercent(model.remainingContextPercent)} left · ${model.modelStep} · ${model.profileId}`;
     compaction.hidden = !model.compaction;
     compaction.textContent = model.compaction
-      ? `Compaction ${formatPercent(model.compaction.beforePercent)} → ${formatPercent(model.compaction.afterPercent)}`
-      : "";
-    provider.hidden = !model.providerUsage;
-    provider.textContent = model.providerUsage
-      ? `Provider reported ${compactNumber(model.providerUsage.inputTokens)} input · ${compactNumber(model.providerUsage.outputTokens)} output tokens`
+      ? `Last compaction (${model.compaction.modelStep} · ${model.compaction.profileId}) ${formatPercent(model.compaction.beforePercent)} → ${formatPercent(model.compaction.afterPercent)}`
       : "";
+    provider.textContent = providerUsageText(model.providerUsage);
+    provider.hidden = !provider.textContent;
   }
 
   reset();

package/dist/src/web-ui/app/components/config-workspace/calibration-disclosure.js

@@ -0,0 +1,39 @@
+function calibrationExpansionTarget(state, details) {
+  const sectionKey = details?.dataset?.calibrationSectionKey;
+  if (sectionKey)
+    return { key: sectionKey, expanded: state.expandedCalibrationSections };
+  const profileKey = details?.dataset?.calibrationKey;
+  if (profileKey)
+    return { key: profileKey, expanded: state.expandedCalibrationKeys };
+  return null;
+}
+
+export function rememberCalibrationDisclosure(state, details) {
+  const target = calibrationExpansionTarget(state, details);
+  if (!target) return;
+  if (details.open) {
+    target.expanded.add(target.key);
+    return;
+  }
+  target.expanded.delete(target.key);
+}
+
+export function createConfigCalibrationDisclosure({ state, root }) {
+  let active = false;
+
+  function setActive(nextActive) {
+    const enteringConfig = nextActive && !active;
+    active = nextActive;
+    if (!enteringConfig) return;
+
+    state.expandedCalibrationKeys.clear();
+    state.expandedCalibrationSections.clear();
+    for (const details of root.querySelectorAll(
+      "details[data-calibration-key], details[data-calibration-section-key]",
+    )) {
+      details.open = false;
+    }
+  }
+
+  return { setActive };
+}

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

@@ -5,12 +5,9 @@ import {
 import { textOf } from "../../lib/text-format.js";
 
 export const CONFIG_CATEGORIES = [
-  "memory",
-  "pipeline",
   "models",
   "plugins",
-  "computer",
-  "advanced",
+  "operations",
 ];
 
 const DEFAULT_MODEL_EXECUTION_POLICY = "supervisor-worker-v1";
@@ -135,9 +132,10 @@ export function createConfigWorkspaceModel() {
     savingKeys: new Set(),
     savedKeys: new Set(),
     expandedCalibrationKeys: new Set(),
+    expandedCalibrationSections: new Set(),
     selectedConfigModelId: "",
     selectedRawConfigKey: "",
-    activeCategory: "memory",
+    activeCategory: "models",
     rawPanelOpen: false,
     loadGeneration: 0,
     loading: false,

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

@@ -117,32 +117,16 @@ export function createConfigDashboardRendering({
     `;
   }
 
-  function renderCategoryTab(category, label) {
-    const active = state.activeCategory === category;
-    return `
-      <button
-        id="configCategory${category[0].toUpperCase()}${category.slice(1)}"
-        class="config-category-tab ${active ? "active" : ""}"
-        type="button"
-        role="tab"
-        data-config-action="select-category"
-        data-config-category="${escapeAttribute(category)}"
-        aria-controls="config${category[0].toUpperCase()}${category.slice(1)}Panel"
-        aria-selected="${active ? "true" : "false"}"
-        tabindex="${active ? "0" : "-1"}"
-      >${escapeHtml(label)}</button>
-    `;
-  }
-
   function renderCategoryPanel(category, content) {
     const capitalized = `${category[0].toUpperCase()}${category.slice(1)}`;
+    const label = category === "operations" ? "System" : capitalized;
     const active = state.activeCategory === category;
     return `
       <section
         id="config${capitalized}Panel"
         class="config-category-panel ${active ? "active" : ""}"
-        role="tabpanel"
-        aria-labelledby="configCategory${capitalized}"
+        role="region"
+        aria-label="${escapeAttribute(label)}"
         data-config-category-panel="${escapeAttribute(category)}"
         ${active ? "" : "hidden"}
       >${content}</section>
@@ -151,7 +135,6 @@ export function createConfigDashboardRendering({
 
   return {
     renderCategoryPanel,
-    renderCategoryTab,
     renderConfigMap,
   };
 }

package/dist/src/web-ui/app/components/config-workspace/model-removal.js

@@ -0,0 +1,105 @@
+function isDefinitiveModelRemovalRejection(error) {
+  const status = error?.status;
+  if (!Number.isInteger(status)) return false;
+  if (status < 400 || status >= 500) return false;
+  return typeof error.payload?.error === "string";
+}
+
+function modelIsStillRegistered(payload, profileId) {
+  const profiles = payload?.dashboard?.files?.runtime?.config?.models?.profiles;
+  if (!profiles || typeof profiles !== "object")
+    throw new Error("The Runtime model declarations could not be read.");
+  if (Array.isArray(profiles))
+    throw new Error("The Runtime model declarations could not be read.");
+  return Object.hasOwn(profiles, profileId);
+}
+
+/** Declaration removal shares Configuration's dirty-state and mutation guards. */
+export function createModelRemovalController({
+  removeModel,
+  loadDashboard,
+  getEnvironmentId,
+  beginRuntimeMutation,
+  endRuntimeMutation,
+  refreshRuntimeConfig,
+  onSaved,
+  setStatus,
+  confirmRemoval = (message) => window.confirm(message),
+}) {
+  let pending = false;
+
+  async function finishConfirmedRemoval(environmentId) {
+    try {
+      if (environmentId !== getEnvironmentId()) {
+        setStatus(
+          "Model removed in the previous environment. Reopen it to apply the saved change.",
+        );
+        return true;
+      }
+      onSaved();
+      const refreshed = await refreshRuntimeConfig(
+        "Model removed; refresh required",
+      );
+      if (refreshed)
+        setStatus("Model removed. Apply changes when your agent is idle.");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setStatus(`Model removed; refresh required: ${message}`, "error-text");
+    }
+    return true;
+  }
+
+  async function reconcileUncertainRemoval(profileId, environmentId, error) {
+    let stillRegistered;
+    try {
+      stillRegistered = modelIsStillRegistered(
+        await loadDashboard(environmentId),
+        profileId,
+      );
+    } catch {
+      setStatus(
+        "Model removal could not be confirmed. Refresh Configuration before trying again.",
+        "error-text",
+      );
+      return false;
+    }
+    if (!stillRegistered) return finishConfirmedRemoval(environmentId);
+    setStatus(
+      error instanceof Error ? error.message : String(error),
+      "error-text",
+    );
+    return false;
+  }
+
+  async function remove({ profileId, label, expectedRevision }) {
+    if (pending) return false;
+    if (!beginRuntimeMutation("model removal")) return false;
+    const environmentId = getEnvironmentId();
+    pending = true;
+    try {
+      if (
+        !confirmRemoval(
+          `Remove ${label || profileId} from configured models? Its model file, provider and credentials will be kept.`,
+        )
+      )
+        return false;
+      try {
+        await removeModel({ profileId, expectedRevision }, environmentId);
+      } catch (error) {
+        if (!isDefinitiveModelRemovalRejection(error))
+          return await reconcileUncertainRemoval(profileId, environmentId, error);
+        setStatus(
+          error instanceof Error ? error.message : String(error),
+          "error-text",
+        );
+        return false;
+      }
+      return await finishConfirmedRemoval(environmentId);
+    } finally {
+      pending = false;
+      endRuntimeMutation();
+    }
+  }
+
+  return { remove };
+}

package/dist/src/web-ui/app/components/config-workspace/model-rendering.js

@@ -2,6 +2,18 @@ import { configRequiresRawRepair } from "./raw-config-repair.js";
 import { escapeAttribute, escapeHtml, textOf } from "../../lib/text-format.js";
 import { isConfigObject } from "./config-model.js";
 
+function modelListStatus(model, hasImage) {
+  if (model.registered === false) return "Not registered";
+  return hasImage ? "image input" : "text input";
+}
+
+function renderModelRegistrationAction(model) {
+  if (model.registered === false)
+    return '<p class="muted">Not registered in the saved configuration. This file is kept for reference.</p>';
+  if (model.registered !== true) return "";
+  return `<button type="button" data-config-action="remove-model" data-id="${escapeAttribute(model.id)}">Remove model</button>`;
+}
+
 export function createConfigModelRendering({
   state,
   calibrationProfileLabel,
@@ -40,7 +52,7 @@ export function createConfigModelRendering({
                 <span>${escapeHtml(model.config?.label || model.id)}</span>
                 <small>
                   <span>${escapeHtml(model.config?.provider || "-")}</span>
-                  <span>${escapeHtml(hasImage ? "image input" : "text input")}</span>
+                  <span>${escapeHtml(modelListStatus(model, hasImage))}</span>
                 </small>
               </button>
             `;
@@ -153,11 +165,13 @@ export function createConfigModelRendering({
       return '<div class="empty-state compact">No model configs found</div>';
     }
     state.selectedConfigModelId = model.id;
-    if (configRequiresRawRepair(
-      model,
-      state.appliedJsonRepairKeys.has(configFileKey(model)),
-    ))
-      return '<p class="error-text">Repair this linked file in Advanced → Raw JSON before editing model settings.</p>';
+    if (
+      configRequiresRawRepair(
+        model,
+        state.appliedJsonRepairKeys.has(configFileKey(model)),
+      )
+    )
+      return `${renderModelRegistrationAction(model)}<p class="error-text">Repair this linked file in the configuration repair section before editing model settings.</p>`;
     const calibration = isConfigObject(model.config?.calibration)
       ? model.config.calibration
       : {};
@@ -165,6 +179,10 @@ export function createConfigModelRendering({
       .sort(([left], [right]) => left.localeCompare(right))
       .map(([stepId, profile]) => renderCalibrationCard(model, stepId, profile))
       .join("");
+    const calibrationSectionKey = configFileKey(model);
+    const calibrationSectionExpanded = state.expandedCalibrationSections.has(
+      calibrationSectionKey,
+    );
     const availableCalibrationProfiles = configStepOptions().filter(
       (step) => !Object.prototype.hasOwnProperty.call(calibration, step),
     );
@@ -180,12 +198,21 @@ export function createConfigModelRendering({
             )}</p>
             <code>${escapeHtml(model.path)}</code>
           </div>
-          ${renderFileActions(model)}
+          <div class="config-file-actions">
+            ${renderFileActions(model)}
+            ${renderModelRegistrationAction(model)}
+          </div>
         </div>
         <div class="config-form-panel">
-          <div class="config-form-panel-title">
-            <strong>Model defaults</strong>
-            <span>Provider, generation, and base context limits.</span>
+          <div class="config-form-panel-title config-model-defaults-title">
+            <div class="config-model-defaults-heading">
+              <strong>Model defaults</strong>
+              ${renderConfigInput(model, ["supportsThinking"], {
+                type: "boolean",
+                label: "Supports reasoning controls",
+              })}
+            </div>
+            <span>Unchecked uses the provider’s default reasoning; it does not disable thinking. When supported, the request mode and reasoning settings choose the effort.</span>
           </div>
           <div class="config-field-grid model-basics">
             <label><span>Label</span>${renderConfigInput(model, ["label"])}</label>
@@ -195,10 +222,6 @@ export function createConfigModelRendering({
               { type: "select", values: configProviderOptions() },
             )}</label>
             <label><span>Model</span>${renderConfigInput(model, ["model"])}</label>
-            ${renderConfigInput(model, ["supportsThinking"], {
-              type: "boolean",
-              label: "Thinking",
-            })}
             <label><span>Temperature</span>${renderConfigInput(
               model,
               ["generation", "temperature"],
@@ -217,38 +240,44 @@ export function createConfigModelRendering({
           </div>
           ${renderExecutionRoute(model)}
         </div>
-        <div class="config-subheader">
-          <div>
+        <details
+          class="config-calibration-section"
+          data-calibration-section-key="${escapeAttribute(calibrationSectionKey)}"
+          ${calibrationSectionExpanded ? "open" : ""}
+        >
+          <summary class="config-calibration-section-title">
             <span>Invocation calibration</span>
             <small>${escapeHtml(
               Object.keys(calibration).length === 1
                 ? "1 profile"
                 : `${Object.keys(calibration).length} profiles`,
             )}</small>
+          </summary>
+          <div class="config-calibration-section-body">
+            <div class="config-add-row compact">
+              <label>
+                <span>Add profile</span>
+                <select data-new-calibration-key>
+                  <option value="">Choose invocation profile</option>
+                  ${renderSelectOptions(availableCalibrationProfiles)}
+                </select>
+              </label>
+              <button
+                type="button"
+                data-config-action="add-calibration"
+                data-kind="model"
+                data-id="${escapeAttribute(model.id)}"
+                ${availableCalibrationProfiles.length ? "" : "disabled"}
+              >Add</button>
+            </div>
+            <div class="config-calibration-grid">
+              ${
+                calibrationCards ||
+                '<div class="empty-state compact">No calibration entries</div>'
+              }
+            </div>
           </div>
-          <div class="config-add-row compact">
-            <label>
-              <span>Add profile</span>
-              <select data-new-calibration-key>
-                <option value="">Choose invocation profile</option>
-                ${renderSelectOptions(availableCalibrationProfiles)}
-              </select>
-            </label>
-            <button
-              type="button"
-              data-config-action="add-calibration"
-              data-kind="model"
-              data-id="${escapeAttribute(model.id)}"
-              ${availableCalibrationProfiles.length ? "" : "disabled"}
-            >Add</button>
-          </div>
-        </div>
-        <div class="config-calibration-grid">
-          ${
-            calibrationCards ||
-            '<div class="empty-state compact">No calibration entries</div>'
-          }
-        </div>
+        </details>
       </section>
     `;
   }

package/dist/src/web-ui/app/components/config-workspace/model-setup-entry.js

@@ -1,4 +1,4 @@
-import { escapeAttribute, escapeHtml } from "../../lib/text-format.js";
+import { escapeHtml } from "../../lib/text-format.js";
 import { isConfigObject } from "./config-model.js";
 
 export function renderModelSetupEntry(runtime, models) {
@@ -10,10 +10,13 @@ export function renderModelSetupEntry(runtime, models) {
       const count = models.filter(
         (model) => model.config?.provider === id,
       ).length;
+      const providerType = String(provider.type || "");
+      const hasDistinctProviderType =
+        providerType.length > 0 &&
+        providerType.toLowerCase() !== id.toLowerCase();
       return `<article class="config-provider-card">
-        <div><h3>${escapeHtml(id)}</h3><span>${escapeHtml(provider.type || "Provider")}</span></div>
+        <div class="config-provider-identity"><h3>${escapeHtml(id)}</h3>${hasDistinctProviderType ? `<span>${escapeHtml(providerType)}</span>` : ""}</div>
         <footer><span>${count} ${count === 1 ? "model" : "models"}</span>
-          <button type="button" data-config-action="add-model" data-provider-id="${escapeAttribute(id)}" aria-label="${escapeAttribute(`Add model to ${id}`)}">Add model</button>
         </footer>
       </article>`;
     })

package/dist/src/web-ui/app/components/config-workspace/raw-config-repair.js

@@ -18,7 +18,7 @@ export function selectMalformedConfigForRepair(state, files, configFileKey) {
   const file = files.find((entry) => configRequiresRawRepair(entry));
   if (!file) return;
   state.selectedRawConfigKey = configFileKey(file);
-  state.activeCategory = "advanced";
+  state.activeCategory = "models";
   state.rawPanelOpen = true;
 }
 

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

@@ -1,15 +1,13 @@
+import { rememberCalibrationDisclosure } from "./calibration-disclosure.js";
 import { textOf } from "../../lib/text-format.js";
-import {
-  CONFIG_CATEGORIES,
-  resolveModelExecutionRoute,
-} from "./config-model.js";
+import { resolveModelExecutionRoute } from "./config-model.js";
 
 export function createConfigWorkspaceEvents({
   state,
   dom,
   eventTarget,
   onAddModel,
-  activateCategory,
+  onRemoveModel,
   applyRawDraft,
   changeRawFile,
   configFileKey,
@@ -102,43 +100,13 @@ export function createConfigWorkspaceEvents({
     }
   }
 
-  function handleCategoryKeydown(event, element) {
-    const keys = ["ArrowLeft", "ArrowRight", "Home", "End"];
-    if (!keys.includes(event.key)) return;
-    event.preventDefault();
-    const currentIndex = CONFIG_CATEGORIES.indexOf(
-      element.dataset.configCategory,
-    );
-    let nextIndex = currentIndex;
-    if (event.key === "Home") nextIndex = 0;
-    if (event.key === "End") nextIndex = CONFIG_CATEGORIES.length - 1;
-    if (event.key === "ArrowLeft") {
-      nextIndex =
-        (currentIndex - 1 + CONFIG_CATEGORIES.length) %
-        CONFIG_CATEGORIES.length;
-    }
-    if (event.key === "ArrowRight") {
-      nextIndex = (currentIndex + 1) % CONFIG_CATEGORIES.length;
-    }
-    activateCategory(CONFIG_CATEGORIES[nextIndex], { focus: true });
-  }
-
-  function handleDashboardKeydown(event) {
-    if (dashboardIsBusy()) return;
-    const element = event.target?.closest?.("[data-config-category]");
-    if (element) handleCategoryKeydown(event, element);
-  }
-
   function handleDashboardToggle(event) {
     const details = event.target;
     if (details?.id === "configRawPanel") {
       state.rawPanelOpen = details.open;
       return;
     }
-    const key = details?.dataset?.calibrationKey;
-    if (!key) return;
-    if (details.open) state.expandedCalibrationKeys.add(key);
-    else state.expandedCalibrationKeys.delete(key);
+    rememberCalibrationDisclosure(state, details);
   }
 
   function stepMappingIsComplete(step, profile) {
@@ -184,21 +152,31 @@ export function createConfigWorkspaceEvents({
     );
   }
 
+  function handleRemoveModelAction(id) {
+    const file = findConfigFile("model", id);
+    if (file?.registered !== true) return;
+    onRemoveModel?.({
+      profileId: file.id,
+      label: file.config?.label || file.id,
+      expectedRevision: state.configDashboard?.files?.runtime?.revision,
+    });
+  }
+
   function handleDashboardClick(event) {
-    if (dashboardIsBusy()) return;
     const element = event.target?.closest?.("[data-config-action]");
     if (!element) return;
     const action = element.dataset.configAction;
     const kind = element.dataset.kind;
     const id = element.dataset.id;
-    if (action === "select-category") {
-      activateCategory(element.dataset.configCategory || "memory");
-      return;
-    }
+    if (dashboardIsBusy()) return;
     if (action === "add-model") {
       onAddModel?.({ providerId: element.dataset.providerId || undefined });
       return;
     }
+    if (action === "remove-model") {
+      handleRemoveModelAction(id);
+      return;
+    }
     if (action === "select-model") {
       state.selectedConfigModelId = element.dataset.modelId || "";
       renderConfigDashboard();
@@ -267,7 +245,6 @@ export function createConfigWorkspaceEvents({
     dom.configDashboard.addEventListener("input", handleDashboardInput);
     dom.configDashboard.addEventListener("input", handleRawEditorInput);
     dom.configDashboard.addEventListener("change", handleDashboardChange);
-    dom.configDashboard.addEventListener("keydown", handleDashboardKeydown);
     dom.configDashboard.addEventListener("toggle", handleDashboardToggle, true);
     eventTarget.addEventListener?.("beforeunload", handleBeforeUnload);
   }

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

@@ -34,7 +34,7 @@ export function createConfigWorkspaceMutations({
     const key = configFileKey(file);
     if (configRequiresRawRepair(file, state.appliedJsonRepairKeys.has(key))) {
       setWorkspaceStatus(
-        "Repair this file in Advanced → Raw JSON before editing its fields.",
+        "Repair this file in the configuration repair section before editing its fields.",
         "error-text",
       );
       return;

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

@@ -14,7 +14,6 @@ export function createConfigWorkspacePersistence({
   memorySetup,
   memoryManagement,
   pluginManagement,
-  hostConnection,
   recordControlEvent,
   applyRawDraft,
   baselineFor,
@@ -93,7 +92,6 @@ export function createConfigWorkspacePersistence({
       replaceDashboard(payload);
       const memoryLoads = [memoryManagement.load()];
       if (pluginManagement) memoryLoads.push(pluginManagement.load());
-      if (hostConnection) memoryLoads.push(hostConnection.load());
       if (options.loadMemorySetup !== false) {
         memoryLoads.unshift(memorySetup.load());
       }