gloomberb 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Bloomberg-style stock portfolio tracker for the terminal",
   "module": "src/index.tsx",
   "type": "module",

package/src/app.tsx

@@ -70,7 +70,7 @@ import {
 } from "./plugins/prediction-markets/launch";
 import { saveConfig } from "./data/config-store";
 import { Toaster, toast } from "@opentui-ui/toast/react";
-import { canSelfUpdate, checkForUpdate, performUpdate } from "./updater";
+import { canSelfUpdate, checkForUpdateDetailed, performUpdate } from "./updater";
 import { VERSION } from "./version";
 import { join } from "path";
 import {
@@ -543,12 +543,46 @@ function AppInner({ pluginRegistry, tickerRepository, dataProvider, marketData,
     }
   }, [state.config.brokerInstances, importBrokerPositions]);
 
+  const runUpdateCheck = useCallback(async (manual = false) => {
+    if (manual) {
+      dispatch({ type: "SET_UPDATE_CHECK_IN_PROGRESS", checking: true });
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: null });
+    }
+
+    const result = await checkForUpdateDetailed(VERSION);
+
+    if (!manual) {
+      if (result.kind === "available") {
+        dispatch({ type: "SET_UPDATE_AVAILABLE", release: result.release });
+      }
+      return;
+    }
+
+    dispatch({ type: "SET_UPDATE_CHECK_IN_PROGRESS", checking: false });
+
+    if (result.kind === "available") {
+      dispatch({ type: "SET_UPDATE_AVAILABLE", release: result.release });
+      return;
+    }
+
+    if (result.kind === "current") {
+      dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: `Already on v${VERSION}` });
+      return;
+    }
+
+    if (result.kind === "disabled") {
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: "Update checks are unavailable in source mode" });
+      return;
+    }
+
+    dispatch({ type: "SET_UPDATE_NOTICE", notice: `Update check failed: ${result.error}` });
+  }, [dispatch]);
+
   // Check for updates on mount
   useEffect(() => {
-    checkForUpdate(VERSION).then((release) => {
-      if (release) dispatch({ type: "SET_UPDATE_AVAILABLE", release });
-    });
-  }, []);
+    void runUpdateCheck(false);
+  }, [runUpdateCheck]);
 
   // Load tickers on mount
   useEffect(() => {
@@ -1155,7 +1189,7 @@ function AppInner({ pluginRegistry, tickerRepository, dataProvider, marketData,
       if (actions.length > 0 && ticker) {
         dispatch({ type: "SET_COMMAND_BAR", open: true, query: "" });
       }
-    } else if (event.name === "u" && state.updateAvailable && !state.updateProgress && canSelfUpdate(state.updateAvailable)) {
+    } else if (event.name === "u" && state.updateAvailable && !state.updateProgress && !state.updateCheckInProgress && canSelfUpdate(state.updateAvailable)) {
       performUpdate(state.updateAvailable, (progress) => {
         dispatch({ type: "SET_UPDATE_PROGRESS", progress });
       });
@@ -1186,6 +1220,7 @@ function AppInner({ pluginRegistry, tickerRepository, dataProvider, marketData,
           tickerRepository={tickerRepository}
           pluginRegistry={pluginRegistry}
           quitApp={() => renderer.destroy()}
+          onCheckForUpdates={() => runUpdateCheck(true)}
         />
       )}
       <Toaster position="bottom-right" />

package/src/components/command-bar/command-bar.test.tsx

@@ -218,6 +218,7 @@ function CommandBarHarness({
   configurePluginRegistry,
   dataProvider = makeDataProvider(),
   hasPaneSettings,
+  onCheckForUpdates,
 }: {
   query: string;
   disabledPlugins?: string[];
@@ -231,6 +232,7 @@ function CommandBarHarness({
   configurePluginRegistry?: (pluginRegistry: PluginRegistry) => void;
   dataProvider?: DataProvider;
   hasPaneSettings?: (paneId: string) => boolean;
+  onCheckForUpdates?: () => void | Promise<void>;
 }) {
   let config = {
     ...createDefaultConfig("/tmp/gloomberb-test"),
@@ -285,6 +287,7 @@ function CommandBarHarness({
             tickerRepository={tickerRepository as any}
             pluginRegistry={pluginRegistry}
             quitApp={() => {}}
+            onCheckForUpdates={onCheckForUpdates}
           />
         )}
       </DialogProvider>
@@ -304,6 +307,25 @@ describe("CommandBar", () => {
     expect(testSetup.captureCharFrame()).toMatchSnapshot();
   });
 
+  test("runs check for updates from the command bar", async () => {
+    const calls = [];
+
+    testSetup = await testRender(<CommandBarHarness query="check for updates" live onCheckForUpdates={() => { calls.push(Date.now()); }} />, {
+      width: 80,
+      height: 24,
+    });
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Check for Updates");
+
+    await clickFrameText("Check for Updates");
+    await Bun.sleep(0);
+    await testSetup.renderOnce();
+
+    expect(calls).toHaveLength(1);
+    expect(testSetup.captureCharFrame()).not.toContain("Commands");
+  });
+
   test("renders theme prefix results in the root query", async () => {
     testSetup = await testRender(<CommandBarHarness query="TH " />, {
       width: 80,

package/src/components/command-bar/command-bar.tsx

@@ -118,6 +118,7 @@ interface CommandBarProps {
   tickerRepository: TickerRepository;
   pluginRegistry: PluginRegistry;
   quitApp: () => void;
+  onCheckForUpdates?: () => void | Promise<void>;
 }
 
 interface ResultItem {
@@ -204,7 +205,13 @@ function getVisibleMultiSelectPickerOptions(
   });
 }
 
-export function CommandBar({ dataProvider, tickerRepository, pluginRegistry, quitApp }: CommandBarProps) {
+export function CommandBar({
+  dataProvider,
+  tickerRepository,
+  pluginRegistry,
+  quitApp,
+  onCheckForUpdates,
+}: CommandBarProps) {
   const { state, dispatch } = useAppState();
   const stateRef = useRef(state);
   stateRef.current = state;
@@ -1985,6 +1992,10 @@ export function CommandBar({ dataProvider, tickerRepository, pluginRegistry, qui
         closeAll({ revertThemePreview: false });
         return;
       }
+      case "check-for-updates":
+        void onCheckForUpdates?.();
+        closeAll({ revertThemePreview: false });
+        return;
       case "search-ticker":
         void runTickerSearchShortcut(arg);
         return;
@@ -2016,6 +2027,7 @@ export function CommandBar({ dataProvider, tickerRepository, pluginRegistry, qui
     openModeRoute,
     openPaneSettingsRoute,
     openPickerRoute,
+    onCheckForUpdates,
     pluginRegistry,
     quitApp,
     runTickerSearchShortcut,
@@ -2219,6 +2231,11 @@ export function CommandBar({ dataProvider, tickerRepository, pluginRegistry, qui
             .filter(Boolean);
           return names?.length ? `from "${names.join(", ")}"` : command.description;
         }
+        case "check-for-updates":
+          if (state.updateCheckInProgress) return "Checking GitHub releases now";
+          if (state.updateAvailable) return `Latest available: v${state.updateAvailable.version}`;
+          if (state.updateNotice) return state.updateNotice;
+          return command.description;
         default:
           return command.description;
       }
@@ -2233,6 +2250,7 @@ export function CommandBar({ dataProvider, tickerRepository, pluginRegistry, qui
         category: command.category,
         kind: "command",
         right: command.prefix || undefined,
+        disabled: command.id === "check-for-updates" && (state.updateCheckInProgress || !!state.updateProgress),
         action: () => runDirectCommand(command, ""),
       };
     }

package/src/components/command-bar/command-registry.ts

@@ -171,6 +171,14 @@ export const commands: Command[] = [
       dispatch({ type: "TOGGLE_STATUS_BAR" });
     },
   },
+  {
+    id: "check-for-updates",
+    prefix: "",
+    label: "Check for Updates",
+    description: "Check GitHub releases for a newer version",
+    category: "Config",
+    execute: () => {}, // handled by command bar
+  },
 
   // Theme
   {

package/src/components/layout/header.tsx

@@ -11,10 +11,19 @@ import { marketStateLabel, marketStateColor, getExtendedHoursInfo } from "../../
 import { VERSION } from "../../version";
 
 const SPY_REFRESH_MS = 5 * 60_000; // 5 min
+const UPDATE_NOTICE_DURATION_MS = 5_000;
 
 function UpdateStatus() {
-  const { state } = useAppState();
-  const { updateAvailable, updateProgress } = state;
+  const { state, dispatch } = useAppState();
+  const { updateAvailable, updateProgress, updateCheckInProgress, updateNotice } = state;
+
+  useEffect(() => {
+    if (!updateNotice || updateAvailable || updateProgress || updateCheckInProgress) return;
+    const timeout = setTimeout(() => {
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: null });
+    }, UPDATE_NOTICE_DURATION_MS);
+    return () => clearTimeout(timeout);
+  }, [dispatch, updateAvailable, updateCheckInProgress, updateNotice, updateProgress]);
 
   if (updateProgress) {
     if (updateProgress.phase === "downloading") {
@@ -43,6 +52,15 @@ function UpdateStatus() {
     }
   }
 
+  if (updateCheckInProgress) {
+    return (
+      <box flexDirection="row" gap={1}>
+        <spinner name="dots" color={colors.headerText} />
+        <text fg={colors.headerText}>Checking for updates...</text>
+      </box>
+    );
+  }
+
   if (updateAvailable) {
     if (updateAvailable.updateAction.kind === "manual") {
       return (
@@ -58,6 +76,10 @@ function UpdateStatus() {
     );
   }
 
+  if (updateNotice) {
+    return <text fg={colors.headerText}>{updateNotice}</text>;
+  }
+
   return null;
 }
 

package/src/components/layout/shell.test.tsx

@@ -160,11 +160,17 @@ function createHeaderDataProvider(): DataProvider {
 
 function HeaderHarness({
   updateAvailable = null,
+  updateCheckInProgress = false,
+  updateNotice = null,
 }: {
   updateAvailable?: ReturnType<typeof createInitialState>["updateAvailable"];
+  updateCheckInProgress?: boolean;
+  updateNotice?: string | null;
 }) {
   const initialState = createInitialState(createDefaultConfig("/tmp/gloomberb-header-test"));
   initialState.updateAvailable = updateAvailable;
+  initialState.updateCheckInProgress = updateCheckInProgress;
+  initialState.updateNotice = updateNotice;
   const [state, dispatch] = useReducer(appReducer, initialState);
 
   return (
@@ -290,6 +296,26 @@ describe("Header", () => {
     expect(frame).toContain("run npm install -g gloomberb@latest");
     expect(frame).not.toContain("press u to update");
   });
+
+  test("shows update check progress and notices", async () => {
+    testSetup = await testRender(
+      <HeaderHarness updateCheckInProgress />,
+      { width: 120, height: 2 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Checking for updates...");
+
+    testSetup.renderer.destroy();
+
+    testSetup = await testRender(
+      <HeaderHarness updateNotice="Already on v0.3.1" />,
+      { width: 120, height: 2 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Already on v0.3.1");
+  });
 });
 
 describe("Shell", () => {

package/src/components/markdown-text.tsx

@@ -0,0 +1,218 @@
+import { useState } from "react";
+import { TextAttributes } from "@opentui/core";
+import { TickerBadge } from "./ticker-badge";
+import { tokenizeTickerText } from "../utils/ticker-tokenizer";
+import type { InlineTickerCatalogEntry } from "../state/use-inline-tickers";
+import { colors } from "../theme/colors";
+
+export interface MarkdownTextProps {
+  text: string;
+  lineWidth: number;
+  catalog: Record<string, InlineTickerCatalogEntry>;
+  textColor: string;
+  openTicker: (symbol: string) => void;
+}
+
+interface StyledSegment {
+  text: string;
+  bold?: boolean;
+  italic?: boolean;
+  dim?: boolean;
+  code?: boolean;
+  color?: string;
+}
+
+interface ParsedLine {
+  segments: StyledSegment[];
+  heading?: boolean;
+  indent?: number;
+}
+
+const INLINE_RE =
+  /(\*\*(?<bold>[^*]+)\*\*|(?<!\*)\*(?!\*)(?<italic>[^*]+)\*(?!\*)|`(?<code>[^`]+)`|~~(?<strike>[^~]+)~~)/g;
+
+function parseInlineMarkdown(text: string): StyledSegment[] {
+  const segments: StyledSegment[] = [];
+  let cursor = 0;
+
+  INLINE_RE.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = INLINE_RE.exec(text)) !== null) {
+    if (match.index > cursor) {
+      segments.push({ text: text.slice(cursor, match.index) });
+    }
+    if (match.groups?.bold != null) {
+      segments.push({ text: match.groups.bold, bold: true });
+    } else if (match.groups?.italic != null) {
+      segments.push({ text: match.groups.italic, italic: true });
+    } else if (match.groups?.code != null) {
+      segments.push({ text: match.groups.code, code: true });
+    } else if (match.groups?.strike != null) {
+      segments.push({ text: match.groups.strike, dim: true });
+    }
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < text.length) {
+    segments.push({ text: text.slice(cursor) });
+  }
+  return segments;
+}
+
+function parseLine(line: string): ParsedLine {
+  // Headings
+  const headingMatch = line.match(/^(#{1,3})\s+(.+)$/);
+  if (headingMatch) {
+    return {
+      heading: true,
+      segments: [{ text: headingMatch[2]!, bold: true, color: colors.borderFocused }],
+    };
+  }
+
+  // List items
+  const listMatch = line.match(/^(\s*)([-*]|\d+\.)\s(.*)$/);
+  if (listMatch) {
+    const indent = listMatch[1]!.length;
+    const marker = listMatch[2]!;
+    const content = listMatch[3]!;
+    return {
+      indent,
+      segments: [
+        { text: `${marker} `, bold: true, color: colors.borderFocused },
+        ...parseInlineMarkdown(content),
+      ],
+    };
+  }
+
+  return { segments: parseInlineMarkdown(line) };
+}
+
+function SegmentSpan({ segment }: { segment: StyledSegment }) {
+  if (segment.code) {
+    return <span fg={colors.textDim}>{segment.text}</span>;
+  }
+  const attrs =
+    (segment.bold ? TextAttributes.BOLD : 0) |
+    (segment.italic ? TextAttributes.ITALIC : 0) |
+    (segment.dim ? TextAttributes.DIM : 0);
+  return (
+    <span
+      fg={segment.color ?? undefined}
+      attributes={attrs || undefined}
+    >
+      {segment.text}
+    </span>
+  );
+}
+
+function MarkdownLine({
+  parsed,
+  lineWidth,
+  catalog,
+  textColor,
+  openTicker,
+  hoveredSymbol,
+  onHover,
+}: {
+  parsed: ParsedLine;
+  lineWidth: number;
+  catalog: Record<string, InlineTickerCatalogEntry>;
+  textColor: string;
+  openTicker: (symbol: string) => void;
+  hoveredSymbol: string | null;
+  onHover: (symbol: string | null) => void;
+}) {
+  const indent = parsed.indent ?? 0;
+  const indentStr = indent > 0 ? " ".repeat(indent) : "";
+
+  // Check if any segment contains ticker symbols
+  const fullText = parsed.segments.map((s) => s.text).join("");
+  const tickerTokens = tokenizeTickerText(fullText);
+  const hasTickers = tickerTokens.some((t) => t.kind === "ticker" && catalog[t.symbol]?.status !== "missing");
+
+  if (!hasTickers) {
+    // Simple case: no tickers, render as styled text
+    return (
+      <text fg={textColor}>
+        {indentStr}
+        {parsed.segments.map((segment, i) => (
+          <SegmentSpan key={i} segment={segment} />
+        ))}
+      </text>
+    );
+  }
+
+  // Complex case: need to handle tickers within styled segments
+  // Render as a flex row to allow badge elements
+  return (
+    <box flexDirection="row" flexWrap="wrap" width={lineWidth}>
+      {indentStr ? <text fg={textColor}>{indentStr}</text> : null}
+      {parsed.segments.map((segment, segIdx) => {
+        const tokens = tokenizeTickerText(segment.text);
+        return tokens.map((token, tokIdx) => {
+          if (token.kind === "text") {
+            if (!token.value) return null;
+            return (
+              <text key={`${segIdx}:${tokIdx}`} fg={textColor}>
+                <SegmentSpan segment={{ ...segment, text: token.value }} />
+              </text>
+            );
+          }
+          const entry = catalog[token.symbol];
+          if (!entry || entry.status === "missing") {
+            return (
+              <text key={`${segIdx}:${tokIdx}`} fg={textColor}>
+                <SegmentSpan segment={{ ...segment, text: token.value }} />
+              </text>
+            );
+          }
+          return (
+            <TickerBadge
+              key={`badge:${segIdx}:${tokIdx}:${token.symbol}`}
+              symbol={token.symbol}
+              status={entry.status}
+              quote={entry.quote}
+              hovered={hoveredSymbol === token.symbol}
+              onHoverStart={() => onHover(token.symbol)}
+              onHoverEnd={() => onHover(null)}
+              onOpen={openTicker}
+            />
+          );
+        });
+      })}
+    </box>
+  );
+}
+
+export function MarkdownText({
+  text,
+  lineWidth,
+  catalog,
+  textColor,
+  openTicker,
+}: MarkdownTextProps) {
+  const [hoveredSymbol, setHoveredSymbol] = useState<string | null>(null);
+  const lines = text.split("\n");
+
+  return (
+    <box flexDirection="column" width={lineWidth}>
+      {lines.map((line, index) => {
+        if (line.trim() === "") {
+          return <text key={index}>{" "}</text>;
+        }
+        const parsed = parseLine(line);
+        return (
+          <MarkdownLine
+            key={index}
+            parsed={parsed}
+            lineWidth={lineWidth}
+            catalog={catalog}
+            textColor={textColor}
+            openTicker={openTicker}
+            hoveredSymbol={hoveredSymbol}
+            onHover={setHoveredSymbol}
+          />
+        );
+      })}
+    </box>
+  );
+}

package/src/data/config-store.test.ts

@@ -3,7 +3,13 @@ import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { join } from "path";
 import { tmpdir } from "os";
 import { loadConfig, sanitizeLayout, saveConfig } from "./config-store";
-import { CURRENT_CONFIG_VERSION, DEFAULT_LAYOUT, findPaneInstance } from "../types/config";
+import {
+  CURRENT_CONFIG_VERSION,
+  DEFAULT_COLUMNS,
+  DEFAULT_LAYOUT,
+  DEFAULT_PORTFOLIO_COLUMN_IDS,
+  findPaneInstance,
+} from "../types/config";
 import { getDockedPaneIds } from "../plugins/pane-manager";
 
 const tempDirs: string[] = [];
@@ -240,7 +246,7 @@ describe("loadConfig", () => {
   test("preserves IBKR gateway configs without migration rewrites", async () => {
     const dataDir = await createTempConfigDir();
     await writeConfigJson(dataDir, createSavedConfig({
-      configVersion: 10,
+      configVersion: 11,
       brokerInstances: [{
         id: "ibkr-interactive-brokers",
         brokerType: "ibkr",
@@ -265,6 +271,37 @@ describe("loadConfig", () => {
     });
   });
 
+  test("migrates legacy main portfolio panes to the portfolio default columns", async () => {
+    const dataDir = await createTempConfigDir();
+    const legacyColumnIds = DEFAULT_COLUMNS.map((column) => column.id);
+    const legacyLayout = {
+      ...DEFAULT_LAYOUT,
+      instances: DEFAULT_LAYOUT.instances.map((instance) => (
+        instance.instanceId === "portfolio-list:main"
+          ? {
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: legacyColumnIds,
+            },
+          }
+          : instance
+      )),
+    };
+
+    await writeConfigJson(dataDir, createSavedConfig({
+      configVersion: 10,
+      layout: legacyLayout,
+      layouts: [{ name: "Default", layout: legacyLayout }],
+    }));
+
+    const config = await loadConfig(dataDir);
+
+    expect(findPaneInstance(config.layout, "portfolio-list:main")?.settings?.columnIds).toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
+    expect(findPaneInstance(config.layouts[0]?.layout ?? DEFAULT_LAYOUT, "portfolio-list:main")?.settings?.columnIds)
+      .toEqual(DEFAULT_PORTFOLIO_COLUMN_IDS);
+  });
+
   test("falls back to the default layout when persisted layouts use the obsolete column shape", async () => {
     const dataDir = await createTempConfigDir();
     const obsoleteLayout = {

package/src/data/config-store.ts

@@ -16,6 +16,8 @@ import {
   createDefaultConfig,
   createPaneInstanceId,
   CURRENT_CONFIG_VERSION,
+  DEFAULT_COLUMNS,
+  DEFAULT_PORTFOLIO_COLUMN_IDS,
   clonePaneSettings,
   normalizePaneLayout,
 } from "../types/config";
@@ -23,6 +25,7 @@ import type { Portfolio, Watchlist } from "../types/ticker";
 import { debugLog } from "../utils/debug-log";
 
 const configLog = debugLog.createLogger("config");
+const LEGACY_MAIN_PORTFOLIO_COLUMN_IDS = DEFAULT_COLUMNS.map((column) => column.id);
 
 function getGlobalConfigDir(): string {
   return join(process.env.HOME || "~", ".gloomberb");
@@ -62,8 +65,16 @@ async function loadConfigState(dataDir: string): Promise<{ config: AppConfig; ne
 
 function normalizeConfig(saved: Record<string, unknown>, dataDir: string): { config: AppConfig; needsSave: boolean } {
   const defaults = createDefaultConfig(dataDir);
-  const directLayout = sanitizeLayout(saved.layout, defaults.layout);
-  const layouts = sanitizeSavedLayouts(saved.layouts, directLayout);
+  const shouldMigratePortfolioDefaults =
+    typeof saved.configVersion !== "number" || saved.configVersion < CURRENT_CONFIG_VERSION;
+  const directLayout = migrateLegacyPortfolioDefaultColumns(
+    sanitizeLayout(saved.layout, defaults.layout),
+    shouldMigratePortfolioDefaults,
+  );
+  const layouts = sanitizeSavedLayouts(saved.layouts, directLayout).map((entry) => ({
+    ...entry,
+    layout: migrateLegacyPortfolioDefaultColumns(entry.layout, shouldMigratePortfolioDefaults),
+  }));
   const activeLayoutIndex = sanitizeActiveLayoutIndex(saved.activeLayoutIndex, layouts.length);
   const layout = cloneLayout(layouts[activeLayoutIndex]?.layout ?? directLayout);
   const syncedLayouts = layouts.map((entry, index) => (
@@ -387,6 +398,33 @@ function sanitizePaneSettings(value: unknown): Record<string, unknown> | undefin
   return Object.keys(settings).length > 0 ? clonePaneSettings(settings) : undefined;
 }
 
+function hasExactColumnIds(value: unknown, expected: string[]): boolean {
+  return Array.isArray(value)
+    && value.length === expected.length
+    && value.every((entry, index) => entry === expected[index]);
+}
+
+function migrateLegacyPortfolioDefaultColumns(layout: LayoutConfig, enabled: boolean): LayoutConfig {
+  if (!enabled) return layout;
+
+  const instanceIndex = layout.instances.findIndex((instance) =>
+    instance.instanceId === "portfolio-list:main"
+    && instance.paneId === "portfolio-list"
+    && hasExactColumnIds(instance.settings?.columnIds, LEGACY_MAIN_PORTFOLIO_COLUMN_IDS)
+  );
+  if (instanceIndex < 0) return layout;
+
+  const nextLayout = cloneLayout(layout);
+  nextLayout.instances[instanceIndex] = {
+    ...nextLayout.instances[instanceIndex]!,
+    settings: {
+      ...(nextLayout.instances[instanceIndex]?.settings ?? {}),
+      columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
+    },
+  };
+  return nextLayout;
+}
+
 function getDefaultFollowSourceInstanceId(instances: PaneInstanceConfig[]): string | null {
   return instances.find((instance) => instance.paneId === "portfolio-list")?.instanceId ?? null;
 }