gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/thirteenf/data.ts

@@ -1,4 +1,5 @@
 import {
+  type Forms13FReadOptions,
   listThirteenFFormHoldings,
   listThirteenFFormHoldingsPage,
   listThirteenFForms,
@@ -6,7 +7,6 @@ import {
   listTopThirteenFFunds,
   lookupThirteenFHoldersByCusip,
   lookupThirteenFTickers,
-  loadLatestFormsForFunds,
   normalizeCik,
   searchThirteenFFunds,
 } from "./api";
@@ -15,23 +15,50 @@ import {
   dateYearsAgo,
   latestLikely13FQuarter,
   recentIso,
-  selectLatestFormsByPeriod,
+  buildPeriodReports,
+  dedupeLatestForms,
   todayIso,
 } from "./model";
 import type {
   FundBrowserRow,
   FundDetailData,
   ThirteenFBrowserTab,
-  ThirteenFFormSummary,
   ThirteenFFund,
   ThirteenFHoldingRecord,
   ThirteenFTopFund,
+  ThirteenFPeriodReport,
 } from "./types";
 
 const BROWSER_PAGE_LIMIT = 75;
 const LATEST_FILINGS_PAGE_LIMIT = 120;
 const FORM_ENRICHMENT_LIMIT = 35;
 
+async function loadReportsForFunds(
+  funds: ThirteenFFund[],
+  options: Forms13FReadOptions & { from: string; to: string; signal?: AbortSignal; periods?: Map<string, string> },
+): Promise<{ reports: Map<string, ThirteenFPeriodReport>; warning?: string }> {
+  const reports = new Map<string, ThirteenFPeriodReport>();
+  const failures: string[] = [];
+  let index = 0;
+  async function worker() {
+    while (!options.signal?.aborted && index < funds.length) {
+      const fund = funds[index++]!;
+      try {
+        const forms = await listThirteenFForms(fund.cik, options.from, options.to, 100, options.signal, options);
+        const periods = buildPeriodReports(forms);
+        const selectedPeriod = options.periods?.get(fund.cik);
+        const report = selectedPeriod ? periods.find((item) => item.periodOfReport === selectedPeriod) : periods[0];
+        if (report) reports.set(fund.cik, report);
+      } catch {
+        if (options.signal?.aborted) throw options.signal.reason;
+        failures.push(`${fund.cik}: filing metadata unavailable.`);
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(5, funds.length) }, worker));
+  return { reports, ...(failures.length ? { warning: failures.join(" ") } : {}) };
+}
+
 export interface BrowserLoadResult {
   rows: FundBrowserRow[];
   period?: string;
@@ -46,6 +73,17 @@ export async function loadBrowserRows(
   query: string,
   signal?: AbortSignal,
   options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
+): Promise<BrowserLoadResult> {
+  const warnings: string[] = [];
+  const result = await loadBrowserPage(tab, query, signal, { ...options, onWarning: warning => warnings.push(warning) });
+  return { ...result, warning: [...new Set([result.warning, ...warnings].filter(Boolean))].join(" ") || undefined };
+}
+
+async function loadBrowserPage(
+  tab: ThirteenFBrowserTab,
+  query: string,
+  signal?: AbortSignal,
+  options: Forms13FReadOptions & { offset?: number; limit?: number } = {},
 ): Promise<BrowserLoadResult> {
   const now = new Date();
   const from = dateYearsAgo(2, now);
@@ -54,15 +92,19 @@ export async function loadBrowserRows(
   const offset = Math.max(0, options.offset ?? 0);
   const browserLimit = Math.max(1, options.limit ?? BROWSER_PAGE_LIMIT);
   const latestLimit = Math.max(1, options.limit ?? LATEST_FILINGS_PAGE_LIMIT);
-  const apiOptions = { forceRefresh: options.forceRefresh };
-  const pageApiOptions = { forceRefresh: options.forceRefresh, offset };
+  const apiOptions = { forceRefresh: options.forceRefresh, onWarning: options.onWarning };
+  const pageApiOptions = { ...apiOptions, offset };
 
   if (tab === "performance") {
     const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, pageApiOptions);
     const funds: ThirteenFFund[] = topFunds.map((fund) => ({ cik: fund.cik, name: fund.name }));
-    const forms = await loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh });
+    const { reports, warning } = await loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), {
+      from, to, signal, ...apiOptions,
+      periods: new Map(topFunds.map((fund) => [fund.cik, fund.periodOfReport])),
+    });
     return {
-      rows: buildBrowserRows({ topFunds, forms, source: "performance" }),
+      rows: buildBrowserRows({ topFunds, reports, source: "performance" }),
+      warning,
       quarter,
       period: topFunds[0]?.periodOfReport,
       hasMore: topFunds.length >= browserLimit,
@@ -72,8 +114,14 @@ export async function loadBrowserRows(
 
   if (tab === "latest") {
     const filings = await listThirteenFFilings(recentIso(21, now), to, latestLimit, signal, pageApiOptions);
+    const selected = dedupeLatestForms(filings);
+    const { reports, warning } = await loadReportsForFunds(selected.map((form) => ({ cik: form.cik, name: form.companyName })), {
+      from, to, signal, ...apiOptions,
+      periods: new Map(selected.map((form) => [form.cik, form.periodOfReport])),
+    });
     return {
-      rows: buildBrowserRows({ latestFilings: filings, source: "latest" }),
+      rows: buildBrowserRows({ latestFilings: filings, reports, source: "latest" }),
+      warning,
       period: filings[0]?.periodOfReport,
       hasMore: filings.length >= latestLimit,
       nextOffset: offset + filings.length,
@@ -98,18 +146,15 @@ export async function loadBrowserRows(
     const periodOfReport = quarterToPeriod(quarter);
     try {
       const holders = await lookupThirteenFHoldersByCusip(cusip, periodOfReport, signal, apiOptions);
-      const forms = new Map<string, ThirteenFFormSummary>();
       const pageCiks = holders.ciks.slice(offset, offset + browserLimit);
-      const funds = await Promise.all(pageCiks.map(async (cik): Promise<ThirteenFFund> => {
-        const fundForms = await listThirteenFForms(cik, from, to, 1, signal, apiOptions);
-        if (fundForms[0]) forms.set(cik, fundForms[0]);
-        return {
-          cik,
-          name: fundForms[0]?.companyName || cik,
-        };
-      }));
+      const { reports, warning } = await loadReportsForFunds(pageCiks.map((cik) => ({ cik, name: cik })), {
+        from, to, signal, ...apiOptions,
+        periods: new Map(pageCiks.map((cik) => [cik, holders.periodOfReport])),
+      });
+      const funds = pageCiks.map((cik) => ({ cik, name: reports.get(cik)?.filings.at(-1)?.companyName || cik }));
       return {
-        rows: buildBrowserRows({ funds, forms, source: "ticker" }),
+        rows: buildBrowserRows({ funds, reports, source: "ticker" }),
+        warning,
         period: holders.periodOfReport,
         hasMore: holders.ciks.length > offset + pageCiks.length,
         nextOffset: offset + pageCiks.length,
@@ -127,21 +172,23 @@ export async function loadBrowserRows(
   if (!trimmed) return { rows: [], quarter };
   if (/^\d{6,10}$/.test(trimmed)) {
     const cik = normalizeCik(trimmed);
-    const forms = await listThirteenFForms(cik, from, to, 1, signal, apiOptions);
-    const fund = { cik, name: forms[0]?.companyName || cik };
-    const formsMap = new Map<string, NonNullable<typeof forms[0]>>();
-    if (forms[0]) formsMap.set(cik, forms[0]);
+    const forms = await listThirteenFForms(cik, from, to, 100, signal, apiOptions);
+    const report = buildPeriodReports(forms)[0];
+    const form = report?.filings.at(-1);
+    const fund = { cik, name: form?.companyName || cik };
+    const reports = new Map<string, ThirteenFPeriodReport>();
+    if (report) reports.set(cik, report);
     return {
-      rows: buildBrowserRows({ funds: [fund], forms: formsMap, source: "funds" }),
-      period: forms[0]?.periodOfReport,
+      rows: buildBrowserRows({ funds: [fund], reports, source: "funds" }),
+      period: form?.periodOfReport,
       hasMore: false,
       nextOffset: offset + 1,
     };
   }
   const funds = await searchThirteenFFunds(trimmed, browserLimit, signal, pageApiOptions);
-  const [forms, topFunds] = await Promise.all([
-    loadLatestFormsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, concurrency: 5, forceRefresh: options.forceRefresh }),
-    listTopThirteenFFunds(quarter, browserLimit, signal, { forceRefresh: options.forceRefresh }).catch(() => []),
+  const [{ reports, warning }, topFunds] = await Promise.all([
+    loadReportsForFunds(funds.slice(0, Math.min(browserLimit, FORM_ENRICHMENT_LIMIT)), { from, to, signal, ...apiOptions }),
+    listTopThirteenFFunds(quarter, browserLimit, signal, apiOptions).catch(() => []),
   ]);
   const topByCik = new Map(topFunds.map((fund) => [fund.cik, fund]));
   const matchedTopFunds = funds
@@ -151,10 +198,11 @@ export async function loadBrowserRows(
     rows: buildBrowserRows({
       funds,
       topFunds: matchedTopFunds,
-      forms,
+      reports,
       source: "funds",
     }),
     quarter,
+    warning,
     hasMore: funds.length >= browserLimit,
     nextOffset: offset + funds.length,
   };
@@ -167,21 +215,46 @@ export async function loadFundDetail(
   options: { forceRefresh?: boolean } = {},
 ): Promise<FundDetailData> {
   const now = new Date();
-  const apiOptions = { forceRefresh: options.forceRefresh };
+  const warnings: string[] = [];
+  const apiOptions = { forceRefresh: options.forceRefresh, onWarning: (warning: string) => warnings.push(warning) };
 
-  const forms = selectLatestFormsByPeriod(await listThirteenFForms(
+  const forms = await listThirteenFForms(
     cik,
     dateYearsAgo(4, now),
     todayIso(now),
-    20,
+    100,
     signal,
     apiOptions,
-  ));
-  const latestForm = forms[0] ?? null;
-  const previousForm = forms[1] ?? null;
+  );
+  const reports = buildPeriodReports(forms);
+  const latestReport = reports[0];
+  const previousReport = reports[1];
+  const latestForm = latestReport?.filings.at(-1) ?? null;
+  const previousForm = previousReport?.filings.at(-1) ?? null;
+  async function loadReport(report: ThirteenFPeriodReport | undefined): Promise<ThirteenFHoldingRecord[]> {
+    if (!report) return [];
+    const holdings: ThirteenFHoldingRecord[] = [];
+    for (const form of report.filings) {
+      const rows = await listThirteenFFormHoldings(cik, form.accessionNumber, signal, apiOptions);
+      holdings.push(...rows);
+      if (form.tableEntryTotal != null && rows.length !== form.tableEntryTotal) {
+        report.complete = false;
+        warnings.push(`${report.periodOfReport}: loaded ${rows.length} of ${form.tableEntryTotal} disclosed entries for ${form.accessionNumber}.`);
+      }
+    }
+    if (!report.complete && !warnings.some((warning) => warning.startsWith(report.periodOfReport))) {
+      warnings.push(`${report.periodOfReport}: amendment type or original report unavailable; disclosed entries cannot be reconciled into a full report.`);
+    }
+    return holdings;
+  }
   const [latestHoldings, previousHoldings] = await Promise.all([
-    latestForm ? listThirteenFFormHoldings(cik, latestForm.accessionNumber, signal, apiOptions) : Promise.resolve([]),
-    previousForm ? listThirteenFFormHoldings(cik, previousForm.accessionNumber, signal, apiOptions) : Promise.resolve([]),
+    loadReport(latestReport),
+    loadReport(previousReport).catch((error) => {
+      if (signal?.aborted) throw error;
+      if (previousReport) previousReport.complete = false;
+      warnings.push(`${previousReport?.periodOfReport ?? "Prior quarter"}: holdings unavailable; comparison unavailable.`);
+      return [];
+    }),
   ]);
   return {
     cik: normalizeCik(cik),
@@ -191,6 +264,9 @@ export async function loadFundDetail(
     previousForm,
     latestHoldings,
     previousHoldings,
+    latestReport,
+    previousReport,
+    warnings,
   };
 }
 
@@ -199,8 +275,12 @@ export async function loadFilingPositions(
   accessionNumber: string,
   signal?: AbortSignal,
   options: { forceRefresh?: boolean; offset?: number; limit?: number } = {},
-): Promise<{ rows: ThirteenFHoldingRecord[]; hasMore: boolean }> {
-  return listThirteenFFormHoldingsPage(cik, accessionNumber, signal, options);
+): Promise<{ rows: ThirteenFHoldingRecord[]; hasMore: boolean; warnings: string[] }> {
+  const warnings: string[] = [];
+  const result = await listThirteenFFormHoldingsPage(cik, accessionNumber, signal, {
+    ...options, onWarning: warning => warnings.push(warning),
+  });
+  return { ...result, warnings };
 }
 
 function quarterToPeriod(quarter: string): string {

package/src/plugins/builtin/thirteenf/format.ts

@@ -45,6 +45,8 @@ export function actionLabel(action: HoldingAction): string {
       return "Exit";
     case "held":
       return "Held";
+    case "unknown":
+      return "--";
   }
 }
 

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

@@ -80,6 +80,42 @@ function args(view: string, limit = 50): HeadlessPaneLoadArgs {
 }
 
 describe("13F headless model", () => {
+  test("retains prior-quarter positions omitted from the current disclosed report", async () => {
+    const headless = createThirteenFHeadless({
+      loadBrowser: async () => ({ rows: [] }),
+      loadDetail: async () => ({ ...detail, previousHoldings: [
+        ...detail.previousHoldings,
+        { ...detail.previousHoldings[0]!, cusip: "21036P108", ticker: "STZ", shares: 632890, value: 94933500 },
+      ] }),
+    });
+    const result = await headless.load(args("holdings"), context());
+    expect(result.rows.find((row) => row.ticker === "STZ")).toMatchObject({
+      action: "exit", previousShares: 632890, sharesChange: -632890,
+      shares: null, value: null, estimatedPnl: null,
+    });
+  });
+
+  test("requires an unambiguous manager even when the requested output has only one row", async () => {
+    const lookups: number[] = [];
+    let loaded = false;
+    const headless = createThirteenFHeadless({
+      loadBrowser: async (_tab, _query, limit) => {
+        lookups.push(limit);
+        return { rows: [
+          { id: "asset", cik: "0000949012", name: "Berkshire Asset Management", source: "funds" },
+          { id: "hathaway", cik: detail.cik, name: detail.name, source: "funds" },
+        ] };
+      },
+      loadDetail: async () => { loaded = true; return detail; },
+    });
+    await expect(headless.load({ ...args("holdings", 1), argument: "Berkshire" }, context()))
+      .rejects.toThrow(/Ambiguous 13F fund.*0001067983/);
+    expect(loaded).toBe(false);
+    expect(lookups).toEqual([25]);
+    const exact = await headless.load({ ...args("holdings", 1), argument: "Berkshire Hathaway" }, context());
+    expect(exact.metadata?.cik).toBe(detail.cik);
+  });
+
   test("projects browser rows and switches to fund holdings", async () => {
     const headless = createThirteenFHeadless({
       loadBrowser: async () => ({

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

@@ -17,6 +17,8 @@ import {
   buildFundHoldingRows,
   buildTimelineRows,
   inferBrowserTabFromQuery,
+  hasComparable13FQuarter,
+  THIRTEENF_OPTIONS_NOTE,
   isCikQuery,
   positionType,
   sortBrowserRows,
@@ -79,7 +81,8 @@ const HOLDING_COLUMNS: HeadlessPaneColumn[] = [
   },
   {
     key: "weight",
-    header: "Weight",
+    header: "13F %",
+    description: "Share of the filing's reported value, including underlying notional for options; not portfolio allocation.",
     align: "right",
     format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
   },
@@ -119,6 +122,7 @@ const FILING_COLUMNS: HeadlessPaneColumn[] = [
     format: (value) => formatPercentMaybe(value == null ? null : Number(value)),
   },
   { key: "submissionType", header: "Form" },
+  { key: "amendmentType", header: "Amendment" },
 ];
 
 type HeadlessThirteenFView =
@@ -164,17 +168,23 @@ function browserTab(view: HeadlessThirteenFView, query: string): ThirteenFBrowse
 
 async function resolveFund(
   query: string,
-  limit: number,
   args: HeadlessPaneLoadArgs,
   ctx: HeadlessPaneContext,
   dependencies: ThirteenFHeadlessDependencies,
 ): Promise<{ cik: string; name: string }> {
   if (!query) throw new Error("13F holdings and filings require a fund name or CIK.");
   if (isCikQuery(query)) return { cik: normalizeCik(query), name: query };
-  const result = await dependencies.loadBrowser("funds", query, Math.min(limit, 25), args, ctx);
-  const exact = result.rows.find((row) => row.name.toLocaleLowerCase() === query.toLocaleLowerCase());
-  const fund = exact ?? result.rows[0];
-  if (!fund) throw new Error(`No 13F fund found for "${query}".`);
+  // A small output limit must not hide other matching managers during lookup.
+  const result = await dependencies.loadBrowser("funds", query, 25, args, ctx);
+  const candidates = [...new Map(result.rows.map((row) => [row.cik, row])).values()];
+  const exact = candidates.filter((row) => row.name.toLocaleLowerCase() === query.toLocaleLowerCase());
+  const fund = exact.length === 1 ? exact[0]
+    : candidates.length === 1 && !result.hasMore ? candidates[0] : undefined;
+  if (candidates.length === 0) throw new Error(`No 13F fund found for "${query}".`);
+  if (!fund) {
+    const choices = candidates.slice(0, 5).map((row) => `${row.name} (${row.cik})`).join("; ");
+    throw new Error(`Ambiguous 13F fund "${query}". Use an exact fund name or CIK: ${choices}.`);
+  }
   return { cik: fund.cik, name: fund.name };
 }
 
@@ -223,7 +233,7 @@ export function createThirteenFHeadless(
       const limit = Number(args.options.limit);
 
       if (view === "holdings" || view === "filings") {
-        const fund = await resolveFund(query, limit, args, ctx, dependencies);
+        const fund = await resolveFund(query, args, ctx, dependencies);
         const detail = await dependencies.loadDetail(fund.cik, fund.name, args, ctx);
         if (view === "filings") {
           const rows = sortTimelineRows(buildTimelineRows(detail.forms), DEFAULT_TIMELINE_SORT)
@@ -232,6 +242,7 @@ export function createThirteenFHeadless(
           return {
             columns: FILING_COLUMNS,
             rows,
+            ...(detail.warnings?.length ? { errors: detail.warnings } : {}),
             metadata: {
               view,
               cik: detail.cik,
@@ -241,7 +252,7 @@ export function createThirteenFHeadless(
           };
         }
         const rows = sortHoldingRows(
-          buildFundHoldingRows(detail).filter((row) => row.value != null),
+          buildFundHoldingRows(detail),
           DEFAULT_HOLDING_SORT,
         )
           .slice(0, limit)
@@ -253,12 +264,20 @@ export function createThirteenFHeadless(
         return {
           columns: HOLDING_COLUMNS,
           rows,
+          ...(detail.warnings?.length ? { errors: detail.warnings } : {}),
           metadata: {
             view,
             cik: detail.cik,
             fund: detail.name,
             latestPeriod: detail.latestForm?.periodOfReport ?? null,
             previousPeriod: detail.previousForm?.periodOfReport ?? null,
+            comparisonAvailable: hasComparable13FQuarter(detail),
+            currentFilings: detail.latestReport?.filings.map((form) => form.accessionNumber) ?? [],
+            previousFilings: detail.previousReport?.filings.map((form) => form.accessionNumber) ?? [],
+            currentReportedValue: detail.latestReport?.complete ? detail.latestReport.tableValueTotal : null,
+            changeBasis: "Changes compare disclosed quarter-end positions, not trades. Omitted or confidential holdings can affect apparent entries and exits.",
+            valueBasis: THIRTEENF_OPTIONS_NOTE,
+            estimatedPnlBasis: "Quarter-end unit-value change on overlapping reported shares; excludes options, trading costs and dividends; not actual fund P&L.",
           },
         };
       }

package/src/plugins/builtin/thirteenf/model.test.ts

@@ -5,7 +5,7 @@ import {
   buildTimelineRows,
   inferBrowserTabFromQuery,
   latestLikely13FQuarter,
-  selectLatestFormsByPeriod,
+  buildPeriodReports,
   sortFilingPositionRows,
 } from "./model";
 import type { FundDetailData, ThirteenFFormSummary, ThirteenFHoldingRecord } from "./types";
@@ -57,31 +57,36 @@ describe("13F model", () => {
   test("uses the latest plausibly filed 13F quarter", () => {
     expect(latestLikely13FQuarter(new Date("2026-05-24T00:00:00Z"))).toBe("2026Q1");
     expect(latestLikely13FQuarter(new Date("2026-04-20T00:00:00Z"))).toBe("2025Q4");
+    expect(latestLikely13FQuarter(new Date("2026-01-15T00:00:00Z"))).toBe("2025Q3");
+    expect(latestLikely13FQuarter(new Date("2026-02-20T00:00:00Z"))).toBe("2025Q4");
   });
 
-  test("selects the latest filing for each period", () => {
-    const selected = selectLatestFormsByPeriod([
-      form({ accessionNumber: "old", periodOfReport: "2025-12-31", filedAsOfDate: "2026-02-14" }),
-      form({ accessionNumber: "amended", periodOfReport: "2025-12-31", filedAsOfDate: "2026-02-20", isAmendment: true }),
-      form({ accessionNumber: "new", periodOfReport: "2026-03-31", filedAsOfDate: "2026-05-15" }),
-    ]);
-    expect(selected.map((entry) => entry.accessionNumber)).toEqual(["new", "amended"]);
+  test("reconciles additions and smaller full restatements without losing filing history", () => {
+    const original = form({ accessionNumber: "original", tableEntryTotal: 110, tableValueTotal: 258701144516 });
+    const addition = form({ accessionNumber: "addition", filedAsOfDate: "2026-05-20", isAmendment: true,
+      amendmentType: "NEW HOLDINGS", tableEntryTotal: 4, tableValueTotal: 1106550356 });
+    const reports = buildPeriodReports([addition, original, addition]);
+    expect(reports[0]).toMatchObject({ complete: true, tableEntryTotal: 114, tableValueTotal: 259807694872 });
+    expect(reports[0]?.filings.map((entry) => entry.accessionNumber)).toEqual(["original", "addition"]);
+    const restatement = form({ accessionNumber: "restated", filedAsOfDate: "2026-06-01", isAmendment: true,
+      amendmentType: "RESTATEMENT", tableEntryTotal: 1, tableValueTotal: 20 });
+    const extra = { ...addition, accessionNumber: "extra", filedAsOfDate: "2026-06-02" };
+    const revised = buildPeriodReports([extra, original, restatement, addition])[0];
+    expect(revised?.filings.map((entry) => entry.accessionNumber)).toEqual(["restated", "extra"]);
+    expect(revised).toMatchObject({ complete: true, tableEntryTotal: 5, tableValueTotal: 1106550376 });
+    expect(buildTimelineRows([original, addition, restatement, extra]).map((row) => row.id))
+      .toEqual(["extra", "restated", "addition", "original"]);
+    expect(buildTimelineRows([original, addition]).every((row) => row.valueChangePercent === null)).toBe(true);
   });
 
-  test("does not replace a full period filing with a supplemental amendment", () => {
-    const selected = selectLatestFormsByPeriod([
-      form({ accessionNumber: "full", periodOfReport: "2025-03-31", filedAsOfDate: "2025-05-15", tableEntryTotal: 110 }),
-      form({
-        accessionNumber: "supplemental",
-        submissionType: "13F-HR/A",
-        periodOfReport: "2025-03-31",
-        filedAsOfDate: "2025-06-03",
-        tableEntryTotal: 4,
-        isAmendment: true,
-        amendmentType: "NEW HOLDINGS",
-      }),
-    ]);
-    expect(selected.map((entry) => entry.accessionNumber)).toEqual(["full"]);
+  test("does not infer a full report from a standalone or untyped amendment", () => {
+    const original = form({ accessionNumber: "original" });
+    for (const amendmentType of [undefined, "NEW HOLDINGS"]) {
+      const amendment = form({ accessionNumber: "amendment", isAmendment: true, amendmentType,
+        filedAsOfDate: "2026-05-20" });
+      expect(buildPeriodReports([amendment])[0]).toMatchObject({ complete: false, tableValueTotal: null });
+      if (!amendmentType) expect(buildPeriodReports([original, amendment])[0]?.complete).toBe(false);
+    }
   });
 
   test("aggregates current and prior holdings into change rows", () => {
@@ -141,10 +146,71 @@ describe("13F model", () => {
     expect(sortFilingPositionRows(rows, { columnId: "value", direction: "desc" }).map((row) => row.ticker)).toEqual(["BBB", "AAA"]);
   });
 
+  test("uses CUSIP and security type across ticker and class-label changes, and excludes option P&L", () => {
+    const current = [
+      holding({ ticker: "NEW", titleOfClass: "ORDINARY", value: 120, shares: 10 }),
+      holding({ ticker: "NEW", putCall: "PUT", value: 120, shares: 10 }),
+      holding({ ticker: "NEW", shareType: "PRN", value: 500, shares: 500 }),
+    ];
+    const rows = buildFundHoldingRows({
+      cik: "0001067983", name: "Fund", forms: [],
+      latestForm: form({}), previousForm: form({ periodOfReport: "2025-12-31" }),
+      latestHoldings: current,
+      previousHoldings: [
+        holding({ ticker: "OLD", titleOfClass: "COM", value: 100, shares: 10 }),
+        holding({ ticker: "OLD", putCall: "PUT", value: 100, shares: 10 }),
+      ],
+    });
+    expect(rows).toHaveLength(3);
+    expect(rows.find((row) => row.shareType === "SH" && !row.putCall))
+      .toMatchObject({ ticker: "NEW", action: "held", sharesChange: 0, estimatedPnl: 20 });
+    expect(rows.find((row) => row.putCall === "PUT"))
+      .toMatchObject({ estimatedPnl: null, shares: 10, action: "held" });
+    expect(rows.find((row) => row.shareType === "PRN")?.shares).toBe(500);
+  });
+
+  test("does not call a first filing or a missing-quarter comparison new buying", () => {
+    for (const previousForm of [null, form({ periodOfReport: "2025-09-30" })]) {
+      const rows = buildFundHoldingRows({
+        cik: "0001067983", name: "Fund", forms: [], latestForm: form({}), previousForm,
+        latestHoldings: [holding({ value: 120, shares: 10 })],
+        previousHoldings: previousForm ? [holding({ value: 100, shares: 9 })] : [],
+      });
+      expect(rows[0]).toMatchObject({
+        value: 120, shares: 10, previousValue: null, sharesChange: null,
+        sharesChangePercent: null, valueChange: null, estimatedPnl: null, action: "unknown",
+      });
+    }
+  });
+
+  test("missing amounts stay unknown through aggregation and incomplete reports do not fabricate exits", () => {
+    const latest = form({});
+    const previous = form({ accessionNumber: "previous", periodOfReport: "2025-12-31" });
+    const data: FundDetailData = { cik: latest.cik, name: "Fund", forms: [latest, previous],
+      latestForm: latest, previousForm: previous,
+      latestHoldings: [holding({ value: 20, shares: 2 }), holding({ value: null, shares: null })],
+      previousHoldings: [holding({ value: 50, shares: 5 }), holding({ cusip: "123456789" })] };
+    const rows = buildFundHoldingRows(data);
+    expect(rows[0]).toMatchObject({ value: null, shares: null, sharesChange: null,
+      valueChange: null, weight: null, estimatedPnl: null, action: "unknown" });
+    const report = buildPeriodReports([latest])[0]!;
+    report.complete = false;
+    expect(buildFundHoldingRows({ ...data, latestReport: report })).toHaveLength(1);
+    expect(buildFilingPositionRows([holding({ value: 20 })], null)[0]?.weight).toBeNull();
+  });
+
+  test("filing value changes do not bridge a missing quarter", () => {
+    const rows = buildTimelineRows([
+      form({ accessionNumber: "current", periodOfReport: "2026-03-31" }),
+      form({ accessionNumber: "old", periodOfReport: "2025-09-30" }),
+    ]);
+    expect(rows[0]?.valueChangePercent).toBeNull();
+  });
+
   test("timeline rows include period-over-period value changes", () => {
     const rows = buildTimelineRows([
-      form({ periodOfReport: "2026-03-31", tableValueTotal: 120, amendmentType: "RESTATEMENT" }),
-      form({ periodOfReport: "2025-12-31", tableValueTotal: 100 }),
+      form({ accessionNumber: "latest", periodOfReport: "2026-03-31", tableValueTotal: 120, amendmentType: "RESTATEMENT" }),
+      form({ accessionNumber: "previous", periodOfReport: "2025-12-31", tableValueTotal: 100 }),
     ]);
     expect(rows[0]?.valueChangePercent).toBeCloseTo(0.2);
     expect(rows[0]).toMatchObject({