@adaptic/utils 0.0.985 → 0.0.987

package/dist/index.cjs

@@ -68029,9 +68029,15 @@ const RiskBudgetPrefsObjectSchema = objectType({
     maxCorrelatedExposurePct: numberType().min(0).max(100).default(40),
     betaTarget: numberType().nullable().default(null),
     maxBeta: numberType().min(0).default(2),
-    maxRiskPerTradePct: numberType().min(0).max(100).default(2),
-    maxLossPerDayPct: numberType().min(0).max(100).default(5),
-    maxLossPerWeekPct: numberType().min(0).max(100).default(10),
+    // Tighter per-trade risk (1.5% vs 2%) for scalping — high turnover means
+    // many small risks compound; per-trade ceiling must be lower than the
+    // swing default to keep daily VAR bounded.
+    maxRiskPerTradePct: numberType().min(0).max(100).default(1.5),
+    // 2% daily loss circuit breaker (vs 5%) — tighter to fail fast when the
+    // regime turns against the scalping strategy.
+    maxLossPerDayPct: numberType().min(0).max(100).default(2.0),
+    // 5% weekly loss cap (vs 10%) — proportional to the daily reduction.
+    maxLossPerWeekPct: numberType().min(0).max(100).default(5.0),
     maxLossPerMonthPct: numberType().min(0).max(100).default(15),
     maxDrawdownFromPeakPct: numberType().min(0).max(100).default(20),
     maxSimultaneousSignalsPerStrategy: numberType().min(0).default(5),
@@ -68040,8 +68046,12 @@ const RiskBudgetPrefsObjectSchema = objectType({
     weekendExposureCapPct: numberType().min(0).max(100).default(30),
     eventRiskExposureCapPct: numberType().min(0).max(100).default(40),
     gapRiskSensitivity: enumType(["low", "medium", "high"]).default("medium"),
-    /** Per-trade equity allocation as % of account equity. Replaces legacy AlpacaAccount.tradeAllocationPct. */
-    perTradeAllocationPct: numberType().min(0).max(100).default(5),
+    /**
+     * Per-trade equity allocation as % of account equity. Replaces legacy AlpacaAccount.tradeAllocationPct.
+     * Smaller per-trade size (2% vs 5%) for scalping — shorter holds + higher
+     * concurrency demand smaller per-position bets.
+     */
+    perTradeAllocationPct: numberType().min(0).max(100).default(2),
     /** Per-trade crypto allocation as % of account equity. Replaces legacy AlpacaAccount.cryptoTradeAllocationPct. */
     perTradeCryptoAllocationPct: numberType().min(0).max(100).default(5),
     /** Alpaca day-trading buying power check enforcement. Synced to Alpaca API. */
@@ -68077,17 +68087,30 @@ const StrategyPriorityRuleSchema = objectType({
 const SignalConsumptionPrefsObjectSchema = objectType({
     enabledStrategies: arrayType(stringType()).default([]),
     disabledStrategies: arrayType(stringType()).default([]),
-    minConfidenceByDefault: numberType().min(0).max(100).default(60),
+    // Slightly higher confidence floor (65 vs 60) reflecting the precision
+    // demands of scalping — false positives compound rapidly at this cadence.
+    minConfidenceByDefault: numberType().min(0).max(100).default(65),
     minConfidenceByAssetClass: recordType(stringType(), numberType()).default({}),
     minConfidenceByStrategy: recordType(stringType(), numberType()).default({}),
-    minExpectedRewardRiskRatio: numberType().min(0).default(1.5),
+    // 1.3 R:R minimum — slightly tighter than the swing default (1.5) since
+    // scalp trades have quicker resolution and tolerate marginally lower
+    // expected R:R when win-rate is high.
+    minExpectedRewardRiskRatio: numberType().min(0).default(1.3),
     minExpectedEdgePct: numberType().min(0).default(0),
-    maxSignalAgeSeconds: numberType().min(0).default(300),
-    cooldownAfterEntrySeconds: numberType().min(0).default(60),
+    // 30s max signal age for scalping — anything older than that has likely
+    // been re-priced out of edge. Previous default (300s) was swing-suitable.
+    maxSignalAgeSeconds: numberType().min(0).default(30),
+    // 5s post-entry cooldown — minimum churn protection while still allowing
+    // rapid re-engagement if the setup persists.
+    cooldownAfterEntrySeconds: numberType().min(0).default(5),
     cooldownAfterExitSeconds: numberType().min(0).default(120),
-    cooldownAfterStopOutSeconds: numberType().min(0).default(300),
+    // 30s post-stop-out cooldown (vs 300s) — fast re-entry allowed once the
+    // setup re-presents.
+    cooldownAfterStopOutSeconds: numberType().min(0).default(30),
     cooldownAfterFailedTradeSeconds: numberType().min(0).default(180),
-    duplicateSignalSuppressionWindowSeconds: numberType().min(0).default(300),
+    // 10s duplicate-signal window — prevents same-second signal dedup but
+    // allows the same setup to trigger again within a minute.
+    duplicateSignalSuppressionWindowSeconds: numberType().min(0).default(10),
     reversalHandlingPolicy: enumType([
         "ignore_reversal",
         "close_only",
@@ -68110,10 +68133,18 @@ const SignalConsumptionPrefsObjectSchema = objectType({
     earningsBlackoutEnabled: booleanType().default(false),
     earningsBlackoutHoursBefore: numberType().min(0).default(24),
     earningsBlackoutHoursAfter: numberType().min(0).default(2),
-    /** Minimum price movement % to qualify as a tradeable signal. Replaces legacy AlpacaAccount.minPercentageChange. */
-    minPercentageChange: numberType().min(0).default(0.5),
-    /** Minimum average daily volume to qualify a symbol for trading. Replaces legacy AlpacaAccount.volumeThreshold. */
-    volumeThreshold: numberType().min(0).default(50000),
+    /**
+     * Minimum price movement % to qualify as a tradeable signal. Replaces legacy AlpacaAccount.minPercentageChange.
+     * Tighter intraday move filter (15bps vs 50bps) — scalping captures
+     * sub-percent moves that the swing-trading default would have ignored.
+     */
+    minPercentageChange: numberType().min(0).default(0.15),
+    /**
+     * Minimum average daily volume to qualify a symbol for trading. Replaces legacy AlpacaAccount.volumeThreshold.
+     * Higher floor (100k vs 50k) — scalping requires consistent liquidity to
+     * keep slippage within the tightened maxSlippageTolerancePct (0.3%).
+     */
+    volumeThreshold: numberType().min(0).default(100000),
 });
 const SignalConsumptionPrefsSchema = SignalConsumptionPrefsObjectSchema.default({});
 
@@ -68138,12 +68169,21 @@ const ExecutionPrefsObjectSchema = objectType({
     preferredOrderType: OrderTypeEnum.default("limit"),
     preferredOrderTypeByAssetClass: recordType(stringType(), stringType())
         .default({ crypto: "market" }),
-    defaultTimeInForce: enumType(["day", "gtc", "ioc", "fok"]).default("day"),
+    // IOC default (immediate-or-cancel) for scalping — orders that don't
+    // fill instantly should be killed, not parked on the book where they
+    // accumulate stale-price risk.
+    defaultTimeInForce: enumType(["day", "gtc", "ioc", "fok"]).default("ioc"),
+    // Passive bias — scalping captures spread by posting on the book rather
+    // than paying it. Aggressive crossings are reserved for risk-off / unwind.
     executionBias: enumType(["passive", "neutral", "aggressive"])
-        .default("neutral"),
-    maxSlippageTolerancePct: numberType().min(0).max(100).default(1.0),
+        .default("passive"),
+    // 30bps slippage tolerance (vs 100bps) — must be tighter than scalping
+    // edge magnitudes (typically ~50-100bps) to preserve PnL.
+    maxSlippageTolerancePct: numberType().min(0).max(100).default(0.3),
     priceCollarEnabled: booleanType().default(true),
-    priceCollarPct: numberType().min(0).default(2),
+    // 50bps price collar (vs 200bps) — same logic as slippage tolerance:
+    // collar must sit inside the edge magnitude.
+    priceCollarPct: numberType().min(0).default(0.5),
     repriceEnabled: booleanType().default(false),
     repriceMaxAttempts: numberType().min(0).default(3),
     repriceIntervalSeconds: numberType().min(0).default(30),
@@ -68175,20 +68215,31 @@ const TrailingStopTighteningRuleSchema = objectType({
 const PositionManagementPrefsObjectSchema = objectType({
     defaultStopLossMethod: enumType(["fixed_percent", "atr_based", "structure_based", "trailing_stop"])
         .default("trailing_stop"),
-    defaultStopLossPct: numberType().min(0).max(100).default(4),
-    atrStopMultiplier: numberType().min(0).default(2),
+    // 50bps stop sized for 5-min bar scalp profiles (audit 2026-05-10).
+    defaultStopLossPct: numberType().min(0).max(100).default(0.5),
+    // 0.75x ATR multiplier — tighter than the previous 2x to keep ATR-based
+    // stops aligned with sub-percent intraday move ranges.
+    atrStopMultiplier: numberType().min(0).default(0.75),
     defaultTakeProfitMethod: enumType(["fixed_percent", "atr_based", "risk_reward_ratio", "none"])
         .default("risk_reward_ratio"),
-    defaultTakeProfitPct: numberType().min(0).max(100).default(3),
-    defaultRiskRewardRatio: numberType().min(0).default(2),
+    // 100bps take-profit pairs with the 50bps stop at a 2:1 R:R via the
+    // explicit defaultRiskRewardRatio below; both serve different code paths
+    // (fixed-percent vs ratio-derived TP).
+    defaultTakeProfitPct: numberType().min(0).max(100).default(1.0),
+    defaultRiskRewardRatio: numberType().min(0).default(1.5),
     breakEvenStopEnabled: booleanType().default(true),
-    breakEvenTriggerPct: numberType().min(0).max(100).default(2),
+    // Move stop to break-even after 1% of profit (vs 2%) — tighter to match
+    // scalping cadence.
+    breakEvenTriggerPct: numberType().min(0).max(100).default(1),
     scaleInEnabled: booleanType().default(false),
     scaleInMaxAdds: numberType().min(0).default(2),
     scaleOutEnabled: booleanType().default(true),
     scaleOutTrimPct: numberType().min(0).max(100).default(50),
-    scaleOutTriggerPct: numberType().min(0).max(100).default(5),
-    maxHoldingPeriodMinutes: numberType().min(0).default(0),
+    // Trim 50% at +0.5% — much earlier than the previous 5% for scalping.
+    scaleOutTriggerPct: numberType().min(0).max(100).default(0.5),
+    // Hard 30-min intraday hold cap. Previous default of 0 (unlimited) is
+    // wrong for scalping where stale positions accumulate undefined risk.
+    maxHoldingPeriodMinutes: numberType().min(0).default(30),
     maxHoldingPeriodByAssetClass: recordType(stringType(), numberType()).default({}),
     dayTradeOnly: booleanType().default(false),
     autoCloseBeforeEarnings: booleanType().default(false),
@@ -68206,7 +68257,9 @@ const PositionManagementPrefsObjectSchema = objectType({
         { profitThresholdPct: 10, newTrailPct: 1.0 },
     ]),
     portfolioStopOverridesPositionStops: booleanType().default(false),
-    doNotReenterAfterStopOutMinutes: numberType().min(0).default(30),
+    // 10-min stop-out cooldown (vs 30) — fast re-entry permitted once the
+    // adverse regime resolves.
+    doNotReenterAfterStopOutMinutes: numberType().min(0).default(10),
     doNotReenterAfterForcedCloseMinutes: numberType().min(0).default(60),
 });
 const PositionManagementPrefsSchema = PositionManagementPrefsObjectSchema.default({});
@@ -68462,6 +68515,26 @@ const EffectiveTradingPolicySchema = objectType({
     perTradeEquityAllocationPct: numberType(),
     /** Percentage of the crypto allocation slice of account equity allocated per crypto trade. Canonical replacement for legacy AlpacaAccount.cryptoTradeAllocationPct. */
     perTradeCryptoAllocationPct: numberType(),
+    /**
+     * Wash-trade cooldown period in milliseconds for equities. Defines the
+     * minimum elapsed time between opposing-side fills on the same symbol per
+     * FINRA Rule 5210, mirroring the 30s default already enforced for crypto.
+     * Mirrors `TradingPolicy.equityWashTradeCooldownMs` in backend-legacy.
+     * Optional so that legacy snapshots that pre-date this field continue to
+     * parse cleanly; consumers should fall back to a 30_000ms static default
+     * when undefined.
+     */
+    equityWashTradeCooldownMs: numberType().int().nonnegative().optional(),
+    /**
+     * Maximum daily portfolio loss as a fraction of account equity, evaluated
+     * intraday from the broker's `equity` vs `last_equity` delta. Breach
+     * activates a 24h `BLOCK_NEW_OPENS` halt per Reg-T daily-loss-limit
+     * controls. Optional so legacy snapshots parse cleanly; consumers
+     * should fall back to the static default in `defaultRiskConfig.dailyLossLimits.maxDailyLossPercent`
+     * (3%) when undefined. Range constrained to [0, 1) — a 100% daily-loss
+     * threshold would be nonsensical.
+     */
+    maxDailyLossPercent: numberType().min(0).max(1).optional(),
     macroOverlayEnabled: booleanType(),
     sectorOverlayEnabled: booleanType(),
     volatilityOverlayEnabled: booleanType(),
@@ -68491,9 +68564,14 @@ const EffectiveTradingPolicySchema = objectType({
 });
 
 /**
- * Conservative default trading policy used as the baseline when no
- * user-customized policy exists. All nested preference sub-objects are
- * passed as empty objects so Zod applies their field-level defaults.
+ * Default trading policy used as the baseline when no user-customized policy
+ * exists. Calibrated for short-horizon day trading / HFT-microstructuring /
+ * scalping (intraday holds, 5-min-bar-sized stops, fast cooldowns) per the
+ * 2026-05-10 audit, replacing the previous swing-trading calibration.
+ *
+ * All nested preference sub-objects are passed as empty objects so Zod applies
+ * their field-level defaults (which are themselves tuned for scalping in their
+ * respective schema files).
  *
  * Key choices:
  * - Advisory-only autonomy (no autonomous execution)
@@ -68502,6 +68580,14 @@ const EffectiveTradingPolicySchema = objectType({
  * - No shorting or margin (user must opt-in)
  * - All protective overlays disabled (user must opt-in)
  * - No LLM providers pre-configured
+ * - Tighter per-trade allocation (2% vs 5%) and concurrency (8 positions vs 20)
+ *   reflecting the increased turnover and decreased per-position conviction
+ *   characteristic of scalping
+ * - Faster equity wash-trade cooldown (5s vs 30s) — FINRA Rule 5210 governs
+ *   opposing-side wash trades; same-side intraday re-entry can be much faster
+ * - Tighter daily-loss circuit breaker (2% vs 3%) reflecting that scalping
+ *   strategies should fail fast rather than burn the day's risk budget on
+ *   one bad regime
  */
 const DEFAULT_TRADING_POLICY = EffectiveTradingPolicySchema.parse({
     autonomyMode: exports.AutonomyMode.ADVISORY_ONLY,
@@ -68522,12 +68608,23 @@ const DEFAULT_TRADING_POLICY = EffectiveTradingPolicySchema.parse({
     maxGrossExposurePct: 100,
     maxNetExposurePct: 100,
     maxLeverage: 1,
-    maxSymbolConcentrationPct: 15,
+    maxSymbolConcentrationPct: 8,
     maxSectorConcentrationPct: 30,
-    maxOpenPositions: 20,
+    maxOpenPositions: 8,
     maxOpenOrders: 50,
-    perTradeEquityAllocationPct: 5,
-    perTradeCryptoAllocationPct: 5,
+    perTradeEquityAllocationPct: 2,
+    perTradeCryptoAllocationPct: 2,
+    // 5s same-side intraday re-entry cooldown for scalping. FINRA Rule 5210
+    // governs opposing-side wash trades; same-side rapid re-entry off the
+    // same setup is permitted within tighter bounds suited to 5-min-bar
+    // strategies. Backend-legacy `TradingPolicy.equityWashTradeCooldownMs`
+    // default of 30_000 ms remains the canonical row-level fallback for
+    // accounts that have not opted into the scalping profile.
+    equityWashTradeCooldownMs: 5_000,
+    // 2% daily loss cap: tighter than the engine's 3% defaultRiskConfig
+    // because scalping strategies should fail fast — three bad regimes at 3%
+    // each is a 9% intraday burn before the kill-switch fires.
+    maxDailyLossPercent: 0.02,
     macroOverlayEnabled: false,
     sectorOverlayEnabled: false,
     volatilityOverlayEnabled: false,