gloomberb 0.11.2 → 0.12.0

package/src/time-series/chart-data.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, test } from "bun:test";
+import { appendLiveQuotePoint } from "./chart-data";
+import type { PricePoint, Quote } from "../types/financials";
+
+function quoteFixture(overrides: Partial<Quote> = {}): Quote {
+  return {
+    symbol: "INTC",
+    price: 129,
+    currency: "USD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.parse("2026-05-15T20:30:00Z"),
+    listingExchangeName: "NASDAQ",
+    marketState: "REGULAR",
+    ...overrides,
+  };
+}
+
+describe("appendLiveQuotePoint", () => {
+  test("extends coarse chart histories with a fresh quote tail", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-04T00:00:00Z"), close: 56 },
+      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture(),
+      { now: Date.parse("2026-05-15T21:00:00Z") },
+    );
+
+    expect(extended).toHaveLength(3);
+    expect(extended.at(-1)).toEqual({
+      date: new Date("2026-05-15T20:30:00Z"),
+      close: 129,
+    });
+  });
+
+  test("merges a quote into the active OHLC bucket", () => {
+    const history: PricePoint[] = [
+      {
+        date: new Date("2026-05-15T20:25:00Z"),
+        open: 124,
+        high: 130,
+        low: 122,
+        close: 126,
+        volume: 1_000,
+      },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-05-15T20:29:00Z") }),
+      {
+        now: Date.parse("2026-05-15T20:30:00Z"),
+        mode: "ohlc",
+        resolution: "5m",
+      },
+    );
+
+    expect(extended).toHaveLength(1);
+    expect(extended[0]).toEqual({
+      date: new Date("2026-05-15T20:25:00Z"),
+      open: 124,
+      high: 130,
+      low: 122,
+      close: 129,
+      volume: 1_000,
+    });
+  });
+
+  test("seeds a new OHLC bucket from the live price instead of prior-bar extremes", () => {
+    const history: PricePoint[] = [
+      {
+        date: new Date("2026-05-15T20:25:00Z"),
+        open: 124,
+        high: 180,
+        low: 80,
+        close: 126,
+        volume: 1_000,
+      },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-05-15T20:30:00Z") }),
+      {
+        now: Date.parse("2026-05-15T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "5m",
+      },
+    );
+
+    expect(extended).toHaveLength(2);
+    expect(extended[1]).toEqual({
+      date: new Date("2026-05-15T20:30:00Z"),
+      open: 129,
+      high: 129,
+      low: 129,
+      close: 129,
+    });
+  });
+
+  test("treats calendar-month bars as variable-length buckets", () => {
+    const history: PricePoint[] = [{
+      date: new Date("2026-01-01T00:00:00Z"),
+      open: 120,
+      high: 140,
+      low: 110,
+      close: 125,
+    }];
+
+    const endOfJanuary = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-01-31T20:30:00Z") }),
+      {
+        now: Date.parse("2026-01-31T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "1mo",
+      },
+    );
+    const startOfFebruary = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-02-01T20:30:00Z") }),
+      {
+        now: Date.parse("2026-02-01T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "1mo",
+      },
+    );
+
+    expect(endOfJanuary).toHaveLength(1);
+    expect(endOfJanuary[0]?.close).toBe(129);
+    expect(startOfFebruary).toHaveLength(2);
+    expect(startOfFebruary[1]).toMatchObject({
+      open: 129,
+      high: 129,
+      low: 129,
+      close: 129,
+    });
+  });
+
+  test("uses the active extended-hours price for the live tail", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-15T19:30:00Z"), close: 128 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        marketState: "POST",
+        postMarketPrice: 131,
+        lastUpdated: Date.parse("2026-05-15T21:10:00Z"),
+      }),
+      { now: Date.parse("2026-05-15T21:15:00Z") },
+    );
+
+    expect(extended.at(-1)?.close).toBe(131);
+  });
+
+  test("does not bridge a missing intraday history window with one synthetic candle", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-07-22T14:49:00Z"), close: 347.73 },
+      { date: new Date("2026-07-22T14:50:00Z"), close: 347.76 },
+      { date: new Date("2026-07-22T14:51:00Z"), close: 347.68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        symbol: "GOOG",
+        price: 346.27,
+        lastUpdated: Date.parse("2026-07-22T18:52:00Z"),
+      }),
+      Date.parse("2026-07-22T18:53:00Z"),
+    );
+
+    expect(extended).toBe(history);
+  });
+
+  test("does not append a live quote tail with a likely unit mismatch", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-18T00:00:00Z"), close: 405 },
+      { date: new Date("2026-05-22T00:00:00Z"), close: 379 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        symbol: "FTC",
+        currency: "GBP",
+        price: 3.79,
+        lastUpdated: Date.parse("2026-05-22T16:39:00Z"),
+      }),
+      { now: Date.parse("2026-05-22T16:45:00Z") },
+    );
+
+    expect(extended).toBe(history);
+  });
+
+  test("does not append stale quotes from an older active session", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
+      }),
+      { now: Date.parse("2026-05-15T15:00:00Z") },
+    );
+
+    expect(extended).toBe(history);
+  });
+});

package/src/time-series/range.ts

@@ -7,3 +7,15 @@ export interface ChartDateWindow {
 }
 
 export const TIME_RANGES: TimeRange[] = ["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"];
+export const CHART_RESOLUTIONS: ChartResolution[] = [
+  "auto",
+  "1m",
+  "5m",
+  "15m",
+  "30m",
+  "45m",
+  "1h",
+  "1d",
+  "1wk",
+  "1mo",
+];

package/src/time-series/resolution.test.ts

@@ -44,7 +44,7 @@ describe("chart-resolution", () => {
     expect(sortChartResolutions(["1wk", "auto", "15m", "1d"])).toEqual(["auto", "15m", "1d", "1wk"]);
   });
 
-  test("picks a denser supported resolution as the visible window narrows", () => {
+  test("picks the supported resolution whose bar count sits nearest the target", () => {
     const support = [
       { resolution: "1m", maxRange: "1D" },
       { resolution: "5m", maxRange: "1W" },
@@ -53,31 +53,30 @@ describe("chart-resolution", () => {
       { resolution: "1d", maxRange: "5Y" },
       { resolution: "1wk", maxRange: "ALL" },
     ] as const;
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2021-01-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1wk");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-01-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1d");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-12-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1h");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-12-25T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("15m");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2026-01-01T00:00:00Z"),
-      end: new Date("2026-01-02T00:00:00Z"),
-    }, support, 100)).toBe("1m");
+    const pick = (start: string, end: string, current?: "5m" | "15m") => (
+      getBestSupportedResolutionForVisibleWindow(
+        { start: new Date(start), end: new Date(end) },
+        support,
+        230,
+        current,
+      )
+    );
+
+    expect(pick("2021-01-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1wk");
+    expect(pick("2025-01-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1d");
+    // Five months of daily bars beat 1h bars packed three to a pixel.
+    expect(pick("2025-08-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1d");
+    expect(pick("2025-12-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1h");
+    // Two weeks hold ten sessions: 15m bars, not the 780 5m bars of a
+    // calendar-day estimate.
+    expect(pick("2025-12-18T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("15m");
+    expect(pick("2025-12-29T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("5m");
+    expect(pick("2026-01-01T00:00:00Z", "2026-01-02T00:00:00Z")).toBe("1m");
+
+    // A modest zoom keeps the resolution on screen; a large one still switches.
+    expect(pick("2025-12-26T09:36:00Z", "2026-01-01T00:00:00Z", "15m")).toBe("15m");
+    expect(pick("2025-12-29T00:00:00Z", "2026-01-01T00:00:00Z", "15m")).toBe("5m");
+    expect(pick("2025-12-15T00:00:00Z", "2026-01-01T00:00:00Z", "5m")).toBe("15m");
 
     expect(CHART_RESOLUTION_STEP_MS["1h"]).toBe(60 * 60_000);
   });

package/src/time-series/resolution.ts

@@ -1,5 +1,5 @@
 import type { ChartResolution, TimeRange } from "./range";
-import { TIME_RANGES } from "./range";
+import { CHART_RESOLUTIONS, TIME_RANGES } from "./range";
 import { isDateWindowWithinTimeRange } from "./date-window";
 
 export type ManualChartResolution = Exclude<ChartResolution, "auto">;
@@ -9,20 +9,8 @@ export interface ChartResolutionSupport {
   maxRange: TimeRange;
 }
 
-export const TIME_RANGE_ORDER: TimeRange[] = [...TIME_RANGES];
-
-const CHART_RESOLUTION_ORDER: ChartResolution[] = [
-  "auto",
-  "1m",
-  "5m",
-  "15m",
-  "30m",
-  "45m",
-  "1h",
-  "1d",
-  "1wk",
-  "1mo",
-];
+export const TIME_RANGE_ORDER = TIME_RANGES;
+const CHART_RESOLUTION_ORDER = CHART_RESOLUTIONS;
 
 const CHART_RESOLUTION_LABELS: Record<ChartResolution, string> = {
   auto: "AUTO",
@@ -268,15 +256,42 @@ export function isRangePresetSupported(
   return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
 }
 
+const INTRADAY_TRADING_DAY_RATIO = 5 / 7;
+/** Bars packed tighter than the target cost more than bars spread wider. */
+const DENSE_SCORE_PENALTY = 1.5;
+/** Score margin a candidate must win by before the active resolution changes. */
+const RESOLUTION_SWITCH_HYSTERESIS = 0.35;
+
+function estimateVisiblePointCount(resolution: ManualChartResolution, spanMs: number): number {
+  const calendarDays = Math.max(spanMs / CHART_RESOLUTION_STEP_MS["1d"], 1 / 24);
+  // Intraday bars only exist on trading days, so a multi-day window holds
+  // about five sessions a week. Anything up to a day is one session.
+  const days = isIntradayResolution(resolution) && calendarDays > 1
+    ? Math.max(calendarDays * INTRADAY_TRADING_DAY_RATIO, 1)
+    : calendarDays;
+  return Math.max(days * CHART_RESOLUTION_POINTS_PER_DAY[resolution], 1);
+}
+
+function resolutionFitScore(estimatedPointCount: number, targetPointCount: number): number {
+  const ratio = estimatedPointCount / targetPointCount;
+  return ratio > 1 ? Math.log(ratio) * DENSE_SCORE_PENALTY : -Math.log(ratio);
+}
+
+/**
+ * Picks the supported resolution whose bar count sits closest to the target
+ * on a log scale, leaning toward fewer bars. A current resolution is kept
+ * until another candidate is clearly better, so a small zoom does not swap
+ * the whole data set.
+ */
 export function getBestSupportedResolutionForVisibleWindow(
   window: { start: Date | null; end: Date | null } | null,
   support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
   targetPointCount: number,
+  currentResolution?: ManualChartResolution | null,
 ): ManualChartResolution | null {
   if (!window?.start || !window.end) return null;
 
   const spanMs = Math.max(window.end.getTime() - window.start.getTime(), 0);
-  const dayCount = Math.max(spanMs / CHART_RESOLUTION_STEP_MS["1d"], 1 / 24);
   const supportedResolutions = sortChartResolutions(
     CHART_RESOLUTION_ORDER
       .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
@@ -285,16 +300,20 @@ export function getBestSupportedResolutionForVisibleWindow(
         return maxRange !== null && isDateWindowWithinTimeRange(window.start!, window.end!, maxRange);
       }),
   );
-
   if (supportedResolutions.length === 0) return null;
 
-  const minimumPointTarget = Math.max(targetPointCount, 1);
-  for (const resolution of [...supportedResolutions].reverse()) {
-    const estimatedPointCount = Math.max(dayCount * CHART_RESOLUTION_POINTS_PER_DAY[resolution], 1);
-    if (estimatedPointCount >= minimumPointTarget) {
-      return resolution;
-    }
+  const target = Math.max(targetPointCount, 1);
+  const scores = new Map(supportedResolutions.map((resolution) => [
+    resolution,
+    resolutionFitScore(estimateVisiblePointCount(resolution, spanMs), target),
+  ] as const));
+  let best = supportedResolutions[0]!;
+  for (const resolution of supportedResolutions) {
+    if (scores.get(resolution)! <= scores.get(best)!) best = resolution;
   }
-
-  return supportedResolutions[0] ?? null;
+  if (currentResolution && scores.has(currentResolution)) {
+    const currentScore = scores.get(currentResolution)!;
+    if (currentScore <= scores.get(best)! + RESOLUTION_SWITCH_HYSTERESIS) return currentResolution;
+  }
+  return best;
 }

package/src/time-series/resolve.ts

@@ -98,6 +98,8 @@ export interface ChartResolveOptions {
   requestViewport?: { start: Date; end: Date } | null;
   /** Approximate number of horizontal observations the current surface can use. */
   targetPointCount?: number;
+  /** Resolution currently on screen, kept through small Auto zooms. */
+  currentResolution?: ManualChartResolution | null;
 }
 
 /** Raw source data retained while live quotes recompute the chart tail. */
@@ -290,6 +292,7 @@ function requestResolution(
         { start: new Date(runtimeBounds.start), end: new Date(runtimeBounds.end) },
         sharedSupport,
         options.targetPointCount ?? 120,
+        options.currentResolution,
       )
     : null;
   const preferred = adaptive
@@ -388,6 +391,9 @@ export function seedChartResolutionResult(
     loading: false,
     errors: [],
     warnings: [],
+    resolution: spec.viewport.resolution === "auto"
+      ? getPresetResolution(spec.viewport.range)
+      : spec.viewport.resolution,
   };
 }
 
@@ -1224,5 +1230,6 @@ export async function resolveChartSpecData(
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],
     viewport,
+    resolution,
   };
 }

package/src/time-series/spec.ts

@@ -1,4 +1,4 @@
-import type { ChartResolution, TimeRange } from "./range";
+import { CHART_RESOLUTIONS, TIME_RANGES, type ChartResolution, type TimeRange } from "./range";
 import { getChartResolutionLabel } from "./resolution";
 import {
   canonicalTimeSeriesFieldId,
@@ -31,8 +31,8 @@ import {
   isValidChartSeriesId,
 } from "../capabilities/chart-series";
 
-const TIME_RANGES = new Set<TimeRange>(["1D", "1W", "1M", "3M", "6M", "1Y", "5Y", "ALL"]);
-const RESOLUTIONS = new Set<ChartResolution>(["auto", "1m", "5m", "15m", "30m", "45m", "1h", "1d", "1wk", "1mo"]);
+const RANGE_SET = new Set<TimeRange>(TIME_RANGES);
+const RESOLUTIONS = new Set<ChartResolution>(CHART_RESOLUTIONS);
 const PERIODS = new Set<SeriesPeriod>(["auto", "daily", "weekly", "monthly", "quarterly", "annual", "ttm"]);
 const STYLES = new Set<SeriesStyle>(["line", "area", "step", "columns", "points", "candles", "ohlc", "hlc"]);
 const ECONOMIC_STYLES = new Set<SeriesStyle>(["line", "area", "step", "columns", "points"]);
@@ -306,7 +306,7 @@ export function normalizeChartSpec(value: unknown, fallback: ChartSpec = DEFAULT
   return {
     version: CHART_SPEC_VERSION,
     viewport: {
-      range: TIME_RANGES.has(viewport?.range as TimeRange)
+      range: RANGE_SET.has(viewport?.range as TimeRange)
         ? viewport!.range as TimeRange
         : fallbackCopy.viewport.range,
       resolution: RESOLUTIONS.has(viewport?.resolution as ChartResolution)
@@ -340,7 +340,7 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
   if (spec.version !== CHART_SPEC_VERSION) {
     errors.push(issue("version", "unsupported-version", `Unsupported chart spec version ${String(spec.version)}.`));
   }
-  if (!TIME_RANGES.has(spec.viewport.range)) errors.push(issue("viewport.range", "invalid-range", "Invalid date range."));
+  if (!RANGE_SET.has(spec.viewport.range)) errors.push(issue("viewport.range", "invalid-range", "Invalid date range."));
   if (!RESOLUTIONS.has(spec.viewport.resolution)) {
     errors.push(issue("viewport.resolution", "invalid-resolution", "Invalid chart resolution."));
   }

package/src/time-series/types.ts

@@ -1,5 +1,5 @@
 import type { ChartResolution, TimeRange } from "./range";
-import type { ChartResolutionSupport } from "./resolution";
+import type { ChartResolutionSupport, ManualChartResolution } from "./resolution";
 import type { InstrumentRef } from "../market-data/request-types";
 
 export const CHART_SPEC_VERSION = 2 as const;
@@ -175,4 +175,6 @@ export interface ChartResolutionResult {
   warnings: string[];
   /** Effective inclusive bounds used to clip the resolved chart data. */
   viewport?: { start: Date; end: Date };
+  /** Bar resolution the loaded market history was fetched at. */
+  resolution?: ManualChartResolution;
 }

package/src/time-series/use-chart-resolution.ts

@@ -35,6 +35,7 @@ export interface UseChartResolutionOptions {
   autoViewport?: ChartResolveOptions["autoViewport"];
   requestViewport?: ChartResolveOptions["requestViewport"];
   targetPointCount?: number;
+  currentResolution?: ChartResolveOptions["currentResolution"];
 }
 
 const DEFAULT_QUOTE_POLL_INTERVAL_MS = 60_000;
@@ -146,10 +147,14 @@ export function useChartResolution(
     ? { start: new Date(requestViewportStart), end: new Date(requestViewportEnd) }
     : null;
   const adaptiveTargetPointCount = validAutoViewport ? options.targetPointCount : undefined;
+  // Read at resolve time only: hysteresis breaks ties when the viewport moves,
+  // and echoing the chosen resolution back must not trigger another resolve.
+  const currentResolution = validAutoViewport ? options.currentResolution ?? null : null;
   const resolveOptions: ChartResolveOptions = {
     autoViewport: validAutoViewport,
     requestViewport: validRequestViewport,
     targetPointCount: adaptiveTargetPointCount,
+    currentResolution,
   };
   const latestRequestRef = useRef({ spec, sources, options: resolveOptions });
   latestRequestRef.current = { spec, sources, options: resolveOptions };

package/src/types/config.ts

@@ -1,7 +1,7 @@
 import type { Portfolio, Watchlist } from "./ticker";
 import type { LanguagePreference } from "../i18n/languages";
 
-export const CURRENT_CONFIG_VERSION = 21;
+export const CURRENT_CONFIG_VERSION = 22;
 
 type ChartRendererPreference = "auto" | "kitty" | "braille";
 
@@ -148,6 +148,13 @@ export interface AppConfig {
   activeLayoutIndex: number;
   brokerInstances: BrokerInstanceConfig[];
   disabledPlugins: string[];
+  /**
+   * Plugins that used to ship inside Gloomberb and have since moved to their own
+   * repositories. Recorded once installed, so an upgrade restores them without
+   * re-installing on every launch, and so a user who removes one on purpose is
+   * not fought with.
+   */
+  seededPlugins?: string[];
   disabledSources: string[];
   pluginConfig: Record<string, Record<string, unknown>>;
   theme: string;
@@ -264,6 +271,71 @@ const DEFAULT_HOME_LAYOUT: LayoutConfig = {
   detached: [],
 };
 
+/**
+ * One screen for "where are we": valuation and the economy in the wide slots,
+ * with the faster sentiment, volatility and credit reads beside them. These stay
+ * separate panes because each measures a different thing on a different horizon;
+ * the layout is what puts them on one screen.
+ */
+const DEFAULT_MACRO_LAYOUT: LayoutConfig = {
+  dockRoot: {
+    kind: "split",
+    axis: "vertical",
+    ratio: 0.54,
+    first: {
+      kind: "split",
+      axis: "horizontal",
+      ratio: 0.58,
+      first: { kind: "pane", instanceId: "market-valuation:macro" },
+      second: { kind: "pane", instanceId: "fear-greed:macro" },
+    },
+    second: {
+      kind: "split",
+      axis: "horizontal",
+      ratio: 0.58,
+      first: { kind: "pane", instanceId: "econ-statistics:macro" },
+      second: {
+        kind: "split",
+        axis: "vertical",
+        ratio: 0.5,
+        first: { kind: "pane", instanceId: "volatility-term-structure:macro" },
+        second: { kind: "pane", instanceId: "credit-conditions:macro" },
+      },
+    },
+  },
+  instances: [
+    {
+      instanceId: "market-valuation:macro",
+      paneId: "market-valuation",
+      binding: { kind: "none" },
+      settings: { indicator: "buffett", range: "25Y" },
+    },
+    {
+      instanceId: "econ-statistics:macro",
+      paneId: "econ-statistics",
+      binding: { kind: "none" },
+      settings: { stat: "cpi-yoy", range: "20Y" },
+    },
+    {
+      instanceId: "fear-greed:macro",
+      paneId: "fear-greed",
+      binding: { kind: "none" },
+    },
+    {
+      instanceId: "volatility-term-structure:macro",
+      paneId: "volatility-term-structure",
+      binding: { kind: "none" },
+    },
+    {
+      instanceId: "credit-conditions:macro",
+      paneId: "credit-conditions",
+      binding: { kind: "none" },
+    },
+  ],
+  floating: [],
+  detached: [],
+};
+
 const DEFAULT_MONITOR_LAYOUT: LayoutConfig = {
   dockRoot: {
     kind: "split",
@@ -385,6 +457,14 @@ function getDockedPaneIdsFromNode(node: DockLayoutNode | null, result: string[]
   return result;
 }
 
+export function getPlacedPaneInstanceIds(layout: LayoutConfig): string[] {
+  return [...new Set([
+    ...getDockedPaneIdsFromNode(layout.dockRoot),
+    ...layout.floating.map((entry) => entry.instanceId),
+    ...(layout.detached ?? []).map((entry) => entry.instanceId),
+  ])];
+}
+
 export function createPaneInstanceId(paneId: string): string {
   nextPaneInstanceSeq += 1;
   return `${paneId}:${Date.now().toString(36)}${nextPaneInstanceSeq.toString(36)}`;
@@ -488,8 +568,24 @@ export function removePaneInstances(layout: LayoutConfig, instanceIds: Iterable<
   const removedIds = new Set(instanceIds);
   if (removedIds.size === 0) return layout;
 
-  const instances = layout.instances.filter((instance) => !removedIds.has(instance.instanceId));
-  const validInstanceIds = new Set(instances.map((instance) => instance.instanceId));
+  const retainedInstances = layout.instances.filter((instance) => !removedIds.has(instance.instanceId));
+  const validInstanceIds = new Set(retainedInstances.map((instance) => instance.instanceId));
+  const instances = retainedInstances
+    .map((instance) => {
+      const memory = clonePlacementMemory(instance.placementMemory);
+      if (!memory?.docked?.anchorInstanceId || validInstanceIds.has(memory.docked.anchorInstanceId)) {
+        return instance;
+      }
+      const docked = {
+        ...memory.docked,
+        anchorInstanceId: undefined,
+      };
+      const nextDocked = docked.path || docked.position ? docked : undefined;
+      const placementMemory = nextDocked || memory.floating || memory.detached
+        ? { ...memory, docked: nextDocked }
+        : undefined;
+      return { ...instance, placementMemory };
+    });
   const dockRoot = normalizeDockNode(layout.dockRoot, validInstanceIds, new Set<string>());
   const dockedPaneIds = new Set(getDockedPaneIdsFromNode(dockRoot));
   const detached = layout.detached ?? [];
@@ -502,6 +598,28 @@ export function removePaneInstances(layout: LayoutConfig, instanceIds: Iterable<
   };
 }
 
+export function removeUnreachablePaneInstances(layout: LayoutConfig): LayoutConfig {
+  const instancesById = new Map(layout.instances.map((instance) => [instance.instanceId, instance] as const));
+  const reachableIds = new Set(getPlacedPaneInstanceIds(layout));
+  const pendingIds = [...reachableIds];
+
+  for (let index = 0; index < pendingIds.length; index += 1) {
+    const instance = instancesById.get(pendingIds[index]!);
+    if (instance?.binding?.kind !== "follow") continue;
+    const sourceId = instance.binding.sourceInstanceId;
+    if (!instancesById.has(sourceId) || reachableIds.has(sourceId)) continue;
+    reachableIds.add(sourceId);
+    pendingIds.push(sourceId);
+  }
+
+  return removePaneInstances(
+    layout,
+    layout.instances
+      .filter((instance) => !reachableIds.has(instance.instanceId))
+      .map((instance) => instance.instanceId),
+  );
+}
+
 export function normalizePaneLayout(
   layout: LayoutConfig,
   options?: {
@@ -653,10 +771,12 @@ export function createDefaultConfig(dataDir: string): AppConfig {
     layouts: [
       { name: "Home", layout: cloneLayout(layout), paneState: {} },
       { name: "Monitor", layout: cloneLayout(DEFAULT_MONITOR_LAYOUT), paneState: {} },
+      { name: "Macro", layout: cloneLayout(DEFAULT_MACRO_LAYOUT), paneState: {} },
     ],
     activeLayoutIndex: 0,
     brokerInstances: [],
     disabledPlugins: [],
+    seededPlugins: [],
     disabledSources: [],
     pluginConfig: {},
     theme: "amber",