openbroker 1.9.4 → 1.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbroker",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Hyperliquid trading CLI - execute orders, manage positions, and run trading strategies",
   "type": "module",
   "bin": {
@@ -51,10 +51,12 @@
     "funding-scan": "tsx scripts/info/funding-scan.ts",
     "outcomes": "tsx scripts/info/outcomes.ts",
     "build": "tsc",
-    "prepublishOnly": "npm run build && npm run test:guardrails && npm run test:realtime && npm run test:cli",
+    "prepublishOnly": "npm run build && npm run test:guardrails && npm run test:realtime && npm run test:advanced && npm run test:install && npm run test:cli",
     "test:cli": "node --import tsx bin/cli.ts --help",
     "test:guardrails": "node --import tsx --test scripts/auto/guardrails.test.ts",
-    "test:realtime": "node --import tsx --test scripts/auto/realtime.test.ts"
+    "test:realtime": "node --import tsx --test scripts/auto/realtime.test.ts",
+    "test:advanced": "node --import tsx --test scripts/operations/advanced-orders.test.ts",
+    "test:install": "node --import tsx --test scripts/setup/package-catalog.test.ts"
   },
   "dependencies": {
     "@nktkas/hyperliquid": "^0.30.3",

package/scripts/core/client.ts

@@ -2703,6 +2703,97 @@ export class HyperliquidClient {
     return this.triggerOrder(coin, isBuy, size, triggerPrice, triggerPrice, 'tp', true);
   }
 
+  /**
+   * Place a paired TP/SL trigger set using Hyperliquid's normalTpsl grouping.
+   * The two orders are submitted together so the venue treats them as a linked
+   * bracket pair instead of two unrelated reduce-only triggers.
+   */
+  async tpslPair(
+    coin: string,
+    isBuy: boolean,
+    size: number,
+    takeProfitPrice: number,
+    stopLossPrice: number,
+    stopLossSlippageBps: number = 100,
+    leverage?: number
+  ): Promise<OrderResponse> {
+    await this.requireTrading();
+    await this.getMetaAndAssetCtxs();
+
+    if (leverage && !this.isHip3(coin)) {
+      this.log(`Setting leverage for ${coin} to ${leverage}x cross`);
+      await this.updateLeverage(coin, leverage, true);
+    }
+
+    const slippageMult = stopLossSlippageBps / 10000;
+    const stopLossLimitPrice = isBuy
+      ? stopLossPrice * (1 + slippageMult)
+      : stopLossPrice * (1 - slippageMult);
+
+    await this.ensureHip3Ready(coin, size * Math.max(takeProfitPrice, stopLossLimitPrice), leverage);
+
+    const assetIndex = this.getAssetIndex(coin);
+    const szDecimals = this.getSzDecimals(coin);
+    const roundedSize = roundSize(size, szDecimals);
+
+    const orderWires = [
+      {
+        a: assetIndex,
+        b: isBuy,
+        p: roundPrice(takeProfitPrice, szDecimals),
+        s: roundedSize,
+        r: true,
+        t: {
+          trigger: {
+            triggerPx: roundPrice(takeProfitPrice, szDecimals),
+            isMarket: false,
+            tpsl: 'tp' as const,
+          },
+        },
+      },
+      {
+        a: assetIndex,
+        b: isBuy,
+        p: roundPrice(stopLossLimitPrice, szDecimals),
+        s: roundedSize,
+        r: true,
+        t: {
+          trigger: {
+            triggerPx: roundPrice(stopLossPrice, szDecimals),
+            isMarket: false,
+            tpsl: 'sl' as const,
+          },
+        },
+      },
+    ];
+
+    const orderRequest: {
+      orders: typeof orderWires;
+      grouping: 'normalTpsl';
+      builder?: BuilderInfo;
+    } = {
+      orders: orderWires,
+      grouping: 'normalTpsl',
+    };
+
+    if (!this.isTestnet && this.config.builderAddress !== '0x0000000000000000000000000000000000000000') {
+      orderRequest.builder = this.builderInfo;
+      this.log('Including builder fee:', this.builderInfo);
+    }
+
+    try {
+      const response = await this.exchange.order(orderRequest, this.vaultParam);
+      this.log('TP/SL pair response:', JSON.stringify(response, null, 2));
+      return response as unknown as OrderResponse;
+    } catch (error) {
+      this.log('TP/SL pair error:', error);
+      return {
+        status: 'err',
+        response: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
   async cancel(coin: string, oid: number): Promise<CancelResponse> {
     await this.requireTrading();
     await this.getMetaAndAssetCtxs();

package/scripts/lib.ts

@@ -59,6 +59,9 @@ export type { BracketOptions, BracketResult } from './operations/bracket.js';
 export { runChase } from './operations/chase.js';
 export type { ChaseOptions, ChaseResult } from './operations/chase.js';
 
+export { runScale, calculateLevels } from './operations/scale.js';
+export type { ScaleOptions, ScaleResult, OrderLevel } from './operations/scale.js';
+
 // ── Automation runtime ──────────────────────────────────────────────
 
 export {

package/scripts/operations/advanced-orders.test.ts

@@ -0,0 +1,209 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runBracket, type BracketClient } from './bracket.js';
+import { runChase, type ChaseClient } from './chase.js';
+import { runScale, type ScaleClient } from './scale.js';
+import { UserFillWatcher, type FillSummary, type FillWatcher } from './execution.js';
+import type { CancelResponse, OpenOrder, OrderResponse } from '../core/types.js';
+
+const okOrder = (statuses: OrderResponse['response'] extends infer R
+  ? R extends { data: { statuses: infer S } } ? S : never
+  : never): OrderResponse => ({
+    status: 'ok',
+    response: { type: 'order', data: { statuses } },
+  });
+
+const okCancel = (): CancelResponse => ({
+  status: 'ok',
+  response: { type: 'cancel', data: { statuses: ['success'] } },
+});
+
+class StaticFillWatcher implements FillWatcher {
+  constructor(private readonly fills: Map<number, FillSummary>) {}
+  async start(): Promise<void> {}
+  async stop(): Promise<void> {}
+  getFilled(oid: number): FillSummary {
+    return this.fills.get(oid) ?? { size: 0, notional: 0 };
+  }
+  async waitForFill(oid: number): Promise<FillSummary> {
+    return this.getFilled(oid);
+  }
+}
+
+test('scale rejects invalid levels and rolls back resting orders on partial ladder placement', async () => {
+  const cancelled: Array<{ coin: string; oid: number }> = [];
+  const client: ScaleClient = {
+    verbose: false,
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async bulkOrder() {
+      return okOrder([
+        { resting: { oid: 101 } },
+        { error: 'insufficient margin' },
+        { resting: { oid: 103 } },
+      ]);
+    },
+    async bulkCancel(cancels) {
+      cancelled.push(...cancels);
+      return okCancel();
+    },
+  };
+
+  await assert.rejects(
+    () => runScale({
+      coin: 'ETH',
+      side: 'buy',
+      size: 1,
+      levels: 0,
+      rangePct: 2,
+      client,
+      output: () => {},
+    }),
+    /levels must be a positive integer/,
+  );
+
+  const result = await runScale({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    levels: 3,
+    rangePct: 2,
+    client,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'partial');
+  assert.equal(result.rolledBack, true);
+  assert.deepEqual(cancelled, [
+    { coin: 'ETH', oid: 101 },
+    { coin: 'ETH', oid: 103 },
+  ]);
+});
+
+test('bracket waits for limit-entry fill and arms linked TP/SL for confirmed size', async () => {
+  const pairCalls: Array<{ size: number; tp: number; sl: number; isBuy: boolean }> = [];
+  const client: BracketClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      return { ETH: '1000' };
+    },
+    async marketOrder() {
+      throw new Error('marketOrder should not be called');
+    },
+    async limitOrder() {
+      return okOrder([{ resting: { oid: 777 } }]);
+    },
+    async tpslPair(_coin, isBuy, size, tp, sl) {
+      pairCalls.push({ size, tp, sl, isBuy });
+      return okOrder([{ resting: { oid: 778 } }, { resting: { oid: 779 } }]);
+    },
+    async getUserFills() {
+      return [];
+    },
+  };
+
+  const fillWatcher = new StaticFillWatcher(new Map([
+    [777, { size: 0.4, notional: 392, avgPrice: 980 }],
+  ]));
+
+  const result = await runBracket({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    tpPct: 5,
+    slPct: 2,
+    entryType: 'limit',
+    entryPrice: 990,
+    entryTimeoutSec: 5,
+    client,
+    fillWatcher,
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'complete');
+  assert.equal(result.protectedSize, 0.4);
+  assert.equal(result.entryPrice, 980);
+  assert.equal(pairCalls.length, 1);
+  assert.equal(pairCalls[0].size, 0.4);
+  assert.equal(pairCalls[0].isBuy, false);
+  assert.equal(pairCalls[0].tp, 1029);
+  assert.equal(pairCalls[0].sl, 960.4);
+});
+
+test('chase requotes only the remaining size after a partial fill', async () => {
+  const limitSizes: number[] = [];
+  const cancelled: number[] = [];
+  const fills = new Map<number, FillSummary>();
+  let orderCount = 0;
+  let mid = 1000;
+
+  const client: ChaseClient = {
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getAllMids() {
+      mid += 2;
+      return { ETH: String(mid) };
+    },
+    async getOpenOrders(): Promise<OpenOrder[]> {
+      return [];
+    },
+    async getUserFills() {
+      return [];
+    },
+    async limitOrder(_coin, _isBuy, size) {
+      limitSizes.push(size);
+      orderCount += 1;
+      const oid = 900 + orderCount;
+      if (orderCount === 1) {
+        fills.set(oid, { size: 0.4, notional: 400, avgPrice: 1000 });
+      } else {
+        fills.set(oid, { size, notional: size * 1002, avgPrice: 1002 });
+      }
+      return okOrder([{ resting: { oid } }]);
+    },
+    async cancel(_coin, oid) {
+      cancelled.push(oid);
+      return okCancel();
+    },
+  };
+
+  const result = await runChase({
+    coin: 'ETH',
+    side: 'buy',
+    size: 1,
+    offsetBps: 5,
+    timeoutSec: 2,
+    intervalMs: 1,
+    maxChaseBps: 1_000,
+    client,
+    fillWatcher: new StaticFillWatcher(fills),
+    output: () => {},
+  });
+
+  assert.equal(result.status, 'filled');
+  assert.equal(limitSizes.length, 2);
+  assert.equal(limitSizes[0], 1);
+  assert(Math.abs(limitSizes[1] - 0.6) < 1e-9);
+  assert.deepEqual(cancelled, [901]);
+});
+
+test('user fill watcher de-duplicates repeated REST fallback fills', async () => {
+  const fillTime = Date.now();
+  const watcher = new UserFillWatcher({
+    verbose: false,
+    address: '0x0000000000000000000000000000000000000001',
+    async getUserFills() {
+      return [
+        { coin: 'ETH', px: '1000', sz: '0.25', time: fillTime, oid: 123 },
+      ];
+    },
+  }, { ws: null, sinceMs: fillTime - 1000 });
+
+  await watcher.start();
+  await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+  await watcher.waitForFill(123, 1, 1, { coin: 'ETH', pollMs: 1 });
+
+  assert.equal(watcher.getFilled(123).size, 0.25);
+});

package/scripts/operations/bracket.ts

@@ -3,7 +3,9 @@
 
 import { fileURLToPath } from 'url';
 import { getClient } from '../core/client.js';
+import type { OrderResponse } from '../core/types.js';
 import { formatUsd, parseArgs, sleep } from '../core/utils.js';
+import { UserFillWatcher, type FillWatcher } from './execution.js';
 
 function printUsage() {
   console.log(`
@@ -25,6 +27,8 @@ Options:
   --tp          Take profit distance in % from entry
   --sl          Stop loss distance in % from entry
   --slippage    Slippage for market entry in bps (default: 50)
+  --entry-timeout Seconds to wait for limit entry fill before returning (default: 300)
+  --sl-slippage Stop-loss trigger limit slippage in bps (default: 100)
   --leverage    Set leverage (e.g., 10 for 10x). Cross for main perps, isolated for HIP-3
   --dry         Dry run - show bracket plan without executing
 
@@ -53,13 +57,27 @@ export interface BracketOptions {
   entryType?: 'market' | 'limit';
   entryPrice?: number;
   slippage?: number;
+  entryTimeoutSec?: number;
+  slSlippageBps?: number;
   leverage?: number;
   dryRun?: boolean;
   verbose?: boolean;
+  client?: BracketClient;
+  fillWatcher?: FillWatcher;
   /** Receives each output line. Defaults to console.log. */
   output?: (line: string) => void;
 }
 
+export interface BracketClient {
+  verbose: boolean;
+  getAllMids(): Promise<Record<string, string>>;
+  marketOrder(coin: string, isBuy: boolean, size: number, slippageBps?: number, leverage?: number): Promise<OrderResponse>;
+  limitOrder(coin: string, isBuy: boolean, size: number, price: number, tif?: 'Gtc' | 'Ioc' | 'Alo', reduceOnly?: boolean, leverage?: number): Promise<OrderResponse>;
+  tpslPair(coin: string, isBuy: boolean, size: number, takeProfitPrice: number, stopLossPrice: number, stopLossSlippageBps?: number, leverage?: number): Promise<OrderResponse>;
+  address: string;
+  getUserFills(user?: string): Promise<Array<{ coin: string; px: string; sz: string; time: number; oid: number }>>;
+}
+
 export interface BracketResult {
   status: 'dry' | 'limit_resting' | 'complete' | 'entry_failed' | 'partial';
   entryPrice?: number;
@@ -68,6 +86,7 @@ export interface BracketResult {
   tpOid?: number | null;
   slOid?: number | null;
   entryOid?: number | null;
+  protectedSize?: number;
   reason?: string;
 }
 
@@ -82,7 +101,7 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
     throw new Error('entryPrice is required for limit entry');
   }
 
-  const client = getClient();
+  const client = opts.client ?? getClient();
   if (opts.verbose) client.verbose = true;
 
   out('Open Broker - Bracket Order');
@@ -135,48 +154,87 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
   out('Step 1: Entry order');
   let actualEntry = entry;
   let entryOid: number | null = null;
+  let filledSize = 0;
+  const ownsFillWatcher = !opts.fillWatcher;
+  const fillWatcher = opts.fillWatcher ?? new UserFillWatcher(client, { sinceMs: Date.now() });
 
-  if (entryType === 'market') {
-    const entryResponse = await client.marketOrder(opts.coin, isLong, opts.size, opts.slippage, opts.leverage);
+  await fillWatcher.start();
 
-    if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
-      const status = entryResponse.response.data.statuses[0];
-      if (status?.filled) {
-        actualEntry = parseFloat(status.filled.avgPx);
-        out(`  ✅ Filled @ ${formatUsd(actualEntry)}`);
-      } else if (status?.error) {
-        out(`  ❌ Entry failed: ${status.error}`);
+  try {
+    if (entryType === 'market') {
+      const entryResponse = await client.marketOrder(opts.coin, isLong, opts.size, opts.slippage, opts.leverage);
+
+      if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+        const status = entryResponse.response.data.statuses[0];
+        if (status?.filled) {
+          actualEntry = parseFloat(status.filled.avgPx);
+          filledSize = parseFloat(status.filled.totalSz);
+          out(`  ✅ Filled ${filledSize} @ ${formatUsd(actualEntry)}`);
+        } else if (status?.error) {
+          out(`  ❌ Entry failed: ${status.error}`);
+          out('\n⚠️ Bracket aborted - no position opened');
+          return { status: 'entry_failed', reason: status.error };
+        } else {
+          out(`  ❌ Entry failed: unexpected response`);
+          out('\n⚠️ Bracket aborted - no confirmed position opened');
+          return { status: 'entry_failed', reason: 'Unexpected entry response' };
+        }
+      } else {
+        const reason = typeof entryResponse.response === 'string' ? entryResponse.response : 'Unknown error';
+        out(`  ❌ Entry failed: ${reason}`);
         out('\n⚠️ Bracket aborted - no position opened');
-        return { status: 'entry_failed', reason: status.error };
+        return { status: 'entry_failed', reason };
       }
     } else {
-      const reason = typeof entryResponse.response === 'string' ? entryResponse.response : 'Unknown error';
-      out(`  ❌ Entry failed: ${reason}`);
-      out('\n⚠️ Bracket aborted - no position opened');
-      return { status: 'entry_failed', reason };
-    }
-  } else {
-    const entryResponse = await client.limitOrder(opts.coin, isLong, opts.size, entry, 'Gtc', false, opts.leverage);
-
-    if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
-      const status = entryResponse.response.data.statuses[0];
-      if (status?.resting) {
-        entryOid = status.resting.oid;
-        out(`  ✅ Limit order placed @ ${formatUsd(entry)} (OID: ${entryOid})`);
-        out(`  ⏳ Waiting for fill before placing TP/SL...`);
-        out('\n⚠️ Note: TP/SL will be placed after entry fills. Monitor manually or use a strategy script.');
-        return { status: 'limit_resting', entryOid, entryPrice: entry };
-      } else if (status?.filled) {
-        actualEntry = parseFloat(status.filled.avgPx);
-        out(`  ✅ Filled immediately @ ${formatUsd(actualEntry)}`);
-      } else if (status?.error) {
-        out(`  ❌ Entry failed: ${status.error}`);
-        return { status: 'entry_failed', reason: status.error };
+      const entryResponse = await client.limitOrder(opts.coin, isLong, opts.size, entry, 'Gtc', false, opts.leverage);
+
+      if (entryResponse.status === 'ok' && entryResponse.response && typeof entryResponse.response === 'object') {
+        const status = entryResponse.response.data.statuses[0];
+        if (status?.resting) {
+          entryOid = status.resting.oid;
+          const entryTimeoutSec = opts.entryTimeoutSec ?? 300;
+          out(`  ✅ Limit order placed @ ${formatUsd(entry)} (OID: ${entryOid})`);
+
+          if (entryTimeoutSec <= 0) {
+            out(`  ⏳ Entry resting; TP/SL not armed until a fill is confirmed.`);
+            return { status: 'limit_resting', entryOid, entryPrice: entry };
+          }
+
+          out(`  ⏳ Waiting up to ${entryTimeoutSec}s for fill confirmation...`);
+          const fill = await fillWatcher.waitForFill(entryOid, opts.size, entryTimeoutSec * 1000, { coin: opts.coin });
+          if (fill.size <= 0) {
+            out(`  ⚠️ Entry still resting after ${entryTimeoutSec}s; TP/SL not armed.`);
+            return { status: 'limit_resting', entryOid, entryPrice: entry };
+          }
+          filledSize = Math.min(fill.size, opts.size);
+          actualEntry = fill.avgPrice ?? entry;
+          out(`  ✅ Fill confirmed: ${filledSize} @ ${formatUsd(actualEntry)}`);
+          if (filledSize < opts.size * 0.999) {
+            out(`  ⚠️ Partial entry fill; arming TP/SL for filled size only.`);
+          }
+        } else if (status?.filled) {
+          actualEntry = parseFloat(status.filled.avgPx);
+          filledSize = parseFloat(status.filled.totalSz);
+          out(`  ✅ Filled immediately ${filledSize} @ ${formatUsd(actualEntry)}`);
+        } else if (status?.error) {
+          out(`  ❌ Entry failed: ${status.error}`);
+          return { status: 'entry_failed', reason: status.error };
+        } else {
+          out(`  ❌ Entry failed: unexpected response`);
+          return { status: 'entry_failed', reason: 'Unexpected entry response' };
+        }
+      } else {
+        out(`  ❌ Entry failed`);
+        return { status: 'entry_failed', reason: 'Unknown error' };
       }
-    } else {
-      out(`  ❌ Entry failed`);
-      return { status: 'entry_failed', reason: 'Unknown error' };
     }
+  } finally {
+    if (ownsFillWatcher) await fillWatcher.stop();
+  }
+
+  if (!Number.isFinite(filledSize) || filledSize <= 0) {
+    out('\n⚠️ Bracket aborted - no confirmed fill size');
+    return { status: 'entry_failed', reason: 'No confirmed fill size' };
   }
 
   // Recalculate TP/SL based on actual entry
@@ -190,59 +248,52 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
 
   await sleep(500);
 
-  // Step 2: Take Profit (trigger order)
-  out('\nStep 2: Take Profit order (trigger)');
-  const tpSide = !isLong;
-  const tpResponse = await client.takeProfit(opts.coin, tpSide, opts.size, tpPrice);
+  // Step 2: Paired TP/SL trigger orders
+  out('\nStep 2: Paired TP/SL trigger orders');
+  const exitSide = !isLong;
+  const pairResponse = await client.tpslPair(
+    opts.coin,
+    exitSide,
+    filledSize,
+    tpPrice,
+    slPrice,
+    opts.slSlippageBps,
+    opts.leverage,
+  );
 
   let tpOid: number | null = null;
-  if (tpResponse.status === 'ok' && tpResponse.response && typeof tpResponse.response === 'object') {
-    const status = tpResponse.response.data.statuses[0];
-    if (status?.resting) {
-      tpOid = status.resting.oid;
+  let slOid: number | null = null;
+  if (pairResponse.status === 'ok' && pairResponse.response && typeof pairResponse.response === 'object') {
+    const [tpStatus, slStatus] = pairResponse.response.data.statuses;
+    if (tpStatus?.resting) {
+      tpOid = tpStatus.resting.oid;
       out(`  ✅ TP trigger placed @ ${formatUsd(tpPrice)} (OID: ${tpOid})`);
-    } else if (status?.error) {
-      out(`  ❌ TP failed: ${status.error}`);
+    } else if (tpStatus?.error) {
+      out(`  ❌ TP failed: ${tpStatus.error}`);
     } else {
-      out(`  ⚠️ TP status: ${JSON.stringify(status)}`);
+      out(`  ⚠️ TP status: ${JSON.stringify(tpStatus)}`);
     }
-  } else {
-    const reason = typeof tpResponse.response === 'string' ? tpResponse.response : 'Unknown error';
-    out(`  ❌ TP failed: ${reason}`);
-  }
 
-  await sleep(500);
-
-  // Step 3: Stop Loss (trigger order)
-  out('\nStep 3: Stop Loss order (trigger)');
-  const slSide = !isLong;
-  const slResponse = await client.stopLoss(opts.coin, slSide, opts.size, slPrice);
-
-  let slOid: number | null = null;
-  if (slResponse.status === 'ok' && slResponse.response && typeof slResponse.response === 'object') {
-    const status = slResponse.response.data.statuses[0];
-    if (status?.resting) {
-      slOid = status.resting.oid;
+    if (slStatus?.resting) {
+      slOid = slStatus.resting.oid;
       out(`  ✅ SL trigger placed @ ${formatUsd(slPrice)} (OID: ${slOid})`);
-    } else if (status?.error) {
-      out(`  ❌ SL failed: ${status.error}`);
+    } else if (slStatus?.error) {
+      out(`  ❌ SL failed: ${slStatus.error}`);
     } else {
-      out(`  ⚠️ SL status: ${JSON.stringify(status)}`);
+      out(`  ⚠️ SL status: ${JSON.stringify(slStatus)}`);
     }
   } else {
-    const reason = typeof slResponse.response === 'string' ? slResponse.response : 'Unknown error';
-    out(`  ❌ SL failed: ${reason}`);
+    const reason = typeof pairResponse.response === 'string' ? pairResponse.response : 'Unknown error';
+    out(`  ❌ TP/SL pair failed: ${reason}`);
   }
 
   out('\n========== Bracket Summary ==========');
-  out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${opts.size} ${opts.coin}`);
+  out(`Position:    ${isLong ? 'LONG' : 'SHORT'} ${filledSize} ${opts.coin}`);
   out(`Entry:       ${formatUsd(actualEntry)}`);
   out(`Take Profit: ${formatUsd(tpPrice)} (+${opts.tpPct}%) - Trigger order`);
   out(`Stop Loss:   ${formatUsd(slPrice)} (-${opts.slPct}%) - Trigger order`);
   if (tpOid && slOid) {
-    out(`\n✅ Bracket complete! TP and SL are trigger orders.`);
-    out(`   They will only execute when price reaches trigger level.`);
-    out(`   When one fills, cancel the other manually.`);
+    out(`\n✅ Bracket complete! TP and SL are linked trigger orders.`);
   }
 
   return {
@@ -252,6 +303,7 @@ export async function runBracket(opts: BracketOptions): Promise<BracketResult> {
     slPrice,
     tpOid,
     slOid,
+    protectedSize: filledSize,
   };
 }
 
@@ -266,6 +318,8 @@ async function main() {
   const tpPct = parseFloat(args.tp as string);
   const slPct = parseFloat(args.sl as string);
   const slippage = args.slippage ? parseInt(args.slippage as string) : undefined;
+  const entryTimeoutSec = args['entry-timeout'] ? parseInt(args['entry-timeout'] as string) : undefined;
+  const slSlippageBps = args['sl-slippage'] ? parseInt(args['sl-slippage'] as string) : undefined;
   const leverage = args.leverage ? parseInt(args.leverage as string) : undefined;
   const dryRun = args.dry as boolean;
 
@@ -288,6 +342,8 @@ async function main() {
       entryType,
       entryPrice,
       slippage,
+      entryTimeoutSec,
+      slSlippageBps,
       leverage,
       dryRun,
       verbose: args.verbose as boolean,