gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/news/wire/feed-config.ts

@@ -1,4 +1,5 @@
 import type { PluginConfigState } from "../../../../types/plugin";
+import { logFailure } from "../../../../utils/log-failure";
 import { DEFAULT_FEEDS } from "./default-feeds";
 import { hashString } from "./hash";
 import type { RssFeedConfig } from "./rss/parser";
@@ -8,11 +9,13 @@ const USER_FEEDS_KEY = "feeds";
 const DISABLED_DEFAULT_FEED_IDS_KEY = "disabledDefaultFeedIds";
 
 const DEFAULT_FEED_IDS = new Set(DEFAULT_FEEDS.map((feed) => feed.id));
+const UNREADABLE_SETTINGS = "News feed settings could not be read. Saved settings were kept.";
 
 export interface NewsFeedSettings {
   userFeeds: RssFeedConfig[];
   disabledDefaultFeedIds: string[];
   needsMigration: boolean;
+  error?: string;
 }
 
 export interface UserNewsFeedInput {
@@ -24,14 +27,15 @@ export interface UserNewsFeedInput {
   enabled?: boolean;
 }
 
-function parseJsonArray(value: unknown): unknown[] {
+function parseJsonArray(value: unknown): unknown[] | null {
   if (Array.isArray(value)) return value;
-  if (typeof value !== "string" || !value.trim()) return [];
+  if (typeof value !== "string") return [];
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
+  } catch (error) {
+    logFailure("news.feed-config", "Read stored news feed settings failed")(error);
+    return null;
   }
 }
 
@@ -93,6 +97,7 @@ function normalizeUserFeed(value: unknown): RssFeedConfig | null {
       enabled: record.enabled !== false,
     });
   } catch {
+    // Intentional ignore: invalid stored feed entries are omitted during normalization.
     return null;
   }
 }
@@ -131,14 +136,20 @@ function sameIdList(raw: unknown, normalized: string[]): boolean {
 }
 
 export function loadNewsFeedSettings(configState: PluginConfigState): NewsFeedSettings {
-  const rawUserFeeds = configState.get<unknown>(USER_FEEDS_KEY);
+  return parseNewsFeedSettings(configState.get(USER_FEEDS_KEY), configState.get(DISABLED_DEFAULT_FEED_IDS_KEY));
+}
+
+export function parseNewsFeedSettings(rawUserFeeds: unknown, rawDisabledIds: unknown): NewsFeedSettings {
   const userFeedValues = parseJsonArray(rawUserFeeds);
-  const userFeeds = userFeedValues
+  const userFeeds = (userFeedValues ?? [])
     .map(normalizeUserFeed)
     .filter((feed): feed is RssFeedConfig => !!feed);
 
-  const rawDisabledIds = configState.get<unknown>(DISABLED_DEFAULT_FEED_IDS_KEY);
-  const disabledDefaultFeedIds = normalizeDisabledDefaultFeedIds(parseJsonArray(rawDisabledIds));
+  const disabledIdValues = parseJsonArray(rawDisabledIds);
+  const disabledDefaultFeedIds = normalizeDisabledDefaultFeedIds(disabledIdValues ?? []);
+  if (userFeedValues === null || disabledIdValues === null) {
+    return { userFeeds, disabledDefaultFeedIds, needsMigration: false, error: UNREADABLE_SETTINGS };
+  }
 
   const needsMigration = (rawUserFeeds !== null && !sameUserFeeds(rawUserFeeds, userFeeds))
     || (rawDisabledIds !== null && !sameIdList(rawDisabledIds, disabledDefaultFeedIds));
@@ -146,15 +157,24 @@ export function loadNewsFeedSettings(configState: PluginConfigState): NewsFeedSe
   return { userFeeds, disabledDefaultFeedIds, needsMigration };
 }
 
+function requireReadableSettings(configState: PluginConfigState): NewsFeedSettings {
+  const settings = loadNewsFeedSettings(configState);
+  if (settings.error) throw new Error(settings.error);
+  return settings;
+}
+
 export async function saveNewsFeedSettings(
   configState: PluginConfigState,
   settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">,
 ): Promise<void> {
+  requireReadableSettings(configState);
   await configState.set(USER_FEEDS_KEY, settings.userFeeds);
+  requireReadableSettings(configState);
   await configState.set(DISABLED_DEFAULT_FEED_IDS_KEY, settings.disabledDefaultFeedIds);
 }
 
-export function getEnabledNewsFeeds(settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">): RssFeedConfig[] {
+export function getEnabledNewsFeeds(settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds" | "error">): RssFeedConfig[] {
+  if (settings.error) return [];
   const disabled = new Set(settings.disabledDefaultFeedIds);
   return [
     ...DEFAULT_FEEDS.filter((feed) => feed.enabled && !disabled.has(feed.id)),
@@ -166,7 +186,7 @@ export async function addUserNewsFeed(
   configState: PluginConfigState,
   input: UserNewsFeedInput,
 ): Promise<RssFeedConfig> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const feed = createUserFeed(input);
   const nextUserFeeds = [
     ...settings.userFeeds.filter((entry) => entry.id !== feed.id),
@@ -184,7 +204,7 @@ export async function updateUserNewsFeed(
   feedId: string,
   patch: Partial<UserNewsFeedInput>,
 ): Promise<RssFeedConfig | null> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const existing = settings.userFeeds.find((feed) => feed.id === feedId);
   if (!existing) return null;
   const nextFeed = createUserFeed({
@@ -203,7 +223,7 @@ export async function removeUserNewsFeed(
   configState: PluginConfigState,
   feedId: string,
 ): Promise<boolean> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const nextUserFeeds = settings.userFeeds.filter((feed) => feed.id !== feedId);
   if (nextUserFeeds.length === settings.userFeeds.length) return false;
   await saveNewsFeedSettings(configState, {
@@ -219,7 +239,7 @@ export async function setDefaultNewsFeedEnabled(
   enabled: boolean,
 ): Promise<boolean> {
   if (!DEFAULT_FEED_IDS.has(feedId)) return false;
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const disabled = new Set(settings.disabledDefaultFeedIds);
   if (enabled) disabled.delete(feedId);
   else disabled.add(feedId);

package/src/plugins/builtin/news/wire/index.tsx

@@ -26,6 +26,7 @@ import { createRssNewsCapability } from "./rss/source";
 import { rssCliCommand } from "./rss/cli";
 import { newsFeedHeadless } from "../headless";
 import type { PaneDef } from "../../../../types/plugin";
+import { logFailure } from "../../../../utils/log-failure";
 
 const TopPane = createNewsPresetPane({
   paneKey: "top:curated",
@@ -195,11 +196,15 @@ export const newsWireModule: PluginModule = {
   setup(ctx) {
     const initialSettings = loadNewsFeedSettings(ctx.configState);
     if (initialSettings.needsMigration) {
-      void saveNewsFeedSettings(ctx.configState, initialSettings);
+      void saveNewsFeedSettings(ctx.configState, initialSettings)
+        .catch(logFailure("news.feed-config", "Migrate news feed settings failed"));
     }
 
     const source = createRssNewsCapability(
-      () => getEnabledNewsFeeds(loadNewsFeedSettings(ctx.configState)),
+      () => {
+        const settings = loadNewsFeedSettings(ctx.configState);
+        return { feeds: getEnabledNewsFeeds(settings), error: settings.error };
+      },
       { persistence: ctx.persistence },
     );
     ctx.registerCapability(source);

package/src/plugins/builtin/news/wire/letters/client.ts

@@ -31,6 +31,7 @@ const isWebUrl = (value: unknown): value is string => {
     const url = new URL(value);
     return url.protocol === "https:" || url.protocol === "http:";
   } catch {
+    // Intentional ignore: malformed links fail letter validation like other invalid fields.
     return false;
   }
 };

package/src/plugins/builtin/news/wire/news/command-bar-search.ts

@@ -8,6 +8,7 @@ import type {
   GloomPluginContext,
 } from "../../../../../types/plugin";
 import { formatFeedTime } from "../../../../../utils/datetime-format";
+import { logFailure } from "../../../../../utils/log-failure";
 import { openNewsStoryPane } from "./pop-out";
 import { NEWS_QUERY_PRESETS } from "./query-presets";
 
@@ -75,9 +76,11 @@ let warming: Promise<unknown> | null = null;
  */
 async function warmLatestStories(service: NewsService): Promise<void> {
   if (service.getQueryState(NEWS_QUERY_PRESETS.feed).articles.length > 0) return;
-  warming ??= service.load(NEWS_QUERY_PRESETS.feed).catch(() => null).finally(() => {
-    warming = null;
-  });
+  warming ??= service.load(NEWS_QUERY_PRESETS.feed)
+    .catch(logFailure("news.command-bar-search", "Load news for command bar search failed", null))
+    .finally(() => {
+      warming = null;
+    });
   await warming;
 }
 

package/src/plugins/builtin/news/wire/news/detail-view.tsx

@@ -14,6 +14,7 @@ import { useInlineTickers } from "../../../../../state/hooks/inline-tickers";
 import { truncateToDisplayWidth } from "../../../../../utils/format";
 import { wrapTextLines } from "../../../../../utils/text-wrap";
 import { formatDetailDate } from "../../../../../utils/datetime-format";
+import { logFailure } from "../../../../../utils/log-failure";
 import { mergeNewsArticle } from "../../../../../news/news-model";
 import { usePluginPaneState } from "../../../../runtime";
 import { formatNewsCategory } from "../categories";
@@ -277,7 +278,7 @@ export function NewsDetailView({ item, focused, width, showTitle = true }: {
     }).then((choice) => {
       const url = choice ? coverage[Number(choice)]?.url : undefined;
       if (url) void rendererHost.openExternal(url);
-    }).catch(() => {});
+    }).catch(logFailure("news.detail-view", "Choose news coverage failed"));
   }, [coverage, dialog, rendererHost]);
   usePaneFooter("news-detail:story", () => ({
     order: -1,

package/src/plugins/builtin/news/wire/news/preset-pane.tsx

@@ -1,9 +1,9 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import { Box } from "../../../../../ui";
 import type { NewsArticle, NewsQuery } from "../../../../../news/types";
 import { useLoadNewsStory, useNewsArticles, useNewsTableLoadMore } from "../../../../../news/hooks";
 import type { PaneProps } from "../../../../../types/plugin";
-import { useDebouncedPluginPaneState, usePluginPaneState } from "../../../../runtime";
+import { useDebouncedPluginPaneState, usePluginConfigState, usePluginPaneState } from "../../../../runtime";
 import { PaneStatusBody, QueryBar, type QueryBarSearch } from "../../../../../components";
 import { NewsDetailView, useNewsArticleDetail } from "./detail-view";
 import {
@@ -18,6 +18,7 @@ import { newsListEmptyCopy } from "../filter-articles";
 import { NEWS_LIST_SEARCH_PLACEHOLDER, useNewsListSearch, useNewsListSearchHint } from "./list-search";
 import { newsMutesApplyToFeed, useNewsMuteFilter } from "../mutes";
 import { usePopOutNewsArticle } from "./pop-out";
+import { parseNewsFeedSettings } from "../feed-config";
 
 interface NewsArticleStackOptions {
   /** Prefix of every key the pane persists, and of its footer registration. */
@@ -146,6 +147,13 @@ export function NewsPresetPane({
   emptyStateTitle,
   emptyStateHint,
 }: PaneProps & NewsPresetPaneConfig) {
+  const [storedFeeds] = usePluginConfigState<unknown>("feeds", null);
+  const [storedDisabledIds] = usePluginConfigState<unknown>("disabledDefaultFeedIds", null);
+  // The first query can finish before RSS registers, and desktop queries may
+  // use Cloud alone. A settings failure must remain visible in either case.
+  const settingsError = useMemo(() => query.feed === "latest"
+    ? parseNewsFeedSettings(storedFeeds, storedDisabledIds).error
+    : undefined, [query.feed, storedFeeds, storedDisabledIds]);
   const newsState = useNewsArticles(query);
   const persisted = usePersistedNewsArticles(`${paneKey}:articles`, newsState.articles);
   const articles = useNewsMuteFilter(persisted, newsMutesApplyToFeed(query.feed));
@@ -154,7 +162,7 @@ export function NewsPresetPane({
   // body rather than a definitive empty wire.
   const loading = newsState.phase === "loading"
     || (newsState.phase === "refreshing" && persisted.length === 0);
-  const error = newsState.error;
+  const error = settingsError ?? newsState.error;
   const { search, searchQuery, ...stack } = useNewsArticleStack({
     paneKey,
     articles,

package/src/plugins/builtin/news/wire/news/table.tsx

@@ -15,6 +15,7 @@ import { colors } from "../../../../../theme/colors";
 import { collectNewsDisplayTickers } from "../../../../../news/ticker-symbols";
 import { useLoadNewsStory } from "../../../../../news/hooks";
 import { formatFeedTime } from "../../../../../utils/datetime-format";
+import { logFailure } from "../../../../../utils/log-failure";
 import { nextHeaderSort } from "../../../../../utils/sort-values";
 import { formatNewsCategory } from "../categories";
 import { useOpenTickerChoice } from "../../../shared/ticker-choice";
@@ -270,7 +271,7 @@ export function NewsArticleStackView({
   const loadNewsStory = useLoadNewsStory();
   const prefetchStory = useCallback((article: MarketNewsItem) => {
     if ((article.items?.length ?? 0) > 0) return;
-    void loadNewsStory(article.id).catch(() => {});
+    void loadNewsStory(article.id).catch(logFailure("news.table", "Prefetch news story failed"));
   }, [loadNewsStory]);
 
   // A crosshair pinned in the tab picks the newest story out by then, and

package/src/plugins/builtin/news/wire/rss/cli.ts

@@ -26,8 +26,9 @@ export const rssCliCommand: CliCommandDef = {
       authority: 50,
       enabled: true,
     }]);
-    const articles = await capability.provider.fetchNews({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
-    ctx.printResult({ data: articles.map((article) => ({
+    const page = await capability.provider.fetchNewsPage!({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
+    if (page.error) ctx.fail(page.error);
+    ctx.printResult({ data: page.articles.map((article) => ({
       title: article.title,
       source: article.source,
       publishedAt: article.publishedAt.toISOString(),

package/src/plugins/builtin/news/wire/rss/feed-xml.ts

@@ -14,7 +14,12 @@ export interface FeedElement {
 
 export function resolveFeedUrl(value: string, base: string): string {
   if (!value.trim()) return "";
-  try { return new URL(value.trim(), base).href; } catch { return ""; }
+  try {
+    return new URL(value.trim(), base).href;
+  } catch {
+    // Intentional ignore: malformed optional feed links are treated as absent.
+    return "";
+  }
 }
 
 // Read the structure of a syndication document without executing declarations or

package/src/plugins/builtin/news/wire/rss/managed-feed.ts

@@ -14,6 +14,7 @@ export function isManagedNewsFeedUrl(value: string): boolean {
     const url = new URL(value);
     return url.origin === "https://api.gloom.sh" && url.pathname.replace(/\/$/, "") === "/news/rss";
   } catch {
+    // Intentional ignore: malformed URLs cannot identify the managed news feed.
     return false;
   }
 }

package/src/plugins/builtin/news/wire/rss/source.ts

@@ -129,11 +129,14 @@ function writeFeedCache(
 }
 
 export function createRssNewsCapability(
-  feedsOrGetter: RssFeedConfig[] | (() => RssFeedConfig[]),
+  feedsOrGetter: RssFeedConfig[] | (() => RssFeedConfig[] | { feeds: RssFeedConfig[]; error?: string }),
   options: RssNewsCapabilityOptions = {},
 ): NewsCapability {
   const fetchText = options.fetchText ?? ((url: string) => rssClient.fetch(url));
-  const getFeeds = () => Array.isArray(feedsOrGetter) ? feedsOrGetter : feedsOrGetter();
+  const getFeeds = () => {
+    const selection = Array.isArray(feedsOrGetter) ? feedsOrGetter : feedsOrGetter();
+    return Array.isArray(selection) ? { feeds: selection } : selection;
+  };
 
   async function fetchFeed(feed: RssFeedConfig): Promise<{ articles: MarketNewsItem[]; failed: boolean }> {
     const freshCache = readFeedCache(options.persistence, feed);
@@ -153,7 +156,9 @@ export function createRssNewsCapability(
 
   async function fetchPage(query: NewsQuery) {
     if (!supportsQuery(query)) return { articles: [] };
-    const feeds = getFeeds().filter((feed) => feed.enabled);
+    const selection = getFeeds();
+    if (selection.error) return { articles: [], error: selection.error };
+    const feeds = selection.feeds.filter((feed) => feed.enabled);
     const results = await Promise.all(feeds.map(fetchFeed));
     const failed = results.filter((result) => result.failed).length;
     return {
@@ -170,11 +175,15 @@ export function createRssNewsCapability(
       supports: supportsQuery,
       getCachedNews(query: NewsQuery): MarketNewsItem[] {
         if (!supportsQuery(query)) return [];
-        const enabledFeeds = getFeeds().filter((feed) => feed.enabled);
+        const selection = getFeeds();
+        if (selection.error) return [];
+        const enabledFeeds = selection.feeds.filter((feed) => feed.enabled);
         return enabledFeeds.flatMap((feed) => readFeedCache(options.persistence, feed, { allowExpired: true }) ?? []);
       },
       fetchNewsPage: fetchPage,
       async fetchNews(query: NewsQuery): Promise<MarketNewsItem[]> {
+        const error = supportsQuery(query) ? getFeeds().error : undefined;
+        if (error) throw new Error(error);
         return (await fetchPage(query)).articles;
       },
     },

package/src/plugins/builtin/notes/cli.ts

@@ -1,5 +1,6 @@
 import { apiClient } from "../../../api-client";
 import { withCliServices, withConfigData } from "../../../cli/scoped-context";
+import type { CliServicesContext } from "../../../cli/types";
 import { CLI_COMMAND_GROUPS } from "../../../cli/help";
 import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
@@ -7,9 +8,10 @@ import { EXCHANGE_OPTION, listingReadNotes, requireListingArg } from "../../../c
 import { createPluginPersistence } from "../../plugin-persistence";
 import type { CliCommandDef } from "../../../types/plugin";
 import { cliStyles } from "../../../utils/cli-output";
+import { errorMessage } from "../../../utils/errors";
 import { logFailure } from "../../../utils/log-failure";
 import { readChatSessionState } from "../chat/controller/persistence";
-import { exportNotesToDirectory, type NotesExportSource } from "./export";
+import { describeExportSkip, exportNotesToDirectory, type NotesExportSource } from "./export";
 import { NotesFiles } from "./files";
 import { CloudNotesStore } from "./store";
 
@@ -42,29 +44,52 @@ export const notesCliCommand: CliCommandDef = {
         // (personal and every team), one folder each.
         const dir = args[1] ?? `${config.dataDir}/notes-export-${new Date().toISOString().slice(0, 10)}`;
         const sources: NotesExportSource[] = [{ label: "local", store: notes }];
-        await withCliServices(ctx, async (services) => {
+        // A Cloud source left out or unreadable is a warning, as `quote` reports
+        // a symbol it found nothing for: the local files are always written.
+        const warnings: string[] = [];
+        const leftOut = (what: string, failure: string) => (error: unknown) => {
+          logFailure("notes.cli", failure)(error);
+          warnings.push(`${what} (${errorMessage(error)}).`);
+          return null;
+        };
+        const addCloudSources = async (services: CliServicesContext) => {
           const cloudPersistence = createPluginPersistence(services.persistence.pluginState, services.persistence.resources, "plugin:gloomberb-cloud", "gloomberb-cloud");
           const session = readChatSessionState(cloudPersistence, null);
           if (!session?.sessionToken) return;
           apiClient.setSessionToken(session.sessionToken);
           const user = await apiClient.ensureVerifiedSession()
-            .catch(logFailure("notes.cli", "Verify the saved session for the notes export failed", null));
+            .catch(leftOut("Skipped Gloom Cloud notes: the saved session could not be checked", "Verify the saved session for the notes export failed"));
           if (!user) return;
           const notesPersistence = createPluginPersistence(services.persistence.pluginState, services.persistence.resources, "plugin:notes", "notes");
           sources.push({ label: "mine", store: new CloudNotesStore({ kind: "user" }, notesPersistence) });
-          const teams = await apiClient.listTeams().catch(logFailure("notes.cli", "List teams for the notes export failed", []));
+          const teams = await apiClient.listTeams()
+            .catch(leftOut("Skipped team notes: the team list could not be read", "List teams for the notes export failed")) ?? [];
           for (const team of teams) {
             sources.push({ label: team.name, store: new CloudNotesStore({ kind: "team", teamId: team.id }, notesPersistence) });
           }
+        };
+        // The Cloud stores read and cache through these services, so the
+        // export runs before they close.
+        const result = await withCliServices(ctx, async (services) => {
+          await addCloudSources(services);
+          return ctx.cliOptions.dryRun ? null : await exportNotesToDirectory(dir, sources);
         });
-        if (ctx.cliOptions.dryRun) {
-          ctx.printResult({ data: { dryRun: true, dir, sources: sources.map((source) => source.label) } }, {
+        if (!result) {
+          ctx.printResult({ data: { dryRun: true, dir, sources: sources.map((source) => source.label) }, ...(warnings.length > 0 ? { warnings } : {}) }, {
             text: (data) => `Would export ${data.sources.join(", ")} notes to ${data.dir}.${dryRunNote(true)}`,
           });
           return;
         }
-        const result = await exportNotesToDirectory(dir, sources);
-        ctx.printResult({ data: { dir: result.dir, files: result.files, sources: sources.map((source) => source.label) } }, {
+        warnings.push(...result.skipped.map(describeExportSkip));
+        ctx.printResult({
+          data: {
+            dir: result.dir,
+            files: result.files,
+            sources: result.exported,
+            ...(result.skipped.length > 0 ? { skipped: result.skipped } : {}),
+          },
+          ...(warnings.length > 0 ? { warnings } : {}),
+        }, {
           text: (data) => `Exported ${data.files} notes from ${data.sources.join(", ")} to ${data.dir}.`,
         });
         return;

package/src/plugins/builtin/notes/export.ts

@@ -1,3 +1,4 @@
+import { errorMessage } from "../../../utils/errors";
 import type { NoteFileEntry, QuickNoteEntry } from "./files";
 import type { NotesStore } from "./store";
 import { noteOwnerKey, splitNoteKey } from "./store";
@@ -7,9 +8,23 @@ export interface NotesExportSource {
   store: NotesStore;
 }
 
+/**
+ * What an export left out, and why: a whole source whose notes could not be
+ * listed, or with `note`, one note of that source that could not be read.
+ */
+export interface NotesExportSkip {
+  label: string;
+  /** The note's symbol, or a quick note's title. */
+  note?: string;
+  reason: string;
+}
+
 export interface NotesExportResult {
   dir: string;
   files: number;
+  /** The sources whose notes were written, in the order given. */
+  exported: string[];
+  skipped: NotesExportSkip[];
 }
 
 function safeFileName(value: string): string {
@@ -29,16 +44,27 @@ export async function exportNotesToDirectory(
   const fsModulePath = "fs/promises";
   const { mkdir, writeFile } = await import(fsModulePath) as typeof import("fs/promises");
   let files = 0;
+  const exported: string[] = [];
+  const skipped: NotesExportResult["skipped"] = [];
   for (const source of sources) {
     const folder = sources.length > 1 ? `${dir}/${safeFileName(source.label)}` : dir;
     let entries: NoteFileEntry[];
     let quick: QuickNoteEntry[];
+    const unreadable: Array<{ key: string; error: unknown }> = [];
     try {
-      [entries, quick] = await Promise.all([source.store.list(), source.store.loadQuickNotesIndex()]);
-    } catch {
+      [entries, quick] = await Promise.all([
+        source.store.list({ strict: true, skipped: (key, error) => unreadable.push({ key, error }) }),
+        source.store.loadQuickNotesIndex(),
+      ]);
+    } catch (error) {
+      skipped.push({ label: source.label, reason: errorMessage(error) });
       continue;
     }
     const titles = new Map(quick.map((entry) => [entry.id, entry.title]));
+    for (const { key: noteKey, error } of unreadable) {
+      const { kind, key } = splitNoteKey(noteKey);
+      skipped.push({ label: source.label, note: kind === "quick" ? (titles.get(key) ?? key) : key, reason: errorMessage(error) });
+    }
     for (const entry of entries) {
       const { kind, key } = splitNoteKey(entry.key);
       const path = kind === "quick"
@@ -48,8 +74,28 @@ export async function exportNotesToDirectory(
       await writeFile(path, entry.text, "utf-8");
       files += 1;
     }
+    exported.push(source.label);
   }
-  return { dir, files };
+  return { dir, files, exported, skipped };
+}
+
+/** One line per skip, as `notes export` warns and the Export Notes command reports. */
+export function describeExportSkip(skip: NotesExportSkip): string {
+  return skip.note === undefined
+    ? `Skipped ${skip.label}: its notes could not be read (${skip.reason}).`
+    : `Skipped the ${skip.label} note ${skip.note}: it could not be read (${skip.reason}).`;
+}
+
+/** The Export Notes command's notice: the count, then what was skipped. */
+export function exportNotice(result: NotesExportResult): { body: string; type: "success" | "error" } {
+  const exported = `Exported ${result.files} ${result.files === 1 ? "note" : "notes"} to ${result.dir}`;
+  if (result.skipped.length === 0) return { body: exported, type: "success" };
+  const shown = result.skipped.slice(0, 3).map(describeExportSkip);
+  const more = result.skipped.length - shown.length;
+  return {
+    body: [`${exported}.`, ...shown, ...(more > 0 ? [`${more} more could not be read.`] : [])].join(" "),
+    type: "error",
+  };
 }
 
 export function exportSourceLabel(store: NotesStore, teamName?: string): string {

package/src/plugins/builtin/notes/files.ts

@@ -35,6 +35,13 @@ export interface NotesFilesIO {
 }
 
 const QUICK_NOTES_INDEX_FILE = "__quick-notes-index__.json";
+
+export interface NotesListOptions {
+  /** A notes folder that cannot be listed rejects instead of listing nothing. */
+  strict?: boolean;
+  /** Hears each note left out because it could not be read, for a caller that says so. */
+  skipped?: (key: string, error: unknown) => void;
+}
 const LOCAL_KEY_PREFIX = "gloomberb:notes:";
 const LOCAL_TIMESTAMP_KEY = "gloomberb:notes:__updated-at__";
 
@@ -237,8 +244,8 @@ export class NotesFiles implements NotesStore {
   }
 
   /** Every stored note, ticker notes and quick notes alike, newest first. */
-  async list(): Promise<NoteFileEntry[]> {
-    const { entries } = await this.readEach(await this.io.listKeys());
+  async list(options: NotesListOptions = {}): Promise<NoteFileEntry[]> {
+    const { entries } = await this.readEach(await this.io.listKeys({ strict: options.strict }), options.skipped);
     return entries.sort((left, right) => right.updatedAt - left.updatedAt);
   }
 
@@ -277,7 +284,10 @@ export class NotesFiles implements NotesStore {
   }
 
   /** An unreadable note is left out and counted rather than synced as empty. */
-  private async readEach(keys: Array<[string, number]>): Promise<{ entries: NoteFileEntry[]; unreadable: number }> {
+  private async readEach(
+    keys: Array<[string, number]>,
+    skipped?: NotesListOptions["skipped"],
+  ): Promise<{ entries: NoteFileEntry[]; unreadable: number }> {
     const entries: NoteFileEntry[] = [];
     let unreadable = 0;
     for (const [key, updatedAt] of keys) {
@@ -286,6 +296,7 @@ export class NotesFiles implements NotesStore {
       } catch (error) {
         unreadable += 1;
         logFailure("notes.files", "Read a note while listing notes failed")(error);
+        skipped?.(key, error);
       }
     }
     return { entries, unreadable };

package/src/plugins/builtin/notes/index.tsx

@@ -2,7 +2,7 @@ import { apiClient } from "../../../api-client";
 import type { GloomPlugin } from "../../../types/plugin";
 import { teamStore } from "../../../team/store";
 import { notesCliCommand } from "./cli";
-import { exportNotesToDirectory, exportSourceLabel } from "./export";
+import { exportNotesToDirectory, exportNotice, exportSourceLabel } from "./export";
 import { NotesFiles } from "./files";
 import { migrateLocalNotes, notesMigratedAt } from "./migration";
 import { createQuickNotesPane } from "./quick-notes-pane";
@@ -114,8 +114,8 @@ export const notesPlugin: GloomPlugin = {
           ...teams.map((team) => ({ label: exportSourceLabel(registry.forOwner({ kind: "team", teamId: team.id }), team.name), store: registry.forOwner({ kind: "team", teamId: team.id }) })),
         ];
         try {
-          const result = await exportNotesToDirectory(dir, sources);
-          ctx.notify({ body: `Exported ${result.files} ${result.files === 1 ? "note" : "notes"} to ${result.dir}`, type: "success" });
+          // What was skipped is said with the count, as `notes export` warns.
+          ctx.notify(exportNotice(await exportNotesToDirectory(dir, sources)));
         } catch (error) {
           ctx.notify({ body: error instanceof Error ? error.message : "Could not export notes.", type: "error" });
         }