gloomberb 0.16.3 → 0.16.4

package/src/renderers/dom/desktop/query-bar.tsx

@@ -10,6 +10,53 @@ import { WebIcon } from "./icons";
 
 /** Input width of a text filter that names none, in cells (the terminal's default). */
 const DEFAULT_TEXT_FIELD_CELLS = 20;
+/** Beyond this many choices an inline filter is a strip that scrolls by itself, as the terminal's does. */
+const STRIP_OPTION_LIMIT = 6;
+
+function isStrip(item: HostQueryBarItem): boolean {
+  return item.kind === "select" && item.inline === true && item.options.length > STRIP_OPTION_LIMIT;
+}
+
+/**
+ * The choices of an inline filter. A long one (expiries, chart ranges) is a
+ * strip that scrolls on its own, so the label and the controls beside it stay
+ * in view while it brings the chosen one into view.
+ */
+function InlineChoices({ item }: { item: HostQueryBarItem }) {
+  const stripRef = useRef<HTMLDivElement | null>(null);
+  const strip = isStrip(item);
+  const overflow = useHorizontalOverflow(stripRef, [item.options.length, strip]);
+  return (
+    <div className="gloom-qb-inline" data-item-id={item.id} data-narrowing={item.narrowing ? "true" : undefined}
+      data-strip={strip ? "true" : undefined}>
+      <span className="gloom-qb-label">{item.label}</span>
+      <div
+        ref={stripRef}
+        className="gloom-qb-view gloom-qb-segments"
+        role="radiogroup"
+        aria-label={item.label}
+        style={strip ? overflow.maskStyle : undefined}
+        onWheel={strip ? overflow.onWheel : undefined}
+      >
+        {item.options.map((option) => (
+          <button
+            key={option.value}
+            type="button"
+            role="radio"
+            aria-checked={option.selected}
+            disabled={option.disabled}
+            title={option.hint ? `${option.label} (${option.hint})` : undefined}
+            data-active={option.selected ? "true" : undefined}
+            onMouseDown={(event) => event.stopPropagation()}
+            onClick={() => item.onSelect(option.value)}
+          >
+            <span className="gloom-qb-text">{option.label}</span>
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}
 
 function Chevron() {
   return <span className="gloom-qb-chevron"><WebIcon name="chevron-down" size={9} /></span>;
@@ -87,30 +134,7 @@ function FilterChip({ item, open, onOpenChange }: { item: HostQueryBarItem; open
   useEffect(() => {
     if (open) triggerRef.current?.scrollIntoView({ block: "nearest", inline: "nearest" });
   }, [open]);
-  if (item.kind === "select" && item.inline) {
-    return (
-      <div className="gloom-qb-inline" data-item-id={item.id} data-narrowing={item.narrowing ? "true" : undefined}>
-        <span className="gloom-qb-label">{item.label}</span>
-        <div className="gloom-qb-view gloom-qb-segments" role="radiogroup" aria-label={item.label}>
-          {item.options.map((option) => (
-            <button
-              key={option.value}
-              type="button"
-              role="radio"
-              aria-checked={option.selected}
-              disabled={option.disabled}
-              title={option.hint ? `${option.label} (${option.hint})` : undefined}
-              data-active={option.selected ? "true" : undefined}
-              onMouseDown={(event) => event.stopPropagation()}
-              onClick={() => item.onSelect(option.value)}
-            >
-              <span className="gloom-qb-text">{option.label}</span>
-            </button>
-          ))}
-        </div>
-      </div>
-    );
-  }
+  if (item.kind === "select" && item.inline) return <InlineChoices item={item} />;
   if (item.kind === "toggle") {
     return (
       <button
@@ -190,27 +214,30 @@ export function WebQueryBar({ search, items, view, onClearAll, meta, openRequest
   const overflow = useHorizontalOverflow(scrollRef, [items.length, !!search, !!view, !!onClearAll, meta]);
   const searchRef = useRef<HTMLDivElement | null>(null);
   // When an inline choice or the view changes (a shortcut, the next expiry),
-  // bring the new selection into a scrolled bar. Not on mount: a view at the
-  // right edge must not scroll the search away when the pane opens.
+  // bring the new selection into a scrolled bar. On mount only a strip that
+  // scrolls by itself shows its choice: an expiry chosen far down the strip
+  // is what the pane shows, but scrolling the whole bar to a view at the right
+  // edge would hide the search when the pane opens.
   const selectionKey = [
     ...items.filter((item) => item.inline).map((item) => `${item.id}=${item.options.find((option) => option.selected)?.value ?? ""}`),
     `view=${view?.value ?? ""}`,
   ].join("|");
-  const previousSelectionKey = useRef(selectionKey);
+  const previousSelectionKey = useRef<string | null>(null);
   useEffect(() => {
     const previous = previousSelectionKey.current;
     previousSelectionKey.current = selectionKey;
     if (previous === selectionKey) return;
-    const before = new Map(previous.split("|").map((entry) => entry.split("=") as [string, string]));
+    const before = previous == null ? null : new Map(previous.split("|").map((entry) => entry.split("=") as [string, string]));
     const bar = scrollRef.current;
     if (!bar) return;
     for (const entry of selectionKey.split("|")) {
       const [id, value] = entry.split("=") as [string, string];
-      if (before.get(id) === value) continue;
+      if (before?.get(id) === value) continue;
       const group = id === "view"
         ? bar.querySelector(":scope > .gloom-qb-view")
-        : bar.querySelector(`[data-item-id="${CSS.escape(id)}"]`);
-      group?.querySelector<HTMLElement>("button[data-active=true]")?.scrollIntoView({ block: "nearest", inline: "nearest" });
+        : [...bar.querySelectorAll("[data-item-id]")].find((item) => item.getAttribute("data-item-id") === id);
+      if (!before && group?.getAttribute("data-strip") !== "true") continue;
+      group?.querySelector<HTMLElement>("button[data-active=true]")?.scrollIntoView?.({ block: "nearest", inline: "nearest" });
     }
   }, [selectionKey]);
   useEffect(() => {
@@ -280,7 +307,7 @@ export function WebQueryBar({ search, items, view, onClearAll, meta, openRequest
       )}
       {searchNode}
       {items.length > 0 && (
-        <div className="gloom-qb-filters">
+        <div className="gloom-qb-filters" data-strip={items.some(isStrip) ? "true" : undefined}>
           {items.map((item) => (
             <FilterChip key={item.id} item={item} open={openId === item.id} onOpenChange={(open) => setOpen(item.id, open)} />
           ))}

package/src/renderers/dom/host/box.tsx

@@ -248,7 +248,7 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
         if (current && !current.shielded) {
           if (dx * dx + dy * dy < 9) return;
           current.shielded = true;
-          showDragShield();
+          showDragShield(elementRef.current);
           // Captured once it is a drag (a click keeps its usual target), the
           // moves skip hit testing and leave every other element's hover state
           // alone: nothing under the pointer restyles or repaints while a pane,

package/src/renderers/dom/host/drag-shield.ts

@@ -7,14 +7,25 @@ let shield: HTMLElement | null = null;
  * It is a single element on purpose: a class on body matched by descendant
  * rules restyled every element with a role (thousands on a busy layout) in
  * the frame the drag began, and again when it ended.
+ *
+ * A press on a resize edge (a pane's corner, a split) keeps its resize cursor
+ * for the drag instead, as a window edge does.
  */
-export function showDragShield(): void {
+export function showDragShield(pressed?: Element | null): void {
   document.body.classList.add("gloom-dragging");
-  if (shield?.isConnected) return;
-  shield = document.createElement("div");
-  shield.setAttribute("data-gloom-role", "drag-shield");
-  shield.setAttribute("aria-hidden", "true");
-  document.body.appendChild(shield);
+  if (!shield?.isConnected) {
+    shield = document.createElement("div");
+    shield.setAttribute("data-gloom-role", "drag-shield");
+    shield.setAttribute("aria-hidden", "true");
+    document.body.appendChild(shield);
+  }
+  shield.style.cursor = resizeCursor(pressed);
+}
+
+function resizeCursor(element: Element | null | undefined): string {
+  if (!element || typeof getComputedStyle !== "function") return "";
+  const cursor = getComputedStyle(element).cursor;
+  return cursor.endsWith("-resize") ? cursor : "";
 }
 
 export function hideDragShield(): void {

package/src/renderers/dom/host/live-frame.ts

@@ -18,7 +18,9 @@ const ANIMATION_CARRIES_SLIDE = typeof navigator !== "undefined"
 
 const slides = new WeakMap<HTMLElement, Animation>();
 
+/** A style value as React writes it: a bare number is pixels. */
 function renderedValue(value: unknown): string {
+  if (typeof value === "number") return `${value}px`;
   return typeof value === "string" ? value : "";
 }
 
@@ -36,7 +38,8 @@ function slide(element: HTMLElement, transform: string): void {
 /**
  * Draws a box where a drag has it this frame by restyling its element,
  * outside React: an offset on its own compositor layer, with no layout or
- * repaint. `null` hands the properties back to what React last rendered.
+ * repaint, and a size, which lays out only the box's subtree. `null` hands
+ * the properties back to what React last rendered.
  */
 export function applyLiveFrame(element: HTMLElement, frame: LiveBoxFrame | null, props: Record<string, unknown>): void {
   const style = element.style;
@@ -46,9 +49,14 @@ export function applyLiveFrame(element: HTMLElement, frame: LiveBoxFrame | null,
     slides.delete(element);
     style.transform = renderedValue(rendered.transform);
     style.willChange = renderedValue(rendered.willChange);
+    style.width = renderedValue(rendered.width);
+    style.height = renderedValue(rendered.height);
     return;
   }
+  if (frame.width !== undefined) style.width = `${frame.width * WEB_CELL_WIDTH}px`;
+  if (frame.height !== undefined) style.height = `${frame.height * WEB_CELL_HEIGHT}px`;
+  if (frame.dx === undefined && frame.dy === undefined) return;
   // Promoted once, before the first frame of the drag.
   if (style.willChange !== "transform") style.willChange = "transform";
-  slide(element, `translate3d(${frame.dx * WEB_CELL_WIDTH}px, ${frame.dy * WEB_CELL_HEIGHT}px, 0)`);
+  slide(element, `translate3d(${(frame.dx ?? 0) * WEB_CELL_WIDTH}px, ${(frame.dy ?? 0) * WEB_CELL_HEIGHT}px, 0)`);
 }

package/src/renderers/dom/input-host.tsx

@@ -1,8 +1,10 @@
 /** @jsxImportSource react */
 import { useEffect, useMemo, useSyncExternalStore, type ReactNode } from "react";
+import { flushSync } from "react-dom";
 import {
   createShortcutRegistry,
   InputHostProvider,
+  useRegisteredBeforeShortcut,
   useRegisteredShortcut,
   type InputHost,
   type KeyEventLike,
@@ -76,7 +78,7 @@ function getViewport() {
 }
 
 export function WebInputHostProvider({ children }: { children: ReactNode }) {
-  const shortcutRegistry = useMemo(() => createShortcutRegistry(), []);
+  const shortcutRegistry = useMemo(() => createShortcutRegistry({ flushSync }), []);
 
   useEffect(() => {
     // Windows fires the Menu key's contextmenu on keyup. When the app used the
@@ -144,6 +146,9 @@ export function WebInputHostProvider({ children }: { children: ReactNode }) {
     useShortcut(handler, options) {
       useRegisteredShortcut(shortcutRegistry, handler, options);
     },
+    useBeforeShortcut(listener) {
+      useRegisteredBeforeShortcut(shortcutRegistry, listener);
+    },
     useViewport() {
       return useSyncExternalStore(subscribeViewport, getViewport, getViewport);
     },

package/src/renderers/dom/styles.css

@@ -753,6 +753,19 @@ html[data-gloom-screenshot="true"] [data-gloom-role="chart-watermark"] {
   box-shadow: inset 1px 0 0 var(--qb-hairline);
 }
 .gloom-qb-inline .gloom-qb-view { margin-left: 0; box-shadow: none; align-self: stretch; }
+/* A long inline choice (an expiry strip) scrolls by itself, as the terminal's
+   does, so its label and the controls beside it stay in view. */
+.gloom-qb-filters[data-strip="true"],
+.gloom-qb-inline[data-strip="true"] { flex: 0 1 auto; min-width: 0; }
+.gloom-qb-inline[data-strip="true"] .gloom-qb-segments {
+  flex: 0 1 auto;
+  min-width: 12ch;
+  overflow-x: auto;
+  scrollbar-width: none;
+}
+.gloom-qb-inline[data-strip="true"] .gloom-qb-segments::-webkit-scrollbar { display: none; }
+.gloom-qb-inline[data-strip="true"] .gloom-qb-segments > button { flex: none; white-space: nowrap; }
+.gloom-qb-filters[data-strip="true"] > :not([data-strip="true"]) { flex: none; }
 .gloom-qb-view button {
   height: 100%;
   padding: 0 8px;

package/src/renderers/electrobun/bun/desktop/backend.ts

@@ -105,6 +105,8 @@ export class DesktopBackend {
     getWindowKey: this.rpcs.getRpcWindowKey,
   });
   readonly detachedWindows = new DesktopDetachedWindowManager(this);
+  /** Each pane type's plugin, for hiding popped-out windows with their plugin. */
+  paneOwners: ReadonlyMap<string, string> = new Map();
 
   private crashReporterInstalled = false;
   private restartInProgress = false;
@@ -162,9 +164,11 @@ export class DesktopBackend {
   async startServices(nextConfig: AppConfig): Promise<{ config: AppConfig; services: AppServices }> {
     this.setConfig(nextConfig);
     const config = this.requireConfig();
+    const { paneOwners, ...backendPlugins } = await loadDesktopBackendPlugins();
+    this.paneOwners = paneOwners;
     const services = createAppServices({
       config,
-      ...await loadDesktopBackendPlugins(),
+      ...backendPlugins,
     });
     this.services = services;
     await services.ready;

package/src/renderers/electrobun/bun/desktop/detached-windows.ts

@@ -73,7 +73,18 @@ export class DesktopDetachedWindowManager {
     const config = this.backend.config;
     if (!config) return;
 
-    const desiredEntries = new Map(config.layout.detached.map((entry) => [entry.instanceId, entry] as const));
+    // A pane whose plugin is switched off stays in the layout, out of sight,
+    // as it does in the main window: its window closes without undocking or
+    // removing it, and opens again where it was when the plugin is back on.
+    const disabledPlugins = new Set(config.disabledPlugins);
+    const hidden = (instanceId: string) => {
+      const paneType = findPaneInstance(config.layout, instanceId)?.paneId;
+      const owner = paneType ? this.backend.paneOwners.get(paneType) : undefined;
+      return !!owner && disabledPlugins.has(owner);
+    };
+    const desiredEntries = new Map(config.layout.detached
+      .filter((entry) => !hidden(entry.instanceId))
+      .map((entry) => [entry.instanceId, entry] as const));
     for (const [instanceId, entry] of desiredEntries) {
       const existingWindow = this.windows.get(instanceId);
       if (!existingWindow) {

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync } from "fs";
-import { homedir } from "os";
+import { homedir, hostname } from "os";
 import { getGloomberbDirs } from "../../../../data/config/home";
 import type { AppServices } from "../../../../core/app-services";
 import { restoreExtractedPlugins } from "../../../../cli/restore-plugins";
@@ -81,6 +81,7 @@ function buildInitializationPayload(
     savedResources: loadSavedResources(services, config),
     capabilityManifests: desktopRendererCapabilityManifests(services.pluginRegistry.capabilities),
     desktopPlatform: process.platform,
+    hostName: hostname(),
     windowKind: windowTarget.kind,
     paneId: windowTarget.paneId,
     telemetry: {

package/src/renderers/electrobun/shared/protocol.ts

@@ -23,6 +23,8 @@ export interface ElectrobunBackendInit {
   savedResources?: CachedResourceRecord[];
   capabilityManifests: CapabilityManifest[];
   desktopPlatform: string;
+  /** The machine name, which a remote assistant sees this desktop app under. */
+  hostName?: string;
   windowKind: "main" | "detached";
   paneId?: string;
   /** What the view needs to send crash reports and usage counts the same way the Bun process would. */

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -441,7 +441,7 @@ function ShotPane({ payload, registry }: { payload: DesktopPaneShotPayload; regi
   const height = payload.heightCells;
   // PORT keeps what its basket covers, so a capture never reads as the whole account.
   return (
-    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} preserveStatus={["time-sales", "gpu", "hiring", "apps", "catalysts", "litigation", "perps", "members", "analytics"].includes(pane.id)}>
+    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} statusLine={payload.statusLine === true} preserveStatus={["time-sales", "gpu", "hiring", "apps", "catalysts", "litigation", "perps", "members", "analytics"].includes(pane.id)}>
       {(bodyFrame) => <PaneContent
         component={pane.component}
         paneId={instance.instanceId}

package/src/renderers/electrobun/view/cli-pane-shot-frame.tsx

@@ -1,20 +1,116 @@
 /** @jsxImportSource react */
-import type { ReactNode } from "react";
+import { useEffect, useState, type ReactNode } from "react";
 import { FloatingPaneWrapper } from "../../../components/layout/floating-pane";
-import { PaneFooterProvider, hasPaneFooterContent } from "../../../components/layout/pane/footer";
+import { PaneFooterProvider, hasPaneFooterContent, type PaneFooterSegment } from "../../../components/layout/pane/footer";
 import { resolvePaneBodyFrame } from "../../../components/layout/pane/sizing";
 
-/** Static captures retain warnings and optional source status without action shortcuts. */
-export function PaneShotFrame({ paneId, title, width, height, preserveStatus = false, children }: {
+declare global {
+  interface Window {
+    /**
+     * Set by a capture that carries a status line: shows the first of the
+     * variants (longest first) that fits the footer, cut in the middle when
+     * none does, and resolves to the text shown.
+     */
+    __GLOOM_CLI_SHOT_FIT_STATUS__?: (variants: string[]) => Promise<string>;
+  }
+}
+
+/**
+ * Holds the footer row from the first frame, while the status line is still
+ * being worked out from what the pane loaded, so the body never resizes.
+ */
+const PENDING_STATUS = "\u00a0";
+
+function nextFrames(count: number): Promise<void> {
+  return new Promise((resolve) => {
+    const step = (left: number) => (left <= 0 ? resolve() : requestAnimationFrame(() => step(left - 1)));
+    step(count);
+  });
+}
+
+/** Keeps the start and the end of a line that does not fit, `keep` characters in all. */
+function middleEllipsis(text: string, keep: number): string {
+  if (keep >= text.length) return text;
+  const head = Math.ceil(keep / 2);
+  const tail = Math.max(0, keep - head);
+  return `${text.slice(0, head).trimEnd()}…${tail > 0 ? text.slice(text.length - tail).trimStart() : ""}`;
+}
+
+/**
+ * The first variant that fits, else the last one cut in the middle as little
+ * as it must be. `show` puts a text on screen and resolves once it is drawn.
+ */
+async function fitStatusLine(
+  variants: readonly string[],
+  show: (text: string) => Promise<void>,
+  overflows: () => boolean,
+): Promise<string> {
+  for (const variant of variants) {
+    await show(variant);
+    if (!overflows()) return variant;
+  }
+  const last = variants.at(-1) ?? "";
+  let low = 1;
+  let high = last.length - 1;
+  let best = middleEllipsis(last, 1);
+  while (low <= high) {
+    const keep = Math.floor((low + high) / 2);
+    const text = middleEllipsis(last, keep);
+    await show(text);
+    if (overflows()) {
+      high = keep - 1;
+    } else {
+      best = text;
+      low = keep + 1;
+    }
+  }
+  await show(best);
+  return best;
+}
+
+function footerOverflows(): boolean {
+  const footer = document.querySelector('[data-gloom-role="pane-footer"]');
+  if (!footer) return false;
+  return [footer, ...footer.querySelectorAll("*")].some((element) => (
+    element instanceof HTMLElement && element.scrollWidth > element.clientWidth + 1
+  ));
+}
+
+function useShotStatusLine(enabled: boolean): string {
+  const [text, setText] = useState(PENDING_STATUS);
+  useEffect(() => {
+    if (!enabled) return;
+    window.__GLOOM_CLI_SHOT_FIT_STATUS__ = (variants) => fitStatusLine(variants, async (next) => {
+      setText(next);
+      await nextFrames(2);
+    }, footerOverflows);
+    return () => {
+      delete window.__GLOOM_CLI_SHOT_FIT_STATUS__;
+    };
+  }, [enabled]);
+  return text;
+}
+
+/**
+ * Static captures retain warnings and optional source status without action
+ * shortcuts. With `statusLine` the footer also carries the capture's dated
+ * status line (`Fri 9 Oct close · 15 min delayed · markets closed until Mon`),
+ * inside the requested size: the body gives up the footer row for it.
+ */
+export function PaneShotFrame({ paneId, title, width, height, preserveStatus = false, statusLine = false, children }: {
   paneId: string;
   title: string;
   width: number;
   height: number;
   preserveStatus?: boolean;
+  statusLine?: boolean;
   children: (frame: ReturnType<typeof resolvePaneBodyFrame>) => ReactNode;
 }) {
+  const statusText = useShotStatusLine(statusLine);
   return <PaneFooterProvider>{(registeredFooter) => {
-    const footer = { info: registeredFooter.info.filter((segment) => preserveStatus || segment.icon === "warning"), hints: [], menu: [], keys: [] };
+    const status: PaneFooterSegment[] = statusLine ? [{ id: "shot-status", parts: [{ text: statusText, tone: "label" }] }] : [];
+    const info = registeredFooter.info.filter((segment) => preserveStatus || segment.icon === "warning");
+    const footer = { info: [...info, ...status], hints: [], menu: [], keys: [] };
     const bodyFrame = resolvePaneBodyFrame({
       width,
       height,

package/src/renderers/electrobun/view/main.tsx

@@ -210,7 +210,10 @@ async function boot() {
   });
 
   const remoteControlAdapter = init.windowKind === "main"
-    ? { registerHandler: setElectrobunRemoteRequestHandler }
+    ? {
+      registerHandler: setElectrobunRemoteRequestHandler,
+      terminalDevice: { kind: "desktop" as const, name: init.hostName?.trim() || "Gloom desktop" },
+    }
     : undefined;
   measurePerfAsync("startup.electrobun.root-render", async () => {
     root.render(

package/src/renderers/opentui/input-host.tsx

@@ -1,8 +1,10 @@
+import { flushSync } from "@opentui/react";
 import { useMemo, type ReactNode } from "react";
 import { useNativeRenderer } from "../../ui";
 import {
   createShortcutRegistry,
   InputHostProvider,
+  useRegisteredBeforeShortcut,
   useRegisteredShortcut,
   type InputHost,
 } from "../../react/input";
@@ -10,7 +12,7 @@ import { toKeyEventLike, useKeyboard, useTerminalDimensions } from "./host";
 
 export function OpenTuiInputHostProvider({ children }: { children: ReactNode }) {
   const renderer = useNativeRenderer();
-  const shortcutRegistry = useMemo(() => createShortcutRegistry(), []);
+  const shortcutRegistry = useMemo(() => createShortcutRegistry({ flushSync }), []);
 
   useKeyboard((event) => {
     const shortcutEvent = toKeyEventLike(event);
@@ -22,6 +24,9 @@ export function OpenTuiInputHostProvider({ children }: { children: ReactNode })
     useShortcut(handler, options) {
       useRegisteredShortcut(shortcutRegistry, handler, options);
     },
+    useBeforeShortcut(listener) {
+      useRegisteredBeforeShortcut(shortcutRegistry, listener);
+    },
     useViewport() {
       const dimensions = useTerminalDimensions();
       return { width: dimensions.width, height: dimensions.height };

package/src/renderers/opentui/start.tsx

@@ -1,3 +1,4 @@
+import { hostname } from "os";
 import { getGloomberbDirs } from "../../data/config/home";
 import { existsSync, mkdirSync } from "fs";
 import { App } from "../../app";
@@ -38,6 +39,8 @@ import {
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
 import { attentionCountsEnabled, installAttentionCounter } from "../../telemetry/attention-counts";
+import { starPromptEnvironmentAllows } from "../../app/star-prompt/model";
+import { allowStarPrompt } from "../../app/star-prompt/runtime";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
@@ -56,6 +59,7 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
   const appLog = debugLog.createLogger("app");
   appLog.info("Gloomberb starting");
   const remoteControlAdapter: RemoteControlAdapter = {
+    terminalDevice: { kind: "tui", name: hostname() },
     startServer: ({ dataDir, handle }) => {
       let closed = false;
       const serverPromise: Promise<RemoteControlServer> = startRemoteControlServer({
@@ -121,6 +125,11 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       officialPluginIds: loadOfficialPluginIds,
     });
     const stopAttention = installAttentionCounter(() => attentionCountsEnabled(currentTelemetryConfig(config), process.env));
+    allowStarPrompt(starPromptEnvironmentAllows({
+      env: process.env,
+      stdinIsTTY: process.stdin.isTTY,
+      stdoutIsTTY: process.stdout.isTTY,
+    }));
     host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
     const renderer = host.renderer;
     renderer.once("destroy", stopAttention);

package/src/shares/portable-layout.ts

@@ -1,4 +1,5 @@
 import type { PaneRuntimeState } from "../core/state/app/types";
+import { foldPaneLayout } from "../data/config/store/fold-panes";
 import { publicTickerBindingSymbol } from "../tickers/selection";
 import { pinFollowingPane } from "../layout/pane-follow";
 import {
@@ -641,28 +642,37 @@ export function materializeMarketplaceLayout(
     `${paneId.slice(0, 80)}:shared-${crypto.randomUUID().replaceAll("-", "").slice(0, 20)}`
   ),
 ): { layout: LayoutConfig; paneState: Record<string, PaneRuntimeState> } {
-  const ids = new Map(payload.layout.instances.map((instance, index) => [
+  // A layout or pane shared before SIV and SOVR folded into SI and CDX still
+  // names the old panes. It opens the way a saved layout migrates.
+  const folded = foldPaneLayout(payload.layout);
+  const source = {
+    layout: folded.layout,
+    paneState: Object.fromEntries(Object.entries(payload.paneState).flatMap(([id, state]) => (
+      folded.removed.has(id) ? [] : [[folded.idMap.get(id) ?? id, state]]
+    ))),
+  };
+  const ids = new Map(source.layout.instances.map((instance, index) => [
     instance.instanceId,
     createId(instance.paneId, index),
   ]));
   if (new Set(ids.values()).size !== ids.size) throw new Error("Could not create unique pane ids for this layout.");
   const layout: LayoutConfig = {
-    dockRoot: mapDockNode(payload.layout.dockRoot, ids),
-    instances: payload.layout.instances.map((instance) => ({
+    dockRoot: mapDockNode(source.layout.dockRoot, ids),
+    instances: source.layout.instances.map((instance) => ({
       ...structuredClone(instance),
       instanceId: ids.get(instance.instanceId)!,
       ...(instance.binding ? { binding: mapBinding(instance.binding, ids) } : {}),
     })),
-    floating: payload.layout.floating.map((entry) => ({
+    floating: source.layout.floating.map((entry) => ({
       ...entry,
       instanceId: ids.get(entry.instanceId) ?? entry.instanceId,
     })),
-    detached: payload.layout.detached.map((entry) => ({
+    detached: source.layout.detached.map((entry) => ({
       ...entry,
       instanceId: ids.get(entry.instanceId) ?? entry.instanceId,
     })),
   };
-  const paneState = Object.fromEntries(Object.entries(payload.paneState).flatMap(([id, state]) => {
+  const paneState = Object.fromEntries(Object.entries(source.paneState).flatMap(([id, state]) => {
     const materializedId = ids.get(id);
     return materializedId ? [[materializedId, structuredClone(state)]] : [];
   }));