@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/plugins/builtin/kelly-sizer/model.ts

@@ -282,7 +282,7 @@ export function calculateKellySizing({
   price?: number | null;
 }): KellySizingResult {
   const warnings: string[] = [];
-  if (!finite(bankroll) || bankroll <= 0 || !finite(currentValue)) {
+  if (!finite(currentValue)) {
     return {
       mode,
       bankroll: 0,
@@ -301,7 +301,7 @@ export function calculateKellySizing({
       riskFraction: 0,
       expectedReturn: 0,
       expectedLogGrowth: 0,
-      warnings: [!finite(currentValue) ? "Current holding value unavailable; check FX rates." : "No positive bankroll available."],
+      warnings: ["Current holding value unavailable; check FX rates."],
       clipReasons: [],
       recommendationLabel: "Unavailable",
     };
@@ -342,20 +342,24 @@ export function calculateKellySizing({
 
   const safeCurrentValue = finite(currentValue) ? Math.max(0, currentValue) : 0;
   const safePrice = price != null && finite(price) && price > 0 ? price : null;
-  const targetValue = clippedFraction * bankroll;
-  const addTrimValue = targetValue - safeCurrentValue;
-  const estimatedUnits = safePrice ? addTrimValue / safePrice : null;
+  // Sizes are shares of the bankroll; only the money amounts need one.
+  const hasBankroll = finite(bankroll) && bankroll > 0;
+  const targetValue = hasBankroll ? clippedFraction * bankroll : null;
+  const addTrimValue = targetValue == null ? null : targetValue - safeCurrentValue;
+  const estimatedUnits = safePrice && addTrimValue != null ? addTrimValue / safePrice : null;
   const riskFraction = clippedFraction * downsideLossFraction;
-  const riskValue = riskFraction * bankroll;
+  const riskValue = hasBankroll ? riskFraction * bankroll : null;
+  // Nothing held is 0% of any bankroll; a holding with no bankroll has no share.
+  const currentFraction = hasBankroll ? safeCurrentValue / bankroll : safeCurrentValue > 0 ? null : 0;
 
   if (fullKellyFraction === 0 && solve.expectedReturn <= 0) warnings.push("No positive Kelly edge.");
   if (downsideLossFraction <= 0) warnings.push("No downside assumption; risk caps cannot bind.");
 
   return {
     mode,
-    bankroll,
+    bankroll: hasBankroll ? bankroll : 0,
     currentValue: safeCurrentValue,
-    currentFraction: safeCurrentValue / bankroll,
+    currentFraction,
     price: safePrice,
     fullKellyFraction,
     fractionalKellyFraction,

package/src/plugins/builtin/kelly-sizer/pane.tsx

@@ -372,7 +372,7 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const sensitivity = useMemo(() => buildSensitivityGrid(sizingMode, activeDraft), [activeDraft, sizingMode]);
   const curveMaxFraction = useMemo(
     () => getKellyCurveMaxFraction(sizingMode, activeDraft, [
-      result.currentFraction,
+      result.currentFraction ?? 0,
       result.clippedFraction,
       result.fullKellyFraction,
     ]),
@@ -384,7 +384,9 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   );
   const curveXAxisLabels = useMemo(() => buildKellyCurveXAxisLabels(curveMaxFraction), [curveMaxFraction]);
   const currentGrowth = useMemo(
-    () => calculateExpectedLogGrowthAtFraction(sizingMode, activeDraft, result.currentFraction),
+    () => result.currentFraction == null
+      ? null
+      : calculateExpectedLogGrowthAtFraction(sizingMode, activeDraft, result.currentFraction),
     [activeDraft, sizingMode, result.currentFraction],
   );
   const targetGrowth = useMemo(
@@ -393,15 +395,16 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   );
   const curveMarkers = useMemo<StaticChartXMarker[]>(() => {
     if (!Number.isFinite(curveMaxFraction) || curveMaxFraction <= 0) return [];
-    const targetLabel = result.clipReasons[0]?.replace(/^max /, "") ?? "target";
+    // Caps apply in turn, so with both binding the last one set the target.
+    const targetLabel = result.clipReasons.at(-1)?.replace(/^max /, "") ?? "target";
     const markers: StaticChartXMarker[] = [
-      {
+      ...(result.currentFraction == null ? [] : [{
         id: "current",
         xRatio: result.currentFraction / curveMaxFraction,
         label: "current",
         color: colors.textDim,
         lineChar: "┊",
-      },
+      }]),
       {
         id: "target",
         xRatio: result.clippedFraction / curveMaxFraction,
@@ -474,9 +477,6 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   usePaneFooter(KELLY_PANE_ID, () => ({
     info: historyStatus
       ? [{ id: "history", parts: [historyStatus] }]
-      : bankroll <= 0 && ticker
-      // Every size reads 0% until there is a bankroll; say so where status lives.
-      ? [{ id: "bankroll", parts: [{ text: "no bankroll", tone: "warning" as const }] }]
       : result.warnings.length > 0
         ? [{ id: "warning", parts: [{ text: result.warnings[0]!, tone: "warning" as const }] }]
         : result.clipReasons.length > 0
@@ -488,7 +488,7 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
       { id: "search", key: "/", label: "search", onPress: focusTickerSearch },
       ...(viewInBar ? [] : [{ id: "sensitivity", key: "s", label: showSensitivity ? "ensitivity off" : "ensitivity", onPress: toggleSensitivity }]),
     ],
-  }), [activeInputId, bankroll, editSelectedField, focusTickerSearch, historyStatus?.text, historyStatus?.tone, result.clipReasons, result.warnings, selectedField?.id, selectedField?.label, showSensitivity, ticker, toggleSensitivity, viewInBar]);
+  }), [activeInputId, editSelectedField, focusTickerSearch, historyStatus?.text, historyStatus?.tone, result.clipReasons, result.warnings, selectedField?.id, selectedField?.label, showSensitivity, ticker, toggleSensitivity, viewInBar]);
 
   const portfolioTabs = useMemo(
     () => config.portfolios.map((portfolio) => ({ label: portfolio.name, value: portfolio.id })),

package/src/plugins/builtin/kelly-sizer/sections.tsx

@@ -11,7 +11,7 @@ import { resolveChartPalette } from "../../../components/chart/core/palette";
 import type { StaticChartXMarker } from "../../../components/chart/static";
 import { colors, priceColor } from "../../../theme/colors";
 import { Box } from "../../../ui";
-import { displayWidth, formatCurrency, formatNumber } from "../../../utils/format";
+import { displayWidth, formatCurrency, formatNumber, MISSING_VALUE } from "../../../utils/format";
 import type { KellySizingResult, SensitivityGrid } from "./types";
 import type { KellyHistoryInputs } from "./history";
 import { formatPct, formatSignedPct } from "./view";
@@ -32,10 +32,15 @@ export function buildKellyHistoryItems(inputs: KellyHistoryInputs): StatItem[] {
   ];
 }
 
+/** What the first money figure says while there is no bankroll to size in. */
+const BANKROLL_HINT = "Set a bankroll";
+
 /**
  * The sizing result as one band under the inputs, laid out in the FieldGrid's
  * columns: the Kelly fractions, then the move in money, then risk, then log
- * growth at full Kelly, at the current size and at the target.
+ * growth at full Kelly, at the current size and at the target. Money figures
+ * read a dash until there is a bankroll; the fractions and growth never wait
+ * for one.
  */
 export function buildKellyResultItems({
   result,
@@ -47,12 +52,13 @@ export function buildKellyResultItems({
 }: {
   result: KellySizingResult;
   baseCurrency: string;
-  currentGrowth: number;
+  /** Null when the holding is not a share of any bankroll. */
+  currentGrowth: number | null;
   targetGrowth: number;
   width: number;
   columns: number;
 }): StatItem[] {
-  const addTrim = formatCurrency(result.addTrimValue, baseCurrency);
+  const addTrim = result.addTrimValue == null ? MISSING_VALUE : formatCurrency(result.addTrimValue, baseCurrency);
   const units = result.estimatedUnits == null ? null : `${formatNumber(result.estimatedUnits, 1)} units`;
   // The units ride beside the amount when the column has room for label,
   // amount and units (plus the cell inset and gaps); otherwise they take a
@@ -68,14 +74,16 @@ export function buildKellyResultItems({
       value: formatPct(result.clippedFraction, 2),
       tone: result.clipReasons.length > 0 ? "positive" : undefined,
     },
-    { id: "current", label: "Current %", value: formatPct(result.currentFraction, 1) },
-    { id: "target", label: "Target val", value: formatCurrency(result.targetValue, baseCurrency) },
+    { id: "current", label: "Current %", value: result.currentFraction == null ? MISSING_VALUE : formatPct(result.currentFraction, 1) },
+    result.targetValue == null
+      ? { id: "target", label: "Target val", value: MISSING_VALUE, detail: BANKROLL_HINT }
+      : { id: "target", label: "Target val", value: formatCurrency(result.targetValue, baseCurrency) },
     {
       id: "addTrim",
       label: "Add / trim",
       value: addTrim,
       detail: unitsInline ? units ?? undefined : undefined,
-      color: priceColor(result.addTrimValue),
+      color: result.addTrimValue == null ? undefined : priceColor(result.addTrimValue),
     },
     ...(units != null && !unitsInline
       ? [{ id: "units", label: "Units", value: formatNumber(result.estimatedUnits!, 1) }]
@@ -83,9 +91,10 @@ export function buildKellyResultItems({
     {
       id: "risk",
       label: "Risk",
-      value: formatCurrency(result.riskValue, baseCurrency),
+      value: result.riskValue == null ? MISSING_VALUE : formatCurrency(result.riskValue, baseCurrency),
       detail: formatPct(result.riskFraction, 2),
-      tone: "negative",
+      // Nothing at risk is not a loss.
+      tone: result.riskValue != null && result.riskValue > 0 ? "negative" : undefined,
     },
     { id: "worstLoss", label: "Worst loss", value: formatPct(result.downsideLossFraction, 1) },
     {
@@ -95,7 +104,7 @@ export function buildKellyResultItems({
       color: priceColor(result.expectedReturn),
     },
     { id: "fullGrowth", label: "Full growth", value: formatSignedPct(result.expectedLogGrowth) },
-    { id: "growthNow", label: "Growth now", value: formatSignedPct(currentGrowth) },
+    { id: "growthNow", label: "Growth now", value: currentGrowth == null ? MISSING_VALUE : formatSignedPct(currentGrowth) },
     { id: "growthTarget", label: "Growth tgt", value: formatSignedPct(targetGrowth) },
   ];
 }

package/src/plugins/builtin/kelly-sizer/types.ts

@@ -69,25 +69,31 @@ export interface KellySolveResult {
   warning?: string;
 }
 
+/**
+ * The fractions, expected return and growth need no bankroll. The money fields
+ * (target, add or trim, units, risk) are null until there is one, and
+ * `currentFraction` is null for a holding that has no bankroll to be a share of.
+ */
 export interface KellySizingResult {
   mode: KellySizingMode;
   bankroll: number;
   currentValue: number;
-  currentFraction: number;
+  currentFraction: number | null;
   price: number | null;
   fullKellyFraction: number;
   fractionalKellyFraction: number;
   unclippedFraction: number;
   clippedFraction: number;
-  targetValue: number;
-  addTrimValue: number;
+  targetValue: number | null;
+  addTrimValue: number | null;
   estimatedUnits: number | null;
   downsideLossFraction: number;
-  riskValue: number;
+  riskValue: number | null;
   riskFraction: number;
   expectedReturn: number;
   expectedLogGrowth: number;
   warnings: string[];
+  /** The caps that cut the size, in the order applied; the last one set the target. */
   clipReasons: string[];
   recommendationLabel: string;
 }

package/src/plugins/builtin/macro-day/release-table.ts

@@ -5,9 +5,9 @@ export const MACRO_RELEASE_TABLE: {
   coveredThrough: string;
   days: Record<"cpi" | "jobs" | "fomc", Record<number, readonly string[]>>;
 } = {
-  checkedAt: "2026-10-15",
+  checkedAt: "2026-10-28",
   /** The last day the lists are complete for: later sessions are left out, release day or not. */
-  coveredThrough: "2026-10-14",
+  coveredThrough: "2026-10-27",
   days: {
     // BLS Consumer Price Index, 8:30 ET.
     cpi: {

package/src/plugins/builtin/market-heatmap/data.ts

@@ -1,4 +1,5 @@
 import { apiClient } from "../../../api-client";
+import { createTtlCache } from "../../../data/ttl-cache";
 import type { MarketHeatmapResult, MarketHeatmapUniverseId } from "../../../api-client/market-discovery";
 export type { MarketHeatmapUniverseId } from "../../../api-client/market-discovery";
 
@@ -39,8 +40,7 @@ const MAX_MARKET_HEATMAP_COUNT = 500;
 export function heatmapCheckIntervalMs(board: Pick<MarketHeatmapResult, "access"> | null | undefined): number {
   return board?.access === "realtime" ? 15_000 : 60_000;
 }
-const activeFetches = new Map<string, Promise<MarketHeatmapBoard>>();
-const memoryCache = new Map<string, { expiresAt: number; result: MarketHeatmapBoard }>();
+const boards = createTtlCache<MarketHeatmapBoard>({ ttlMs: heatmapCheckIntervalMs });
 
 /**
  * One tile per symbol. A company listed on two exchanges (KHC on NASDAQ and
@@ -75,43 +75,18 @@ async function loadMarketHeatmap(universe: MarketHeatmapUniverseId, count: numbe
   };
 }
 
-export async function fetchMarketHeatmap(
+export function fetchMarketHeatmap(
   universe: MarketHeatmapUniverseId,
   options?: MarketHeatmapFetchOptions,
   sources?: MarketHeatmapSources,
 ): Promise<MarketHeatmapBoard> {
   const count = Math.max(1, Math.min(MAX_MARKET_HEATMAP_COUNT, Math.round(options?.count ?? DEFAULT_COUNT)));
-  const cacheKey = `${universe}:${count}`;
-  const useCache = options?.cache !== false && !sources?.client;
-  const now = Date.now();
-  const cached = memoryCache.get(cacheKey);
-  if (useCache && !options?.forceRefresh && cached && cached.expiresAt > now) {
-    return cached.result;
-  }
-
-  if (useCache) {
-    const active = activeFetches.get(cacheKey);
-    if (active) return active;
-  }
-
-  const fetchPromise = loadMarketHeatmap(universe, count, sources)
-    .then((result) => {
-      if (useCache) {
-        memoryCache.set(cacheKey, { result, expiresAt: Date.now() + heatmapCheckIntervalMs(result) });
-      }
-      return result;
-    })
-    .finally(() => {
-      if (activeFetches.get(cacheKey) === fetchPromise) {
-        activeFetches.delete(cacheKey);
-      }
-    });
-
-  if (useCache) activeFetches.set(cacheKey, fetchPromise);
-  return fetchPromise;
+  const load = () => loadMarketHeatmap(universe, count, sources);
+  // A board asked for uncached, or through another client, neither reads nor fills the shared cache.
+  if (options?.cache === false || sources?.client) return load();
+  return boards.load(`${universe}:${count}`, load, { force: options?.forceRefresh });
 }
 
 export function resetMarketHeatmapCache(): void {
-  activeFetches.clear();
-  memoryCache.clear();
+  boards.clear();
 }

package/src/plugins/builtin/market-movers/client.ts

@@ -24,6 +24,7 @@ import {
   type PreferredMoversOptions,
   type TrendingSymbol,
 } from "./screener";
+import { meetsMinFloat } from "./min-float";
 
 export interface MarketMoverTabResult extends MarketMoversResult {
   tab: ScreenerTabId;
@@ -100,10 +101,14 @@ export function marketMoverQuoteError(result: Pick<MarketMoverTabResult, "unavai
 export async function loadMarketMoverTab(
   tab: ScreenerTabId,
   provider: DataProvider | null,
-  options?: Pick<PreferredMoversOptions, "forceRefresh" | "metadataWaitMs"> & { basis?: MoverRankBasis },
+  options?: Pick<PreferredMoversOptions, "forceRefresh" | "metadataWaitMs"> & {
+    basis?: MoverRankBasis;
+    /** Keep the rows with a float of at least this many shares. Trending carries no float and ignores it. */
+    minFloat?: number | null;
+  },
   dependencies: MarketMoverTabDependencies = defaultDependencies,
 ): Promise<MarketMoverTabResult> {
-  const { basis, ...fetchOptions } = options ?? {};
+  const { basis, minFloat = null, ...fetchOptions } = options ?? {};
   if (tab === "trending") {
     const trending = await dependencies.fetchTrending(LIST_ROWS, fetchOptions);
     const hydrated = await hydrateTrending(trending.data, provider);
@@ -116,13 +121,15 @@ export async function loadMarketMoverTab(
   }
   const category = CATEGORY_MAP[tab];
   // The server picks the candidates on the basis the list ranks by, so after the close they are the session's movers.
-  const result = await dependencies.fetchPreferred(category, category === "most_actives" ? LIST_ROWS : MOVER_CANDIDATES, {
+  // A minimum float drops rows, so Most Active then reads as many candidates as the price lists.
+  const result = await dependencies.fetchPreferred(category, category === "most_actives" && minFloat == null ? LIST_ROWS : MOVER_CANDIDATES, {
     ...fetchOptions,
     session: basis ?? "regular",
   });
   // Each row read as `ticker` reads it, then ranked by the move its Chg% shows.
   const { quotes, rankedBy } = rankMoverQuotes(category, result.quotes.map(moverRegularSession), basis);
-  return { ...result, quotes: quotes.slice(0, LIST_ROWS), rankedBy, tab };
+  const kept = quotes.filter((quote) => meetsMinFloat(quote.floatShares, minFloat));
+  return { ...result, quotes: kept.slice(0, LIST_ROWS), rankedBy, tab };
 }
 
 /** The server refused the list for the account's plan (gaps, without Pro). */
@@ -136,12 +143,23 @@ export class SessionMoversAccessError extends Error {
 export async function loadSessionMovers(
   view: CloudSessionMoversCategory,
   side: CloudSessionMoversSide,
-  options?: { forceRefresh?: boolean },
+  options?: { forceRefresh?: boolean; minFloat?: number | null },
 ): Promise<CloudSessionMoversPayload> {
-  const response = await apiClient.getCloudMarketScreener(view, 25, options?.forceRefresh ? "refresh" : "cache-first", side);
+  const minFloat = options?.minFloat ?? null;
+  // A minimum float drops rows, so it reads the most the server lists.
+  const response = await apiClient.getCloudMarketScreener(view, minFloat == null ? LIST_ROWS : MOVER_CANDIDATES, options?.forceRefresh ? "refresh" : "cache-first", side);
   if (response.reasonCode === "PRO_REQUIRED") throw new SessionMoversAccessError();
   if ((response.status === "success" || response.status === "partial") && response.data) {
-    return response.stale ? { ...response.data, stale: true } : response.data;
+    const payload = response.stale ? { ...response.data, stale: true } : response.data;
+    return minFloat == null ? payload : { ...payload, items: withMinFloat(payload.items, minFloat) };
   }
   throw new Error("Session movers temporarily unavailable");
 }
+
+/** The rows with a float of at least `minFloat`, the first LIST_ROWS of them, ranked again from 1. */
+export function withMinFloat<T extends { rank: number; floatShares: number | null }>(items: readonly T[], minFloat: number): T[] {
+  return items
+    .filter((item) => meetsMinFloat(item.floatShares, minFloat))
+    .slice(0, LIST_ROWS)
+    .map((item, index) => ({ ...item, rank: index + 1 }));
+}

package/src/plugins/builtin/market-movers/headless.ts

@@ -14,6 +14,7 @@ import { createRows, fiftyTwoWeekPositionPercent, formatMoverPrice, MOVER_RANKIN
 import { EXTENDED_SESSION_LABELS, type ExtendedSession } from "../../../market-data/market/status";
 import type { HeadlessPaneColumn } from "../../../types/headless";
 import { isSessionTab, resolveSide } from "./session";
+import { hasPartialFloat, minFloatShares, normalizeMinFloat, PARTIAL_FLOAT_NOTE } from "./min-float";
 
 const rowPrice = (value: unknown, row: Record<string, unknown>) => formatMoverPrice(typeof value === "number" ? value : null, typeof row.currency === "string" ? row.currency : "", moverReferencePrice(row as unknown as MarketMoverRow));
 
@@ -69,15 +70,19 @@ function sessionColumns(view: CloudSessionMoversCategory) {
   ];
 }
 
+const FLOAT_COLUMN: HeadlessPaneColumn = { key: "floatShares", header: "Float", align: "right", format: compact };
+
 export interface MarketMoversHeadlessDependencies {
   load(
     args: HeadlessPaneLoadArgs,
     tab: ScreenerTabId,
     provider: DataProvider,
+    minFloat: number | null,
   ): Promise<MarketMoverTabResult>;
   loadSession(
     view: CloudSessionMoversCategory,
     side: CloudSessionMoversSide,
+    minFloat: number | null,
   ): Promise<CloudSessionMoversPayload>;
 }
 
@@ -89,8 +94,8 @@ export interface MarketMoversHeadlessDependencies {
 const ONE_SHOT_METADATA_WAIT_MS = 10_000;
 
 const defaultDependencies: MarketMoversHeadlessDependencies = {
-  load: (_args, tab, provider) => loadMarketMoverTab(tab, provider, { metadataWaitMs: ONE_SHOT_METADATA_WAIT_MS }),
-  loadSession: (view, side) => loadSessionMovers(view, side),
+  load: (_args, tab, provider, minFloat) => loadMarketMoverTab(tab, provider, { metadataWaitMs: ONE_SHOT_METADATA_WAIT_MS, minFloat }),
+  loadSession: (view, side, minFloat) => loadSessionMovers(view, side, { minFloat }),
 };
 
 export function createMarketMoversHeadless(
@@ -128,6 +133,14 @@ export function createMarketMoversHeadless(
       ],
       defaultValue: "up",
       pluginState: { pluginId: "market-overview", key: "sessionSide" },
+    }, {
+      key: "min-float",
+      description: "Keep the rows whose float (the one EQS serves) is at least this many shares, such as 10M or 500k; any lifts it. A row with no float is left out. Trending carries no float and ignores it.",
+      type: "string",
+      placeholder: "shares",
+      example: "--min-float 10M",
+      normalize: normalizeMinFloat,
+      pluginState: { pluginId: "market-overview", key: "minFloat" },
     }],
     columns: COLUMNS,
     describe: (args) => isSessionTab(String(args.options.list))
@@ -135,21 +148,26 @@ export function createMarketMoversHeadless(
       : `Market Movers | ${String(args.options.list)}`,
     async load(args, ctx) {
       const tab = args.options.list as TabId;
+      const minFloatValue = typeof args.options["min-float"] === "string" ? args.options["min-float"] : null;
+      const minFloat = minFloatShares(minFloatValue);
       if (isSessionTab(tab)) {
         const side = resolveSide(tab, String(args.options.side));
-        const payload = await dependencies.loadSession(tab, side);
+        const payload = await dependencies.loadSession(tab, side, minFloat);
         return {
           columns: sessionColumns(tab),
           rows: payload.items.map((item) => ({
             ...item,
             events: item.catalysts.map((catalyst) => CATALYST_LABEL[catalyst] ?? catalyst).join(" "),
           })),
-          metadata: { list: tab, side, session: payload.session, phase: payload.phase, asOf: payload.asOf, stale: payload.stale === true },
+          ...(hasPartialFloat(payload.items) ? { notes: [PARTIAL_FLOAT_NOTE] } : {}),
+          metadata: { list: tab, side, session: payload.session, phase: payload.phase, asOf: payload.asOf, stale: payload.stale === true, minFloat },
           // A Pro account's list is the live board; the free one says it is delayed.
           ...(payload.access === "delayed" ? {} : { freshness: { status: "live" as const } }),
         };
       }
-      const result = await dependencies.load(args, tab, ctx.marketData);
+      // Trending carries no float, so a minimum does not apply to it.
+      const floatFiltered = minFloat != null && tab !== "trending";
+      const result = await dependencies.load(args, tab, ctx.marketData, floatFiltered ? minFloat : null);
       const ranked = createRows(result.quotes);
       // Last and Change % are the regular session; an extended print is a column of its own.
       const extendedSessions = moverExtendedSessions(ranked);
@@ -168,16 +186,18 @@ export function createMarketMoversHeadless(
       // Beside an extended column, say which move the order follows.
       const rankedBy = result.rankedBy ?? null;
       const quoteError = marketMoverQuoteError(result);
+      const columns = [...COLUMNS.slice(0, 5), ...extendedSessions.map(extendedColumn), ...COLUMNS.slice(5), ...(floatFiltered ? [FLOAT_COLUMN] : [])];
+      const notes = [
+        ...(rankedBy && rankedBy !== "volume" && extendedSessions.length > 0 ? [`Ranked by ${MOVER_RANKING_LABELS[rankedBy]}.`] : []),
+        ...(minFloat != null && !floatFiltered ? ["Trending carries no float, so --min-float does not apply to it."] : []),
+        ...(floatFiltered && hasPartialFloat(rows) ? [PARTIAL_FLOAT_NOTE] : []),
+      ];
       return {
-        ...(extendedSessions.length > 0
-          ? { columns: [...COLUMNS.slice(0, 5), ...extendedSessions.map(extendedColumn), ...COLUMNS.slice(5)] }
-          : {}),
+        ...(columns.length !== COLUMNS.length ? { columns } : {}),
         rows,
         ...(quoteError ? { complete: false, unavailableSymbols: result.unavailableSymbols, errors: [quoteError] } : {}),
-        ...(rankedBy && rankedBy !== "volume" && extendedSessions.length > 0
-          ? { notes: [`Ranked by ${MOVER_RANKING_LABELS[rankedBy]}.`] }
-          : {}),
-        metadata: { list: tab, source: result.source, stale: result.stale, rankedBy },
+        ...(notes.length > 0 ? { notes } : {}),
+        metadata: { list: tab, source: result.source, stale: result.stale, rankedBy, minFloat: floatFiltered ? minFloat : null },
         // A Pro account's Gainers, Losers and Most Active are the real-time lists.
         ...(result.source === "cloud" ? { freshness: { status: "live" as const } } : {}),
       };

package/src/plugins/builtin/market-movers/index.tsx

@@ -1,7 +1,7 @@
 import { Box, useUiCapabilities } from "../../../ui";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { DataTableView, EmptyState, usePaneFooter, usePaneTabs, type DataTableKeyEvent } from "../../../components";
+import { DataTableView, EmptyState, QueryBar, usePaneFooter, usePaneTabs, type DataTableKeyEvent } from "../../../components";
 import { handleRefreshKey } from "../../../components/data-table/table-pane";
 import type { PaneProps } from "../../../types/plugin";
 import type { PluginModule } from "../plugin-module";
@@ -41,6 +41,7 @@ import { loadMarketMoverTab, marketMoverQuoteError } from "./client";
 import { summaryFooterSegments } from "./footer";
 import { isSessionTab, resolveActiveTab, usSessionAt, type UsSession } from "./session";
 import { SessionMoversBody } from "./session-body";
+import { ANY_FLOAT, minFloatEmptyTitle, minFloatFilter, minFloatShares, partialFloatFooter } from "./min-float";
 import { marketMoversHeadless } from "./headless";
 import { buildMarketMoverColumns, renderMarketMoverCell } from "./table";
 import type { ExtendedSession } from "../../../market-data/market/status";
@@ -152,16 +153,21 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
 }) {
   const dataProvider = useAssetData();
   const { pinTicker } = usePluginTickerActions();
+  const [minFloatValue, setMinFloatValue] = usePluginPaneState<string>("minFloat", ANY_FLOAT);
+  // Trending carries no float, so the minimum is not offered there.
+  const floatFiltered = activeTab !== "trending";
+  const minFloat = floatFiltered ? minFloatShares(minFloatValue) : null;
+  const listKey = `${activeTab}:${minFloat ?? ""}`;
   const [quotes, setQuotes] = useState<MoverQuote[]>([]);
-  const [loadedTab, setLoadedTab] = useState<TabId | null>(null);
-  const visibleQuotes = loadedTab === activeTab ? quotes : NO_QUOTES;
+  const [loadedKey, setLoadedKey] = useState<string | null>(null);
+  const visibleQuotes = loadedKey === listKey ? quotes : NO_QUOTES;
   // The first load starts before the effect runs; an empty board is not "no data".
   const [loading, setLoading] = useState(true);
   const [loadError, setLoadError] = useState<string | null>(null);
   const [selectedSymbol, setSelectedSymbol] = useState<string | null>(null);
   const [sortPreference, setSortPreference] = useState<MarketMoverSortPreference>(DEFAULT_SORT_PREFERENCE);
   const [moversStale, setMoversStale] = useState(false);
-  const [lastSuccess, setLastSuccess] = useState<{ tab: ScreenerTabId; at: number } | null>(null);
+  const [lastSuccess, setLastSuccess] = useState<{ key: string; at: number } | null>(null);
 
   const fetchGenRef = useRef(0);
 
@@ -192,8 +198,8 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
   // A pre-market or after-hours column only while a row has such a print.
   const extendedSessionsKey = moverExtendedSessions(rankedRows).join(",");
   const columns = useMemo(
-    () => buildMarketMoverColumns(width, extendedSessionsKey ? extendedSessionsKey.split(",") as ExtendedSession[] : []),
-    [extendedSessionsKey, width],
+    () => buildMarketMoverColumns(width, extendedSessionsKey ? extendedSessionsKey.split(",") as ExtendedSession[] : [], { float: minFloat != null }),
+    [extendedSessionsKey, minFloat, width],
   );
   const rows = useMemo(() => sortRows(rankedRows, sortPreference), [rankedRows, sortPreference]);
   const selectedIdx = selectedSymbol
@@ -223,6 +229,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
     try {
       const result = await loadMarketMoverTab(tab, dataProvider, {
         forceRefresh: options?.forceRefresh,
+        minFloat,
       });
       if (fetchGenRef.current !== gen) return;
 
@@ -230,12 +237,12 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
       // A partial list shows only its current rows; a total failure keeps this list's prior rows.
       if (!quoteError || result.quotes.length > 0) {
         setQuotes(result.quotes);
-        setLoadedTab(tab);
+        setLoadedKey(`${tab}:${minFloat ?? ""}`);
         if (!options?.background) setSelectedSymbol(null);
       }
       setMoversStale(result.stale);
       setLoadError(quoteError);
-      if (!quoteError && !result.stale) setLastSuccess({ tab, at: Date.now() });
+      if (!quoteError && !result.stale) setLastSuccess({ key: `${tab}:${minFloat ?? ""}`, at: Date.now() });
     } catch {
       if (fetchGenRef.current !== gen) return;
       setMoversStale(true);
@@ -244,7 +251,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
     finally {
       if (fetchGenRef.current === gen && !options?.background) setLoading(false);
     }
-  }, [dataProvider]);
+  }, [dataProvider, minFloat]);
 
   useEffect(() => {
     setSelectedSymbol(null);
@@ -254,7 +261,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
   const backgroundRefresh = useCallback(() => {
     void loadTab(activeTab, { background: true });
   }, [activeTab, loadTab]);
-  useAutoRefresh(lastSuccess?.tab === activeTab ? lastSuccess.at : null, backgroundRefresh);
+  useAutoRefresh(lastSuccess?.key === listKey ? lastSuccess.at : null, backgroundRefresh);
 
   const openSymbol = useCallback((row: MarketMoverRow) => {
     pinTicker(moverKey(row), { floating: true, paneType: TICKER_RESEARCH_PANE_ID, instrument: null });
@@ -281,16 +288,21 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
         id: "feed",
         parts: [{ text: feedStatus, tone: feedStatus === "live" ? "value" as const : "muted" as const }],
       }] : []),
-      ...(moversStale && loadedTab === activeTab ? [{
+      ...(moversStale && loadedKey === listKey ? [{
         id: "stale",
         parts: [{ text: "stale", tone: "muted" as const }],
       }] : []),
+      // The FLOAT column shows while a minimum is set; a float the source does not date says so once.
+      ...partialFloatFooter(columns.some((column) => column.id === "floatShares"), rows),
     ],
-  }), [activeTab, feedStatus, loadedTab, loadError, loading, moversStale, summaryQuotes]);
+  }), [columns, feedStatus, listKey, loadedKey, loadError, loading, moversStale, rows, summaryQuotes]);
 
   return (
     <DataTableView<MarketMoverRow, MarketMoverColumn>
       focused={focused}
+      rootBefore={floatFiltered ? (
+        <QueryBar width={Math.max(1, width - 2)} filters={[minFloatFilter(minFloatValue, setMinFloatValue)]} />
+      ) : undefined}
       selection={{
         kind: "id",
         selectedId: selectedSymbol,
@@ -298,7 +310,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
         onChange: (symbol) => setSelectedSymbol(symbol),
       }}
       onRootKeyDown={handleTableKeyDown}
-      resetScrollKey={activeTab}
+      resetScrollKey={listKey}
       sortable
       columns={columns}
       items={rows}
@@ -309,7 +321,7 @@ function ScreenerMoversBody({ activeTab, focused, width, summaryQuotes, liveStre
       onActivate={openSymbol}
       renderCell={renderCell}
       selectedTextOverridesCellColor
-      emptyStateTitle={loading ? "Loading movers..." : loadError ?? "No movers returned."}
+      emptyStateTitle={loading ? "Loading movers..." : loadError ?? (minFloat != null ? minFloatEmptyTitle(minFloatValue) : "No movers returned.")}
       emptyContent={loadError ? (
         <Box paddingX={1} paddingY={1}>
           <EmptyState title={loadError} message="Try again in a moment." />