local-operator-ui 0.31.26 → 0.31.28

package/out/main/index.js

@@ -62,11 +62,14 @@ function pairingHasRemedy(cause) {
 const id$1 = zod.z.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/);
 const settingKey = zod.z.string().min(1).max(256).regex(/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/);
 const secret = zod.z.string().min(1).max(32768);
-const sessionId = zod.z.string().regex(/^[a-f0-9]{12}$/);
+const sessionIdPattern = /^[a-f0-9]{12}$/;
+const sessionId = zod.z.string().regex(sessionIdPattern);
+const skillCwd = zod.z.string().min(1).max(4096);
 const mcpServerName = zod.z.string().regex(/^[A-Za-z0-9_.:-]{1,100}$/);
 const mcpSecretReference = zod.z.string().regex(/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/);
 const mcpOperationId = zod.z.string().regex(/^[a-f0-9]{32}$/);
-const mcpCatalogCwd = zod.z.string().min(1).max(4096).regex(/^(\/|[A-Za-z]:[\\/])/);
+const mcpCatalogCwdPattern = /^(\/|[A-Za-z]:[\\/])/;
+const mcpCatalogCwd = zod.z.string().min(1).max(4096).regex(mcpCatalogCwdPattern);
 const SUBSCRIPTION_ID_PATTERN = /^[a-f0-9]{32}$/;
 const requestId = zod.z.string().regex(/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/);
 const meshId = zod.z.string().regex(/^[A-Za-z0-9_-]{1,128}$/);
@@ -262,6 +265,7 @@ const projectKey = zod.z.string().min(1).max(64);
 const PROJECT_PROGRESS_MAX_CHARS = 1e3;
 const PROJECT_DESCRIPTION_MAX_CHARS = 240;
 const PROJECT_MILESTONE_NAME_MAX_CHARS = 80;
+const hubItemKind = zod.z.enum(["agent", "team"]);
 const desktopRequestUnion = zod.z.discriminatedUnion("op", [
   zod.z.object({ op: zod.z.literal("capabilities") }).strict(),
   zod.z.object({ op: zod.z.literal("profiles.list") }).strict(),
@@ -282,6 +286,47 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
     requestId,
     fields: profileFields
   }).strict(),
+  /*
+   * THE HUB AUTO-UPDATE PLANE (backend `server/routes/desktop_hub.py`, gated by
+   * the `hub_updates` capability). `hub.updates` is a STORE READ on the backend
+   * (no network, O(items)), which is what makes it safe to poll from the
+   * sidebar; the five mutations are the ones that touch the hub or write a
+   * local definition, and each carries a `requestId` so a lost response is
+   * replayed by the server's receipts rather than re-run.
+   *
+   * `kind` is closed to the two definition families the hub carries, and `name`
+   * is the profile/team NAME because names are the runtime's attachment keys.
+   * `prefer` is per-item only: the backend refuses it on apply-all, since a
+   * conflict decision cannot be made for a set of items at once, so the
+   * apply-all schema does not offer it.
+   */
+  zod.z.object({ op: zod.z.literal("hub.updates") }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.check"),
+    requestId,
+    kind: hubItemKind.optional(),
+    name: profileName.optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.apply"),
+    requestId,
+    kind: hubItemKind,
+    name: profileName,
+    prefer: zod.z.enum(["local", "remote"]).optional(),
+    acknowledgeUnknownBaseline: zod.z.boolean().optional(),
+    dryRun: zod.z.boolean().optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.applyAll"),
+    requestId,
+    kind: hubItemKind.optional()
+  }).strict(),
+  zod.z.object({
+    op: zod.z.literal("hub.retry"),
+    requestId,
+    kind: hubItemKind,
+    name: profileName
+  }).strict(),
   zod.z.object({ op: zod.z.literal("teams.list") }).strict(),
   zod.z.object({ op: zod.z.literal("teams.get"), name: profileName }).strict(),
   zod.z.object({
@@ -1163,7 +1208,20 @@ const desktopRequestUnion = zod.z.discriminatedUnion("op", [
      */
     recentLimit: zod.z.number().int().min(0).max(50).optional()
   }).strict(),
-  zod.z.object({ op: zod.z.literal("skills.list"), sessionId, name: id$1.optional() }).strict(),
+  zod.z.object({
+    op: zod.z.literal("skills.list"),
+    /*
+     * The sessionless arm's pair, both optional, `cwd` wins when both are sent
+     * (the explicit folder beats the implied one; the route's docstring owns
+     * the rule). `cwd` given → the folder's own discovery roots (identical to
+     * the session created there); `session_id` given → the session's cwd
+     * (compat, for the `/skills` panel and released clients); NEITHER → the
+     * daemon's home roots, explicitly — never the daemon's process cwd.
+     */
+    sessionId: sessionId.optional(),
+    cwd: skillCwd.optional(),
+    name: id$1.optional()
+  }).strict(),
   zod.z.object({ op: zod.z.literal("sessions.failovers"), sessionId }).strict(),
   zod.z.object({
     op: zod.z.literal("sessions.credential"),
@@ -1860,11 +1918,36 @@ function moveClientBoundMs(shape) {
   const waitS = Math.max(0, shape.waitS ?? 0);
   return (MOVE_OP_DEADLINE_S + hold + MOVE_CONTROL_SLACK_S + MOVE_CLIENT_MARGIN_S) * 1e3 + waitS * 1e3;
 }
+const HUB_ITEM_MERGE_S = 120;
+const HUB_ITEM_WRITE_DEADLINE_MS = (HUB_ITEM_MERGE_S + 30 + MOVE_CLIENT_MARGIN_S) * 1e3;
+const HUB_CHECK_DEADLINE_MS = 6e4;
+const HUB_APPLY_ALL_DEADLINE_MS = 5 * HUB_ITEM_WRITE_DEADLINE_MS;
+const HUB_WRITE_OPS = /* @__PURE__ */ new Set([
+  "hub.apply",
+  "hub.retry",
+  "hub.check",
+  "hub.applyAll"
+]);
+function hubWriteDeadlineMs(op) {
+  switch (op) {
+    case "hub.apply":
+    case "hub.retry":
+      return HUB_ITEM_WRITE_DEADLINE_MS;
+    case "hub.check":
+      return HUB_CHECK_DEADLINE_MS;
+    case "hub.applyAll":
+      return HUB_APPLY_ALL_DEADLINE_MS;
+    default:
+      return null;
+  }
+}
 function desktopRequestDeadlineMs(request) {
   if (typeof request !== "string" && request.op === "sessions.transfer") {
     return moveClientBoundMs(request) + MOVE_APP_MARGIN_MS;
   }
   const op = typeof request === "string" ? request : request.op;
+  const hub = hubWriteDeadlineMs(op);
+  if (hub !== null) return hub;
   return LONG_READ_OPS.has(op) ? DESKTOP_LONG_READ_DEADLINE_MS : DESKTOP_CONTROL_DEADLINE_MS;
 }
 const DESKTOP_DEADLINE_EXCEEDED_CODE = "deadline_exceeded";
@@ -1878,6 +1961,7 @@ const READ_ONLY_OPS = /* @__PURE__ */ new Set([
   "commands.list",
   "config.get",
   "credentials.list",
+  "hub.updates",
   "info.get",
   "instructions.get",
   "legacy.agent.get",
@@ -1934,6 +2018,12 @@ function desktopRequestDeadlineDetail(op, deadlineMs) {
       message: `The app waits up to ${seconds} seconds for a move, and it was still running when the app stopped waiting. The move was asked for, so its outcome is unknown from here: read the session again before moving it anywhere else.`
     };
   }
+  if (HUB_WRITE_OPS.has(op)) {
+    return {
+      code,
+      message: "This is taking longer than expected. It may still finish; the mark will update."
+    };
+  }
   if (READ_ONLY_OPS.has(op)) {
     return {
       code,
@@ -2062,6 +2152,52 @@ function desktopEndpoint(request) {
         method: "PATCH",
         body: { request_id: request.requestId, ...request.fields }
       };
+    case "hub.updates":
+      return { path: "/v1/desktop/hub/updates", method: "GET" };
+    case "hub.check":
+      return {
+        path: "/v1/desktop/hub/updates/check",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          ...request.kind ? { kind: request.kind } : {},
+          ...request.name ? { name: request.name } : {}
+        }
+      };
+    case "hub.apply":
+      return {
+        path: "/v1/desktop/hub/updates/apply",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          kind: request.kind,
+          name: request.name,
+          ...request.prefer ? { prefer: request.prefer } : {},
+          ...request.acknowledgeUnknownBaseline !== void 0 ? {
+            acknowledge_unknown_baseline: request.acknowledgeUnknownBaseline
+          } : {},
+          ...request.dryRun !== void 0 ? { dry_run: request.dryRun } : {}
+        }
+      };
+    case "hub.applyAll":
+      return {
+        path: "/v1/desktop/hub/updates/apply-all",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          ...request.kind ? { kind: request.kind } : {}
+        }
+      };
+    case "hub.retry":
+      return {
+        path: "/v1/desktop/hub/updates/retry",
+        method: "POST",
+        body: {
+          request_id: request.requestId,
+          kind: request.kind,
+          name: request.name
+        }
+      };
     case "teams.list":
       return { path: "/v1/desktop/teams", method: "GET" };
     case "teams.get":
@@ -2684,11 +2820,17 @@ function desktopEndpoint(request) {
         method: "GET"
       };
     }
-    case "skills.list":
+    case "skills.list": {
+      const query = new URLSearchParams();
+      if (request.sessionId) query.set("session_id", request.sessionId);
+      if (request.cwd) query.set("cwd", request.cwd);
+      if (request.name) query.set("name", request.name);
+      const encoded = query.toString();
       return {
-        path: `/v1/desktop/skills?session_id=${request.sessionId}${request.name ? `&name=${encodeURIComponent(request.name)}` : ""}`,
+        path: `/v1/desktop/skills${encoded ? `?${encoded}` : ""}`,
         method: "GET"
       };
+    }
     case "sessions.failovers":
       return {
         path: `/v1/desktop/sessions/${request.sessionId}/failovers`,
@@ -2968,6 +3110,9 @@ const MINI_VIEW_SUMMONED = "mini-view:summoned";
 const MINI_VIEW_DISMISS = "mini-view:dismiss";
 const MINI_VIEW_REGISTRATION = "mini-view:registration";
 const MINI_VIEW_REGISTRATION_GET = "mini-view:registration-get";
+const MINI_VIEW_RESIZE = "mini-view:resize";
+const MINI_VIEW_DIALOG = "mini-view:dialog";
+const MINI_VIEW_PAINTED = "mini-view:painted";
 const MINI_VIEW_DISMISS_REASONS = [
   "escape",
   "blur",
@@ -2979,6 +3124,10 @@ function isMiniViewDismissReason(value) {
 }
 const MINI_VIEW_WIDTH = 640;
 const MINI_VIEW_HEIGHT = 168;
+const MINI_VIEW_MAX_HEIGHT = 560;
+function isMiniViewResizePayload(value) {
+  return value !== null && typeof value === "object" && typeof value.height === "number" && Number.isFinite(value.height);
+}
 const DEFAULT_QUICK_SEND_VALUE = "primary+alt+shift+space";
 const FUNCTION_KEY_TOKEN = /^f([1-9]|1[0-9]|2[0-4])$/;
 function isFunctionKeyToken(token) {
@@ -33106,17 +33255,43 @@ const MINI_DOCUMENT = "mini.html";
 function miniViewUrlFor(rendererUrl) {
   return INDEX_DOCUMENT_SUFFIX.test(rendererUrl) ? rendererUrl.replace(INDEX_DOCUMENT_SUFFIX, `/${MINI_DOCUMENT}`) : `${rendererUrl.replace(TRAILING_SLASH, "")}/${MINI_DOCUMENT}`;
 }
+const MINI_VIEW_GROUND = "#22201c";
+const MINI_VIEW_PAINT_TIMEOUT_MS = 1500;
+function miniViewPresentationFor(input) {
+  if (input.show !== "focus") return "present";
+  if (input.painted) return "present";
+  if (input.timedOut) return "error-surface";
+  return "wait";
+}
+function miniViewErrorSurfaceHtml() {
+  return `<!doctype html>
+<html><head><meta charset="utf-8" /><title>Quick send</title>
+<style>
+	:root { color-scheme: dark; }
+	html, body { margin: 0; height: 100%; background: ${MINI_VIEW_GROUND}; }
+	body { display: flex; align-items: center; padding: 0 16px;
+		font: 13px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+		color: #c2bcb0; }
+	p { margin: 0; }
+	strong { font-weight: 600; color: #ef8078; }
+</style></head>
+<body><p><strong>Quick send could not open.</strong> Try the hotkey again, or restart Local Operator if it keeps failing.</p></body></html>`;
+}
 function createMiniView(options) {
   const window = new electron.BrowserWindow({
     width: MINI_VIEW_WIDTH,
     height: MINI_VIEW_HEIGHT,
     /*
-     * Sized in content, not window, terms: the design fixes the COMPOSER at
-     * 640x168 and the frames are captured and reviewed at that size, so the
-     * page's viewport is the number that must be exact on every platform.
+     * Sized in content, not window, terms, and the content size is now the
+     * BASE of a measured range rather than the whole story: the restyle's
+     * chrome (previews, the readings strip, the picker sheet) asks for more
+     * through `MINI_VIEW_RESIZE` below, and this call is what makes the
+     * page's viewport the number every frame is captured at.
      */
     useContentSize: true,
     show: false,
+    /* The dark ground under an as-yet-unpainted document; see MINI_VIEW_GROUND. */
+    backgroundColor: MINI_VIEW_GROUND,
     // A composer that floats over other apps carries no frame of its own:
     // the app's own rows are the entire surface, and the one sanctioned
     // elevation step is the card's ground.
@@ -33164,7 +33339,91 @@ function createMiniView(options) {
   if (process.platform === "darwin") {
     window.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
   }
+  let paintedForLoad = false;
+  let paintTimer = null;
+  let paintWaiters = [];
+  const settlePaint = (ready) => {
+    if (paintTimer !== null) {
+      clearTimeout(paintTimer);
+      paintTimer = null;
+    }
+    paintedForLoad = ready;
+    const waiting = paintWaiters;
+    paintWaiters = [];
+    for (const resolve of waiting) resolve();
+  };
+  const showErrorSurface = () => {
+    if (disposed || window.isDestroyed()) return;
+    settlePaint(false);
+    void window.loadURL(
+      `data:text/html;charset=utf-8,${encodeURIComponent(miniViewErrorSurfaceHtml())}`
+    );
+    window.webContents.once("did-finish-load", () => {
+      if (disposed || window.isDestroyed()) return;
+      positionForCursorDisplay();
+      presentMiniView(window, options.show, {
+        trigger: "mini-view",
+        report: options.report
+      });
+      if (options.show === "focus") {
+        window.webContents.send(MINI_VIEW_SUMMONED, {
+          at: Date.now()
+        });
+      }
+    });
+  };
+  window.webContents.on("did-start-loading", () => {
+    paintedForLoad = false;
+  });
+  window.webContents.on(
+    "did-fail-load",
+    (_event, errorCode, errorDescription, validatedURL, isMainFrame) => {
+      if (!isMainFrame) return;
+      options.report?.(
+        `[mini-view] load failed (${errorCode} ${errorDescription}) for ${validatedURL}; showing the error card`
+      );
+      showErrorSurface();
+    }
+  );
+  window.webContents.on("render-process-gone", (_event, details) => {
+    options.report?.(
+      `[mini-view] renderer gone (${details.reason}); showing the error card`
+    );
+    showErrorSurface();
+  });
   void window.loadURL(options.url);
+  const onResize = (event, payload) => {
+    if (window.isDestroyed() || event.sender !== window.webContents || event.senderFrame !== window.webContents.mainFrame) {
+      return;
+    }
+    if (!isMiniViewResizePayload(payload)) return;
+    const area = electron.screen.getDisplayMatching(window.getBounds()).workArea;
+    const ceiling = Math.max(
+      MINI_VIEW_HEIGHT,
+      Math.min(MINI_VIEW_MAX_HEIGHT, area.height - 64)
+    );
+    const height = Math.max(
+      MINI_VIEW_HEIGHT,
+      Math.min(Math.round(payload.height), ceiling)
+    );
+    const bounds = window.getContentBounds();
+    if (bounds.height === height) return;
+    window.setContentSize(MINI_VIEW_WIDTH, height);
+    const bottom = bounds.y + height;
+    if (bottom > area.y + area.height) {
+      window.setPosition(
+        bounds.x,
+        Math.max(area.y, area.y + area.height - height)
+      );
+    }
+  };
+  electron.ipcMain.on(MINI_VIEW_RESIZE, onResize);
+  const onPainted = (event) => {
+    if (window.isDestroyed() || event.sender !== window.webContents || event.senderFrame !== window.webContents.mainFrame)
+      return;
+    settlePaint(true);
+  };
+  electron.ipcMain.on(MINI_VIEW_PAINTED, onPainted);
   let disposed = false;
   function hide() {
     if (disposed || window.isDestroyed()) return;
@@ -33194,42 +33453,86 @@ function createMiniView(options) {
     }
     hide();
   });
-  function toggle() {
-    if (disposed) return;
-    if (!window.isDestroyed() && window.isVisible()) {
-      hide();
+  function presentWhenReady() {
+    if (disposed || window.isDestroyed()) return;
+    const decision = miniViewPresentationFor({
+      show: options.show,
+      painted: paintedForLoad,
+      timedOut: false
+    });
+    if (decision === "error-surface") {
+      showErrorSurface();
       return;
     }
+    if (decision === "present") {
+      presentNow();
+      return;
+    }
+    paintWaiters.push(() => {
+      if (miniViewPresentationFor({
+        show: options.show,
+        painted: paintedForLoad,
+        timedOut: false
+      }) === "present")
+        presentNow();
+    });
+    if (paintTimer === null) {
+      paintTimer = setTimeout(() => {
+        paintTimer = null;
+        if (miniViewPresentationFor({
+          show: options.show,
+          painted: paintedForLoad,
+          timedOut: true
+        }) === "error-surface")
+          showErrorSurface();
+      }, MINI_VIEW_PAINT_TIMEOUT_MS);
+    }
+  }
+  function presentNow() {
+    if (disposed || window.isDestroyed()) return;
     positionForCursorDisplay();
     presentMiniView(window, options.show, {
       trigger: "mini-view",
       report: options.report
     });
-    if (options.show === "focus" && !window.isDestroyed()) {
-      const payload = { at: Date.now() };
-      window.webContents.send(MINI_VIEW_SUMMONED, payload);
+    if (options.show === "focus") {
+      window.webContents.send(MINI_VIEW_SUMMONED, {
+        at: Date.now()
+      });
     }
   }
+  function toggle() {
+    if (disposed) return;
+    if (!window.isDestroyed() && window.isVisible()) {
+      hide();
+      return;
+    }
+    presentWhenReady();
+  }
   function positionForCursorDisplay() {
     if (window.isDestroyed()) return;
     const display = electron.screen.getDisplayNearestPoint(
       electron.screen.getCursorScreenPoint()
     );
     const area = display.workArea;
+    const height = window.isDestroyed() ? MINI_VIEW_HEIGHT : window.getContentBounds().height;
     const x = Math.round(area.x + (area.width - MINI_VIEW_WIDTH) / 2);
-    const desiredY = area.y + area.height / 3 - MINI_VIEW_HEIGHT / 2;
+    const desiredY = area.y + area.height / 3 - height / 2;
     const y = Math.round(
-      Math.min(
-        Math.max(desiredY, area.y),
-        area.y + area.height - MINI_VIEW_HEIGHT
-      )
+      Math.min(Math.max(desiredY, area.y), area.y + area.height - height)
     );
     window.setPosition(x, y);
   }
   function dispose() {
     if (disposed) return;
     disposed = true;
+    electron.ipcMain.removeListener(MINI_VIEW_RESIZE, onResize);
+    electron.ipcMain.removeListener(MINI_VIEW_PAINTED, onPainted);
     electron.ipcMain.removeHandler(MINI_VIEW_DISMISS);
+    if (paintTimer !== null) {
+      clearTimeout(paintTimer);
+      paintTimer = null;
+    }
     if (!window.isDestroyed()) window.destroy();
   }
   return { window, toggle, hide, dispose };
@@ -40376,9 +40679,15 @@ if (process.platform === "darwin" && electron.app.dock) {
   if (windowLaunch.hideDock) {
     electron.app.dock.hide();
   } else {
+    electron.app.dock.show();
     electron.app.dock.setIcon(image);
   }
 }
+function reassertDockParticipation() {
+  if (process.platform !== "darwin" || !electron.app.dock) return;
+  if (windowLaunch.hideDock) return;
+  electron.app.dock.show();
+}
 const telemetryLaunch = resolveTelemetryLaunch({
   env: launchEnv,
   projectKey: backendConfig.VITE_PUBLIC_POSTHOG_KEY
@@ -41566,24 +41875,37 @@ electron.app.whenReady().then(async () => {
       return false;
     }
   });
-  electron.ipcMain.handle("show-open-dialog", async (_, options) => {
-    if (!mainWindow) {
+  electron.ipcMain.handle("show-open-dialog", async (event, options) => {
+    const parent = electron.BrowserWindow.fromWebContents(event.sender) ?? mainWindow;
+    if (!parent) {
       logger.error(
-        "Cannot show open dialog: mainWindow is not available.",
+        "Cannot show open dialog: no window can own it.",
         LogFileType.BACKEND
       );
       return { canceled: true, filePaths: [] };
     }
-    const result = await electron.dialog.showOpenDialog(
-      mainWindow,
-      withRememberedDirectory(
-        "open-file",
-        options,
-        pickerFallbackDirectory()
-      )
-    );
-    rememberPickedDirectory("open-file", result.filePaths);
-    return result;
+    const mini = miniView;
+    const fromMini = mini !== null && !mini.window.isDestroyed() && event.sender === mini.window.webContents;
+    const dialogPayload = { open: true };
+    if (fromMini)
+      mini.window.webContents.send(MINI_VIEW_DIALOG, dialogPayload);
+    try {
+      const result = await electron.dialog.showOpenDialog(
+        parent,
+        withRememberedDirectory(
+          "open-file",
+          options,
+          pickerFallbackDirectory()
+        )
+      );
+      rememberPickedDirectory("open-file", result.filePaths);
+      return result;
+    } finally {
+      if (fromMini && mini !== null && !mini.window.isDestroyed())
+        mini.window.webContents.send(MINI_VIEW_DIALOG, {
+          open: false
+        });
+    }
   });
   electron.ipcMain.handle("select-directory", async () => {
     if (!mainWindow) {
@@ -41992,6 +42314,7 @@ electron.app.whenReady().then(async () => {
   };
   setupMainWindowWithUpdateService(launchSession, launchCatalogue);
   electron.app.on("activate", () => {
+    reassertDockParticipation();
     if (electron.BrowserWindow.getAllWindows().length === 0) {
       if (quitState.isQuitting()) {
         reportSkippedWhileQuitting(
@@ -42031,6 +42354,13 @@ electron.app.on("window-all-closed", () => {
       electron.app.quit();
       return;
     }
+    if (quitState.isQuitting()) {
+      logger.info(
+        "All windows closed as part of a quit in progress; will-quit owns the completion",
+        LogFileType.BACKEND
+      );
+      return;
+    }
     logger.info(
       "All windows closed, but keeping app active (macOS platform)",
       LogFileType.BACKEND
@@ -42070,7 +42400,7 @@ electron.app.on("will-quit", (event) => {
   failsafe.unref();
   void backendService.stop(false).then(() => {
     clearTimeout(failsafe);
-    electron.app.quit();
+    electron.app.exit(0);
   }).catch((error) => {
     clearTimeout(failsafe);
     logger.error(
@@ -42089,22 +42419,33 @@ const holdQuitForSessionCookieSnapshot = createSessionCookieQuitHold({
 });
 electron.app.on("before-quit", async (event) => {
   quitState.begin();
+  electron.globalShortcut.unregisterAll();
+  miniViewRegistrar?.dispose();
+  quickSendWatcher?.stop();
+  miniView?.dispose();
+  if (windowLaunch.mode === "headless") {
+    launcherWatch?.stop();
+    armHeadlessExitDeadline("the app is quitting");
+  }
   if (await holdQuitForSessionCookieSnapshot(event)) return;
   logger.info("App is about to quit", LogFileType.BACKEND);
+  if (!backendService.isOwnedCleanupComplete()) {
+    try {
+      await backendService.stop(false);
+    } catch (error) {
+      logger.error(
+        "Owned backend stop rejected during quit; continuing the shutdown",
+        LogFileType.BACKEND,
+        error
+      );
+    }
+  }
   if (parkedLaunches.length > 0) {
     reportParksAtQuit(
       parkedLaunches.map((parked) => parked.session),
       reportRaise
     );
   }
-  if (windowLaunch.mode === "headless") {
-    launcherWatch?.stop();
-    armHeadlessExitDeadline("the app is quitting");
-  }
-  electron.globalShortcut.unregisterAll();
-  miniViewRegistrar?.dispose();
-  quickSendWatcher?.stop();
-  miniView?.dispose();
   activeUpdateService?.quitForInFlightInstall("app quit");
   void stopBrowserHost();
 });

package/out/preload/index.js

@@ -94,6 +94,9 @@ const MINI_VIEW_SUMMONED = "mini-view:summoned";
 const MINI_VIEW_DISMISS = "mini-view:dismiss";
 const MINI_VIEW_REGISTRATION = "mini-view:registration";
 const MINI_VIEW_REGISTRATION_GET = "mini-view:registration-get";
+const MINI_VIEW_RESIZE = "mini-view:resize";
+const MINI_VIEW_DIALOG = "mini-view:dialog";
+const MINI_VIEW_PAINTED = "mini-view:painted";
 const MINI_VIEW_REGISTRATION_STATUSES = [
   "registered",
   "taken",
@@ -114,6 +117,9 @@ function isMiniViewRegistrationState(value) {
     state.status
   );
 }
+function isMiniViewDialogPayload(value) {
+  return value !== null && typeof value === "object" && typeof value.open === "boolean";
+}
 const OPEN_SESSION_FLAG = "--open-session";
 const OPEN_CATALOGUE_FLAG = "--open-catalogue";
 const SESSION_ID = /^[a-f0-9]{12}$/;
@@ -1019,6 +1025,37 @@ const api = {
     },
     /** This window -> main: put the mini window away, naming the act. */
     dismiss: (reason) => electron.ipcRenderer.invoke(MINI_VIEW_DISMISS, reason),
+    /**
+     * This window -> main: the content height this frame needs (design R2's
+     * measure -> IPC -> resize). Fire-and-forget by design: the frame measures
+     * on every layout settle, there is no answer to await, and main owns the
+     * clamp - see `MINI_VIEW_RESIZE` in `src/shared/mini-view.ts`.
+     */
+    resize: (height) => {
+      electron.ipcRenderer.send(MINI_VIEW_RESIZE, { height });
+    },
+    /**
+     * This window -> main: the document has committed its first paint, so the
+     * window may be shown without flashing white (see `MINI_VIEW_PAINTED`).
+     * Fire-and-forget, and sent once per load.
+     */
+    painted: () => {
+      electron.ipcRenderer.send(MINI_VIEW_PAINTED);
+    },
+    /**
+     * Main -> this window: a native dialog the window opened is up, or answered.
+     * The frame latches its blur-hide guard for the duration (see
+     * `MINI_VIEW_DIALOG`).
+     */
+    onDialog: (callback) => {
+      const handler = (_event, payload) => {
+        if (isMiniViewDialogPayload(payload)) callback(payload);
+      };
+      electron.ipcRenderer.on(MINI_VIEW_DIALOG, handler);
+      return () => {
+        electron.ipcRenderer.removeListener(MINI_VIEW_DIALOG, handler);
+      };
+    },
     /** Main -> every renderer: the live global-shortcut state. */
     onRegistration: (callback) => {
       const handler = (_event, state) => {