gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/sec/filing-documents.ts

@@ -53,3 +53,13 @@ export function isDefaultVisibleFilingDocument(document: SecFilingDocument): boo
   if (isInlineExhibitDocument(document)) return true;
   return !SEC_SUPPORT_DOCUMENT_TYPE_RE.test(document.type.trim());
 }
+
+/** A primary preview or a rendered exhibit can independently hit the extraction limit. */
+export function filingPreviewTruncated(
+  filing: SecFilingItem,
+  documents: readonly SecFilingDocument[],
+  contentCache: ReadonlyMap<string, string | null>,
+): boolean {
+  const keys = [filing.accessionNumber, ...documents.filter(isInlineExhibitDocument).map((document) => documentContentKey(filing, document))];
+  return keys.some((key) => contentCache.get(key)?.trimEnd().endsWith("[truncated]"));
+}

package/src/plugins/builtin/sec/headless.test.ts

@@ -4,6 +4,7 @@ import { createDefaultConfig } from "../../../types/config";
 import type { SecFilingItem } from "../../../types/data-provider";
 import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
 import { createSecHeadless } from "./headless";
+import { buildSecFilingRows, secAcceptanceTimestamp } from "./model";
 
 const filings: SecFilingItem[] = [
   {
@@ -56,12 +57,15 @@ describe("SEC headless model", () => {
     expect(first.rows).toEqual([{
       filedAt: "2026-08-25T00:00:00.000Z",
       acceptedAt: null,
+      acceptedAtRaw: null,
+      acceptanceReported: null,
       form: "8-K",
       filing: "8-K | Results of Operations | Current Report",
       items: "2.02,9.01",
       accessionNumber: "0000320193-26-000100",
       primaryDocument: null,
       cik: "0000320193",
+      companyName: null,
       url: "https://www.sec.gov/filing/one",
     }]);
 
@@ -70,3 +74,26 @@ describe("SEC headless model", () => {
     expect(requestedLimits).toEqual([1, 2]);
   });
 });
+
+test("ticker reuse preserves the actual filing issuer rather than the requested ticker's former company", async () => {
+  const headless = createSecHeadless({ loadFilings: async () => [{
+    ...filings[0]!, cik: "0001826011", companyName: "Banzai International, Inc."
+  }] });
+  const result = await headless.load({ ...args(1), argument: "PARA", symbols: ["PARA"] }, context());
+  expect(result.rows[0]).toMatchObject({ cik: "0001826011", companyName: "Banzai International, Inc." });
+  expect(result.metadata?.issuers).toEqual([{ cik: "0001826011", companyName: "Banzai International, Inc." }]);
+});
+
+test("accepted timestamps survive persisted JSON rows and invalid cached values remain unknown", () => {
+  const filing = { ...filings[0]!, acceptedAt: new Date("2025-03-20T20:10:11.000Z") };
+  const restored = JSON.parse(JSON.stringify(filing)) as SecFilingItem;
+  expect(secAcceptanceTimestamp(restored.acceptedAt)).toBe("2025-03-20T20:10:11.000Z");
+  expect(buildSecFilingRows([restored])[0]?.acceptedAt).toBe("2025-03-20T20:10:11.000Z");
+  const compact = { ...restored, acceptedAt: undefined, acceptedAtRaw: "20250320161011" };
+  expect(buildSecFilingRows([compact])[0]).toMatchObject({ acceptedAt: null, acceptedAtRaw: "20250320161011", acceptanceReported: "20250320161011 (timezone unspecified)" });
+  expect(secAcceptanceTimestamp("2025-03-20T16:10:11")).toBeNull();
+  const naive = JSON.parse(JSON.stringify({ ...filing, acceptedAt: "2025-03-20T16:10:11" })) as SecFilingItem;
+  expect(buildSecFilingRows([naive])[0]).toMatchObject({ acceptedAt: null, acceptanceReported: "2025-03-20T16:10:11 (timezone unspecified)" });
+  expect(secAcceptanceTimestamp("invalid")).toBeNull();
+  expect(secAcceptanceTimestamp(undefined)).toBeNull();
+});

package/src/plugins/builtin/sec/headless.ts

@@ -6,7 +6,7 @@ import type {
 } from "../../../types/plugin";
 import type { SecFilingItem } from "../../../types/data-provider";
 import { loadSecFilings } from "./client";
-import { buildSecFilingRows } from "./model";
+import { buildSecFilingRows, secFilingIssuers, SEC_ACCEPTANCE_NOTE } from "./model";
 
 const SEC_COLUMNS: HeadlessPaneColumn[] = [
   {
@@ -14,7 +14,9 @@ const SEC_COLUMNS: HeadlessPaneColumn[] = [
     header: "Filed",
     format: (value) => typeof value === "string" ? value.slice(0, 10) : "-",
   },
+  { key: "acceptanceReported", header: "SEC-reported acceptance" },
   { key: "form", header: "Form" },
+  { key: "companyName", header: "Issuer" },
   { key: "filing", header: "Filing" },
   { key: "items", header: "Items" },
   { key: "accessionNumber", header: "Accession" },
@@ -60,7 +62,7 @@ export function createSecHeadless(
       const filings = await dependencies.loadFilings(symbol, limit, args, ctx);
       return {
         rows: buildSecFilingRows(filings).slice(0, limit),
-        metadata: { symbol, returned: Math.min(filings.length, limit) },
+        metadata: { acceptanceNote: SEC_ACCEPTANCE_NOTE, symbol, returned: Math.min(filings.length, limit), issuers: secFilingIssuers(filings.slice(0, limit)) },
       };
     },
   };

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

@@ -1,18 +1,22 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { PluginModule } from "../plugin-module";
 import type { SecFilingDocument, SecFilingItem } from "../../../types/data-provider";
 import { useResolvedEntryValue, useSecFilingDocuments, useSecFilingsQuery } from "../../../market-data/hooks";
+import { getSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import { useShortcut } from "../../../react/input";
+import { isPlainKey } from "../../../utils/keyboard";
 import { instrumentFromTicker } from "../../../market-data/request-types";
 import { useDebouncedPluginPaneState } from "../../runtime";
 import { usePaneTicker } from "../../../state/app/context";
-import type { ScrollBoxRenderable } from "../../../ui";
-import { EmptyState, FeedDataTableStackView, Spinner, useTableLoadMore, type FeedDataTableItem } from "../../../components";
+import { Box, type ScrollBoxRenderable } from "../../../ui";
+import { EmptyState, FeedDataTableStackView, Prose, Spinner, useTableLoadMore, type FeedDataTableItem } from "../../../components";
 import { isUsEquityTicker } from "../../../utils/sec";
 import { parseForm4Xml, transactionTypeLabel } from "../insider/insider-data";
-import { formatCompact, formatCurrency } from "../../../utils/format";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import {
   formatFilingMetaDate,
+  buildInsiderTransactionTitle,
+  buildInsiderTransactionDetailBody,
   renderFilingNotice,
 } from "./filing-display";
 import {
@@ -21,17 +25,23 @@ import {
   formatCompactDocumentLabel,
   isDefaultVisibleFilingDocument,
   isInlineExhibitDocument,
+  filingPreviewTruncated,
 } from "./filing-documents";
 import {
   buildInlineFilingContentTargets,
   useSecFilingContentCache,
 } from "./filing-content";
 import { usePaneStatusLinkFooter } from "../shared/pane-footer";
+import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
+import { SignInWall } from "../cloud/auth-actions";
 import { secHeadless } from "./headless";
 import {
   getFilingDisplayTitle,
   getFormDescription,
   getMeaningfulPrimaryDescription,
+  secFilingIssuers,
+  secIssuerLabel,
+  secReportedAcceptance,
 } from "./model";
 
 export { secHeadless } from "./headless";
@@ -60,18 +70,24 @@ function buildDetailBodyWithDocuments({
   filing,
   documents,
   documentsLoading,
+  documentsError,
   contentCache,
+  contentErrors,
   primaryContent,
 }: {
   filing: SecFilingItem;
   documents: SecFilingDocument[];
   documentsLoading: boolean;
+  documentsError: string | null;
+  contentErrors: Map<string, string>;
   contentCache: Map<string, string | null>;
   primaryContent: string;
 }): string {
   const lines: string[] = [];
   lines.push("Documents");
-  if (documentsLoading && documents.length === 0) {
+  if (documentsError && documents.length === 0) {
+    lines.push(`Filing documents unavailable: ${documentsError}`);
+  } else if (documentsLoading && documents.length === 0) {
     lines.push("Loading filing documents...");
   } else if (documents.length === 0) {
     lines.push("No filing documents were listed for this filing.");
@@ -90,8 +106,9 @@ function buildDetailBodyWithDocuments({
       const hasContent = contentCache.has(key);
       const content = contentCache.get(key);
       lines.push("", documentHeading(document));
-      lines.push(hasContent
-        ? content || "Readable document content was not available for this exhibit."
+      lines.push(contentErrors.has(key) && !content
+        ? `Exhibit content unavailable: ${contentErrors.get(key)}`
+        : hasContent ? content || "Readable document content was not available for this exhibit."
         : "Loading exhibit content...");
     }
   }
@@ -102,27 +119,27 @@ function buildDetailBodyWithDocuments({
 
 function buildForm4Preview(content: string | null): string | null {
   if (!content) return null;
-  const tx = parseForm4Xml(content);
+  const transactions = parseForm4Xml(content);
+  const tx = transactions[0];
   if (!tx) return null;
-  const type = transactionTypeLabel(tx.transactionType);
-  const shares = formatCompact(tx.shares);
-  const price = tx.pricePerShare != null ? ` @ ${formatCurrency(tx.pricePerShare)}` : "";
-  return `${tx.reportedName} — ${type} ${shares} shares${price}`;
+  if (transactions.length === 1) return `${tx.reportedName} — ${buildInsiderTransactionTitle(tx)}`;
+  const types = [...new Set(transactions.map((transaction) => transactionTypeLabel(transaction.transactionType)))];
+  return `${tx.reportedName} — ${transactions.length} transactions: ${types.join(", ")}`;
 }
 
 function buildForm4Detail(content: string | null, filing: SecFilingItem): string {
   if (!content) return buildDetailBody(filing);
-  const tx = parseForm4Xml(content);
+  const transactions = parseForm4Xml(content);
+  const tx = transactions[0];
   if (!tx) return buildDetailBody(filing);
 
   const lines: string[] = [];
   lines.push(`Insider: ${tx.reportedName}`);
   if (tx.title) lines.push(`Title: ${tx.title}`);
-  lines.push(`Transaction: ${transactionTypeLabel(tx.transactionType)}`);
-  lines.push(`Shares: ${formatCompact(tx.shares)}`);
-  if (tx.pricePerShare != null) lines.push(`Price/Share: ${formatCurrency(tx.pricePerShare)}`);
-  if (tx.totalValue != null) lines.push(`Total Value: ${formatCurrency(tx.totalValue)}`);
-  if (tx.sharesOwned != null) lines.push(`Shares Owned After: ${formatCompact(tx.sharesOwned)}`);
+  for (const [index, transaction] of transactions.entries()) {
+    if (transactions.length > 1) lines.push("", `Transaction ${index + 1}`);
+    lines.push(buildInsiderTransactionDetailBody(transaction));
+  }
   return lines.join("\n");
 }
 
@@ -133,9 +150,12 @@ function toFeedItems(
   loadingContent: boolean,
   selectedDocuments: SecFilingDocument[],
   loadingDocuments: boolean,
+  documentsError: string | null,
+  contentErrors: Map<string, string>,
 ): FeedDataTableItem[] {
   return filings.map((filing) => {
     const displayTitle = getFilingDisplayTitle(filing);
+    const acceptedAt = secReportedAcceptance(filing);
     const formDesc = getFormDescription(filing.form);
     const hasFetchedContent = contentCache.has(filing.accessionNumber);
     const fetchedContent = contentCache.get(filing.accessionNumber);
@@ -154,13 +174,17 @@ function toFeedItems(
     const selected = filing.accessionNumber === selectedAccessionNumber;
     const primaryDetailBody = loadingContent && selected
       ? "Loading filing content..."
-      : form4Detail ?? fetchedContent ?? fallbackBody;
+      : contentErrors.has(filing.accessionNumber) && !fetchedContent
+        ? `Filing content unavailable: ${contentErrors.get(filing.accessionNumber)}`
+        : form4Detail ?? fetchedContent ?? fallbackBody;
     const detailBody = selected
       ? buildDetailBodyWithDocuments({
           filing,
           documents: selectedDocuments,
           documentsLoading: loadingDocuments,
+          documentsError,
           contentCache,
+          contentErrors,
           primaryContent: primaryDetailBody,
         })
       : form4Detail ?? fallbackBody;
@@ -176,9 +200,13 @@ function toFeedItems(
       timestamp: filing.filingDate,
       detailTitle: enrichedTitle,
       detailMeta: [
+        secIssuerLabel(filing),
         `Filed ${formatFiledAt(filing)}`,
+        ...(acceptedAt ? [`SEC-reported acceptance ${acceptedAt}`] : []),
         `Accession ${filing.accessionNumber}`,
         ...(filing.items ? [`Items ${filing.items}`] : []),
+        ...(filingPreviewTruncated(filing, selected ? selectedDocuments : [], contentCache)
+          ? ["Preview truncated. Open the SEC filing for the complete documents and terms."] : []),
       ],
       detailBody,
     };
@@ -189,7 +217,16 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
   const { ticker } = usePaneTicker();
   const selectionKey = `selectedIdx:${ticker?.metadata.ticker ?? "none"}`;
   const [selectedIdx, setSelectedIdx] = useDebouncedPluginPaneState<number>(selectionKey, 0);
-  const [openItemId, setOpenItemId] = useState<string | null>(null);
+  // The open filing is what the pane shows, so it is pane state: it restores
+  // on relaunch and a shared pane opens on the same document.
+  const [openItemId, setOpenItemIdState] = useDebouncedPluginPaneState<string | null>(
+    `openAccession:${ticker?.metadata.ticker ?? "none"}`,
+    null,
+  );
+  const setOpenItemId = useCallback(
+    (itemId: string | null) => setOpenItemIdState(itemId, { immediate: true }),
+    [setOpenItemIdState],
+  );
   const eligibleTicker = isUsEquityTicker(ticker);
   const instrument = instrumentFromTicker(ticker, ticker?.metadata.ticker ?? null);
   const filingsEntry = useSecFilingsQuery(
@@ -209,14 +246,31 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
   useEffect(() => {
     setVisibleCount(SEC_FILING_PAGE_SIZE);
   }, [ticker?.metadata.ticker, ticker?.metadata.exchange]);
-  const loading = filingsEntry?.phase === "loading" || (filingsEntry?.phase === "refreshing" && filings.length === 0);
-  const error = filingsEntry?.phase === "error" ? filingsEntry.error?.message ?? "Failed to load SEC filings" : null;
+  const loading = filingsEntry?.phase === "loading" || filingsEntry?.phase === "refreshing";
+  // A restored or shared open filing can sit past the first page, or be gone
+  // from the feed entirely.
+  useEffect(() => {
+    if (!openItemId || filings.length === 0) return;
+    const index = filings.findIndex((filing) => filing.accessionNumber === openItemId);
+    if (index < 0) {
+      if (!loading) setOpenItemId(null);
+      return;
+    }
+    if (index >= visibleCount) {
+      setVisibleCount(Math.ceil((index + 1) / SEC_FILING_PAGE_SIZE) * SEC_FILING_PAGE_SIZE);
+    }
+  }, [filings, loading, openItemId, setOpenItemId, visibleCount]);
+  const error = filingsEntry?.error && filingsEntry.error.reasonCode !== "NO_DATA" ? filingsEntry.error.message : null;
+  // Hosted, the only filings source is Gloom Cloud, which needs an account.
+  const cloudSession = useResearchCloudSession();
+  const authWall = filings.length === 0 && isCloudSessionRequired(error);
 
   const openFiling = openItemId
     ? filings.find((filing) => filing.accessionNumber === openItemId) ?? null
     : null;
   const documentsEntry = useSecFilingDocuments(openFiling ?? null);
   const openDocuments = useResolvedEntryValue(documentsEntry) ?? [];
+  const documentsError = documentsEntry?.error && documentsEntry.error.reasonCode !== "NO_DATA" ? documentsEntry.error.message : null;
   const loadingDocuments = !!openFiling && (
     documentsEntry?.phase === "idle"
     || documentsEntry?.phase === "loading"
@@ -231,11 +285,45 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
     ...buildInlineFilingContentTargets(openFiling, openDocuments),
     ...(selectedFiling && OWNERSHIP_FORMS.has(selectedFiling.form.trim()) ? [selectedFiling] : []),
   ], [openDocuments, openFiling, selectedFiling]);
-  const { contentCache } = useSecFilingContentCache({
+  const { contentCache, contentErrors, retry: retryContent, loadingKey } = useSecFilingContentCache({
     scopeKey: `${ticker?.metadata.ticker ?? "none"}:${ticker?.metadata.exchange ?? ""}:${eligibleTicker}`,
     targets: contentTargets,
   });
-  const loadingContent = !!openFiling && !contentCache.has(openFiling.accessionNumber);
+  const loadingContent = !!openFiling && (!contentCache.has(openFiling.accessionNumber) || loadingKey === openFiling.accessionNumber);
+  const activeContentError = [openFiling, ...buildInlineFilingContentTargets(openFiling, openDocuments)]
+    .filter((target): target is SecFilingItem => !!target)
+    .map((target) => contentErrors.get(target.accessionNumber)).find(Boolean);
+  const detailError = openFiling ? documentsError ?? activeContentError ?? null : null;
+
+  // The document list is the first of the two round trips behind a filing.
+  // Warming it while the cursor rests on the row leaves only the content
+  // fetch for Enter; the content itself stays on demand, as the note above
+  // says, so a scroll through the list does not fire a request per filing.
+  const prefetchDocuments = useCallback((item: { id: string }) => {
+    const coordinator = getSharedMarketDataCoordinator();
+    const filing = visibleFilings.find((candidate) => candidate.accessionNumber === item.id);
+    if (!coordinator || !filing) return;
+    if (coordinator.getSecDocumentsEntry(filing.accessionNumber).phase !== "idle") return;
+    void coordinator.loadSecFilingDocuments(filing).catch(() => {});
+  }, [visibleFilings]);
+
+  const refresh = useCallback(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !instrument || !eligibleTicker) return;
+    void coordinator.loadSecFilings({ instrument, count: SEC_FILING_FETCH_LIMIT }, { forceRefresh: true });
+    if (openFiling && (documentsError || openDocuments.length === 0)) {
+      void coordinator.loadSecFilingDocuments(openFiling, { forceRefresh: true });
+    }
+    void retryContent();
+  }, [instrument, eligibleTicker, openFiling, documentsError, openDocuments.length, retryContent]);
+  useShortcut((event) => { if (isPlainKey(event, "r")) refresh(); }, { enabled: focused, scope: "sec" });
+  // Signing in must retry the request the wall was shown for.
+  const sessionKeyRef = useRef(cloudSession.requestKey);
+  useEffect(() => {
+    if (sessionKeyRef.current === cloudSession.requestKey) return;
+    sessionKeyRef.current = cloudSession.requestKey;
+    refresh();
+  }, [cloudSession.requestKey, refresh]);
 
   useEffect(() => {
     if (visibleFilings.length > 0 && selectedIdx >= visibleFilings.length) {
@@ -246,20 +334,21 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
   usePaneStatusLinkFooter({
     registrationId: "sec",
     focused,
-    url: error ? null : openFiling?.filingUrl,
+    url: openFiling?.filingUrl,
     source: openFiling?.form,
     label: "filing",
-    loading,
-    error,
-    showOpenHint: !error && !!openFiling?.filingUrl,
+    loading: loading || loadingDocuments || !!loadingKey,
+    error: authWall ? null : error ?? detailError,
+    showOpenHint: !!openFiling?.filingUrl,
   });
 
   if (!ticker) {
     return <EmptyState title="No ticker selected." message="Select a ticker to view SEC filings." />;
   }
   if (!eligibleTicker) return renderFilingNotice("SEC filings are only shown for US equities.", width);
+  if (authWall) return <SignInWall action="view SEC filings" needsVerification={cloudSession.needsVerification} />;
   if (loading && filings.length === 0) return <Spinner label="Loading SEC filings..." />;
-  if (error) return <EmptyState title="SEC filings unavailable." message={error} />;
+  if (error && filings.length === 0) return <EmptyState title="SEC filings unavailable." message={error} />;
   if (filings.length === 0) return renderFilingNotice(`No recent SEC filings for ${ticker.metadata.ticker}.`, width);
 
   return (
@@ -274,10 +363,17 @@ function SecView({ width, height, focused }: { width: number; height: number; fo
         loadingContent,
         openDocuments,
         loadingDocuments,
+        documentsError,
+        contentErrors,
       )}
       selectedIdx={selectedIdx}
       onSelect={setSelectedIdx}
+      openItemId={openItemId}
       onOpenItemIdChange={setOpenItemId}
+      prefetchDetail={prefetchDocuments}
+      rootBefore={<Box flexDirection="column" paddingX={1}>
+        {secFilingIssuers(filings).map((issuer) => <Prose key={issuer.cik} text={secIssuerLabel(issuer)} width={Math.max(width - 2, 12)} />)}
+      </Box>}
       sourceLabel="Form"
       titleLabel="Filing"
       emptyStateTitle="No SEC filings."

package/src/plugins/builtin/sec/model.ts

@@ -52,6 +52,9 @@ export function getFormDescription(form: string): string {
     case "10-Q/A": return "Quarterly Report (Amended)";
     case "8-K": return "Current Report";
     case "8-K/A": return "Current Report (Amended)";
+    case "8-K12B": return "Successor Issuer Current Report";
+    case "S-4": return "Business Combination or Exchange Offer Registration";
+    case "S-4/A": return "Business Combination or Exchange Offer Registration (Amended)";
     case "4": return "Insider Transaction";
     case "3": return "Initial Insider Ownership";
     case "5": return "Annual Insider Ownership";
@@ -74,16 +77,51 @@ export function buildSecFilingRows(filings: readonly SecFilingItem[]) {
       filedAt: filing.filingDate instanceof Date
         ? filing.filingDate.toISOString()
         : String(filing.filingDate),
-      acceptedAt: filing.acceptedAt instanceof Date
-        ? filing.acceptedAt.toISOString()
-        : filing.acceptedAt ? String(filing.acceptedAt) : null,
+      acceptedAt: secAcceptanceTimestamp(filing.acceptedAt),
+      acceptedAtRaw: filing.acceptedAtRaw ?? null,
+      acceptanceReported: secReportedAcceptance(filing),
       form: filing.form,
       filing: formDescription ? `${displayTitle} | ${formDescription}` : displayTitle,
       items: filing.items ?? null,
       accessionNumber: filing.accessionNumber,
       primaryDocument: filing.primaryDocument ?? null,
       cik: filing.cik,
+      companyName: filing.companyName ?? null,
       url: filing.filingUrl,
     };
   });
 }
+
+export function secFilingIssuers(filings: readonly SecFilingItem[]) {
+  const issuers = new Map<string, { cik: string; companyName: string | null }>();
+  for (const filing of filings) {
+    const previous = issuers.get(filing.cik);
+    if (!previous || (!previous.companyName && filing.companyName)) {
+      issuers.set(filing.cik, { cik: filing.cik, companyName: filing.companyName ?? null });
+    }
+  }
+  return [...issuers.values()];
+}
+
+export function secIssuerLabel(issuer: { cik: string; companyName?: string | null }): string {
+  return `${issuer.companyName || "Issuer name unavailable"} · CIK ${issuer.cik}`;
+}
+
+/** Persistence may return timestamps as strings even when the network model uses Date. */
+export function secAcceptanceTimestamp(value: unknown): string | null {
+  if (!(value instanceof Date) && typeof value !== "string") return null;
+  if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(value)) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+
+export function secReportedAcceptance(filing: SecFilingItem): string | null {
+  const persistedValue: unknown = filing.acceptedAt;
+  const raw = filing.acceptedAtRaw?.trim() || (typeof persistedValue === "string" ? persistedValue.trim() : undefined);
+  if (raw) return /^\d{14}$/.test(raw) || !/(?:Z|[+-]\d{2}:\d{2})$/.test(raw)
+    ? `${raw} (timezone unspecified)`
+    : raw;
+  return secAcceptanceTimestamp(filing.acceptedAt);
+}
+
+export const SEC_ACCEPTANCE_NOTE = "SEC-reported acceptance is not verified public availability or an announcement time. Source timestamps without a timezone remain unconverted.";

package/src/plugins/builtin/sec/pane.test.tsx

@@ -0,0 +1,152 @@
+import { afterAll, afterEach, expect, test } from "bun:test";
+import { act, useMemo, useState } from "react";
+import { mkdirSync, writeFileSync } from "node:fs";
+const source = process.env.FILING_SOURCE ?? new URL("../../../../", import.meta.url).pathname.replace(/\/$/, ""), out = process.env.FILING_OUT;
+if (out)
+    mkdirSync(out, { recursive: true });
+const { secModule, secHeadless } = await import(`${source}/src/plugins/builtin/sec`);
+const { TestPaneProvider, createTestPaneConfig, createTestTicker } = await import(`${source}/src/test-support/pane`);
+const { createStatefulTestPluginRuntime } = await import(`${source}/src/test-support/plugin-runtime`);
+const { createTestDataProvider } = await import(`${source}/src/test-support/data-provider`);
+const { createInitialState } = await import(`${source}/src/state/app/context`);
+const { MarketDataCoordinator, setSharedMarketDataCoordinator } = await import(`${source}/src/market-data/coordinator`);
+const { PaneFooterProvider, PaneFooterBar } = await import(`${source}/src/components/layout/pane/footer`);
+const { testRender, settleFrame, emitKeypress } = await import(`${source}/src/renderers/opentui/test-utils`);
+const { Box } = await import(`${source}/src/ui`);
+const Pane = secModule.panes[0].component;
+const filing = { accessionNumber: "0000000001-26-000001", form: "8-K", filingDate: new Date("2026-09-10T00:00:00Z"), cik: "1", companyName: "CONTROL issuer", primaryDocument: "current.htm", filingUrl: "https://www.sec.gov/Archives/1/filing-index.htm", primaryDocumentUrl: "https://www.sec.gov/Archives/1/current.htm" };
+let setup: any, coordinator: any, footer: any, selectCompany: (symbol: string) => void;
+let frames = 0;
+const observations: any[] = [];
+async function mount(provider: any) { coordinator = new MarketDataCoordinator(provider); setSharedMarketDataCoordinator(coordinator); function Harness() { const [symbol, setSymbol] = useState("CONTROL"); selectCompany = setSymbol; const config = createTestPaneConfig("/tmp/unused-sec-audit", { instanceId: "sec-audit", paneId: "sec", binding: { kind: "fixed", symbol } }); const state = createInitialState(config); state.tickers = new Map([[symbol, createTestTicker(symbol)]]); state.focusedPaneId = "sec-audit"; const runtime = useMemo(() => createStatefulTestPluginRuntime(), []); return <TestPaneProvider state={state} paneId="sec-audit" pluginId="ticker-research" runtime={runtime}><PaneFooterProvider>{(value: any) => { footer = value; return <Box width={110} height={36} flexDirection="column"><Box height={35}><Pane focused width={110} height={35}/></Box><PaneFooterBar footer={value} focused width={110}/></Box>; }}</PaneFooterProvider></TestPaneProvider>; } ; await act(async () => { setup = await testRender(<Harness />, { width: 110, height: 36 }); }); await settleFrame(setup, 8); }
+function capture(name: string) { const frame = setup.captureCharFrame(); frames++; if (out) {
+    writeFileSync(`${out}/${name}.txt`, frame);
+    writeFileSync(`${out}/${name}-footer.json`, JSON.stringify(footer, null, 2));
+} return frame; }
+afterEach(async () => { if (setup)
+    await act(async () => setup.renderer.destroy()); setup = null; coordinator?.destroy(); coordinator = null; setSharedMarketDataCoordinator(null); });
+afterAll(() => { if (out)
+    writeFileSync(`${out}/observations.json`, JSON.stringify({ source, frames, observations }, null, 2)); });
+test("SEC reports document failures honestly and plain refresh retries only failed reading", async () => {
+    let recovered = false;
+    const calls: string[] = [];
+    const provider = createTestDataProvider({ getSecFilings: async () => { calls.push("filings"); return [filing]; }, getSecFilingDocuments: async () => { calls.push("documents"); if (!recovered)
+            throw new Error("Controlled document-index outage"); return [{ document: "current.htm", type: "8-K", url: filing.primaryDocumentUrl, isPrimary: true }]; }, getSecFilingContent: async () => { calls.push("content"); if (!recovered)
+            throw new Error("Controlled primary outage"); return "Recovered acquisition agreement terms"; } });
+    await mount(provider);
+    capture("sec-list");
+    await emitKeypress(setup, { name: "return", sequence: "\r" });
+    await settleFrame(setup, 12);
+    const failed = capture("sec-failed-detail");
+    expect(calls).toContain("documents");
+    expect(calls).toContain("content");
+    expect(failed).not.toContain("No filing documents were listed");
+    expect(failed).toContain("Controlled document-index outage");
+    expect(failed).toContain("Controlled primary outage");
+    recovered = true;
+    const count = calls.length;
+    await emitKeypress(setup, { name: "r", sequence: "r" });
+    await settleFrame(setup, 8);
+    expect(calls.length).toBe(count + 3);
+    expect(capture("sec-refresh-recovered")).toContain("Recovered acquisition");
+    expect(JSON.stringify(footer)).not.toContain("outage");
+    const reads = calls.filter(c => c !== "filings").length;
+    await emitKeypress(setup, { name: "r", sequence: "r" });
+    await settleFrame(setup, 8);
+    expect(calls.filter(c => c !== "filings").length).toBe(reads);
+    observations.push({ case: "document-outages", calls, footer, contentEntry: coordinator.getSecContentEntry(filing.accessionNumber), documentsEntry: coordinator.getSecDocumentsEntry(filing.accessionNumber) });
+});
+test("cached router failures retry and true empty document results stay distinct", async () => {
+    const { AssetDataRouter } = await import(`${source}/src/sources/provider-router`);
+    const { AppPersistence } = await import(`${source}/src/data/app-persistence`);
+    const persistence = new AppPersistence(":memory:");
+    let failed = true;
+    let documents = 0, contents = 0;
+    const provider = createTestDataProvider({ id: "controlled-sec", getSecFilings: async () => [filing], getSecFilingDocuments: async () => { documents++; if (failed)
+            throw new Error("Cached index outage"); return []; }, getSecFilingContent: async () => { contents++; if (failed)
+            throw new Error("Cached primary outage"); return "Recovered cached primary document"; } });
+    try {
+        await mount(new AssetDataRouter(provider, [], persistence.resources));
+        await emitKeypress(setup, { name: "return", sequence: "\r" });
+        await settleFrame(setup, 12);
+        expect(capture("cached-failure")).toContain("Cached index outage");
+        failed = false;
+        await emitKeypress(setup, { name: "r", sequence: "r" });
+        await settleFrame(setup, 12);
+        const frame = capture("cached-recovered-empty-index");
+        expect(documents).toBe(2);
+        expect(contents).toBe(2);
+        expect(frame).toContain("No filing documents were listed");
+        expect(frame).toContain("Recovered cached primary document");
+        expect(JSON.stringify(footer)).not.toContain("outage");
+    }
+    finally {
+        await act(async () => setup.renderer.destroy());
+        setup = null;
+        coordinator.destroy();
+        coordinator = null;
+        setSharedMarketDataCoordinator(null);
+        persistence.close();
+    }
+});
+test("SEC refresh joins an active request and preserves filing ownership across companies", async () => {
+    let finish!: (rows: any[]) => void;
+    const calls: string[] = [];
+    const second = { ...filing, accessionNumber: "0000000002-26-000002", companyName: "SECOND issuer", cik: "2", primaryDocumentUrl: "https://www.sec.gov/Archives/2/current.htm", filingUrl: "https://www.sec.gov/Archives/2/index.htm" };
+    const provider = createTestDataProvider({ getSecFilings: async (symbol: string) => { calls.push(symbol); return symbol === "CONTROL" ? new Promise(resolve => finish = resolve) : [second]; }, getSecFilingDocuments: async () => [], getSecFilingContent: async (item: any) => `Only ${item.companyName} source terms` });
+    await mount(provider);
+    await emitKeypress(setup, { name: "r", sequence: "r" });
+    await settleFrame(setup, 6);
+    expect(calls).toEqual(["CONTROL"]);
+    await act(async () => selectCompany("SECOND"));
+    await settleFrame(setup, 8);
+    await emitKeypress(setup, { name: "return", sequence: "\r" });
+    await settleFrame(setup, 10);
+    expect(capture("second-detail-before-old-completion")).toContain("Only SECOND issuer source terms");
+    await act(async () => finish([filing]));
+    await settleFrame(setup, 8);
+    const frame = capture("second-detail-after-old-completion");
+    expect(frame).toContain("Only SECOND issuer source terms");
+    expect(frame).not.toContain("CONTROL issuer");
+    expect(coordinator.getSecContentEntry(second.accessionNumber).data).toBe("Only SECOND issuer source terms");
+});
+test("as-filed originals and amendments retain independent detail and headless accession/date identity", async () => {
+    const amendment = { ...filing, accessionNumber: "0000000001-26-000003", form: "8-K/A", filingDate: new Date("2026-09-11T00:00:00Z"), acceptedAt: new Date("2026-09-11T21:05:00Z"), acceptedAtRaw: "2026-09-11T21:05:00Z", filingUrl: "https://www.sec.gov/Archives/1/amendment-index.htm", primaryDocumentUrl: "https://www.sec.gov/Archives/1/amendment.htm" };
+    const provider = createTestDataProvider({ getSecFilings: async () => [amendment, filing], getSecFilingDocuments: async () => [], getSecFilingContent: async (item: any) => `As filed ${item.form}, accession ${item.accessionNumber}` });
+    await mount(provider);
+    await emitKeypress(setup, { name: "return", sequence: "\r" });
+    await settleFrame(setup, 10);
+    expect(capture("amendment-detail")).toContain("As filed 8-K/A, accession 0000000001-26-000003");
+    await emitKeypress(setup, { name: "escape", sequence: "\x1b" });
+    await emitKeypress(setup, { name: "down", sequence: "j" });
+    await emitKeypress(setup, { name: "return", sequence: "\r" });
+    await settleFrame(setup, 8);
+    expect(capture("original-detail")).toContain("As filed 8-K, accession 0000000001-26-000001");
+    const report = await secHeadless.load({ symbols: ["CONTROL"], options: { limit: 50 } }, { marketData: provider, signal: new AbortController().signal });
+    expect(report.rows.map((row: any) => row.accessionNumber)).toEqual([amendment.accessionNumber, filing.accessionNumber]);
+    expect(report.rows[0]).toMatchObject({ form: "8-K/A", filedAt: "2026-09-11T00:00:00.000Z", acceptedAt: "2026-09-11T21:05:00.000Z", url: amendment.filingUrl });
+    expect(report.rows[1].acceptedAt).toBeNull();
+    if (out)
+        writeFileSync(`${out}/sec-headless.json`, JSON.stringify(report, null, 2));
+});
+test("discovery refresh failure preserves the opened as-filed document and its source action", async () => {
+    let failed = false, reads = 0;
+    const provider = createTestDataProvider({ getSecFilings: async () => { if (failed)
+            throw new Error("Controlled discovery outage"); return [filing]; }, getSecFilingDocuments: async () => [{ document: "current.htm", type: "8-K", url: filing.primaryDocumentUrl, isPrimary: true }], getSecFilingContent: async () => { reads++; return "Immutable acquisition source terms"; } });
+    await mount(provider);
+    await emitKeypress(setup, { name: "return", sequence: "\r" });
+    await settleFrame(setup, 10);
+    failed = true;
+    await emitKeypress(setup, { name: "r", sequence: "r" });
+    await settleFrame(setup, 8);
+    expect(capture("discovery-failed-detail-retained")).toContain("Immutable acquisition source terms");
+    expect(JSON.stringify(footer)).toContain("Controlled discovery outage");
+    expect(footer.hints.some((hint: any) => hint.id === "open")).toBe(true);
+    expect(reads).toBe(1);
+    failed = false;
+    await emitKeypress(setup, { name: "r", sequence: "r" });
+    await settleFrame(setup, 8);
+    capture("discovery-recovered-detail-retained");
+    expect(JSON.stringify(footer)).not.toContain("Controlled discovery outage");
+    expect(reads).toBe(1);
+});