@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/app/components/system-host/windows-store-setup.js

@@ -0,0 +1,293 @@
+import { escapeHtml } from "../../lib/text-format.js";
+import { renderConnectionCard, renderComputerMetadata } from "./connection-card.js";
+
+const companionStoreUrl = "https://apps.microsoft.com/detail/9PK2FDQQLQS9";
+
+export function windowsStoreSetupIsAvailable(snapshot) {
+  const readiness = snapshot?.readiness;
+  if (readiness?.ready === true) return false;
+  if (!readiness?.platforms?.includes("windows")) return false;
+  if (readiness.restartRequired === true) return false;
+  return ["setup_required", "companion"].includes(readiness.route);
+}
+
+export function windowsStorePanelIsAvailable(snapshot) {
+  if (windowsStoreSetupIsAvailable(snapshot)) return true;
+  if (snapshot?.readiness?.restartRequired === true) return false;
+  if (snapshot?.readiness?.route !== "companion") return false;
+  if (snapshot.readiness.ready !== true) return false;
+  return snapshot.identity?.os === "windows";
+}
+
+function windowsCompanionCanReconnect(snapshot) {
+  if (!windowsStoreSetupIsAvailable(snapshot)) return false;
+  if (snapshot?.paired !== true) return false;
+  return snapshot.connected === false;
+}
+
+function hasConfirmedUnpairedConnection(snapshot) {
+  if (snapshot?.ok === false) return false;
+  if (snapshot?.paired !== false) return false;
+  return snapshot.connected === false;
+}
+
+function storeInvitationIsCurrent(invitation) {
+  if (!invitation) return false;
+  return Date.parse(invitation.expiresAt) > Date.now();
+}
+
+function storeRepairConfirmationIsCurrent(snapshot, attempt) {
+  if (!windowsCompanionCanReconnect(snapshot)) return false;
+  return attempt?.phase === "confirm-repair";
+}
+
+function storeConnectionStage(snapshot, invitation, attempt) {
+  if (snapshot?.readiness?.ready === true) return "ready";
+  if (attempt?.phase === "repairing") return "repairing";
+  if (storeRepairConfirmationIsCurrent(snapshot, attempt)) return "confirm-repair";
+  if (windowsCompanionCanReconnect(snapshot)) return "reconnect";
+  if (attempt?.expiresAt && Date.parse(attempt.expiresAt) <= Date.now()) return "expired";
+  if (attempt?.phase === "preparing") return "preparing";
+  if (attempt?.phase === "waiting") return "waiting";
+  if (storeInvitationIsCurrent(invitation)) return "open";
+  if (attempt?.phase === "expired") return "expired";
+  return "start";
+}
+
+function connectionButton(label, disabled, secondary = false) {
+  return `<button type="button" class="system-host-card-${secondary ? "secondary" : "primary"}" data-system-host-store-connect ${disabled ? "disabled" : ""}>${label}</button>`;
+}
+
+function companionLaunchLink(invitation, secondary = false) {
+  return `<a class="system-host-card-${secondary ? "secondary" : "primary"}" href="${escapeHtml(invitation.launchUrl)}" data-system-host-store-launch rel="noreferrer">${secondary ? "Open Companion again" : "Open Companion"}</a>`;
+}
+
+function connectionStageContent(stage, snapshot, invitation, disabled) {
+  if (stage === "ready") return {
+    status: "Connected", step: "Your computer is ready", copy: "You can use computer tools from your ABot chat.",
+  };
+  if (stage === "reconnect") return {
+    status: "Offline", step: "Your computer is offline", copy: `Open Companion on ${snapshot?.identity?.name || "your computer"} to reconnect.`,
+    action: `<a class="system-host-card-primary" href="abot-companion://open" data-system-host-store-open-existing rel="noreferrer">Open Companion</a><button type="button" class="system-host-card-secondary" data-system-host-store-repair ${disabled ? "disabled" : ""}>Set up again</button>`,
+    help: "Removed the connection in Companion? Choose Set up again.",
+  };
+  if (stage === "confirm-repair") return {
+    status: "Confirm reset", step: "Set up this computer again?", copy: "The previous connection will be removed. You’ll approve a new connection in Companion.",
+    action: `<button type="button" class="system-host-card-primary" data-system-host-store-repair-confirm ${disabled ? "disabled" : ""}>Continue</button><button type="button" class="system-host-card-secondary" data-system-host-store-repair-cancel ${disabled ? "disabled" : ""}>Cancel</button>`,
+    help: "Your conversations and saved insights will be kept.",
+  };
+  if (stage === "repairing") return {
+    status: "Preparing", step: "Setting up this computer again", copy: "Removing the previous connection before preparing your new connection…",
+    action: '<button type="button" class="system-host-card-primary" disabled>Preparing connection…</button>',
+  };
+  if (stage === "preparing") return {
+    status: "Preparing", step: "Connect your Windows computer", copy: "Preparing your connection…",
+    action: connectionButton("Preparing connection…", true),
+  };
+  if (stage === "open") return {
+    status: "Waiting for you", step: "Approve the connection in Companion", copy: "Open the app and check the ABot address. This page will confirm when your computer is connected.",
+    action: companionLaunchLink(invitation),
+    help: "Your browser may ask permission to open the app.",
+  };
+  if (stage === "waiting") return {
+    status: "Waiting for approval", step: "Approve the connection in Companion", copy: "Check the ABot address and approve the connection in the app. This page will confirm when your computer is connected.",
+    help: "If Companion did not open, use the option below.",
+    action: storeInvitationIsCurrent(invitation)
+      ? companionLaunchLink(invitation, true)
+      : connectionButton("Start connection again", disabled, true),
+  };
+  if (stage === "expired") return {
+    status: "Expired", step: "Connection link expired", copy: "Connect again to get a fresh invitation.",
+    action: connectionButton("Connect again", disabled),
+  };
+  const update = snapshot?.readiness?.companionUpdateRequired === true;
+  return {
+    status: update ? "Update needed" : "Not connected",
+    step: update ? "Update Companion" : "Connect your Windows computer",
+    copy: update ? "Update Companion from Microsoft Store, then return here to reconnect."
+      : "Companion lets ABot work with files, apps and desktop tools on this computer.",
+    action: `<a class="system-host-card-primary" href="${companionStoreUrl}" target="_blank" rel="noopener noreferrer"><svg class="system-host-store-icon" width="18" height="18" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><path d="M4 7h16v14H4ZM8 7V5a4 4 0 0 1 8 0v2" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linejoin="round"/><path d="M8 10h3v3H8Zm5 0h3v3h-3Zm-5 5h3v3H8Zm5 0h3v3h-3Z" fill="currentColor"/></svg><span>${update ? "Update in Microsoft Store" : "Install from Microsoft Store"}</span></a>${connectionButton(update ? "I already updated it" : "I already have it", disabled, true)}`,
+    help: update ? "Your saved connection is kept during an update." : "Install once from Microsoft Store, then return here to connect.",
+  };
+}
+
+function storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable) {
+  if (statusUnavailable) return {
+    status: "Status unavailable", step: "Check your computer connection",
+    copy: "The current connection status could not be checked. Refresh to try again.",
+  };
+  if (disabled && stage === "ready") return {
+    status: "Checking", step: "Checking your computer connection",
+    copy: "Waiting for the current connection status…",
+  };
+  return connectionStageContent(stage, snapshot, invitation, disabled);
+}
+
+function shouldRenderReadyWindowsSummary(compact, ready, error, message, otherSetup) {
+  if (!compact || !ready) return false;
+  if (error || message || otherSetup) return false;
+  return true;
+}
+
+export function renderWindowsStoreSetup({ snapshot, invitation, attempt, disabled, statusUnavailable, error, message, compact, otherSetup = "" }) {
+  if (!windowsStorePanelIsAvailable(snapshot)) return "";
+  const stage = storeConnectionStage(snapshot, invitation, attempt);
+  const content = storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable);
+  const ready = stage === "ready" && !statusUnavailable && !disabled;
+  const summary = shouldRenderReadyWindowsSummary(compact, ready, error, message, otherSetup);
+  const refresh = statusUnavailable || error ? '<button type="button" class="system-host-card-secondary" data-system-host-refresh' + (disabled ? " disabled" : "") + '>Refresh status</button>' : "";
+  return renderConnectionCard({
+    title: content.step, status: content.status, ready, disabled,
+    compact: summary,
+    description: content.copy, actions: content.action, help: content.help, error, message,
+    metadata: ["ready", "reconnect"].includes(stage) ? renderComputerMetadata(snapshot, disabled) : "",
+    details: summary ? "" : (ready ? '<p class="system-host-card-access-note">Computer actions follow your permission settings. Spark collection is managed separately.</p>' : "") + refresh + otherSetup,
+    attributes: `data-system-host-store-setup data-system-host-store-stage="${stage}"`,
+  });
+}
+
+function readStoreInvitation(receipt) {
+  if (!storeInvitationIsCurrent(receipt)) throw new Error("store_invitation_expired");
+  const launch = new URL(receipt.launchUrl);
+  if (launch.protocol !== "abot-companion:") throw new Error("store_invitation_invalid");
+  if (launch.hostname !== "connect") throw new Error("store_invitation_invalid");
+  if (launch.username || launch.password || launch.port || launch.hash) throw new Error("store_invitation_invalid");
+  if (launch.pathname !== "" && launch.pathname !== "/") throw new Error("store_invitation_invalid");
+  if (!/^[A-Za-z0-9_-]+$/.test(launch.searchParams.get("invitation") || "")) throw new Error("store_invitation_invalid");
+  if (receipt.storeUrl !== companionStoreUrl) throw new Error("store_invitation_invalid");
+  return { launchUrl: launch.href, expiresAt: receipt.expiresAt };
+}
+
+/** The invitation exists only on the active surface, until readiness or expiry. */
+export function createWindowsStoreConnectionActions({
+  state,
+  requestStoreConnection,
+  revokeConnection,
+  receiveUnpairedConnection,
+  canInstallOnPlatform,
+  beginRequest,
+  finishRequest,
+  isCurrentResponse,
+  getSurfaceRevision,
+  getEnvironmentId = () => "",
+  isVisible,
+  notify,
+  scheduleExpiration = setTimeout,
+  cancelExpiration = clearTimeout,
+}) {
+  let expirationTimer;
+  function clear({ preserveWaiting = false } = {}) {
+    if (expirationTimer !== undefined) cancelExpiration(expirationTimer);
+    expirationTimer = undefined;
+    if (state.windowsStoreInvitation) state.message = "";
+    state.windowsStoreInvitation = null;
+    if (preserveWaiting && state.windowsStoreAttempt?.phase === "waiting") return;
+    state.windowsStoreAttempt = null;
+  }
+  function canApplyStoreResponse(operation, surface, environment) {
+    if (!isCurrentResponse(operation)) return false;
+    if (surface !== getSurfaceRevision()) return false;
+    if (environment !== getEnvironmentId()) return false;
+    return isVisible();
+  }
+  function receiveStoreInvitation(receipt) {
+    state.windowsStoreInvitation = readStoreInvitation(receipt);
+    state.windowsStoreAttempt = { phase: "open", expiresAt: receipt.expiresAt };
+    state.downloaded = null;
+    state.manualMac = null;
+    state.message = "";
+    expirationTimer = scheduleExpiration(() => {
+      clear();
+      state.windowsStoreAttempt = { phase: "expired" };
+      notify();
+    }, Date.parse(receipt.expiresAt) - Date.now());
+  }
+  async function connectWindowsStore() {
+    if (typeof requestStoreConnection !== "function") return false;
+    if (!canInstallOnPlatform("windows")) return false;
+    if (!windowsStoreSetupIsAvailable(state.snapshot)) return false;
+    if (windowsCompanionCanReconnect(state.snapshot)) return false;
+    if (storeInvitationIsCurrent(state.windowsStoreInvitation)) return false;
+    clear();
+    const operation = beginRequest();
+    const surface = getSurfaceRevision();
+    const environment = getEnvironmentId();
+    state.windowsStoreAttempt = { phase: "preparing" };
+    notify();
+    try {
+      const receipt = await requestStoreConnection();
+      if (!canApplyStoreResponse(operation, surface, environment)) return false;
+      receiveStoreInvitation(receipt);
+      return true;
+    } catch {
+      if (!canApplyStoreResponse(operation, surface, environment)) return false;
+      clear();
+      state.actionError = "The Companion connection link could not be created. Refresh status and try again.";
+      return false;
+    } finally {
+      finishRequest(operation);
+    }
+  }
+  function canRepairWindowsPairing() {
+    if (!canInstallOnPlatform("windows")) return false;
+    return windowsCompanionCanReconnect(state.snapshot);
+  }
+  function beginWindowsStoreRepair() {
+    if (!canRepairWindowsPairing()) return false;
+    clear();
+    state.windowsStoreAttempt = { phase: "confirm-repair" };
+    state.actionError = "";
+    notify();
+    return true;
+  }
+  function cancelWindowsStoreRepair() {
+    if (state.busy) return false;
+    if (state.windowsStoreAttempt?.phase !== "confirm-repair") return false;
+    clear();
+    notify();
+    return true;
+  }
+  async function confirmWindowsStoreRepair() {
+    if (!canRepairWindowsPairing()) return false;
+    if (state.windowsStoreAttempt?.phase !== "confirm-repair") return false;
+    if (typeof revokeConnection !== "function" || typeof requestStoreConnection !== "function") return false;
+    const operation = beginRequest();
+    const surface = getSurfaceRevision();
+    const environment = getEnvironmentId();
+    state.windowsStoreAttempt = { phase: "repairing" };
+    notify();
+    let revoked = false;
+    try {
+      const snapshot = await revokeConnection();
+      if (!canApplyStoreResponse(operation, surface, environment)) return false;
+      if (!hasConfirmedUnpairedConnection(snapshot)) throw new Error("unpair_not_confirmed");
+      receiveUnpairedConnection(snapshot);
+      revoked = true;
+      if (!windowsStoreSetupIsAvailable(snapshot)) throw new Error("store_setup_unavailable");
+      state.windowsStoreAttempt = { phase: "preparing" };
+      state.message = "";
+      notify();
+      const receipt = await requestStoreConnection();
+      if (!canApplyStoreResponse(operation, surface, environment)) return false;
+      receiveStoreInvitation(receipt);
+      return true;
+    } catch {
+      if (!canApplyStoreResponse(operation, surface, environment)) return false;
+      clear();
+      state.message = "";
+      state.actionError = revoked
+        ? "The previous pairing was removed, but a new connection link could not be created. Connect again to continue."
+        : "The previous pairing could not be removed. No new connection was created. Refresh status and try again.";
+      return false;
+    } finally {
+      finishRequest(operation);
+    }
+  }
+  function markLaunchRequested() {
+    if (!storeInvitationIsCurrent(state.windowsStoreInvitation)) return;
+    state.windowsStoreAttempt = { phase: "waiting", expiresAt: state.windowsStoreInvitation.expiresAt };
+    // Leave the anchor intact until the browser has dispatched its native protocol.
+    setTimeout(notify, 0);
+  }
+  return { connectWindowsStore, beginWindowsStoreRepair, cancelWindowsStoreRepair, confirmWindowsStoreRepair, markLaunchRequested, clear };
+}

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

@@ -29,6 +29,7 @@ export function createWorkspaceShell({
   };
   let navigationRevision = 0;
   const workspaceListeners = new Set();
+  const runtimeAvailabilityListeners = new Set();
   const workspaceGuards = new Set();
   function notifyWorkspaceListeners(workspace) {
     onWorkspaceChange(workspace);
@@ -406,6 +407,7 @@ export function createWorkspaceShell({
     workspaceAccess.update(availability);
     if (!workspaceAccess.isAvailable(shellState.workspace))
       activateWorkspace("home", { focus: false });
+    for (const listener of runtimeAvailabilityListeners) listener();
   }
 
   function load() {
@@ -421,6 +423,10 @@ export function createWorkspaceShell({
     runtimeAvailabilityChanged,
     workspaceUnavailableMessage: workspaceAccess.unavailableMessage,
     navigationRevision: () => navigationRevision,
+    subscribeRuntimeAvailabilityChange(listener) {
+      runtimeAvailabilityListeners.add(listener);
+      return () => runtimeAvailabilityListeners.delete(listener);
+    },
     subscribeWorkspaceChange(listener) {
       workspaceListeners.add(listener);
       return () => workspaceListeners.delete(listener);

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

@@ -0,0 +1,37 @@
+export async function acknowledgeWorkspaceStorage(storage, documentRoot = document) {
+  if (storage.snapshot().introductionSeen) return;
+  const dialog = documentRoot.createElement("dialog");
+  dialog.className = "workspace-storage-notice";
+  dialog.innerHTML = `<h2>Your workspace settings stay with ABot</h2>
+    <p>Settings and queued messages are now saved with this ABot installation, across browsers and app restarts.</p>
+    <p>This is a one-time fresh start. Previous browser-only pins, archives, model choices, memory review markers and queued messages are not imported.</p>
+    <p>Your conversations, memories, configuration and read status are kept. Tool permissions start in <strong>Ask</strong>; you can change them in the composer.</p>
+    <p role="alert" hidden></p><button type="button" class="primary">Continue</button>`;
+  documentRoot.body.append(dialog);
+  dialog.addEventListener("cancel", (event) => event.preventDefault());
+  dialog.showModal();
+  await new Promise((resolve) => {
+    const button = dialog.querySelector("button");
+    button.addEventListener("click", async () => {
+      button.disabled = true;
+      try { await storage.execute({ kind: "introduction" }); dialog.close(); dialog.remove(); resolve(); }
+      catch (error) {
+        const notice = dialog.querySelector('[role="alert"]');
+        notice.textContent = `${error.message} Reload to try again.`;
+        notice.hidden = false;
+      }
+    });
+  });
+}
+
+export function showWorkspaceStorageFailure(error, documentRoot = document) {
+  let notice = documentRoot.querySelector("[data-workspace-storage-error]");
+  if (!notice) {
+    notice = documentRoot.createElement("div");
+    notice.dataset.workspaceStorageError = "";
+    notice.setAttribute("role", "alert");
+    notice.className = "workspace-storage-failure";
+    documentRoot.body.append(notice);
+  }
+  notice.textContent = `${error.message} Changes are not confirmed. Reload before sending more messages.`;
+}

package/dist/src/web-ui/app/computer-access-feature.js

@@ -1,11 +1,12 @@
 import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
 import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
 
-/** One connection owner, always first on Home and shared with the chat notice. */
+/** One connection owner for configured Home and its shared chat notice. */
 export function createComputerAccessFeature({
   dom,
   runtimeClient,
   getEnvironmentId = () => "",
+  isComputerAccessAvailable = () => true,
   onChange = () => {},
 }) {
   const documentRoot = dom.homeDashboardRoot?.ownerDocument;
@@ -18,6 +19,7 @@ export function createComputerAccessFeature({
     loadConnection: () => runtimeClient.getSystemHostConnection(),
     connectLocal: () => runtimeClient.connectLocalSystemHost(),
     createPairing: () => runtimeClient.createSystemHostPairing(),
+    requestStoreConnection: () => runtimeClient.requestSystemHostStoreConnection(),
     requestPermissions: (input) => runtimeClient.requestSystemHostPermissions(input),
     downloadSetup: (platform) =>
       runtimeClient.downloadSystemHostSetup(platform),
@@ -30,6 +32,7 @@ export function createComputerAccessFeature({
   });
 
   function open() {
+    if (!isComputerAccessAvailable()) return false;
     dom.homeWorkspaceButton?.click();
     if (dom.homeWorkspacePanel?.hidden !== false || !root) return false;
     connection.openManagement();
@@ -38,16 +41,29 @@ export function createComputerAccessFeature({
     return true;
   }
 
+  function runtimeAvailabilityChanged() {
+    const ready = isComputerAccessAvailable();
+    if (root) root.hidden = !ready;
+    connection.setActive(ready);
+    notice?.render();
+  }
+
+  function load(background) {
+    if (!isComputerAccessAvailable()) return Promise.resolve(false);
+    return connection.load(background);
+  }
+
   notice = createSystemHostSetupNotice({
     container: dom.chatPanel?.querySelector(".composer-dock"),
     conversationRegion: dom.messagesList,
     getConnectionState: () => connection.state,
-    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
-    refreshConnection: () => connection.load(true),
+    supportsConnection: () => isComputerAccessAvailable() && runtimeClient.supportsSystemHostConnection(),
+    refreshConnection: () => load(true),
     onOpen: open,
   });
   if (root) {
     root.className = "home-computer-access";
+    root.hidden = !isComputerAccessAvailable();
     root.setAttribute("tabindex", "-1");
     root.setAttribute("aria-label", "Computer access");
     dom.homeDashboardRoot.parentElement?.insertBefore(
@@ -55,13 +71,14 @@ export function createComputerAccessFeature({
       dom.homeDashboardRoot,
     );
     connection.mount(root);
-    connection.setActive(true);
+    runtimeAvailabilityChanged();
   }
   dom.environmentSelect?.addEventListener("change", connection.environmentChanged);
   return {
     state: connection.state,
-    load: connection.load,
+    load,
     open,
+    runtimeAvailabilityChanged,
     dispose() {
       dom.environmentSelect?.removeEventListener("change", connection.environmentChanged);
       notice.dispose();

package/dist/src/web-ui/app/configuration-environment-refresh.js

@@ -6,6 +6,7 @@ export function createAppliedEnvironmentProjection({
   dom,
   selection,
   loadWebConfig,
+  changeEnvironment,
 }) {
   let generation = 0;
   let pending = null;
@@ -23,11 +24,10 @@ export function createAppliedEnvironmentProjection({
     );
   }
 
-  function restoreProjection(config, selected) {
+  function applyProjection(config, selected) {
     state.config = config;
     selection.renderEnvironmentOptions();
     dom.environmentSelect.value = selected;
-    selection.renderAgentPicker();
   }
 
   function preferredEnvironmentId(options, selected, defaultId) {
@@ -36,45 +36,36 @@ export function createAppliedEnvironmentProjection({
     return options[0]?.value || "";
   }
 
-  function changeProjectedEnvironment(
-    next,
-    previousConfig,
-    previousEnvironment,
-  ) {
-    const ChangeEvent = dom.environmentSelect.ownerDocument.defaultView.Event;
-    dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
-    if (dom.environmentSelect.value === next) return true;
-    restoreProjection(previousConfig, previousEnvironment);
-    // Existing listeners also own composer/environment presentation after a refusal.
-    dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
-    return false;
-  }
-
-  function flush() {
+  async function flush() {
     if (!pending) return "unchanged";
-    const previousConfig = state.config;
     const previousEnvironment = selection.selectedEnvironmentId();
-    state.config = pending;
-    selection.renderEnvironmentOptions();
+    const projected = pending;
+    const revision = generation;
     const next = preferredEnvironmentId(
-      selection.environmentOptions(),
+      selection.configuredEnvironmentOptions(projected),
       previousEnvironment,
-      textOf(pending.defaultEnvironmentId).trim(),
+      textOf(projected.defaultEnvironmentId).trim(),
     );
-    if (!next) {
-      restoreProjection(previousConfig, previousEnvironment);
-      return "blocked";
-    }
-    dom.environmentSelect.value = next;
-    const unchanged = next === previousEnvironment;
-    if (unchanged) {
+    if (!next) return "blocked";
+    if (next === previousEnvironment) {
+      applyProjection(projected, next);
       pending = null;
       selection.renderAgentPicker();
       return "unchanged";
     }
-    if (!changeProjectedEnvironment(next, previousConfig, previousEnvironment))
-      return "blocked";
-    pending = null;
+    // Keep the old catalog and selected option until draft preparation commits.
+    const commitEnvironmentOptions = () => {
+      applyProjection(projected, next);
+      pending = null;
+    };
+    commitEnvironmentOptions.canCommit = () => {
+      if (revision !== generation) return false;
+      return pending === projected;
+    };
+    let accepted = false;
+    try { accepted = await changeEnvironment(next, { commitEnvironmentOptions }); }
+    catch { /* The old catalog remains active when draft persistence fails. */ }
+    if (!accepted) return "blocked";
     selection.renderAgentPicker();
     return "changed";
   }
@@ -87,6 +78,7 @@ export function createConfigurationFeature({
   state,
   selection,
   onConfigurationApplied,
+  changeEnvironment,
   ...options
 }) {
   const projection = createAppliedEnvironmentProjection({
@@ -94,6 +86,7 @@ export function createConfigurationFeature({
     dom: options.dom,
     selection,
     loadWebConfig: () => options.runtimeClient.loadWebConfig(),
+    changeEnvironment,
   });
   const workspace = createWorkspaceFeature({
     ...options,
@@ -101,13 +94,13 @@ export function createConfigurationFeature({
       const currentStillConfigured = await projection.prepare();
       if (currentStillConfigured) await onConfigurationApplied();
     },
-    onConfigurationSettled: () => projection.flush() !== "blocked",
+    onConfigurationSettled: async () => await projection.flush() !== "blocked",
   });
   return {
     ...workspace,
     async reloadAppliedEnvironmentModels() {
       await projection.prepare();
-      const result = projection.flush();
+      const result = await projection.flush();
       if (result === "blocked") return false;
       if (result === "changed") return true;
       const refreshed = await workspace.load();

package/dist/src/web-ui/app/configuration-feature.js

@@ -15,11 +15,13 @@ export function createConfigurationFeature({
   runtimeClient,
   selectedEnvironmentId,
   recordControlEvent,
+  getOperationsSummary,
   onNavigationChange = () => {},
   onConfigurationApplied = async () => {},
   onConfigurationSettled = () => true,
   getLearningSnapshot = () => null,
   isRuntimeReady = () => true,
+  isComputerAccessAvailable = () => true,
 }) {
   let configWorkspace;
   let activation;
@@ -72,9 +74,26 @@ export function createConfigurationFeature({
   });
 
   const pluginManager = createPluginManager({
+    onSummaryChange: () => configWorkspace?.syncSummary(),
     getEnvironmentId: selectedEnvironmentId,
+    loadConfiguration: (id, environment) =>
+      runtimeClient.getPluginConfiguration(id, environment),
+    saveConfiguration: (id, input, environment) =>
+      runtimeClient.savePluginConfiguration(id, input, environment),
     onConfigurationSaved: () => activation?.markPending(),
+    onConfigurationSettled,
     loadPlugins: () => runtimeClient.getRuntimePlugins(),
+    inspectPlugin: (input, environment) =>
+      runtimeClient.inspectRuntimePlugin(input, environment),
+    removePlugin: (input, environment) =>
+      runtimeClient.removeRuntimePlugin(input, environment),
+    onConfigurationApplied: async () => {
+      activation?.markApplied();
+      await onConfigurationApplied();
+    },
+    installPlugin: (input, environment) =>
+      runtimeClient.installRuntimePlugin(input, environment),
+    onNavigationChange,
     setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
     beginRuntimeMutation: (subject) =>
       configWorkspace?.beginExternalRuntimeMutation(subject) ?? false,
@@ -90,6 +109,7 @@ export function createConfigurationFeature({
     dom,
     runtimeClient,
     getEnvironmentId: selectedEnvironmentId,
+    isComputerAccessAvailable,
     onChange: () => homeSetupSuggestion?.render(),
   });
   homeSetupSuggestion = createHomeGuidance({
@@ -99,7 +119,7 @@ export function createConfigurationFeature({
     getEnvironmentId: selectedEnvironmentId,
     getLearningSnapshot,
     isRuntimeReady,
-    // Computer access is permanently visible above the Home suggestions.
+    // Configured Home owns computer access above the suggestions.
     getConnectionState: () => null,
     supportsConnection: () => false,
     refreshConnection: () => {},
@@ -115,6 +135,7 @@ export function createConfigurationFeature({
     },
   });
   configWorkspace = createConfigWorkspace({
+    getOperationsSummary,
     onNavigationChange,
     onRemoveModel: (model) => {
       if (modelSetup?.isOpen()) return;
@@ -127,6 +148,8 @@ export function createConfigurationFeature({
     },
     loadDashboard: () =>
       runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
+    loadModelPlugins: () =>
+      runtimeClient.getRuntimePlugins(selectedEnvironmentId()),
     saveFile: async ({ kind, id, config, expectedRevision }) => {
       const result = await runtimeClient.saveConfigFile({
         environmentId: selectedEnvironmentId(),
@@ -231,21 +254,39 @@ export function createConfigurationFeature({
   const prepareDiscardChanges = configWorkspace.prepareDiscardChanges;
   return {
     ...configWorkspace,
+    activePluginTab: pluginManager.activeTab,
+    openPluginRoute: pluginManager.openRoute,
     openComputerSetup: computerAccess.open,
     refreshComputerAccess: computerAccess.load,
-    renderHomeGuidance: () => homeSetupSuggestion.render(),
+    renderHomeGuidance: () => {
+      computerAccess.runtimeAvailabilityChanged();
+      homeSetupSuggestion.render();
+    },
     showActivityMemories: () => {
       memoryWorkspace.activate("memories");
       void longTermMemoryController.setOriginFilter("passive_observation");
       longTermMemoryManager.focus();
     },
     prepareDiscardChanges: (...args) => {
+      if (pluginManager.hasConfigurationDraft()) {
+        dom.configStatus.textContent =
+          "Finish or cancel plugin configuration before leaving.";
+        return null;
+      }
       if (modelSetup.isOpen()) {
         dom.configStatus.textContent =
           "Finish or cancel model setup before leaving configuration.";
         return null;
       }
-      return prepareDiscardChanges(...args);
+      const prepared = prepareDiscardChanges(...args);
+      if (typeof prepared !== "function") return prepared;
+      const commit = () => prepared();
+      commit.canCommit = () => {
+        if (pluginManager.hasConfigurationDraft()) return false;
+        if (modelSetup.isOpen()) return false;
+        return prepared.canCommit?.() !== false;
+      };
+      return commit;
     },
   };
 }