Futures legs respect a firm's per-instrument contract limit

A firm can cap how many contracts of an instrument its accounts may hold
(the catalog's instrumentLimits, set on the master's Firms page). A leg
trades one contract per $1,000, capped by the account type's max contracts
and that limit. The Auto draw sizes each instrument's hold with the capped
count, so a limit that slows a leg past 12 hours takes it out of the draw.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

lib/auto-trade.ts

@@ -23,7 +23,7 @@ import {
 } from './trading-logic';
 import { getSetting, setSetting } from './db';
 import type { LaneTick, TickReason } from './master-protocol';
-import { POINT_VALUES, housekeepingRoot, HOUSEKEEPING_ROOT, MAX_HOLD_HOURS } from './instrument-specs';
+import { POINT_VALUES, housekeepingRoot, HOUSEKEEPING_ROOT, MAX_HOLD_HOURS, futuresContracts } from './instrument-specs';
 import { firmInstruments, drawFuturesInstrument, spreadBlock, type LegShape } from './instruments';
 import { recordEntry } from './trade-mix';
 import { errorMessage, isClientReady, isOrderNotPlaced, type PlatformClient, type PlatformContract, type PickContext } from './platform-client';
@@ -486,7 +486,12 @@ function legShapeFor(item: SizingItem, tradeDate: string): LegShape {
     const hard = Number.isFinite(item.dllRoom) && dll > 0
         ? dllStopDollars({ room: item.dllRoom, dailyLossLimit: dll, entryFee: FALLBACK_COMMISSION_PER_CONTRACT, commissionPct: 0 })
         : Infinity;
-    return { leg, stopDollars: Math.min(Number.isFinite(obf) && obf > 0 ? obf : Infinity, hard), maxPositionSize: cfg.maxPositionSize };
+    return {
+        leg,
+        stopDollars: Math.min(Number.isFinite(obf) && obf > 0 ? obf : Infinity, hard),
+        maxPositionSize: cfg.maxPositionSize,
+        limits: item.firm.instrumentLimits,
+    };
 }
 
 /** What the fire path needs of a contract — PlatformContract minus the id. */
@@ -1310,8 +1315,10 @@ async function fireLeg(
                 }
             }
         } else {
-            const rawContracts = Math.max(1, Math.ceil(legAmount / 1000));
-            contracts = cfg.maxPositionSize > 0 ? Math.min(rawContracts, cfg.maxPositionSize) : rawContracts;
+            // One per $1,000, capped by the account type's max contracts and
+            // the firm's limit on this instrument.
+            const legRoot = item.drain ? housekeepingFor(item.firm) : symbolLabel;
+            contracts = futuresContracts(legAmount, cfg.maxPositionSize, item.firm.instrumentLimits?.[legRoot] ?? 0);
         }
     } catch (err) {
         unrecordLeg(acc.id, tradeDate, legAmount);

lib/firm-catalog.ts

@@ -18,7 +18,7 @@
  */
 
 import { isFirmPlatform } from './master-protocol';
-import { sanitizeInstruments, DEFAULT_MAX_ENTRY_SPREAD } from './instrument-specs';
+import { sanitizeInstruments, sanitizeInstrumentLimits, DEFAULT_MAX_ENTRY_SPREAD } from './instrument-specs';
 import type {
     CatalogAccountType, CatalogFirm, CatalogTradingSettings, FirmCatalogPayload, FirmPlatform, SymbolMap, SymbolMapCandidate,
 } from './master-protocol';
@@ -245,6 +245,7 @@ function validatePayload(raw: unknown): FirmCatalogPayload {
             // The master's list when it sends one; absent from an older
             // master, whose bannedSymbols / symbolMap then apply.
             ...(Array.isArray(firm.instruments) ? { instruments: sanitizeInstruments(platform, firm.instruments) } : {}),
+            ...(platform !== 'dxtrade' ? { instrumentLimits: sanitizeInstrumentLimits(firm.instrumentLimits) } : {}),
             bannedSymbols: Array.isArray(firm.bannedSymbols) ? (firm.bannedSymbols as string[]) : [],
             accountTypes,
             serverUrl: typeof firm.serverUrl === 'string' ? firm.serverUrl : '',

lib/instrument-specs.ts

@@ -107,10 +107,24 @@ export function dailyMoveDollars(closes: number[], pointValue: number, barsPerDa
 }
 
 /** Contracts a futures leg trades: one per $1,000, capped by the account
- *  type's max contracts (0 = no cap) — the rule fireLeg sizes by. */
-export function futuresContracts(leg: number, maxPositionSize: number): number {
+ *  type's max contracts and the firm's limit on the instrument (0 = no
+ *  cap) — the rule fireLeg sizes by. */
+export function futuresContracts(leg: number, maxPositionSize: number, instrumentLimit = 0): number {
     const raw = Math.max(1, Math.ceil(leg / 1000));
-    return maxPositionSize > 0 ? Math.min(raw, maxPositionSize) : raw;
+    const caps = [maxPositionSize, instrumentLimit].filter((c) => c > 0);
+    return caps.length > 0 ? Math.min(raw, ...caps) : raw;
+}
+
+/** The most contracts a firm allows on one instrument, as its catalog entry
+ *  says: CME roots only, whole numbers from 1 to 1000. Anything else is
+ *  dropped — no limit beyond the account type's max contracts. */
+export function sanitizeInstrumentLimits(raw: unknown): Record<string, number> {
+    const out: Record<string, number> = {};
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) return out;
+    for (const [root, value] of Object.entries(raw as Record<string, unknown>)) {
+        if (CME_SPECS[root] && typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 1000) out[root] = value;
+    }
+    return out;
 }
 
 /**

lib/instruments.ts

@@ -36,6 +36,7 @@ export interface FirmLike {
     id?: string;
     platform: string;
     instruments?: string[];
+    instrumentLimits?: Record<string, number>;
     bannedSymbols?: string[];
     symbolMap?: Record<string, { symbol: string }[]>;
 }
@@ -155,6 +156,8 @@ export interface LegShape {
     leg: number;
     stopDollars: number;
     maxPositionSize: number;
+    /** The firm's most contracts per instrument, by root (absent = none). */
+    limits?: Record<string, number>;
 }
 
 function progressNow(now: Date): number | null {
@@ -188,11 +191,13 @@ export function futuresBoard(roots: readonly string[], leg: LegShape | null, now
     disabled: string[];
     wide: string[];
 } {
-    const contracts = leg ? futuresContracts(leg.leg, leg.maxPositionSize) : 1;
     const max = maxEntrySpread();
     const candidates = roots.filter((r) => CME_SPECS[r]).map((root) => {
         const dailyMove = market.get(root)?.dailyMove ?? null;
         const spread = entrySpread(root, now.getTime());
+        // The size this leg would trade on this root: a firm's cap on the
+        // instrument slows it, and may push it past the hold cap.
+        const contracts = leg ? futuresContracts(leg.leg, leg.maxPositionSize, leg.limits?.[root] ?? 0) : 1;
         return {
             symbol: root,
             spreadDollars: spread.dollars,
@@ -254,10 +259,10 @@ export function instrumentStatsFor(
     lead: (LegShape & { account: string }) | null,
 ): InstrumentStats {
     const listed = firmInstruments(firm);
-    const board = futuresBoard(listed, lead);
+    const limits = firm.instrumentLimits ?? {};
+    const board = futuresBoard(listed, lead ? { ...lead, limits } : null);
     const disabled = new Set(board.disabled);
     const max = maxEntrySpread();
-    const leg = lead ? { leg: lead.leg, stopDollars: lead.stopDollars, contracts: futuresContracts(lead.leg, lead.maxPositionSize) } : null;
     return {
         at: new Date().toISOString(),
         account: lead?.account ?? null,
@@ -268,7 +273,12 @@ export function instrumentStatsFor(
         quoteSource: quoteSource(),
         instruments: CME_ROOTS.map((root) => {
             const dailyMove = market.get(root)?.dailyMove ?? null;
-            const holdHours = leg ? expectedHoldHours({ ...leg, dailyMove }) : null;
+            const holdHours = lead
+                ? expectedHoldHours({
+                    leg: lead.leg, stopDollars: lead.stopDollars, dailyMove,
+                    contracts: futuresContracts(lead.leg, lead.maxPositionSize, limits[root] ?? 0),
+                })
+                : null;
             const spread = entrySpread(root);
             return {
                 symbol: root,

lib/master-protocol.ts

@@ -381,6 +381,10 @@ export interface CatalogFirm {
      *  own symbols for DXtrade (see lib/instruments.ts). Absent from a master
      *  from before the lists — then bannedSymbols and symbolMap apply. */
     instruments?: string[];
+    /** Futures firms: the most contracts the firm allows on an instrument,
+     *  by root, for every account type (absent = no limit beyond the type's
+     *  max contracts). */
+    instrumentLimits?: Record<string, number>;
     /** Older masters' way to exclude roots; newer ones derive it from
      *  `instruments`. */
     bannedSymbols: string[];