gloomberb 0.13.2 → 0.14.0

package/src/plugins/launch-layout.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig, type AppConfig } from "../types/config";
+import type { AppSessionSnapshot, PaneDef } from "../types/plugin";
+import { openPaneForLaunch, seedPaneLaunchSession } from "./launch-layout";
+
+const PANE_ID = "launch-test-pane";
+
+const PANE_DEF: PaneDef = {
+  id: PANE_ID,
+  name: "Launch test",
+  component: () => null,
+  defaultPosition: "left",
+  defaultMode: "floating",
+  defaultFloatingSize: { width: 120, height: 32 },
+};
+
+function launch(config: AppConfig, params?: Record<string, string>) {
+  return openPaneForLaunch(config, {
+    paneId: PANE_ID,
+    instanceId: `${PANE_ID}:main`,
+    paneDef: PANE_DEF,
+    params,
+    terminalSize: { width: 140, height: 42 },
+  });
+}
+
+describe("openPaneForLaunch", () => {
+  test("adds the pane as a floating instance and syncs the active workspace", () => {
+    const result = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"), { query: "iran" });
+
+    expect(result.paneInstanceId).toBe(`${PANE_ID}:main`);
+    expect(result.config.layout.instances.find((instance) => instance.instanceId === result.paneInstanceId)?.params)
+      .toEqual({ query: "iran" });
+    expect(result.config.layout.floating.some((entry) => entry.instanceId === result.paneInstanceId)).toBe(true);
+    // The saved workspace and the live layout are the same layout; writing only
+    // one of them loses the pane on the next workspace switch.
+    expect(result.config.layouts[result.config.activeLayoutIndex]?.layout.floating
+      .some((entry) => entry.instanceId === result.paneInstanceId)).toBe(true);
+  });
+
+  test("reuses the instance the user already has rather than adding a second one", () => {
+    const first = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"), { query: "iran" });
+    const second = launch(first.config, { query: "fed" });
+
+    expect(second.paneInstanceId).toBe(first.paneInstanceId);
+    expect(second.config.layout.instances.filter((instance) => instance.paneId === PANE_ID)).toHaveLength(1);
+    expect(second.config.layout.instances.find((instance) => instance.instanceId === second.paneInstanceId)?.params)
+      .toEqual({ query: "fed" });
+  });
+
+  test("re-places an instance that is remembered but no longer in the layout", () => {
+    const opened = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"));
+    // Closing a pane keeps its instance so its settings survive; the launch has
+    // to put it back rather than find it and do nothing.
+    const closed: AppConfig = {
+      ...opened.config,
+      layout: { ...opened.config.layout, floating: [] },
+    };
+
+    const relaunched = launch(closed);
+
+    expect(relaunched.paneInstanceId).toBe(opened.paneInstanceId);
+    expect(relaunched.config.layout.floating.some((entry) => entry.instanceId === opened.paneInstanceId)).toBe(true);
+  });
+
+  test("brings an open floating pane to the front", () => {
+    const opened = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"));
+    const behind: AppConfig = {
+      ...opened.config,
+      layout: {
+        ...opened.config.layout,
+        floating: [
+          ...opened.config.layout.floating,
+          { ...opened.config.layout.floating[0]!, instanceId: "other:main" },
+        ],
+      },
+    };
+
+    const relaunched = launch(behind);
+
+    expect(relaunched.config.layout.floating.at(-1)?.instanceId).toBe(opened.paneInstanceId);
+  });
+});
+
+describe("seedPaneLaunchSession", () => {
+  test("focuses the pane and merges plugin state over what the last session saved", () => {
+    const opened = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"));
+    const snapshot: AppSessionSnapshot = {
+      paneState: {
+        [opened.paneInstanceId]: {
+          pluginState: { "launch-test": { query: "old", scrollTop: 40 } },
+        },
+      },
+      focusedPaneId: "portfolio-list:main",
+      activePanel: "right",
+      statusBarVisible: false,
+      openPaneIds: ["portfolio-list:main"],
+      hydrationTargets: [],
+      exchangeCurrencies: [],
+      savedAt: 1,
+    };
+
+    const seeded = seedPaneLaunchSession(opened.config, snapshot, {
+      paneInstanceId: opened.paneInstanceId,
+      pluginId: "launch-test",
+      pluginState: { query: "iran", selectedRowKey: null },
+    });
+
+    expect(seeded.focusedPaneId).toBe(opened.paneInstanceId);
+    expect(seeded.openPaneIds).toContain(opened.paneInstanceId);
+    expect(seeded.openPaneIds).toContain("portfolio-list:main");
+    expect(seeded.activePanel).toBe("right");
+    expect(seeded.statusBarVisible).toBe(false);
+    expect((seeded.paneState[opened.paneInstanceId]?.pluginState as Record<string, Record<string, unknown>>)["launch-test"])
+      .toEqual({ query: "iran", scrollTop: 40, selectedRowKey: null });
+  });
+
+  test("starts from the current layout when there is no previous session", () => {
+    const opened = launch(createDefaultConfig("/tmp/gloomberb-launch-layout"));
+
+    const seeded = seedPaneLaunchSession(opened.config, null, {
+      paneInstanceId: opened.paneInstanceId,
+      pluginId: "launch-test",
+      pluginState: { query: "iran" },
+    });
+
+    expect(seeded.openPaneIds).toContain(opened.paneInstanceId);
+    expect(seeded.activePanel).toBe("left");
+    expect(seeded.statusBarVisible).toBe(true);
+  });
+});

package/src/plugins/launch-layout.ts

@@ -0,0 +1,148 @@
+import {
+  cloneLayout,
+  createPaneInstance,
+  findPaneInstance,
+  type AppConfig,
+  type SavedLayout,
+} from "../types/config";
+import type { AppSessionSnapshot, PaneDef } from "../types/plugin";
+import { addPaneFloating, bringToFront, getDockedPaneIds, isPaneInLayout } from "./pane-manager";
+
+/**
+ * Opening a pane from a CLI command that launches the UI.
+ *
+ * `gloomberb <something> <args>` has to leave the app in the state the
+ * arguments describe before the first frame: the pane present, focused, and
+ * already holding the query rather than whatever the last session left. That is
+ * two writes with different lifetimes — the layout in the config, the pane's
+ * own state in the session snapshot — and getting either subtly wrong (a second
+ * instance, a floating pane behind the others, a stale search) is not visible
+ * until someone runs the command. These two helpers are that logic, so a plugin
+ * with a launch command does not reimplement the layout rules.
+ */
+
+export interface PaneLaunchPlacement {
+  paneId: string;
+  /** Used only when the layout has no instance of this pane yet. */
+  instanceId: string;
+  /** The plugin's own pane definition, for the floating size and position. */
+  paneDef: PaneDef;
+  /** Merged into the instance, so the pane reads the request on first render. */
+  params?: Record<string, string>;
+  terminalSize: { width: number; height: number };
+}
+
+function syncActiveLayout(
+  layouts: SavedLayout[],
+  activeLayoutIndex: number,
+  nextLayout: AppConfig["layout"],
+): SavedLayout[] {
+  return layouts.map((entry, index) => (
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(nextLayout) }
+      : { ...entry, layout: cloneLayout(entry.layout) }
+  ));
+}
+
+/**
+ * Returns the config with the pane open and frontmost, reusing the instance the
+ * user already has rather than adding a second one: a launch command run
+ * against a saved workspace should land in the pane that is already there.
+ */
+export function openPaneForLaunch(
+  config: AppConfig,
+  placement: PaneLaunchPlacement,
+): { config: AppConfig; paneInstanceId: string } {
+  const { paneId, instanceId, paneDef, params, terminalSize } = placement;
+  let nextLayout = cloneLayout(config.layout);
+  let targetInstance = nextLayout.instances.find((instance) => instance.paneId === paneId) ?? null;
+
+  if (!targetInstance) {
+    targetInstance = createPaneInstance(paneId, { instanceId, params });
+    nextLayout = addPaneFloating(
+      nextLayout,
+      targetInstance,
+      terminalSize.width,
+      terminalSize.height,
+      paneDef,
+    );
+  } else {
+    const existingInstanceId = targetInstance.instanceId;
+    nextLayout = {
+      ...nextLayout,
+      instances: nextLayout.instances.map((instance) => (
+        instance.instanceId === existingInstanceId
+          ? { ...instance, params: { ...(instance.params ?? {}), ...(params ?? {}) } }
+          : instance
+      )),
+    };
+    targetInstance = findPaneInstance(nextLayout, existingInstanceId) ?? targetInstance;
+    // Present in `instances` but not placed: a pane the user closed without
+    // discarding its settings. Put it back where a new one would go.
+    if (!isPaneInLayout(nextLayout, existingInstanceId)) {
+      nextLayout = addPaneFloating(
+        nextLayout,
+        targetInstance,
+        terminalSize.width,
+        terminalSize.height,
+        paneDef,
+      );
+    } else if (nextLayout.floating.some((entry) => entry.instanceId === existingInstanceId)) {
+      nextLayout = bringToFront(nextLayout, existingInstanceId);
+    }
+  }
+
+  return {
+    config: {
+      ...config,
+      layout: nextLayout,
+      layouts: syncActiveLayout(config.layouts, config.activeLayoutIndex, nextLayout),
+    },
+    paneInstanceId: targetInstance.instanceId,
+  };
+}
+
+/**
+ * Returns the session snapshot with the pane focused and its plugin state
+ * seeded, preserving everything else the previous session saved.
+ */
+export function seedPaneLaunchSession(
+  config: AppConfig,
+  snapshot: AppSessionSnapshot | null,
+  options: {
+    paneInstanceId: string;
+    pluginId: string;
+    pluginState: Record<string, unknown>;
+  },
+): AppSessionSnapshot {
+  const { paneInstanceId, pluginId, pluginState } = options;
+  const currentPaneState = snapshot?.paneState?.[paneInstanceId] ?? {};
+  const currentPluginState =
+    (currentPaneState.pluginState as Record<string, Record<string, unknown>> | undefined) ?? {};
+
+  return {
+    paneState: {
+      ...(snapshot?.paneState ?? {}),
+      [paneInstanceId]: {
+        ...currentPaneState,
+        pluginState: {
+          ...currentPluginState,
+          [pluginId]: { ...(currentPluginState[pluginId] ?? {}), ...pluginState },
+        },
+      },
+    },
+    focusedPaneId: paneInstanceId,
+    activePanel: snapshot?.activePanel === "right" ? "right" : "left",
+    statusBarVisible: snapshot?.statusBarVisible !== false,
+    openPaneIds: [
+      ...new Set([
+        ...(snapshot?.openPaneIds ?? []),
+        ...getDockedPaneIds(config.layout),
+        ...config.layout.floating.map((entry) => entry.instanceId),
+      ]),
+    ],
+    hydrationTargets: [...(snapshot?.hydrationTargets ?? [])],
+    exchangeCurrencies: [...(snapshot?.exchangeCurrencies ?? [])],
+    savedAt: Date.now(),
+  };
+}

package/src/plugins/loader.test.ts

@@ -0,0 +1,54 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { readPluginCommit } from "./loader";
+
+const scratch: string[] = [];
+
+function checkout(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gloom-plugin-"));
+  scratch.push(dir);
+  mkdirSync(join(dir, ".git", "refs", "heads"), { recursive: true });
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of scratch.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+const SHA = "0123456789abcdef0123456789abcdef01234567";
+
+/**
+ * Read without spawning git, once per plugin at every startup. The three
+ * layouts git actually writes are covered; anything else must come back null
+ * rather than a wrong commit that the update check would then trust.
+ */
+describe("readPluginCommit", () => {
+  test("reads a detached HEAD, which is what a pinned install leaves", () => {
+    const dir = checkout();
+    writeFileSync(join(dir, ".git", "HEAD"), `${SHA}\n`);
+    expect(readPluginCommit(dir)).toBe(SHA);
+  });
+
+  test("follows a branch ref to its loose file", () => {
+    const dir = checkout();
+    writeFileSync(join(dir, ".git", "HEAD"), "ref: refs/heads/main\n");
+    writeFileSync(join(dir, ".git", "refs", "heads", "main"), `${SHA}\n`);
+    expect(readPluginCommit(dir)).toBe(SHA);
+  });
+
+  test("falls back to packed-refs after git gc", () => {
+    const dir = checkout();
+    writeFileSync(join(dir, ".git", "HEAD"), "ref: refs/heads/main\n");
+    writeFileSync(join(dir, ".git", "packed-refs"), `# pack-refs with: peeled fully-peeled sorted\n${SHA} refs/heads/main\n`);
+    expect(readPluginCommit(dir)).toBe(SHA);
+  });
+
+  test("is null for a folder that is not a checkout", () => {
+    const dir = mkdtempSync(join(tmpdir(), "gloom-plain-"));
+    scratch.push(dir);
+    expect(readPluginCommit(dir)).toBeNull();
+  });
+});

package/src/plugins/loader.ts

@@ -1,6 +1,6 @@
 import { readdir } from "fs/promises";
-import { join } from "path";
-import { existsSync } from "fs";
+import { basename, join } from "path";
+import { existsSync, lstatSync, readFileSync, statSync } from "fs";
 import { homedir } from "os";
 import type { GloomPlugin, PluginTarget } from "../types/plugin";
 import { debugLog } from "../utils/debug-log";
@@ -18,9 +18,17 @@ const PLUGIN_CACHE_DIR = join(process.env.HOME || homedir(), ".gloomberb", "plug
 export interface LoadedExternalPlugin {
   plugin: GloomPlugin;
   path: string;
+  /** Folder name under the plugins directory; what `update` and `remove` address. */
+  directory?: string;
+  /** The checked-out git commit, when the install is a git checkout. */
+  commit?: string;
+  /** A symlink to a local checkout (`gloomberb plugin link`) rather than a clone. */
+  linked?: boolean;
   error?: string;
   /** Set when the plugin loaded but does not support the running renderer. */
   unsupportedTarget?: PluginTarget;
+  /** Loaded after startup in a way this session could not fully apply. */
+  needsRestart?: boolean;
 }
 
 export function getPluginsDir(): string {
@@ -96,44 +104,138 @@ export function pluginSupportsTarget(plugin: GloomPlugin, target: PluginTarget):
   return !plugin.targets || plugin.targets.length === 0 || plugin.targets.includes(target);
 }
 
-export async function loadExternalPlugins(target: PluginTarget = "cli"): Promise<LoadedExternalPlugin[]> {
-  if (!existsSync(PLUGINS_DIR)) return [];
+/**
+ * The commit a plugin checkout is at, read from `.git` directly so startup does
+ * not spawn one git process per plugin. Returns null for anything that is not
+ * a git checkout (a hand-copied folder, or a dev symlink without history).
+ */
+export function readPluginCommit(pluginDir: string): string | null {
+  const gitDir = join(pluginDir, ".git");
+  try {
+    const head = readFileSync(join(gitDir, "HEAD"), "utf-8").trim();
+    if (/^[0-9a-f]{40}$/i.test(head)) return head;
+    const ref = head.startsWith("ref: ") ? head.slice(5).trim() : null;
+    if (!ref) return null;
+    const refPath = join(gitDir, ref);
+    if (existsSync(refPath)) return readFileSync(refPath, "utf-8").trim() || null;
+    const packed = join(gitDir, "packed-refs");
+    if (!existsSync(packed)) return null;
+    for (const line of readFileSync(packed, "utf-8").split("\n")) {
+      const [sha, name] = line.trim().split(/\s+/);
+      if (name === ref && sha && /^[0-9a-f]{40}$/i.test(sha)) return sha;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 
-  const results: LoadedExternalPlugin[] = [];
-  const entries = await readdir(PLUGINS_DIR, { withFileTypes: true });
+export interface LoadExternalPluginOptions {
+  /**
+   * Import the entry as a fresh module. Bun caches `import()` by URL, so a
+   * plugin that was already evaluated in this process would otherwise come
+   * back unchanged after `update`.
+   */
+  fresh?: boolean;
+}
 
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !isPluginDirectory(entry.name)) continue;
-    const pluginDir = join(PLUGINS_DIR, entry.name);
-
-    const entryFile = await resolvePluginEntry(pluginDir);
-    if (!entryFile) continue;
-
-    // Repairs `gloomberb`/`react` links for plugins copied in by hand or left
-    // behind by a `bun install` that pruned them.
-    linkHostPackages(pluginDir);
-
-    try {
-      const mod = await import(entryFile);
-      const plugin: GloomPlugin = mod.default ?? mod.plugin;
-      if (plugin && plugin.id && plugin.name) {
-        if (!pluginSupportsTarget(plugin, target)) {
-          loaderLog.info(`Skipped ${plugin.id}: does not support "${target}"`);
-          results.push({ plugin, path: pluginDir, unsupportedTarget: target });
-          continue;
-        }
-        loaderLog.info(`Loaded external plugin: ${plugin.id} v${plugin.version ?? "0.0.0"}`);
-        results.push({ plugin, path: pluginDir });
-      }
-    } catch (err) {
-      loaderLog.error(`Failed to load plugin from ${pluginDir}: ${err}`);
-      results.push({
-        plugin: { id: entry.name, name: entry.name, version: "0.0.0" } as GloomPlugin,
-        path: pluginDir,
-        error: String(err),
-      });
+/** Loads one plugin directory. Never throws: a broken plugin comes back with `error` set. */
+export async function loadExternalPlugin(
+  pluginDir: string,
+  target: PluginTarget = "cli",
+  options: LoadExternalPluginOptions = {},
+): Promise<LoadedExternalPlugin | null> {
+  const directory = basename(pluginDir);
+  const entryFile = await resolvePluginEntry(pluginDir);
+  if (!entryFile) return null;
+
+  // Repairs `gloomberb`/`react` links for plugins copied in by hand or left
+  // behind by a `bun install` that pruned them.
+  linkHostPackages(pluginDir);
+
+  const commit = readPluginCommit(pluginDir);
+  const base = {
+    path: pluginDir,
+    directory,
+    ...(commit ? { commit } : {}),
+    ...(isSymlink(pluginDir) ? { linked: true } : {}),
+  };
+
+  try {
+    const specifier = options.fresh ? `${entryFile}?reload=${Date.now()}` : entryFile;
+    const mod = await import(specifier);
+    const plugin: GloomPlugin = mod.default ?? mod.plugin;
+    if (!plugin || !plugin.id || !plugin.name) {
+      return {
+        ...base,
+        plugin: { id: directory, name: directory, version: "" } as GloomPlugin,
+        error: "Plugin did not export a valid GloomPlugin (missing id or name).",
+      };
     }
+    if (!pluginSupportsTarget(plugin, target)) {
+      loaderLog.info(`Skipped ${plugin.id}: does not support "${target}"`);
+      return { ...base, plugin, unsupportedTarget: target };
+    }
+    loaderLog.info(`Loaded external plugin: ${plugin.id} v${plugin.version ?? "0.0.0"}`);
+    return { ...base, plugin };
+  } catch (err) {
+    loaderLog.error(`Failed to load plugin from ${pluginDir}: ${err}`);
+    return {
+      ...base,
+      plugin: { id: directory, name: directory, version: "" } as GloomPlugin,
+      error: err instanceof Error ? err.message : String(err),
+    };
   }
+}
 
+/**
+ * Every plugin folder under the plugins directory, linked to the host.
+ *
+ * Linking has to finish for all of them before any is imported. A plugin
+ * that imports a sibling (Gateway imports Flex) pulls the sibling's files in
+ * during its own import, and those files resolve `gloomberb/*` from the
+ * sibling's folder. If that folder is linked only when its own turn comes,
+ * the lookup fails, and Bun caches the miss, so linking it afterwards does
+ * not repair the sibling either. Which plugin comes first is up to readdir.
+ */
+export async function listPluginDirectories(pluginsDir: string = PLUGINS_DIR): Promise<string[]> {
+  if (!existsSync(pluginsDir)) return [];
+  const entries = await readdir(pluginsDir, { withFileTypes: true });
+  const dirs: string[] = [];
+  for (const entry of entries) {
+    if (!isPluginDirectory(entry.name)) continue;
+    const pluginDir = join(pluginsDir, entry.name);
+    if (isDirectoryOrLink(entry, pluginDir)) dirs.push(pluginDir);
+  }
+  dirs.sort();
+  for (const pluginDir of dirs) linkHostPackages(pluginDir);
+  return dirs;
+}
+
+export async function loadExternalPlugins(target: PluginTarget = "cli"): Promise<LoadedExternalPlugin[]> {
+  const results: LoadedExternalPlugin[] = [];
+  for (const pluginDir of await listPluginDirectories()) {
+    const loaded = await loadExternalPlugin(pluginDir, target);
+    if (loaded) results.push(loaded);
+  }
   return results;
 }
+
+function isSymlink(path: string): boolean {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/** A linked plugin (`gloomberb plugin link`) is a symlink, which `readdir` does not report as a directory. */
+export function isDirectoryOrLink(entry: { isDirectory(): boolean; isSymbolicLink(): boolean }, path: string): boolean {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/plugins/manager-node.ts

@@ -0,0 +1,41 @@
+import { join } from "path";
+import type { PluginManager, PluginOperationResult } from "./builtin/plugin-marketplace/store";
+import { getPluginsDir, loadExternalPlugin, type LoadedExternalPlugin } from "./loader";
+import type { PluginTarget } from "../types/plugin";
+
+/**
+ * The plugin manager for a process that can run git and bun: the terminal,
+ * and the desktop's Bun side on behalf of its view. Wraps the CLI commands so
+ * the marketplace and `gloomberb install` do exactly the same thing, and
+ * turns their failures into results the pane can show next to the row.
+ */
+
+async function attempt(run: () => Promise<{ directory: string }>): Promise<PluginOperationResult> {
+  try {
+    const { directory } = await run();
+    return { ok: true, directory };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function createNodePluginManager(target: PluginTarget): PluginManager {
+  return {
+    install: (repo, pin) => attempt(async () => {
+      const { installPlugin } = await import("../cli/commands/plugins");
+      return installPlugin(repo, { quiet: true, pin });
+    }),
+    update: (directory, pin) => attempt(async () => {
+      const { updatePlugin } = await import("../cli/commands/plugins");
+      return updatePlugin(directory, { quiet: true, pin });
+    }),
+    remove: (directory) => attempt(async () => {
+      const { removePlugin } = await import("../cli/commands/plugins");
+      await removePlugin(directory, { quiet: true });
+      return { directory };
+    }),
+    load: (directory): Promise<LoadedExternalPlugin | null> => (
+      loadExternalPlugin(join(getPluginsDir(), directory), target, { fresh: true })
+    ),
+  };
+}

package/src/plugins/ownership.ts

@@ -8,18 +8,19 @@ const BUILTIN_PLUGIN_OWNER_ALIASES: Record<string, string> = {
   correlation: "market-overview",
   "earnings-calendar": "macro",
   "earnings-calls": "macro",
-  "ipo-calendar": "macro",
-  "fear-greed": "market-overview",
   "fx-matrix": "market-overview",
   help: "application",
   holders: "ticker-research",
   insider: "ticker-research",
+  jobs: "ticker-research",
   "dividend-yield": "ticker-research",
+  executives: "ticker-research",
+  "filing-events": "ticker-research",
+  "risk-factors": "ticker-research",
   "short-interest": "ticker-research",
   "kelly-sizer": "portfolio",
   "layout-manager": "application",
   "macro-tv": "macro",
-  "market-heatmap": "market-overview",
   "market-movers": "market-overview",
   options: "ticker-research",
   "portfolio-list": "portfolio",

package/src/plugins/pane-manager/dock-tree.ts

@@ -42,7 +42,7 @@ export interface DockResizeTarget extends DockDividerLayout {
 
 export interface DockGeometryOptions {
   precise?: boolean;
-  dividerSize?: number;
+  dividerSize?: number | { horizontal: number; vertical: number };
   reserveDividerGutters?: boolean;
 }
 
@@ -169,7 +169,9 @@ function collectDockGeometry(
   }
 
   const precise = options.precise === true;
-  const dividerSize = options.dividerSize ?? 1;
+  const dividerSize = typeof options.dividerSize === "object"
+    ? options.dividerSize[node.axis]
+    : options.dividerSize ?? 1;
   const reserveDividerGutters = options.reserveDividerGutters === true && !precise;
 
   if (node.axis === "horizontal") {

package/src/plugins/pane-manager/layout-state.ts

@@ -159,14 +159,21 @@ export function removePane(layout: LayoutConfig, instanceId: string): LayoutConf
   ));
 }
 
-export function removeFloatingPanes(layout: LayoutConfig): LayoutConfig {
-  if (layout.floating.length === 0) return layout;
+export function removeFloatingPanes(
+  layout: LayoutConfig,
+  options: { keepInstanceIds?: ReadonlySet<string> } = {},
+): LayoutConfig {
+  const keep = options.keepInstanceIds;
+  const removedIds = layout.floating
+    .map((entry) => entry.instanceId)
+    .filter((instanceId) => !keep?.has(instanceId));
+  if (removedIds.length === 0) return layout;
   return finalizeLayout(removePaneInstances(
     {
       ...layout,
-      floating: [],
+      floating: layout.floating.filter((entry) => keep?.has(entry.instanceId)),
     },
-    layout.floating.map((entry) => entry.instanceId),
+    removedIds,
   ));
 }
 

package/src/plugins/pane-manager/queries.ts

@@ -5,6 +5,7 @@ import type {
 } from "../../types/config";
 import type { PaneDef } from "../../types/plugin";
 import { findPaneInstance } from "../../types/config";
+import { missingPanePlaceholderDef } from "../../components/layout/missing-pane";
 import {
   collectDockLeafRefs,
   countColumnsFromGeometry,
@@ -38,8 +39,9 @@ export function resolveDocked(
   for (const leaf of collectDockLeafRefs(layout.dockRoot)) {
     const instance = findPaneInstance(layout, leaf.instanceId);
     if (!instance) continue;
-    const def = registeredPanes.get(instance.paneId);
-    if (!def) continue;
+    // A pane from a plugin this terminal lacks keeps its slot and its config,
+    // rendered as a placeholder, so a teammate's pane is never dropped.
+    const def = registeredPanes.get(instance.paneId) ?? missingPanePlaceholderDef(instance.paneId);
     result.push({ instance, def, path: leaf.path });
   }
   return result;
@@ -53,8 +55,7 @@ export function resolveFloating(
   for (const entry of layout.floating) {
     const instance = findPaneInstance(layout, entry.instanceId);
     if (!instance) continue;
-    const def = registeredPanes.get(instance.paneId);
-    if (!def) continue;
+    const def = registeredPanes.get(instance.paneId) ?? missingPanePlaceholderDef(instance.paneId);
     result.push({ instance, def, floating: entry });
   }
   result.sort((a, b) => (a.floating?.zIndex ?? 50) - (b.floating?.zIndex ?? 50));