gloomberb 0.7.1 → 0.7.3

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

@@ -1,4 +1,5 @@
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
 import { dirname, join } from "path";
 import type {
   AppConfig,
@@ -20,6 +21,15 @@ import { isLayoutConfig, sanitizeLayout } from "./config-layout";
 
 const configLog = debugLog.createLogger("config");
 const LEGACY_MAIN_PORTFOLIO_COLUMN_IDS = DEFAULT_COLUMNS.map((column) => column.id);
+const PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS = [
+  ...DEFAULT_COLUMNS.map((column) => column.id),
+  "shares",
+  "avg_cost",
+  "cost_basis",
+  "mkt_value",
+  "pnl",
+  "pnl_pct",
+];
 const BUILTIN_SOURCE_IDS = new Set(["yahoo", "gloomberb-cloud"]);
 const BUILTIN_PLUGIN_GROUP_ALIASES: Record<string, string> = {
   "comparison-chart": "market-overview",
@@ -37,13 +47,25 @@ const BUILTIN_PLUGIN_GROUP_ALIASES: Record<string, string> = {
 };
 
 function getGlobalConfigDir(): string {
-  return join(process.env.HOME || "~", ".gloomberb");
+  return join(getHomeDir(), ".gloomberb");
 }
 
 function getGlobalConfigFile(): string {
   return join(getGlobalConfigDir(), "config.json");
 }
 
+function getHomeDir(): string {
+  return process.env.HOME || homedir();
+}
+
+function expandHomePath(filePath: string): string {
+  if (filePath === "~") return getHomeDir();
+  if (filePath.startsWith("~/") || filePath.startsWith("~\\")) {
+    return join(getHomeDir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
 export async function getDataDir(): Promise<string | null> {
   try {
     const raw = await readFile(getGlobalConfigFile(), "utf-8");
@@ -89,7 +111,9 @@ function normalizeConfig(saved: Record<string, unknown>, dataDir: string): { con
   const activeLayoutIndex = sanitizeActiveLayoutIndex(saved.activeLayoutIndex, layouts.length);
   const layout = cloneLayout(layouts[activeLayoutIndex]?.layout ?? directLayout);
   const syncedLayouts = layouts.map((entry, index) => (
-    index === activeLayoutIndex ? { ...entry, layout: cloneLayout(layout) } : entry
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(layout), paneState: sanitizeSavedPaneState(entry.paneState, layout) }
+      : entry
   ));
 
   const disabledPlugins = sanitizeDisabledPlugins(saved, defaults.disabledPlugins, {
@@ -138,7 +162,9 @@ export async function saveConfig(config: AppConfig): Promise<void> {
   const activeLayoutIndex = sanitizeActiveLayoutIndex(config.activeLayoutIndex, config.layouts.length || 1);
   const layout = sanitizeLayout(config.layout, createDefaultConfig(config.dataDir).layout);
   const layouts = sanitizeSavedLayouts(config.layouts, layout).map((entry, index) => (
-    index === activeLayoutIndex ? { ...entry, layout: cloneLayout(layout) } : entry
+    index === activeLayoutIndex
+      ? { ...entry, layout: cloneLayout(layout), paneState: sanitizeSavedPaneState(entry.paneState, layout) }
+      : entry
   ));
 
   const persisted: AppConfig = {
@@ -158,7 +184,14 @@ export async function saveConfig(config: AppConfig): Promise<void> {
     recentTickers: sanitizeStringArray(config.recentTickers, []),
   };
 
-  await writeFile(configPath, JSON.stringify(persisted, null, 2), "utf-8");
+  const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(persisted, null, 2), "utf-8");
+    await rename(tempPath, configPath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => {});
+    throw error;
+  }
 }
 
 export async function initDataDir(dataDir: string): Promise<AppConfig> {
@@ -177,11 +210,11 @@ export async function resetAllData(dataDir: string): Promise<void> {
 
 export async function exportConfig(config: AppConfig, destPath: string): Promise<void> {
   const { dataDir, ...rest } = config;
-  await writeFile(destPath, JSON.stringify(rest, null, 2), "utf-8");
+  await writeFile(expandHomePath(destPath), JSON.stringify(rest, null, 2), "utf-8");
 }
 
 export async function importConfig(dataDir: string, srcPath: string): Promise<AppConfig> {
-  const raw = await readFile(srcPath, "utf-8");
+  const raw = await readFile(expandHomePath(srcPath), "utf-8");
   const saved = JSON.parse(raw) as Record<string, unknown>;
   const { config } = normalizeConfig(saved, dataDir);
   await saveConfig(config);
@@ -238,6 +271,41 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function sanitizeSerializableValue(value: unknown): unknown {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => sanitizeSerializableValue(entry))
+      .filter((entry) => entry !== undefined);
+  }
+  if (isPlainRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value)
+        .map(([key, entry]) => [key, sanitizeSerializableValue(entry)])
+        .filter(([, entry]) => entry !== undefined),
+    );
+  }
+  return undefined;
+}
+
+function sanitizeSavedPaneState(
+  value: unknown,
+  layout: LayoutConfig,
+): Record<string, Record<string, unknown>> | undefined {
+  if (!isPlainRecord(value)) return undefined;
+  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
+  const paneState = Object.fromEntries(
+    Object.entries(value)
+      .filter(([paneId, entry]) => validPaneIds.has(paneId) && isPlainRecord(entry))
+      .map(([paneId, entry]) => [paneId, sanitizeSerializableValue(entry)])
+      .filter((entry): entry is [string, Record<string, unknown>] => isPlainRecord(entry[1])),
+  );
+  return paneState;
+}
+
 function isPluginConfigMap(value: unknown): value is Record<string, Record<string, unknown>> {
   if (!isPlainRecord(value)) return false;
   return Object.values(value).every((entry) => isPlainRecord(entry));
@@ -266,7 +334,8 @@ function isChartPreferences(value: unknown): value is ChartPreferences {
   return (defaultRenderMode === "area"
     || defaultRenderMode === "line"
     || defaultRenderMode === "candles"
-    || defaultRenderMode === "ohlc")
+    || defaultRenderMode === "ohlc"
+    || defaultRenderMode === "hlc")
     && (renderer === "auto" || renderer === "kitty" || renderer === "braille");
 }
 
@@ -278,6 +347,7 @@ function sanitizeChartPreferences(value: unknown, fallback: ChartPreferences): C
     || candidate.defaultRenderMode === "line"
     || candidate.defaultRenderMode === "candles"
     || candidate.defaultRenderMode === "ohlc"
+    || candidate.defaultRenderMode === "hlc"
     ? candidate.defaultRenderMode
     : fallback.defaultRenderMode;
   const renderer = candidate.renderer === "auto"
@@ -342,24 +412,31 @@ function hasExactColumnIds(value: unknown, expected: string[]): boolean {
     && value.every((entry, index) => entry === expected[index]);
 }
 
+function shouldMigratePortfolioColumnIds(value: unknown): boolean {
+  return hasExactColumnIds(value, LEGACY_MAIN_PORTFOLIO_COLUMN_IDS)
+    || hasExactColumnIds(value, PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS);
+}
+
 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 instanceIndices = layout.instances.flatMap((instance, index) => (
+    instance.paneId === "portfolio-list" && shouldMigratePortfolioColumnIds(instance.settings?.columnIds)
+      ? [index]
+      : []
+  ));
+  if (instanceIndices.length === 0) return layout;
 
   const nextLayout = cloneLayout(layout);
-  nextLayout.instances[instanceIndex] = {
-    ...nextLayout.instances[instanceIndex]!,
-    settings: {
-      ...(nextLayout.instances[instanceIndex]?.settings ?? {}),
-      columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
-    },
-  };
+  for (const instanceIndex of instanceIndices) {
+    nextLayout.instances[instanceIndex] = {
+      ...nextLayout.instances[instanceIndex]!,
+      settings: {
+        ...(nextLayout.instances[instanceIndex]?.settings ?? {}),
+        columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
+      },
+    };
+  }
   return nextLayout;
 }
 
@@ -374,10 +451,21 @@ function sanitizeSavedLayouts(value: unknown, fallbackLayout: LayoutConfig): Sav
       && typeof entry === "object"
       && typeof (entry as SavedLayout).name === "string",
     )
-    .map((entry) => ({
-      name: entry.name,
-      layout: sanitizeLayout(entry.layout, fallbackLayout),
-    }));
+    .map((entry) => {
+      const layout = sanitizeLayout(entry.layout, fallbackLayout);
+      return {
+        id: typeof entry.id === "string" ? entry.id : undefined,
+        name: entry.name,
+        layout,
+        paneState: sanitizeSavedPaneState((entry as { paneState?: unknown }).paneState, layout),
+        focusedPaneId: typeof entry.focusedPaneId === "string" || entry.focusedPaneId === null
+          ? entry.focusedPaneId
+          : undefined,
+        activePanel: entry.activePanel === "right" || entry.activePanel === "left"
+          ? entry.activePanel
+          : undefined,
+      };
+    });
 
   return layouts.length > 0 ? layouts : [{ name: "Default", layout: cloneLayout(fallbackLayout) }];
 }

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

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdtemp, readFile, rm, writeFile } from "fs/promises";
 import { join } from "path";
 import { tmpdir } from "os";
-import { loadConfig, sanitizeLayout, saveConfig } from "./config-store";
+import { exportConfig, importConfig, loadConfig, sanitizeLayout, saveConfig } from "./config-store";
 import {
   CURRENT_CONFIG_VERSION,
   DEFAULT_COLUMNS,
@@ -219,7 +219,7 @@ describe("loadConfig", () => {
     await writeConfigJson(dataDir, createSavedConfig({
       configVersion: 7,
       chartPreferences: {
-        defaultRenderMode: "line",
+        defaultRenderMode: "hlc",
         renderer: "nope",
       },
     }));
@@ -227,7 +227,7 @@ describe("loadConfig", () => {
     const config = await loadConfig(dataDir);
 
     expect(config.chartPreferences).toEqual({
-      defaultRenderMode: "line",
+      defaultRenderMode: "hlc",
       renderer: "auto",
     });
     expect(config.pluginConfig).toEqual({});
@@ -342,6 +342,40 @@ describe("loadConfig", () => {
     });
   });
 
+  test("preserves saved layout pane state and focus metadata", async () => {
+    const dataDir = await createTempConfigDir();
+    await writeConfigJson(dataDir, createSavedConfig({
+      layouts: [{
+        name: "Chart",
+        layout: DEFAULT_LAYOUT,
+        paneState: {
+          "ticker-detail:main": { activeTabId: "chart" },
+          "missing:pane": { activeTabId: "overview" },
+        },
+        focusedPaneId: "ticker-detail:main",
+        activePanel: "right",
+      }],
+    }));
+
+    const config = await loadConfig(dataDir);
+
+    expect(config.layouts[0]?.paneState).toEqual({
+      "ticker-detail:main": { activeTabId: "chart" },
+    });
+    expect(config.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
+    expect(config.layouts[0]?.activePanel).toBe("right");
+
+    await saveConfig(config);
+    const persisted = JSON.parse(await readFile(join(dataDir, "config.json"), "utf-8")) as {
+      layouts: Array<{ paneState?: Record<string, unknown>; focusedPaneId?: string | null; activePanel?: string }>;
+    };
+    expect(persisted.layouts[0]?.paneState).toEqual({
+      "ticker-detail:main": { activeTabId: "chart" },
+    });
+    expect(persisted.layouts[0]?.focusedPaneId).toBe("ticker-detail:main");
+    expect(persisted.layouts[0]?.activePanel).toBe("right");
+  });
+
   test("migrates legacy main portfolio panes to the portfolio default columns", async () => {
     const dataDir = await createTempConfigDir();
     const legacyColumnIds = DEFAULT_COLUMNS.map((column) => column.id);
@@ -417,3 +451,31 @@ describe("loadConfig", () => {
     expect(persisted.layouts[1]?.layout).toEqual(DEFAULT_LAYOUT);
   });
 });
+
+describe("config backup files", () => {
+  test("expands a leading tilde when exporting and importing", async () => {
+    const originalHome = process.env.HOME;
+    const homeDir = await createTempConfigDir();
+    const dataDir = await createTempConfigDir();
+    const importDataDir = await createTempConfigDir();
+    process.env.HOME = homeDir;
+
+    try {
+      const config = await loadConfig(dataDir);
+      await exportConfig({ ...config, baseCurrency: "EUR" }, "~/gloomberb-config-backup.json");
+
+      const backupPath = join(homeDir, "gloomberb-config-backup.json");
+      const exported = JSON.parse(await readFile(backupPath, "utf-8")) as Record<string, unknown>;
+      expect(exported.baseCurrency).toBe("EUR");
+      expect(exported.dataDir).toBeUndefined();
+
+      await writeFile(backupPath, JSON.stringify({ ...exported, baseCurrency: "JPY" }), "utf-8");
+      const imported = await importConfig(importDataDir, "~/gloomberb-config-backup.json");
+
+      expect(imported.baseCurrency).toBe("JPY");
+      expect(imported.dataDir).toBe(importDataDir);
+    } finally {
+      process.env.HOME = originalHome;
+    }
+  });
+});

package/src/data/plugin-state-store.ts

@@ -10,6 +10,13 @@ export interface PluginStateRecord<T = unknown> {
   updatedAt: number;
 }
 
+export interface PluginStateSetEntry {
+  pluginId: string;
+  key: string;
+  value: unknown;
+  schemaVersion?: number;
+}
+
 interface CachedPluginStateRecord {
   value: unknown;
   schemaVersion: number;
@@ -64,22 +71,41 @@ export class PluginStateStore {
   }
 
   set(pluginId: string, key: string, value: unknown, schemaVersion = DEFAULT_PLUGIN_STATE_SCHEMA_VERSION): void {
-    const rawValue = serializeJson(value);
+    this.setMany([{ pluginId, key, value, schemaVersion }]);
+  }
+
+  setMany(entries: PluginStateSetEntry[]): void {
+    if (entries.length === 0) return;
     const updatedAt = Date.now();
+    const records = entries.map((entry) => ({
+      pluginId: entry.pluginId,
+      key: entry.key,
+      value: entry.value,
+      schemaVersion: entry.schemaVersion ?? DEFAULT_PLUGIN_STATE_SCHEMA_VERSION,
+      rawValue: serializeJson(entry.value),
+    }));
+
     withSqliteBusyRetry("save plugin state", () => {
-      this.db
-        .query(
-          `INSERT OR REPLACE INTO plugin_state (plugin_id, key, schema_version, value, updated_at)
-           VALUES (?, ?, ?, ?, ?)`,
-        )
-        .run(pluginId, key, schemaVersion, rawValue, updatedAt);
-    });
-    this.cache.set(`${pluginId}:${key}`, {
-      value,
-      schemaVersion,
-      updatedAt,
-      rawValue,
+      const insert = this.db.query(
+        `INSERT OR REPLACE INTO plugin_state (plugin_id, key, schema_version, value, updated_at)
+         VALUES (?, ?, ?, ?, ?)`,
+      );
+      const tx = this.db.transaction(() => {
+        for (const record of records) {
+          insert.run(record.pluginId, record.key, record.schemaVersion, record.rawValue, updatedAt);
+        }
+      });
+      tx();
     });
+
+    for (const record of records) {
+      this.cache.set(`${record.pluginId}:${record.key}`, {
+        value: record.value,
+        schemaVersion: record.schemaVersion,
+        updatedAt,
+        rawValue: record.rawValue,
+      });
+    }
   }
 
   delete(pluginId: string, key: string): void {

package/src/data/sqlite-cache.test.ts

@@ -127,6 +127,19 @@ describe("AppPersistence", () => {
     persistence.close();
   });
 
+  test("stores multiple plugin state records in one batch", () => {
+    const dbPath = createTempDbPath("plugin-state-batch");
+    const persistence = new AppPersistence(dbPath);
+    persistence.pluginState.setMany([
+      { pluginId: "ai", key: "provider", value: "openai", schemaVersion: 1 },
+      { pluginId: "news", key: "resume:read", value: { ids: ["1"] }, schemaVersion: 2 },
+    ]);
+
+    expect(persistence.pluginState.get<string>("ai", "provider", 1)?.value).toBe("openai");
+    expect(persistence.pluginState.get<{ ids: string[] }>("news", "resume:read", 2)?.value.ids).toEqual(["1"]);
+    persistence.close();
+  });
+
   test("stores and returns session snapshots", () => {
     const dbPath = createTempDbPath("session-snapshot");
     const persistence = new AppPersistence(dbPath);

package/src/market-data/coordinator.ts

@@ -202,6 +202,13 @@ function areStreamQuotesEquivalent(current: Quote | null | undefined, next: Quot
     && JSON.stringify(current.provenance ?? null) === JSON.stringify(next.provenance ?? null);
 }
 
+function hasCachedSnapshotData(financials: TickerFinancials): boolean {
+  return !!financials.profile
+    || Object.keys(financials.fundamentals ?? {}).length > 0
+    || financials.annualStatements.length > 0
+    || financials.quarterlyStatements.length > 0;
+}
+
 function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryEntry<T> {
   return {
     ...current,
@@ -365,7 +372,7 @@ export class MarketDataCoordinator {
       const fundamentalsKey = buildFundamentalsKey(instrument);
       const statementsKey = buildStatementsKey(instrument);
 
-      if (this.snapshotStore.get(snapshotKey).phase === "idle") {
+      if (hasCachedSnapshotData(normalized) && this.snapshotStore.get(snapshotKey).phase === "idle") {
         this.snapshotStore.set(
           snapshotKey,
           readyEntry(this.snapshotStore.get(snapshotKey), normalized, source, [], { keepLastGoodOnEmpty: true }),

package/src/news/aggregator.test.ts

@@ -312,4 +312,45 @@ describe("NewsService", () => {
     expect(detail?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
     expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
   });
+
+  it("keeps story detail identity when a duplicate feed item wins ranking", async () => {
+    const url = "https://detail.example.com/duplicate-story";
+    const cloudArticle = makeItem({
+      id: "story-1",
+      url,
+      importance: 60,
+      publishedAt: new Date("2026-04-01T10:00:00.000Z"),
+      items: [],
+    });
+    const feedDuplicate = makeItem({
+      id: "rss-1",
+      url,
+      importance: 95,
+      publishedAt: new Date("2026-04-01T10:05:00.000Z"),
+    });
+    const detailArticle = makeItem({
+      ...cloudArticle,
+      items: [{
+        id: "item-1",
+        sourceKey: "wire-a",
+        sourceName: "Wire A",
+        title: "Original",
+        url: "https://detail.example.com/original",
+        publishedAt: new Date("2026-04-01T10:00:00.000Z"),
+      }],
+    });
+
+    agg.register({ ...makeStorySource("cloud", [cloudArticle], detailArticle), priority: 10 });
+    agg.register({ ...makeSource("rss", [feedDuplicate]), priority: 2000 });
+
+    const initial = await agg.load({ feed: "top", limit: 10 });
+
+    expect(initial.articles[0]?.id).toBe("story-1");
+    expect(initial.articles[0]?.importance).toBe(95);
+
+    await agg.loadStory(initial.articles[0]!.id);
+    const state = agg.getQueryState({ feed: "top", limit: 10 });
+
+    expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-1"]);
+  });
 });

package/src/news/aggregator.ts

@@ -12,6 +12,9 @@ const MAX_ARTICLES = 500;
 const DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;
 const DEFAULT_GLOBAL_QUERY: NewsQuery = { feed: "latest", limit: MAX_ARTICLES };
 const FEEDS = new Set<NewsFeed>(["latest", "top", "breaking", "ticker", "sector", "topic"]);
+const DETAIL_CAPABLE_ARTICLE = Symbol("detail-capable-news-article");
+
+type DetailCapableArticle = NewsArticle & { [DETAIL_CAPABLE_ARTICLE]?: true };
 
 function normalizeTicker(ticker: string | undefined): string {
   return ticker ? normalizeSymbol(ticker) : "";
@@ -101,6 +104,57 @@ function sortByPublishedAt(items: NewsArticle[]): NewsArticle[] {
   return [...items].sort((a, b) => b.publishedAt.getTime() - a.publishedAt.getTime());
 }
 
+function hasStoryItems(item: NewsArticle | null | undefined): boolean {
+  return (item?.items?.length ?? 0) > 0;
+}
+
+function markDetailCapableArticle(source: NewsCapability, item: NewsArticle): NewsArticle {
+  if (!source.provider.fetchNewsStory) return item;
+  Object.defineProperty(item, DETAIL_CAPABLE_ARTICLE, {
+    value: true,
+    configurable: true,
+  });
+  return item;
+}
+
+function isDetailCapableArticle(item: NewsArticle): boolean {
+  return (item as DetailCapableArticle)[DETAIL_CAPABLE_ARTICLE] === true;
+}
+
+function shouldReplaceDuplicate(existing: NewsArticle, item: NewsArticle): boolean {
+  return (
+    item.importance > existing.importance ||
+    (item.importance === existing.importance && item.publishedAt > existing.publishedAt)
+  );
+}
+
+function selectDetailArticle(
+  existing: NewsArticle,
+  item: NewsArticle,
+  winner: NewsArticle,
+): NewsArticle | null {
+  if (isDetailCapableArticle(winner)) return winner;
+  if (isDetailCapableArticle(item)) return item;
+  if (isDetailCapableArticle(existing)) return existing;
+  if (hasStoryItems(winner)) return winner;
+  if (hasStoryItems(item)) return item;
+  if (hasStoryItems(existing)) return existing;
+  return null;
+}
+
+function mergeDuplicateArticle(existing: NewsArticle, item: NewsArticle): NewsArticle {
+  const winner = shouldReplaceDuplicate(existing, item)
+    ? { ...existing, ...item }
+    : existing;
+  const detailArticle = selectDetailArticle(existing, item, winner);
+  if (!detailArticle || detailArticle.id === winner.id) return winner;
+  return {
+    ...winner,
+    id: detailArticle.id,
+    items: hasStoryItems(detailArticle) ? detailArticle.items : winner.items,
+  };
+}
+
 function dedupeArticles(items: NewsArticle[]): NewsArticle[] {
   const byKey = new Map<string, NewsArticle>();
   for (const item of items) {
@@ -110,12 +164,7 @@ function dedupeArticles(items: NewsArticle[]): NewsArticle[] {
       byKey.set(key, item);
       continue;
     }
-    if (
-      item.importance > existing.importance ||
-      (item.importance === existing.importance && item.publishedAt > existing.publishedAt)
-    ) {
-      byKey.set(key, { ...existing, ...item });
-    }
+    byKey.set(key, mergeDuplicateArticle(existing, item));
   }
   return sortByPublishedAt([...byKey.values()]).slice(0, MAX_ARTICLES);
 }
@@ -382,7 +431,8 @@ export class NewsService {
     let firstEmpty: SourceFetchResult | null = null;
     for (const source of sources) {
       try {
-        const articles = await source.provider.fetchNews(query);
+        const articles = (await source.provider.fetchNews(query))
+          .map((article) => markDetailCapableArticle(source, article));
         const result = { articles, sourceIds: [newsCapabilitySourceId(source)] };
         if (articles.length > 0) return result;
         firstEmpty ??= result;
@@ -397,7 +447,8 @@ export class NewsService {
     const settled = await Promise.allSettled(
       sources.map(async (source) => ({
         source,
-        articles: await source.provider.fetchNews(query),
+        articles: (await source.provider.fetchNews(query))
+          .map((article) => markDetailCapableArticle(source, article)),
       })),
     );
     const articles: NewsArticle[] = [];
@@ -418,7 +469,8 @@ export class NewsService {
     let changed = false;
     for (const query of queries) {
       if (source.isEnabled?.() === false || news.supports?.(query) === false) continue;
-      const cached = news.getCachedNews?.(query) ?? [];
+      const cached = (news.getCachedNews?.(query) ?? [])
+        .map((article) => markDetailCapableArticle(source, article));
       if (cached.length === 0) continue;
       const key = buildNewsQueryKey(query);
       const current = this.queryStates.get(key) ?? createIdleState();

package/src/plugins/builtin/ai/ask-ai-detail-tab.tsx

@@ -300,13 +300,32 @@ export function AskAiDetailTab({ width, height, focused, onCapture }: DetailTabP
     nativePaneChrome,
     terminalBottomInset: terminalFooterClearance,
   });
-  const chatHeight = Math.max(height - composerBlockHeight, 0);
+  const chatHeight = nativePaneChrome ? undefined : Math.max(height - composerBlockHeight, 0);
+  const layoutHeight = nativePaneChrome ? "100%" : height;
+  const nativeFillStyle = nativePaneChrome ? { minHeight: 0 } : undefined;
 
   return (
-    <Box flexDirection="column" paddingX={nativePaneChrome ? 0 : 1} height={height} overflow="hidden">
-      {chatHeight > 0 && (
-        <ScrollBox ref={scrollRef} height={chatHeight} scrollY>
-          <Box flexDirection="column" paddingX={nativePaneChrome ? 1 : 0}>
+    <Box
+      flexDirection="column"
+      paddingX={nativePaneChrome ? 0 : 1}
+      height={layoutHeight}
+      flexGrow={nativePaneChrome ? 1 : undefined}
+      overflow="hidden"
+      style={nativeFillStyle}
+    >
+      {(nativePaneChrome || (chatHeight ?? 0) > 0) && (
+        <ScrollBox
+          ref={scrollRef}
+          height={nativePaneChrome ? undefined : chatHeight}
+          flexGrow={nativePaneChrome ? 1 : undefined}
+          scrollY
+          style={nativeFillStyle}
+        >
+          <Box
+            flexDirection="column"
+            paddingX={nativePaneChrome ? 1 : 0}
+            style={nativeFillStyle}
+          >
             {messages.length === 0 ? (
               <Box paddingTop={1}>
                 <Text fg={colors.textDim}>
@@ -354,7 +373,7 @@ export function AskAiDetailTab({ width, height, focused, onCapture }: DetailTabP
         placeholder="Ask a question..."
         terminalPrefix=" > "
         terminalBottomInset={terminalFooterClearance}
-        width={nativePaneChrome ? width : contentWidth}
+        width={nativePaneChrome ? "100%" : contentWidth}
         height={composerHeight}
         onFocusRequest={focusInput}
         onInput={(value) => setInputValue(value)}

package/src/plugins/builtin/ai/settings.ts

@@ -60,6 +60,9 @@ export function resolveVisibleAiScreenerColumns(columnIds: string[]): ColumnConf
 export function buildAiScreenerPaneSettingsDef(settings: AiScreenerPaneSettings): PaneSettingsDef {
   return {
     title: "AI Screener Settings",
+    values: {
+      columnIds: [...settings.columnIds],
+    },
     fields: [
       {
         key: "columnIds",