@vtxmacro/cli 2026.10.8 → 2026.10.9

package/bin/vtx.js

@@ -113,7 +113,7 @@ var init_routing = __esm({
 var agent_cli_release_default;
 var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
-    agent_cli_release_default = { package_name: "@vtxmacro/cli", package_version: "2026.10.8", codex_package_name: "@openai/codex", codex_version: "0.155.0", copilot_sdk_package_name: "@github/copilot-sdk", copilot_sdk_version: "1.0.0-beta.8", copilot_cli_package_name: "@github/copilot", copilot_cli_version: "1.0.80", deepseek_harness_version: "0.1.1-rc.2", deepseek_harness_packages: ["@deepseek-ai/dsh-agent", "@deepseek-ai/dsh-agent-instructions", "@deepseek-ai/dsh-agent-loop", "@deepseek-ai/dsh-agent-spine-demo", "@deepseek-ai/dsh-anonymous-user-id", "@deepseek-ai/dsh-atomic-write", "@deepseek-ai/dsh-attachment", "@deepseek-ai/dsh-brand", "@deepseek-ai/dsh-code-runtime", "@deepseek-ai/dsh-credentials", "@deepseek-ai/dsh-fs", "@deepseek-ai/dsh-goal", "@deepseek-ai/dsh-goal-round-driver", "@deepseek-ai/dsh-home-paths", "@deepseek-ai/dsh-invariants", "@deepseek-ai/dsh-jobs", "@deepseek-ai/dsh-jobs-local", "@deepseek-ai/dsh-launch-environment", "@deepseek-ai/dsh-llm", "@deepseek-ai/dsh-llm-deepseek", "@deepseek-ai/dsh-llm-retry", "@deepseek-ai/dsh-output-retention", "@deepseek-ai/dsh-sandbox", "@deepseek-ai/dsh-sandbox-policy", "@deepseek-ai/dsh-scope", "@deepseek-ai/dsh-session", "@deepseek-ai/dsh-session-checkpoint-policy", "@deepseek-ai/dsh-session-persistence", "@deepseek-ai/dsh-session-persistence-jsonl", "@deepseek-ai/dsh-session-projection", "@deepseek-ai/dsh-session-title", "@deepseek-ai/dsh-settings", "@deepseek-ai/dsh-shell", "@deepseek-ai/dsh-shell-env", "@deepseek-ai/dsh-skill", "@deepseek-ai/dsh-skill-filesystem", "@deepseek-ai/dsh-subprocess", "@deepseek-ai/dsh-system-prompt", "@deepseek-ai/dsh-timeout", "@deepseek-ai/dsh-tool-bash", "@deepseek-ai/dsh-tool-goal", "@deepseek-ai/dsh-tool-jobs", "@deepseek-ai/dsh-tool-skill", "@deepseek-ai/dsh-tools", "@deepseek-ai/dsh-typert-protocol", "@deepseek-ai/dsh-user-approval"], deepseek_cordis_package_name: "@deepseek-ai/cordis", deepseek_cordis_version: "4.0.1", deepseek_support_packages: { "@deepseek-ai/cordis-plugin-timer": "1.1.3" }, platforms: { "linux-x64": { package_name: "@openai/codex-linux-x64", target: "x86_64-unknown-linux-musl", binary_name: "codex", sha256: "660e159a49e823ac8e5986cb238f73158ce4b957d40d9292f8de90862644b501" }, "win32-x64": { package_name: "@openai/codex-win32-x64", target: "x86_64-pc-windows-msvc", binary_name: "codex.exe", sha256: "e4c11374bd9de8ad5c3b7617fd4654bb7839901edb0863f9930666863c7a021b" } }, pi_coding_agent_package_name: "@earendil-works/pi-coding-agent", pi_ai_package_name: "@earendil-works/pi-ai", pi_version: "0.85.1", pi_support_packages: ["@earendil-works/pi-agent-core", "@earendil-works/pi-telemetry", "@earendil-works/pi-tui", "@earendil-works/chord"], grok_version: "1.0.30", grok_platforms: { "linux-x64": { package_name: "@xai-official/grok-linux-x64", binary_name: "grok", sha256: "504dd6546ab991b75d36698242875ce461489cd1f8cd84285873cb55bd5c7d54" }, "win32-x64": { package_name: "@xai-official/grok-win32-x64", binary_name: "grok.exe", sha256: "48736d1a4342a801ea26d0ecde4c516b653f791399065adaa55973f83abd8867" } } };
+    agent_cli_release_default = { package_name: "@vtxmacro/cli", package_version: "2026.10.9", codex_package_name: "@openai/codex", codex_version: "0.155.0", copilot_sdk_package_name: "@github/copilot-sdk", copilot_sdk_version: "1.0.0-beta.8", copilot_cli_package_name: "@github/copilot", copilot_cli_version: "1.0.80", deepseek_harness_version: "0.1.1-rc.2", deepseek_harness_packages: ["@deepseek-ai/dsh-agent", "@deepseek-ai/dsh-agent-instructions", "@deepseek-ai/dsh-agent-loop", "@deepseek-ai/dsh-agent-spine-demo", "@deepseek-ai/dsh-anonymous-user-id", "@deepseek-ai/dsh-atomic-write", "@deepseek-ai/dsh-attachment", "@deepseek-ai/dsh-brand", "@deepseek-ai/dsh-code-runtime", "@deepseek-ai/dsh-credentials", "@deepseek-ai/dsh-fs", "@deepseek-ai/dsh-goal", "@deepseek-ai/dsh-goal-round-driver", "@deepseek-ai/dsh-home-paths", "@deepseek-ai/dsh-invariants", "@deepseek-ai/dsh-jobs", "@deepseek-ai/dsh-jobs-local", "@deepseek-ai/dsh-launch-environment", "@deepseek-ai/dsh-llm", "@deepseek-ai/dsh-llm-deepseek", "@deepseek-ai/dsh-llm-retry", "@deepseek-ai/dsh-output-retention", "@deepseek-ai/dsh-sandbox", "@deepseek-ai/dsh-sandbox-policy", "@deepseek-ai/dsh-scope", "@deepseek-ai/dsh-session", "@deepseek-ai/dsh-session-checkpoint-policy", "@deepseek-ai/dsh-session-persistence", "@deepseek-ai/dsh-session-persistence-jsonl", "@deepseek-ai/dsh-session-projection", "@deepseek-ai/dsh-session-title", "@deepseek-ai/dsh-settings", "@deepseek-ai/dsh-shell", "@deepseek-ai/dsh-shell-env", "@deepseek-ai/dsh-skill", "@deepseek-ai/dsh-skill-filesystem", "@deepseek-ai/dsh-subprocess", "@deepseek-ai/dsh-system-prompt", "@deepseek-ai/dsh-timeout", "@deepseek-ai/dsh-tool-bash", "@deepseek-ai/dsh-tool-goal", "@deepseek-ai/dsh-tool-jobs", "@deepseek-ai/dsh-tool-skill", "@deepseek-ai/dsh-tools", "@deepseek-ai/dsh-typert-protocol", "@deepseek-ai/dsh-user-approval"], deepseek_cordis_package_name: "@deepseek-ai/cordis", deepseek_cordis_version: "4.0.1", deepseek_support_packages: { "@deepseek-ai/cordis-plugin-timer": "1.1.3" }, platforms: { "linux-x64": { package_name: "@openai/codex-linux-x64", target: "x86_64-unknown-linux-musl", binary_name: "codex", sha256: "660e159a49e823ac8e5986cb238f73158ce4b957d40d9292f8de90862644b501" }, "win32-x64": { package_name: "@openai/codex-win32-x64", target: "x86_64-pc-windows-msvc", binary_name: "codex.exe", sha256: "e4c11374bd9de8ad5c3b7617fd4654bb7839901edb0863f9930666863c7a021b" } }, pi_coding_agent_package_name: "@earendil-works/pi-coding-agent", pi_ai_package_name: "@earendil-works/pi-ai", pi_version: "0.85.1", pi_support_packages: ["@earendil-works/pi-agent-core", "@earendil-works/pi-telemetry", "@earendil-works/pi-tui", "@earendil-works/chord"], grok_version: "1.0.30", grok_platforms: { "linux-x64": { package_name: "@xai-official/grok-linux-x64", binary_name: "grok", sha256: "504dd6546ab991b75d36698242875ce461489cd1f8cd84285873cb55bd5c7d54" }, "win32-x64": { package_name: "@xai-official/grok-win32-x64", binary_name: "grok.exe", sha256: "48736d1a4342a801ea26d0ecde4c516b653f791399065adaa55973f83abd8867" } } };
   }
 });
 
@@ -216,6 +216,10 @@ var init_runtime_policy_generated = __esm({
             protective_plan_set_lock: {
               wait_seconds: 120
             },
+            execution_mutation_queue: {
+              wait_seconds: 120,
+              trade_submit_deadline_seconds: 360
+            },
             history_evidence: {
               device_rounds_per_beat: 6,
               device_retry_seconds: 60
@@ -22192,6 +22196,10 @@ var init_runtime_policy_generated2 = __esm({
             protective_plan_set_lock: {
               wait_seconds: 120
             },
+            execution_mutation_queue: {
+              wait_seconds: 120,
+              trade_submit_deadline_seconds: 360
+            },
             history_evidence: {
               device_rounds_per_beat: 6,
               device_retry_seconds: 60
@@ -85520,7 +85528,8 @@ var init_hyperliquid_client = __esm({
         isTrigger,
         triggerKind,
         triggerPrice,
-        isPositionTpsl
+        isPositionTpsl,
+        statusTimestampMs: timestamp
       };
     };
     fetchBrowserOrderStatusEvidence = async (input) => {
@@ -86402,6 +86411,7 @@ var init_hyperliquid_client = __esm({
       return signedAssetId;
     };
     exchangeRejectionReason = (message) => {
+      if (/never placed|already cancel+ed|already filled|or filled/i.test(message)) return "order_not_open";
       if (/insufficient.*margin|margin.*insufficient/i.test(message)) return "insufficient_margin";
       if (/reduce.?only/i.test(message)) return "reduce_only";
       if (/minimum.*(?:value|notional)|(?:value|notional).*minimum|at least.*\$10/i.test(message)) return "minimum_notional";
@@ -86437,6 +86447,8 @@ var init_hyperliquid_client = __esm({
           let exchangeDispatched = false;
           let recoveryPermit = null;
           let settlementAttempted = false;
+          let pinnedAuthority = null;
+          let begunMutation = null;
           assertFreshPreparedExecutionContext(input.preparedContext);
           const captureTimeoutMs = Number(
             input.config?.client_runtime_execution_observability?.capture_timeout_ms
@@ -86458,9 +86470,14 @@ var init_hyperliquid_client = __esm({
               input,
               executionObservabilityDeadlineMs
             );
+            pinnedAuthority = pinClientExchangeMutationAuthority(
+              durableMutation.profileId,
+              ...durableMutationAuthorityArgs(durableMutation)
+            );
             const beginResult = await beginClientRuntimeExchangeMutation(
               durableMutation.profileId,
               {
+                ...pinnedAuthority ? { pinnedAuthority } : {},
                 mutationId: durableMutation.mutationId,
                 operationKind: durableMutation.operationKind,
                 symbol: durableMutation.symbol,
@@ -86486,6 +86503,7 @@ var init_hyperliquid_client = __esm({
               },
               ...durableMutationAuthorityArgs(durableMutation)
             );
+            begunMutation = beginResult;
             if (beginResult.dispatch_authorized !== true) {
               throw new RuntimeExecutionError(
                 "This exchange mutation was already recorded and will not be dispatched again. Durable reconciliation is required before retrying.",
@@ -86503,6 +86521,7 @@ var init_hyperliquid_client = __esm({
                 durableMutation.profileId,
                 durableMutation.mutationId,
                 {
+                  ...pinnedAuthority ? { pinnedAuthority } : {},
                   outcome,
                   ...dispatchDiagnostics ? { dispatchDiagnostics } : {},
                   ...outcome === "success" ? { requireExactSuccessSettlement: true } : {},
@@ -86517,11 +86536,11 @@ var init_hyperliquid_client = __esm({
               } catch {
               }
               return settled;
-            } catch {
-              throw new RuntimeExecutionError(
+            } catch (settlementCause) {
+              throw Object.assign(new RuntimeExecutionError(
                 "Exchange submission may have completed; durable reconciliation is pending.",
                 "outcome_unknown"
-              );
+              ), { settlementCause });
             }
           };
           const settleDefinitiveSuccess = async (exchangeOrderId, orderMemberResults) => {
@@ -86543,6 +86562,17 @@ var init_hyperliquid_client = __esm({
                 if (input.signal?.aborted) {
                   throw input.signal.reason instanceof Error ? input.signal.reason : settlementError;
                 }
+                if (isClientExchangeMutationAuthorityConflict(
+                  settlementError.settlementCause
+                )) {
+                  if (begunMutation != null && pinnedAuthority != null) {
+                    handOffClientExchangeMutationToReconciliation(begunMutation, pinnedAuthority);
+                  }
+                  throw new RuntimeExecutionError(
+                    "Exchange submission may have completed; durable reconciliation is pending.",
+                    "outcome_unknown"
+                  );
+                }
                 await new Promise((resolve14) => {
                   let settled = false;
                   const finish = () => {
@@ -86576,7 +86606,8 @@ var init_hyperliquid_client = __esm({
                       durableMutation.mutationId,
                       {
                         phase: "send_started",
-                        clientObservedAt: (/* @__PURE__ */ new Date()).toISOString()
+                        clientObservedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                        ...pinnedAuthority ? { pinnedAuthority } : {}
                       },
                       captureController.signal,
                       ...durableMutationAuthorityArgs(durableMutation)
@@ -87453,7 +87484,7 @@ async function handOffClientRuntimeSession(profileId, payload, options) {
   );
 }
 async function beginClientRuntimeExchangeMutation(profileId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
-  const authority = resolveClientExchangeMutationAuthority(
+  const authority = payload.pinnedAuthority ?? resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
@@ -87744,7 +87775,7 @@ async function checkServerHostExecutionCapacity(profileId, plans, signal, requir
   return answer.results;
 }
 async function reportClientRuntimeExchangeAttemptTransition(profileId, mutationId, payload, signal, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
-  const authority = resolveClientExchangeMutationAuthority(
+  const authority = payload.pinnedAuthority ?? resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
@@ -87766,7 +87797,7 @@ async function reportClientRuntimeExchangeAttemptTransition(profileId, mutationI
   );
 }
 async function settleClientRuntimeExchangeMutation(profileId, mutationId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
-  const authority = resolveClientExchangeMutationAuthority(
+  const authority = payload.pinnedAuthority ?? resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
@@ -88323,7 +88354,7 @@ async function fetchClientRuntimeKillswitchContext(profileId, payload, options)
     options
   );
 }
-var clientRuntimeSecretHeaders, preferencesWriteQueue, getCopyTradingRuntimeLeaseToken, getCopyTradingSchedulerInstanceId, resolveClientRuntimeStatusViewerHeaders, CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION, CLIENT_PROTECTION_CAPABILITY_VERSION, completedDeferredClientRuntimeStops, rememberCompletedDeferredClientRuntimeStop, consumeCompletedDeferredClientRuntimeStop, toNumericProfileId, buildClientRuntimeBody, shouldAttachRuntimeIdempotencyKey, attachRuntimeLeaseHeader, attachRuntimeSchedulerInstanceHeader, resolveRuntimeLeaseToken, resolveSchedulerBoundRuntimeLeaseToken, persistRuntimeLeaseFromPayload, persistRuntimeLeaseStatusMetadata, shouldClearPersistedRuntimeLeaseOnError, createRuntimeRequestError, parseClientRuntimeRequestContext, recordRuntimeAuthFailureBreadcrumb, classifyRuntimeRequestError, annotateRuntimeRequestError, parseRuntimeRetryAfterMs, isRetryableClientRuntimeStatus, shouldRetryClientRuntimeHttpStatus, isRuntimeIdempotencyInProgressError, isRetryableRuntimeConflictError, resolveClientRuntimeRetryDelayMs, reconcilePendingClientExchangeMutation, CLIENT_RUNTIME_CLAIM_EXCHANGE_MUTATION_WAIT_CODES, CLIENT_EXCHANGE_AUTHORITY_DEVICE_KEY, CLIENT_EXCHANGE_AUTHORITY_SESSION_KEY, getOrCreateClientExchangeAuthorityIdentity, resolveClientExchangeMutationAuthority, clientExchangeMutationAuthorityBody, isPendingClientExchangeMutationError, isMissingActiveClientExchangeMutationError, clientExchangeMutationReconciliationTimers, MAX_CLIENT_EXCHANGE_RECONCILIATION_DELAY_MS, CLIENT_EXCHANGE_RECONCILIATION_CLOCK_SKEW_MS, ClientExchangeMutationRebuildRequiredError, isTerminalClientExchangeMutation, clientExchangeMutationReconciliationKey, clearScheduledClientExchangeMutationReconciliation, snapshotClientExchangeMutationReconciliationAuthority, completeClientExchangeMutationReconciliation, protectiveBoundClientExchangeMutations, rememberProtectiveBoundClientExchangeMutation, isProtectiveBoundClientExchangeMutation, postClientExchangeMutationReconciliation, scheduleClientExchangeMutationReconciliation;
+var clientRuntimeSecretHeaders, preferencesWriteQueue, getCopyTradingRuntimeLeaseToken, getCopyTradingSchedulerInstanceId, resolveClientRuntimeStatusViewerHeaders, CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION, CLIENT_PROTECTION_CAPABILITY_VERSION, completedDeferredClientRuntimeStops, rememberCompletedDeferredClientRuntimeStop, consumeCompletedDeferredClientRuntimeStop, toNumericProfileId, buildClientRuntimeBody, shouldAttachRuntimeIdempotencyKey, attachRuntimeLeaseHeader, attachRuntimeSchedulerInstanceHeader, resolveRuntimeLeaseToken, resolveSchedulerBoundRuntimeLeaseToken, persistRuntimeLeaseFromPayload, persistRuntimeLeaseStatusMetadata, shouldClearPersistedRuntimeLeaseOnError, createRuntimeRequestError, parseClientRuntimeRequestContext, recordRuntimeAuthFailureBreadcrumb, classifyRuntimeRequestError, annotateRuntimeRequestError, parseRuntimeRetryAfterMs, isRetryableClientRuntimeStatus, shouldRetryClientRuntimeHttpStatus, isRuntimeIdempotencyInProgressError, isRetryableRuntimeConflictError, resolveClientRuntimeRetryDelayMs, reconcilePendingClientExchangeMutation, CLIENT_RUNTIME_CLAIM_EXCHANGE_MUTATION_WAIT_CODES, CLIENT_EXCHANGE_AUTHORITY_DEVICE_KEY, CLIENT_EXCHANGE_AUTHORITY_SESSION_KEY, getOrCreateClientExchangeAuthorityIdentity, resolveClientExchangeMutationAuthority, pinClientExchangeMutationAuthority, CLIENT_EXCHANGE_MUTATION_AUTHORITY_MISMATCH, isClientExchangeMutationAuthorityConflict, handOffClientExchangeMutationToReconciliation, clientExchangeMutationAuthorityBody, isPendingClientExchangeMutationError, isMissingActiveClientExchangeMutationError, clientExchangeMutationReconciliationTimers, MAX_CLIENT_EXCHANGE_RECONCILIATION_DELAY_MS, CLIENT_EXCHANGE_RECONCILIATION_CLOCK_SKEW_MS, ClientExchangeMutationRebuildRequiredError, isTerminalClientExchangeMutation, clientExchangeMutationReconciliationKey, clearScheduledClientExchangeMutationReconciliation, snapshotClientExchangeMutationReconciliationAuthority, completeClientExchangeMutationReconciliation, protectiveBoundClientExchangeMutations, rememberProtectiveBoundClientExchangeMutation, isProtectiveBoundClientExchangeMutation, postClientExchangeMutationReconciliation, scheduleClientExchangeMutationReconciliation;
 var init_api2 = __esm({
   "lib/api.ts"() {
     "use strict";
@@ -88808,6 +88839,25 @@ var init_api2 = __esm({
         }
       };
     };
+    pinClientExchangeMutationAuthority = (profileId, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) => resolveClientExchangeMutationAuthority(
+      profileId,
+      requiredRuntimeSessionId,
+      explicitRuntimeLeaseToken,
+      explicitRuntimeDeviceId,
+      explicitSchedulerInstanceId
+    );
+    CLIENT_EXCHANGE_MUTATION_AUTHORITY_MISMATCH = "exchange_mutation_authority_mismatch";
+    isClientExchangeMutationAuthorityConflict = (error48) => {
+      const candidate = error48;
+      if (Number(candidate?.status) !== 409) return false;
+      if (candidate?.code === CLIENT_EXCHANGE_MUTATION_AUTHORITY_MISMATCH) return true;
+      return /does not own this exchange mutation/i.test(String(candidate?.message ?? ""));
+    };
+    handOffClientExchangeMutationToReconciliation = (mutation, authority) => scheduleClientExchangeMutationReconciliation(
+      authority.numericProfileId,
+      mutation,
+      authority.requestOptions
+    );
     clientExchangeMutationAuthorityBody = (authority) => {
       const schedulerInstanceId = String(authority.requestOptions.schedulerInstanceId ?? "").trim();
       return {
@@ -93033,8 +93083,150 @@ var init_protective_trigger_price = __esm({
   }
 });
 
+// lib/runtime/protective-stop-replacement.ts
+var STOP_REPLACED, STOP_REPLACEMENT_EXHAUSTED, STOP_REPLACEMENT_REJECTED, STOP_REPLACEMENT_NOT_LANDED, STOP_CLEANUP_IN_FLIGHT, TERMINAL_WITHOUT_FILL, CANCELLED_BY_USER, POSITION_FLAT_AFTER_TERMINAL, CAPACITY_ALREADY_ALLOCATED, TRIGGER_INVALID, POSITION_ENDED_ORDER_STATUSES, finiteOrNull, floorToLot, positiveSafeInteger, decimalOrNull, positionTolerance, protectivePositionEpisodeEnded, decideProtectiveStopReplacement;
+var init_protective_stop_replacement = __esm({
+  "lib/runtime/protective-stop-replacement.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_hyperliquid_market_symbol();
+    STOP_REPLACED = "protective_stop_replaced";
+    STOP_REPLACEMENT_EXHAUSTED = "protective_stop_replacement_exhausted";
+    STOP_REPLACEMENT_REJECTED = "protective_stop_replacement_rejected";
+    STOP_REPLACEMENT_NOT_LANDED = "protective_stop_replacement_not_landed";
+    STOP_CLEANUP_IN_FLIGHT = "protective_stop_cleanup_in_flight";
+    TERMINAL_WITHOUT_FILL = "protective_order_terminal_without_fill";
+    CANCELLED_BY_USER = "protective_order_cancelled_by_user";
+    POSITION_FLAT_AFTER_TERMINAL = "position_flat_after_protective_terminal";
+    CAPACITY_ALREADY_ALLOCATED = "protective_capacity_already_allocated";
+    TRIGGER_INVALID = "protective_trigger_invalid";
+    POSITION_ENDED_ORDER_STATUSES = /* @__PURE__ */ new Set([
+      "reduceOnlyCanceled",
+      "liquidatedCanceled"
+    ]);
+    finiteOrNull = (value) => {
+      if (value == null || typeof value === "boolean" || value === "") return null;
+      const parsed = Number(value);
+      return Number.isFinite(parsed) ? parsed : null;
+    };
+    floorToLot = (value, sizeDecimals) => {
+      const scale = 10 ** sizeDecimals;
+      const lots = Math.floor(Number((value * scale).toFixed(6)));
+      return Number((lots / scale).toFixed(sizeDecimals));
+    };
+    positiveSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+    decimalOrNull = (value) => {
+      if (typeof value === "string" && /^-?\d+(?:\.\d+)?$/.test(value.trim())) return Number(value);
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+      return null;
+    };
+    positionTolerance = (left, right) => Math.max(1e-10, Math.max(Math.abs(left), Math.abs(right)) * 1e-8);
+    protectivePositionEpisodeEnded = (input) => {
+      if (!POSITION_ENDED_ORDER_STATUSES.has(String(input.orderStatus ?? ""))) return false;
+      const statusMs = positiveSafeInteger(input.statusTimestampMs);
+      if (statusMs == null || !Array.isArray(input.fills)) return false;
+      const market = normalizeHyperliquidMarketSymbol(input.symbol);
+      const sign = input.isLong ? 1 : -1;
+      const rows = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const fill of input.fills) {
+        if (fill == null || typeof fill !== "object" || Array.isArray(fill)) return false;
+        const record5 = fill;
+        if (normalizeHyperliquidMarketSymbol(String(record5.coin ?? "")) !== market) continue;
+        const tradeId = positiveSafeInteger(record5.tid);
+        const time3 = positiveSafeInteger(record5.time);
+        const size = decimalOrNull(record5.sz);
+        const start = decimalOrNull(record5.startPosition);
+        if (tradeId == null || seen.has(tradeId) || time3 == null || record5.side !== "B" && record5.side !== "A" || size == null || size <= 0 || start == null) {
+          return false;
+        }
+        seen.add(tradeId);
+        rows.push({ time: time3, tradeId, start, end: start + (record5.side === "B" ? size : -size) });
+      }
+      rows.sort((left, right) => left.time - right.time || left.tradeId - right.tradeId);
+      for (let index = 1; index < rows.length; index += 1) {
+        const previous = rows[index - 1];
+        const current = rows[index];
+        if (Math.abs(previous.end - current.start) > positionTolerance(previous.end, current.start)) return false;
+      }
+      const before = rows.filter((row) => row.time <= statusMs);
+      const after = rows.filter((row) => row.time > statusMs);
+      const last = before[before.length - 1];
+      if (last == null || sign * last.end > positionTolerance(last.end, 0)) return false;
+      return after.some((row) => sign * row.end > positionTolerance(row.end, 0));
+    };
+    decideProtectiveStopReplacement = (input) => {
+      if (input.botCleanupInFlight) {
+        return { outcome: "defer", reasonCode: STOP_CLEANUP_IN_FLIGHT };
+      }
+      if (input.cancelledByUser) {
+        return { outcome: "not_required", reasonCode: CANCELLED_BY_USER };
+      }
+      const position = finiteOrNull(input.positionSize);
+      if (position == null) {
+        throw new Error("The live position size is required.");
+      }
+      if (position === 0) {
+        return { outcome: "not_required", reasonCode: POSITION_FLAT_AFTER_TERMINAL };
+      }
+      if (input.positionEpisodeEnded && position > 0 === input.isLong) {
+        return { outcome: "not_required", reasonCode: POSITION_FLAT_AFTER_TERMINAL };
+      }
+      if (position > 0 !== input.isLong || input.legKind !== "stop_loss") {
+        return { outcome: "manual_intervention", reasonCode: TERMINAL_WITHOUT_FILL };
+      }
+      if (input.alreadyReplaced) {
+        return { outcome: "manual_intervention", reasonCode: STOP_REPLACEMENT_EXHAUSTED };
+      }
+      const trigger = finiteOrNull(input.triggerPrice);
+      const size = finiteOrNull(input.legSize);
+      if (trigger == null || trigger <= 0 || size == null || size <= 0) {
+        return { outcome: "manual_intervention", reasonCode: TRIGGER_INVALID };
+      }
+      const covered = (finiteOrNull(input.otherLiveStopSize) ?? 0) + (finiteOrNull(input.inFlightStopSize) ?? 0);
+      const uncovered = Math.min(size, Math.max(0, Math.abs(position) - covered));
+      const planned = floorToLot(uncovered, input.sizeDecimals);
+      if (!(planned > 0)) {
+        return { outcome: "not_required", reasonCode: CAPACITY_ALREADY_ALLOCATED };
+      }
+      return { outcome: "replace", reasonCode: STOP_REPLACED, size: planned, triggerPrice: trigger };
+    };
+  }
+});
+
 // lib/runtime/runtime-execution.ts
-var clientProtectiveMutationAuthority, executionReadPriority, serverEntryLeverageAlreadyHeld, fetchClientRuntimeOpenOrders, _extractOrderResponseStates, createRuntimeId, _extractOrderId, _toExecutionMetadata, _extractClientMutationId, _stableMutationIdentity, trailingStopMemory, protectiveGroupMemory, protectiveGroupReadFailures, windowHandoffCleanupAttempts, clientRuntimeProtectionStorage, resolveClientRuntimeProtectionStorage, setClientRuntimeProtectionStorage, trailingStopStorageKey, readTrackedTrailingStops, writeTrackedTrailingStops, rememberTrailingStop, protectiveGroupStorageKey, withClientProtectivePlanSetLock, readClientProtectiveGroups, writeClientProtectiveGroups, hasClientProtectiveGroupReadFailure, readFreshClientProtectiveGroups, stableProtectionSnapshot, exactClientProtectiveGroupSnapshot, exactClientProtectiveGroupSetSnapshot, replaceExactClientProtectiveGroup, replaceExactClientProtectiveGroupSet, isClientRuntimeLeaseOwnershipError, hasClientRuntimeProtectionState, clearClientRuntimeVetoedProtectiveIntent, rethrowWindowHandoffAfterProtectiveReplacementVeto, canPersistClientProtectiveGroups, removeTrackedTrailingStop, replaceTrackedTrailingStop, replaceProtectiveLeg, replacementJournalEntryOrderId, buildProtectiveReplacementJournalGroup, isProtectiveReplacementJournalGroup, reserveProtectiveLegReplacement, ensureProtectiveReplacementJournalCompanion, buildVetoedProtectiveReplacementCleanup, assertExactProtectiveReplacementDispatchAuthority, transitionProtectiveReplacementAcknowledgement, transitionTerminalProtectiveReplacement, pendingProtectiveReplacementReport, isConfiguredProtectionRequested, protectiveAction, isExactClientPositionTpslPair, deviceOwnsClientProtectiveLegKind, isAdoptionNarrowedPositionTpslLeg, hasAmbiguousClientPositionTpslAuthority, protectiveStableShapeMatches, protectiveLiveShapeMatches, protectiveTerminalShapeMatches, cancelClientProtectiveLeg, buildPendingProtectivePlan, persistPendingClientProtectiveGroup, attachClientProtectivePlan, resolveJournaledAttachmentContinuity, recoverJournaledClientProtectiveAttachments, readPendingEntryMutation, requireClientRuntimeConfigSeconds, replacePendingEntryRecovery, recoverPendingClientProtectiveGroups, recoverPendingProtectiveReplacements, reconcileClientProtectiveGroups, cancelAllClientProtectiveGroups, tightenClientTrailingStops, throwIfAborted2, sleep2, isDefinitiveEntryRejection, resolveExchangeSizeDecimals, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, signedRemainingExposureAfterConfirmedReduction, runtimeProtectionAuthority, runtimeProtectionOwners, resolveRuntimeProtectionOwner, drainServerProtectionForRuntime, drainServerProtectionIfOwned, verifyNoLiveClientProtectiveTriggers, clientExecutionMutations, withClientExecutionMutation, allocateServerExecutionCapacity, withClientProtectiveAdoptionMutation, executeClientRuntimeDecisionLocked, SERVER_AUDIT_RECORDED_ELSEWHERE, serverExecutionAuditOutcome, executeClientRuntimeDecision, waitForFlipCloseFreshness, maintainClientRuntimeTrailingStops, listPendingClientProtectiveSymbols, listStoredClientProtectiveSymbols, hasUnresolvedClientProtectiveIdentity, resolveClientProtectiveIdentitiesForAdoption, exportClientProtectiveGroupsForAdoption, adoptionGroupKey, applyClientProtectiveAdoptionOutcomes, hasStoredClientProtectiveGroupsForWallet, hasPendingClientProtectiveGroups, recoverManualClientProtectiveGroups, clientRuntimeDecisionSizesOrders, executeClientRuntimeDecisionUnlocked, executeClientCopyTradingIntent, executeClientCopyTradingOrderAction;
+function capCopiedToActual(copied, actual) {
+  if (Math.abs(copied) <= 1e-12) return 0;
+  if (copied * actual <= 0) return 0;
+  return Math.abs(copied) > Math.abs(actual) ? actual : copied;
+}
+function adjustCopiedTarget(target, longRemovedSince, shortRemovedSince) {
+  if (target > 1e-12) return Math.max(0, target - Math.max(0, longRemovedSince));
+  if (target < -1e-12) return Math.min(0, target + Math.max(0, shortRemovedSince));
+  return 0;
+}
+function removedByCap(copied, capped) {
+  if (copied > 0) return [Math.max(0, copied - Math.max(0, capped)), 0];
+  if (copied < 0) return [0, Math.max(0, Math.min(0, capped) - copied)];
+  return [0, 0];
+}
+function positionSpaceCopyTarget(reconciliation, recordedTarget, actualPosition) {
+  if (!reconciliation || reconciliation.target_space !== "copied") return recordedTarget;
+  const copiedServer = Number(reconciliation.copied_now ?? 0) || 0;
+  const copiedNow = capCopiedToActual(copiedServer, actualPosition);
+  const [deviceLongRemoved, deviceShortRemoved] = removedByCap(copiedServer, copiedNow);
+  const longRemovedNow = (Number(reconciliation.external_long_removed_now ?? 0) || 0) + deviceLongRemoved;
+  const shortRemovedNow = (Number(reconciliation.external_short_removed_now ?? 0) || 0) + deviceShortRemoved;
+  const targetNow = adjustCopiedTarget(
+    recordedTarget,
+    longRemovedNow - (Number(reconciliation.external_long_removed_before ?? 0) || 0),
+    shortRemovedNow - (Number(reconciliation.external_short_removed_before ?? 0) || 0)
+  );
+  return actualPosition + (targetNow - copiedNow);
+}
+var clientProtectiveMutationAuthority, executionReadPriority, serverEntryLeverageAlreadyHeld, fetchClientRuntimeOpenOrders, _extractOrderResponseStates, createRuntimeId, _extractFilledSize, _extractOrderId, _toExecutionMetadata, _extractClientMutationId, _stableMutationIdentity, trailingStopMemory, protectiveGroupMemory, protectiveGroupReadFailures, windowHandoffCleanupAttempts, clientRuntimeProtectionStorage, resolveClientRuntimeProtectionStorage, setClientRuntimeProtectionStorage, trailingStopStorageKey, readTrackedTrailingStops, writeTrackedTrailingStops, rememberTrailingStop, protectiveGroupStorageKey, withClientProtectivePlanSetLock, readClientProtectiveGroups, writeClientProtectiveGroups, hasClientProtectiveGroupReadFailure, readFreshClientProtectiveGroups, stableProtectionSnapshot, exactClientProtectiveGroupSnapshot, exactClientProtectiveGroupSetSnapshot, storableClientProtectiveGroup, replaceExactClientProtectiveGroup, replaceExactClientProtectiveGroupSet, isClientRuntimeLeaseOwnershipError, hasClientRuntimeProtectionState, clearClientRuntimeVetoedProtectiveIntent, rethrowWindowHandoffAfterProtectiveReplacementVeto, canPersistClientProtectiveGroups, removeTrackedTrailingStop, replaceTrackedTrailingStop, replaceProtectiveLeg, replacementJournalEntryOrderId, buildProtectiveReplacementJournalGroup, isProtectiveReplacementJournalGroup, reserveProtectiveLegReplacement, ensureProtectiveReplacementJournalCompanion, buildVetoedProtectiveReplacementCleanup, assertExactProtectiveReplacementDispatchAuthority, transitionProtectiveReplacementAcknowledgement, transitionTerminalProtectiveReplacement, pendingProtectiveReplacementReport, isConfiguredProtectionRequested, protectiveAction, isExactClientPositionTpslPair, deviceOwnsClientProtectiveLegKind, isAdoptionNarrowedPositionTpslLeg, hasAmbiguousClientPositionTpslAuthority, protectiveStableShapeMatches, observedProtectiveGroupingMatches, protectiveLiveShapeMatches, protectiveTerminalShapeMatches, cancelClientProtectiveLeg, buildPendingProtectivePlan, persistPendingClientProtectiveGroup, storedClientProtectiveCover, attachClientProtectivePlan, resolveJournaledAttachmentContinuity, recoverJournaledClientProtectiveAttachments, readPendingEntryMutation, requireClientRuntimeConfigSeconds, replacePendingEntryRecovery, recoverPendingClientProtectiveGroups, recoverPendingProtectiveReplacements, liveProtectiveOrderShape, observedStandaloneProtectiveGroup, migrateTrackedTrailingStopsToStandalone, reconcileClientProtectiveGroups, cancelAllClientProtectiveGroups, tightenClientTrailingStops, throwIfAborted2, sleep2, isDefinitiveEntryRejection, resolveExchangeSizeDecimals, roundAssetSize, resolvePositionSize, resolveCurrentPositionSize, buildPositionSnapshot, signedRemainingExposureAfterConfirmedReduction, runtimeProtectionAuthority, runtimeProtectionOwners, resolveRuntimeProtectionOwner, drainServerProtectionForRuntime, drainServerProtectionIfOwned, verifyNoLiveClientProtectiveTriggers, clientExecutionMutations, CLIENT_EXECUTION_QUEUE_TIMEOUT_MESSAGE, withClientExecutionMutation, withClientProtectivePlanSetMutation, allocateServerExecutionCapacity, withClientProtectiveAdoptionMutation, executeClientRuntimeDecisionLocked, SERVER_AUDIT_RECORDED_ELSEWHERE, serverExecutionAuditOutcome, executeClientRuntimeDecision, waitForFlipCloseFreshness, maintainClientRuntimeTrailingStops, listPendingClientProtectiveSymbols, listStoredClientProtectiveSymbols, hasUnresolvedClientProtectiveIdentity, resolveClientProtectiveIdentitiesForAdoption, exportClientProtectiveGroupsForAdoption, adoptionGroupKey, applyClientProtectiveAdoptionOutcomes, hasStoredClientProtectiveGroupsForWallet, hasPendingClientProtectiveGroups, recoverManualClientProtectiveGroups, clientRuntimeDecisionSizesOrders, executeClientRuntimeDecisionUnlocked, executeClientCopyTradingIntent, executeClientCopyTradingOrderAction;
 var init_runtime_execution = __esm({
   "lib/runtime/runtime-execution.ts"() {
     "use strict";
@@ -93057,6 +93249,7 @@ var init_runtime_execution = __esm({
     init_network_debug();
     init_protective_trigger_price();
     init_runtime_redaction();
+    init_protective_stop_replacement();
     init_error_surface_contract();
     init_runtime_handoff();
     clientProtectiveMutationAuthority = (request) => request.mutationAuthority === "manual_session" ? {} : {
@@ -93145,6 +93338,32 @@ var init_runtime_execution = __esm({
       }
       return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
     };
+    _extractFilledSize = (value) => {
+      const seen = /* @__PURE__ */ new Set();
+      let total = 0;
+      let found = false;
+      const walk = (node) => {
+        if (node == null || typeof node !== "object" || seen.has(node)) return;
+        seen.add(node);
+        if (Array.isArray(node)) {
+          node.forEach(walk);
+          return;
+        }
+        const record5 = node;
+        const filled = record5.filled;
+        if (filled && typeof filled === "object" && !Array.isArray(filled)) {
+          const size = Number(filled.totalSz);
+          if (Number.isFinite(size) && size > 0) {
+            total += size;
+            found = true;
+          }
+          return;
+        }
+        Object.values(record5).forEach(walk);
+      };
+      walk(value);
+      return found ? total : null;
+    };
     _extractOrderId = (value) => {
       const seen = /* @__PURE__ */ new Set();
       const walk = (node) => {
@@ -93362,6 +93581,29 @@ var init_runtime_execution = __esm({
             protectiveGroupReadFailures.add(key);
             return [];
           }
+          const replacedOrderId = legRecord.replacedOrderId == null ? void 0 : Number(legRecord.replacedOrderId);
+          const userCancelledOrderId = legRecord.userCancelledOrderId == null ? void 0 : Number(legRecord.userCancelledOrderId);
+          const replaceJournalRecord = legRecord.replaceJournal;
+          let replaceJournal;
+          if (replaceJournalRecord != null) {
+            const journal = replaceJournalRecord;
+            const journalMutationId = String(journal.mutationId ?? "").trim().toLowerCase();
+            const journalCreatedAtMs = Number(journal.createdAtMs);
+            const journalObservedAtMs = journal.unknownOidObservedAtMs == null ? void 0 : Number(journal.unknownOidObservedAtMs);
+            if (typeof replaceJournalRecord !== "object" || Array.isArray(replaceJournalRecord) || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(journalMutationId) || !Number.isSafeInteger(journalCreatedAtMs) || journalCreatedAtMs <= 0 || journalObservedAtMs !== void 0 && (!Number.isSafeInteger(journalObservedAtMs) || journalObservedAtMs <= 0)) {
+              protectiveGroupReadFailures.add(key);
+              return [];
+            }
+            replaceJournal = {
+              mutationId: journalMutationId,
+              createdAtMs: journalCreatedAtMs,
+              ...journalObservedAtMs !== void 0 ? { unknownOidObservedAtMs: journalObservedAtMs } : {}
+            };
+          }
+          if (replacedOrderId !== void 0 && (!Number.isSafeInteger(replacedOrderId) || replacedOrderId <= 0) || userCancelledOrderId !== void 0 && (!Number.isSafeInteger(userCancelledOrderId) || userCancelledOrderId <= 0)) {
+            protectiveGroupReadFailures.add(key);
+            return [];
+          }
           const replacementRecord = legRecord.replacement;
           let replacement;
           if (replacementRecord != null) {
@@ -93394,6 +93636,9 @@ var init_runtime_execution = __esm({
             size,
             isTrailing: legRecord.isTrailing,
             positionTpsl: legRecord.positionTpsl === true,
+            ...replacedOrderId !== void 0 ? { replacedOrderId } : {},
+            ...replaceJournal ? { replaceJournal } : {},
+            ...userCancelledOrderId !== void 0 ? { userCancelledOrderId } : {},
             ...replacement ? { replacement } : {}
           }];
         });
@@ -93615,7 +93860,9 @@ var init_runtime_execution = __esm({
       }
     });
     exactClientProtectiveGroupSetSnapshot = (groups) => stableProtectionSnapshot(groups.map((group) => exactClientProtectiveGroupSnapshot(group)));
-    replaceExactClientProtectiveGroup = (profileId, symbol2, expected, replacement) => {
+    storableClientProtectiveGroup = (group) => group != null && group.legs.length === 0 && group.pendingEntry == null ? null : group;
+    replaceExactClientProtectiveGroup = (profileId, symbol2, expected, candidateReplacement) => {
+      const replacement = storableClientProtectiveGroup(candidateReplacement);
       const groups = readFreshClientProtectiveGroups(profileId, symbol2);
       if (hasClientProtectiveGroupReadFailure(profileId, symbol2)) return false;
       const expectedSnapshot = exactClientProtectiveGroupSnapshot(expected);
@@ -94050,6 +94297,7 @@ var init_runtime_execution = __esm({
       const observedSize = Number(shape.size);
       return String(shape.coin ?? "").trim().toUpperCase() === symbol2.trim().toUpperCase() && expectedSide.includes(String(shape.side ?? "").trim().toLowerCase()) && Number.isFinite(observedSize) && observedSize === leg.size && shape.reduceOnly === true && shape.triggerKind === leg.kind;
     };
+    observedProtectiveGroupingMatches = (observed, storedPositionTpsl) => observed === false || observed === true && storedPositionTpsl === true;
     protectiveLiveShapeMatches = (input) => {
       const { shape, symbol: symbol2, isLong, leg } = input;
       return protectiveStableShapeMatches({
@@ -94057,7 +94305,7 @@ var init_runtime_execution = __esm({
         symbol: symbol2,
         isLong,
         leg
-      }) && shape.isTrigger === true && Number.isFinite(Number(shape.triggerPrice)) && Number(shape.triggerPrice) === leg.triggerPrice && (input.requirePositionTpsl === false || shape.isPositionTpsl === (leg.positionTpsl === true));
+      }) && shape.isTrigger === true && Number.isFinite(Number(shape.triggerPrice)) && Number(shape.triggerPrice) === leg.triggerPrice && (input.requirePositionTpsl === false || observedProtectiveGroupingMatches(shape.isPositionTpsl, leg.positionTpsl));
     };
     protectiveTerminalShapeMatches = (input) => input.evidence.responseValid === true && input.evidence.orderMatches === true && input.evidence.terminal === true && protectiveStableShapeMatches({
       shape: input.evidence,
@@ -94258,6 +94506,22 @@ var init_runtime_execution = __esm({
       );
       return { group, cleanup, persistedGroupSet: persistenceFailed ? null : nextGroups };
     };
+    storedClientProtectiveCover = async (request, legs) => {
+      const cover = { sl: 0, tp: 0 };
+      if (legs.length === 0) return cover;
+      const symbol2 = request.executionContext.symbol.trim().toUpperCase();
+      const orders = await fetchClientRuntimeOpenOrders(request, "trading_reduce");
+      if (!Array.isArray(orders)) {
+        throw new Error("Malformed live protective-order snapshot.");
+      }
+      const liveOrderIds = new Set(orders.filter((order) => String(order.coin).trim().toUpperCase() === symbol2).map((order) => String(order.oid)));
+      for (const leg of legs) {
+        if (typeof leg.orderId === "string" || liveOrderIds.has(String(leg.orderId))) {
+          cover[leg.kind] += leg.size;
+        }
+      }
+      return cover;
+    };
     attachClientProtectivePlan = async (request, group, fill) => {
       const reports = [];
       const plan = group.pendingEntry;
@@ -94352,8 +94616,28 @@ var init_runtime_execution = __esm({
         return reports;
       }
       const liveExposure = Math.abs(livePositionSize);
+      let storedCover;
+      try {
+        storedCover = await storedClientProtectiveCover(
+          request,
+          existingGroups.flatMap((existing) => existing.legs)
+        );
+      } catch (error48) {
+        if (request.signal?.aborted) throw error48;
+        reports.push({
+          order_id: fill.orderId,
+          symbol: symbol2,
+          action: "PROTECTIVE_RECONCILIATION",
+          status: "failed",
+          execution_metadata: {
+            reason_code: "protective_open_orders_unresolved",
+            error: getSanitizedRuntimeErrorMessage(error48) || "Unable to read live protective orders."
+          }
+        });
+        return reports;
+      }
       const allocatedCandidates = planned.flatMap((candidate) => {
-        const allocated = existingGroups.flatMap((existing) => existing.legs).filter((leg) => leg.kind === candidate.kind).reduce((total, leg) => total + leg.size, 0);
+        const allocated = storedCover[candidate.kind];
         const size = roundAssetSize(
           Math.min(fill.filledSize, Math.max(0, liveExposure - allocated)),
           request.executionContext.sizeDecimals
@@ -94905,11 +95189,11 @@ var init_runtime_execution = __esm({
         });
       }
       canonicalRows.sort((left, right) => left.time - right.time || left.tradeId - right.tradeId);
-      const positionTolerance = (left, right) => Math.max(1e-10, Math.max(Math.abs(left), Math.abs(right)) * 1e-8);
+      const positionTolerance2 = (left, right) => Math.max(1e-10, Math.max(Math.abs(left), Math.abs(right)) * 1e-8);
       for (let index = 1; index < canonicalRows.length; index += 1) {
         const previous = canonicalRows[index - 1];
         const current = canonicalRows[index];
-        if (Math.abs(previous.endPosition - current.startPosition) > positionTolerance(previous.endPosition, current.startPosition)) {
+        if (Math.abs(previous.endPosition - current.startPosition) > positionTolerance2(previous.endPosition, current.startPosition)) {
           throw new Error("Journaled protective fill start-position continuity is unresolved.");
         }
       }
@@ -94930,14 +95214,14 @@ var init_runtime_execution = __esm({
         throw new Error("Journaled protective entry chronology is unresolved.");
       }
       const firstEntry = canonicalRows[firstEntryIndex];
-      if (options.allowOppositeStart !== true && expectedSign * firstEntry.startPosition < -positionTolerance(firstEntry.startPosition, 0)) {
+      if (options.allowOppositeStart !== true && expectedSign * firstEntry.startPosition < -positionTolerance2(firstEntry.startPosition, 0)) {
         throw new Error("Journaled protective entry start position is directionally unresolved.");
       }
       let expectedExposureEstablished = false;
       let continuityInterrupted = false;
       for (let index = firstEntryIndex; index < canonicalRows.length; index += 1) {
         const row = canonicalRows[index];
-        const tolerance = positionTolerance(row.startPosition, row.endPosition);
+        const tolerance = positionTolerance2(row.startPosition, row.endPosition);
         if (expectedSign * row.startPosition > tolerance) {
           expectedExposureEstablished = true;
         }
@@ -94951,13 +95235,13 @@ var init_runtime_execution = __esm({
       if (!Number.isFinite(computedPosition)) {
         throw new Error("Journaled protective final fill exposure is unresolved.");
       }
-      if (Math.abs(computedPosition - livePositionSize) > positionTolerance(computedPosition, livePositionSize)) {
+      if (Math.abs(computedPosition - livePositionSize) > positionTolerance2(computedPosition, livePositionSize)) {
         throw new Error("Journaled protective computed exposure does not match the fresh live position.");
       }
       if (continuityInterrupted) {
         return { disposition: "interrupted" };
       }
-      const liveDirectionMatches = group.isLong ? livePositionSize > positionTolerance(livePositionSize, 0) : livePositionSize < -positionTolerance(livePositionSize, 0);
+      const liveDirectionMatches = group.isLong ? livePositionSize > positionTolerance2(livePositionSize, 0) : livePositionSize < -positionTolerance2(livePositionSize, 0);
       if (!liveDirectionMatches) return { disposition: "exposure_ended" };
       return { disposition: "matching" };
     };
@@ -95827,7 +96111,7 @@ var init_runtime_execution = __esm({
               }
               throw new Error("Ambiguous position-TPSL replacement identity requires exact recovery.");
             }
-            const exactShapeMatches = evidence.responseValid && evidence.orderMatches && Number.isSafeInteger(replacementOrderId) && replacementOrderId > 0 && String(evidence.coin ?? "").trim().toUpperCase() === symbol2.trim().toUpperCase() && expectedSide.includes(String(evidence.side ?? "").trim().toLowerCase()) && evidence.reduceOnly === true && evidence.isTrigger === true && evidence.triggerKind === effectiveLeg.kind && evidence.isPositionTpsl === (effectiveLeg.positionTpsl === true) && evidence.originalSize != null && evidence.originalSize === replacement.size && evidence.triggerPrice != null && evidence.triggerPrice === replacement.triggerPrice;
+            const exactShapeMatches = evidence.responseValid && evidence.orderMatches && Number.isSafeInteger(replacementOrderId) && replacementOrderId > 0 && String(evidence.coin ?? "").trim().toUpperCase() === symbol2.trim().toUpperCase() && expectedSide.includes(String(evidence.side ?? "").trim().toLowerCase()) && evidence.reduceOnly === true && evidence.isTrigger === true && evidence.triggerKind === effectiveLeg.kind && observedProtectiveGroupingMatches(evidence.isPositionTpsl, effectiveLeg.positionTpsl) && evidence.originalSize != null && evidence.originalSize === replacement.size && evidence.triggerPrice != null && evidence.triggerPrice === replacement.triggerPrice;
             const fulfilledShapeMatches = Number.isSafeInteger(replacementOrderId) && replacementOrderId > 0 && classifyHyperliquidOrderStatus(evidence.orderStatus) === "filled" && evidence.fulfilled && protectiveTerminalShapeMatches({
               evidence: {
                 ...evidence,
@@ -96200,6 +96484,44 @@ var init_runtime_execution = __esm({
       }
       return reports;
     };
+    liveProtectiveOrderShape = (order) => ({
+      coin: order.coin,
+      side: order.side,
+      size: order.sz,
+      reduceOnly: order.reduce_only,
+      isTrigger: order.is_trigger,
+      triggerKind: order.trigger_kind,
+      triggerPrice: order.trigger_px,
+      isPositionTpsl: order.is_position_tpsl
+    });
+    observedStandaloneProtectiveGroup = (group, liveOrders, symbol2) => {
+      if (!group.legs.some((leg) => leg.positionTpsl === true) || group.legs.some((leg) => leg.replacement != null)) {
+        return null;
+      }
+      let standaloneObserved = false;
+      for (const leg of group.legs) {
+        const liveOrder = liveOrders.find((order) => order.oid === leg.orderId);
+        if (liveOrder == null) continue;
+        if (liveOrder.is_position_tpsl !== false) return null;
+        if (protectiveLiveShapeMatches({
+          shape: liveProtectiveOrderShape(liveOrder),
+          symbol: symbol2,
+          isLong: group.isLong,
+          leg
+        })) {
+          standaloneObserved = true;
+        }
+      }
+      return standaloneObserved ? { ...group, legs: group.legs.map((leg) => ({ ...leg, positionTpsl: false })) } : null;
+    };
+    migrateTrackedTrailingStopsToStandalone = (profileId, symbol2, group) => {
+      const orderIds = new Set(group.legs.map((leg) => String(leg.orderId)));
+      const records = readTrackedTrailingStops(profileId, symbol2);
+      if (!records.some((record5) => orderIds.has(String(record5.orderId)) && record5.positionTpsl)) {
+        return;
+      }
+      writeTrackedTrailingStops(profileId, symbol2, records.map((record5) => orderIds.has(String(record5.orderId)) ? { ...record5, positionTpsl: false } : record5));
+    };
     reconcileClientProtectiveGroups = async (request, knownPositionSize) => {
       const profileId = String(request.profileId).trim();
       const symbol2 = request.executionContext.symbol;
@@ -96245,7 +96567,8 @@ var init_runtime_execution = __esm({
         return reports;
       }
       let expectedGroupSet = reconciliationGroupSet;
-      const transitionExactGroup = (expected, replacement) => {
+      const transitionExactGroup = (expected, candidateReplacement) => {
+        const replacement = storableClientProtectiveGroup(candidateReplacement);
         if (!replaceExactClientProtectiveGroup(profileId, symbol2, expected, replacement)) {
           return false;
         }
@@ -96303,8 +96626,101 @@ var init_runtime_execution = __esm({
           }
         })));
       }
+      const resolveUnknownStopReplacement = async (group, leg) => {
+        const journal = leg.replaceJournal;
+        if (journal == null) return { leg, notLanded: false, reports: [] };
+        const waiting = (reasonCode, error48) => ({
+          leg,
+          notLanded: false,
+          reports: [{
+            order_id: null,
+            client_mutation_id: journal.mutationId,
+            symbol: symbol2,
+            action: protectiveAction(leg),
+            status: "blocked",
+            execution_metadata: { reason_code: reasonCode, ...error48 ? { error: error48 } : {} }
+          }]
+        });
+        const observedAtMs = Date.now();
+        const marginMs = requireClientRuntimeConfigSeconds(
+          request.config,
+          "client_pending_entry_never_landed_margin_seconds"
+        ) * 1e3;
+        let ledgerKind;
+        let expiresAfterMs = Number.NaN;
+        try {
+          const mutation = await getClientRuntimeExchangeMutation(request.profileId, journal.mutationId, request.signal);
+          if (mutation == null) {
+            ledgerKind = "absent";
+          } else if (mutation.operation_kind === "order" && String(mutation.client_order_id ?? "").trim().toLowerCase() === String(leg.orderId)) {
+            ledgerKind = "found";
+            expiresAfterMs = Number(mutation.exchange_expires_after_ms);
+          } else {
+            ledgerKind = "unavailable";
+          }
+        } catch (error48) {
+          if (request.signal?.aborted) throw error48;
+          ledgerKind = "unavailable";
+        }
+        let provableAtMs;
+        if (ledgerKind === "found" && Number.isSafeInteger(expiresAfterMs) && expiresAfterMs > 0) {
+          provableAtMs = expiresAfterMs + marginMs;
+        } else if (ledgerKind === "absent") {
+          const signedLifetimeSeconds = Number(
+            request.config?.client_runtime_exchange_mutation?.expires_after_seconds
+          );
+          if (!Number.isInteger(signedLifetimeSeconds) || signedLifetimeSeconds <= 0) {
+            throw new Error("Missing required client runtime config: client_runtime_exchange_mutation.expires_after_seconds");
+          }
+          provableAtMs = journal.createdAtMs + signedLifetimeSeconds * 1e3 + marginMs;
+        } else {
+          return waiting("protective_stop_replacement_unresolved", "The stop re-place ledger cannot answer yet.");
+        }
+        if (observedAtMs < provableAtMs) {
+          return waiting("protective_stop_replacement_unresolved");
+        }
+        if (journal.unknownOidObservedAtMs == null || journal.unknownOidObservedAtMs < provableAtMs) {
+          const observedLeg = {
+            ...leg,
+            replaceJournal: { ...journal, unknownOidObservedAtMs: observedAtMs }
+          };
+          const observedGroup = {
+            ...group,
+            legs: group.legs.map((candidate) => candidate.orderId === leg.orderId ? observedLeg : candidate)
+          };
+          if (!transitionExactGroup(group, observedGroup)) {
+            return waiting("protective_lifecycle_persistence_failed");
+          }
+          return { ...waiting("protective_stop_replacement_unresolved"), leg: observedLeg, group: observedGroup };
+        }
+        return { leg, notLanded: true, reports: [] };
+      };
       const inspectedGroups = [];
-      for (const group of groups) {
+      for (const observedGroup of groups) {
+        let group = observedGroup;
+        const standaloneGroup = observedStandaloneProtectiveGroup(group, liveOrders, symbol2);
+        if (standaloneGroup != null) {
+          if (!transitionExactGroup(group, standaloneGroup)) {
+            const legs2 = [];
+            for (const leg of group.legs) {
+              legs2.push({ leg, openOrder: null, state: "unresolved" });
+              reports.push({
+                order_id: String(leg.orderId),
+                symbol: symbol2,
+                action: protectiveAction(leg),
+                status: "failed",
+                execution_metadata: {
+                  reason_code: "protective_lifecycle_persistence_failed",
+                  execution_stage: "observed_standalone_grouping_migration"
+                }
+              });
+            }
+            inspectedGroups.push({ group, legs: legs2 });
+            continue;
+          }
+          migrateTrackedTrailingStopsToStandalone(profileId, symbol2, standaloneGroup);
+          group = standaloneGroup;
+        }
         let durableInspectedGroup = group;
         const legs = [];
         let ambiguousPositionTpslAuthority = hasAmbiguousClientPositionTpslAuthority(group);
@@ -96394,6 +96810,13 @@ var init_runtime_execution = __esm({
               signal: request.signal,
               orderId: leg.orderId
             });
+            if (typeof leg.orderId === "string" && leg.replaceJournal != null && evidence.responseValid && evidence.responseStatus === "unknownOid") {
+              const landing = await resolveUnknownStopReplacement(durableInspectedGroup, leg);
+              if (landing.group != null) durableInspectedGroup = landing.group;
+              legs.push({ leg: landing.leg, openOrder: null, state: landing.notLanded ? "not_landed" : "unresolved" });
+              reports.push(...landing.reports);
+              continue;
+            }
             const terminalShapeMatches = protectiveTerminalShapeMatches({
               evidence: {
                 ...evidence,
@@ -96409,7 +96832,8 @@ var init_runtime_execution = __esm({
             legs.push({
               leg: inspectedLeg,
               openOrder: resolvedOpenOrder,
-              state: evidence.responseValid && evidence.orderMatches ? evidence.fulfilled ? terminalShapeMatches ? "fulfilled" : "unresolved" : evidence.terminal ? terminalShapeMatches ? "terminal" : "unresolved" : classifyHyperliquidOrderStatus(evidence.orderStatus) === "open" ? resolvedOpenOrder == null ? "unresolved" : "open" : "unresolved" : "unresolved"
+              state: evidence.responseValid && evidence.orderMatches ? evidence.fulfilled ? terminalShapeMatches ? "fulfilled" : "unresolved" : evidence.terminal ? terminalShapeMatches ? "terminal" : "unresolved" : classifyHyperliquidOrderStatus(evidence.orderStatus) === "open" ? resolvedOpenOrder == null ? "unresolved" : "open" : "unresolved" : "unresolved",
+              ...evidence.terminal && !evidence.fulfilled ? { terminalStatus: { orderStatus: evidence.orderStatus, statusTimestampMs: evidence.statusTimestampMs ?? null } } : {}
             });
             if (evidence.responseValid && evidence.orderMatches && evidence.terminal && !terminalShapeMatches) {
               reports.push({
@@ -96473,6 +96897,336 @@ var init_runtime_execution = __esm({
         tp: exposure
       };
       const retainedGroups = expectedGroupSet.filter((group) => group.pendingEntry != null || isProtectiveReplacementJournalGroup(group));
+      let stopSizePlacedThisPass = 0;
+      const unresolvedStopSize = inspectedGroups.flatMap((candidate) => candidate.legs).filter((entry) => entry.leg.kind === "sl" && entry.state === "unresolved" && !liveOrders.some((order) => order.oid === entry.leg.orderId)).reduce((total, entry) => total + entry.leg.size, 0);
+      const lostOrderIds = new Set(
+        inspectedGroups.flatMap((candidate) => candidate.legs).filter((entry) => entry.state === "terminal").map((entry) => String(entry.leg.orderId))
+      );
+      let lostLegEvidence = null;
+      const readLostLegEvidence = () => {
+        lostLegEvidence ??= (async () => {
+          const snapshot = await fetchBrowserPositionSnapshot(
+            request.config ?? {},
+            walletAddress,
+            symbol2,
+            request.signal,
+            "trading_reconcile"
+          );
+          const positionSize = Number(snapshot.size);
+          if (!Number.isFinite(positionSize)) {
+            throw new Error("Unable to verify live position exposure for a lost protective order.");
+          }
+          const freshOrders = await fetchClientRuntimeOpenOrders(request);
+          if (!Array.isArray(freshOrders)) {
+            throw new Error("Malformed live protective-order snapshot.");
+          }
+          const freshIsLong = positionSize > 0;
+          const liveStopSize = freshOrders.filter((order) => !lostOrderIds.has(String(order.oid)) && String(order.coin).trim().toUpperCase() === symbol2.trim().toUpperCase() && order.reduce_only && order.is_trigger && order.trigger_kind === "sl" && (freshIsLong ? ["a", "sell"].includes(String(order.side).trim().toLowerCase()) : ["b", "buy"].includes(String(order.side).trim().toLowerCase()))).reduce((total, order) => total + (Number(order.sz) > 0 ? Number(order.sz) : 0), 0);
+          return { positionSize, liveStopSize };
+        })();
+        return lostLegEvidence;
+      };
+      const lostLegPositionEpisodeEnded = async (group, terminalStatus, positionSize) => {
+        if (terminalStatus == null || !POSITION_ENDED_ORDER_STATUSES.has(String(terminalStatus.orderStatus ?? "")) || positionSize === 0 || positionSize > 0 !== group.isLong) {
+          return false;
+        }
+        try {
+          const { rawFills, evidence } = await fetchBrowserUserFills({
+            publicRequestPriority: "trading_reconcile",
+            config: request.config ?? {},
+            walletAddress,
+            symbols: [symbol2],
+            forceRefresh: true,
+            signal: request.signal
+          });
+          return evidence?.exactTerminalFillEvidenceComplete === true && protectivePositionEpisodeEnded({
+            orderStatus: terminalStatus.orderStatus,
+            statusTimestampMs: terminalStatus.statusTimestampMs,
+            isLong: group.isLong,
+            symbol: symbol2,
+            fills: rawFills
+          });
+        } catch (error48) {
+          if (request.signal?.aborted) throw error48;
+          return false;
+        }
+      };
+      const resolveLostClientProtectiveLeg = async (group, leg, botCleanupInFlight, terminalStatus) => {
+        let evidence;
+        try {
+          evidence = await readLostLegEvidence();
+        } catch (error48) {
+          if (request.signal?.aborted) throw error48;
+          return {
+            retain: leg,
+            reports: [{
+              order_id: String(leg.orderId),
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "failed",
+              execution_metadata: {
+                reason_code: "protective_position_unresolved",
+                error: getSanitizedRuntimeErrorMessage(error48) || "Unable to verify live position exposure."
+              }
+            }]
+          };
+        }
+        const decision = decideProtectiveStopReplacement({
+          legKind: leg.kind === "sl" ? "stop_loss" : "take_profit",
+          isLong: group.isLong,
+          positionSize: evidence.positionSize,
+          legSize: leg.size,
+          otherLiveStopSize: evidence.liveStopSize,
+          inFlightStopSize: unresolvedStopSize + stopSizePlacedThisPass,
+          sizeDecimals: request.executionContext.sizeDecimals,
+          triggerPrice: leg.triggerPrice,
+          alreadyReplaced: leg.replacedOrderId != null,
+          botCleanupInFlight: botCleanupInFlight || leg.replacement != null,
+          cancelledByUser: leg.userCancelledOrderId != null && String(leg.userCancelledOrderId) === String(leg.orderId),
+          positionEpisodeEnded: await lostLegPositionEpisodeEnded(group, terminalStatus, evidence.positionSize)
+        });
+        const livePositionSize2 = evidence.positionSize;
+        if (decision.outcome === "defer") {
+          return {
+            retain: leg,
+            reports: [leg.replacement != null ? pendingProtectiveReplacementReport(symbol2, leg) : {
+              order_id: String(leg.orderId),
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "failed",
+              execution_metadata: { reason_code: decision.reasonCode }
+            }]
+          };
+        }
+        const withoutLeg = {
+          ...group,
+          legs: group.legs.filter((candidate) => candidate.orderId !== leg.orderId)
+        };
+        const retireLeg = (reasonCode, status, extra = {}) => {
+          if (!transitionExactGroup(group, withoutLeg)) {
+            return {
+              retain: leg,
+              reports: [{
+                order_id: String(leg.orderId),
+                symbol: symbol2,
+                action: protectiveAction(leg),
+                status: "failed",
+                execution_metadata: {
+                  reason_code: "protective_lifecycle_persistence_failed",
+                  execution_stage: "lost_protective_leg_retire"
+                }
+              }]
+            };
+          }
+          removeTrackedTrailingStop(profileId, symbol2, leg.orderId);
+          return {
+            group: withoutLeg,
+            reports: [{
+              // Trade sync stores blocked rows by order id; this placed no order.
+              order_id: status === "blocked" ? null : String(leg.orderId),
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status,
+              execution_metadata: {
+                reason_code: reasonCode,
+                trigger_price: leg.triggerPrice,
+                protected_size: leg.size,
+                live_position_size: livePositionSize2,
+                ...extra
+              }
+            }]
+          };
+        };
+        if (decision.outcome !== "replace") {
+          return retireLeg(decision.reasonCode, decision.outcome === "not_required" ? "blocked" : "failed");
+        }
+        const triggerPrice = Number(formatHyperliquidTriggerPriceWire(
+          decision.triggerPrice,
+          request.executionContext.sizeDecimals
+        ));
+        const mutationId = createRuntimeId().toLowerCase();
+        const clientOrderId = clientOrderIdForMutation(mutationId);
+        const lostOrderId = Number(leg.orderId);
+        const provisionalLeg = {
+          kind: leg.kind,
+          orderId: clientOrderId,
+          triggerPrice,
+          size: decision.size,
+          isTrailing: leg.isTrailing,
+          positionTpsl: false,
+          replacedOrderId: lostOrderId,
+          replaceJournal: { mutationId, createdAtMs: Date.now() }
+        };
+        const provisionalGroup = {
+          ...group,
+          legs: group.legs.map((candidate) => candidate.orderId === leg.orderId ? provisionalLeg : candidate)
+        };
+        if (!Number.isSafeInteger(lostOrderId) || !transitionExactGroup(group, provisionalGroup)) {
+          return {
+            retain: leg,
+            reports: [{
+              order_id: String(leg.orderId),
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "failed",
+              execution_metadata: {
+                reason_code: "protective_lifecycle_persistence_failed",
+                execution_stage: "lost_stop_replacement_journal"
+              }
+            }]
+          };
+        }
+        stopSizePlacedThisPass += decision.size;
+        let dispatchMayHaveStarted = false;
+        let response;
+        try {
+          response = await executeClientTriggerOrder({
+            profileId: request.profileId,
+            ...clientProtectiveMutationAuthority(request),
+            walletAddress: request.executionContext.walletAddress,
+            config: request.config ?? null,
+            signal: request.signal,
+            signingKey: request.signingKey,
+            onExchangeOrderDispatched: () => {
+              if (!replaceExactClientProtectiveGroupSet(profileId, symbol2, expectedGroupSet, expectedGroupSet)) {
+                throw new Error("Stop re-place dispatch authority is no longer exact.");
+              }
+              request.onExchangeOrderDispatched?.("protection");
+              dispatchMayHaveStarted = true;
+            },
+            symbol: symbol2,
+            side: group.isLong ? "sell" : "buy",
+            size: decision.size,
+            triggerPrice,
+            reduceOnly: true,
+            isTakeProfit: false,
+            triggerIsMarket: true,
+            mutationId,
+            clientOrderId
+          });
+        } catch (error48) {
+          if (error48 instanceof HyperliquidExchangeRejectionError) {
+            const rejectionProjection = projectExecutionErrorContract({ error: error48, symbol: symbol2 });
+            stopSizePlacedThisPass -= decision.size;
+            const rejectedGroup = {
+              ...provisionalGroup,
+              legs: provisionalGroup.legs.filter((candidate) => candidate.orderId !== clientOrderId)
+            };
+            const retired = transitionExactGroup(provisionalGroup, rejectedGroup);
+            if (retired) removeTrackedTrailingStop(profileId, symbol2, leg.orderId);
+            return {
+              ...retired ? { group: rejectedGroup } : { retain: provisionalLeg, group: provisionalGroup },
+              reports: [{
+                order_id: String(leg.orderId),
+                client_mutation_id: error48.clientMutationId ?? mutationId,
+                symbol: symbol2,
+                action: protectiveAction(leg),
+                status: "failed",
+                execution_metadata: {
+                  reason_code: STOP_REPLACEMENT_REJECTED,
+                  error: rejectionProjection?.message ?? getSanitizedRuntimeErrorMessage(error48) ?? "Hyperliquid rejected the stop re-place.",
+                  replaced_order_id: lostOrderId,
+                  trigger_price: triggerPrice,
+                  protected_size: decision.size,
+                  order_diagnostics: error48.orderDiagnostics
+                }
+              }]
+            };
+          }
+          if (!dispatchMayHaveStarted) {
+            stopSizePlacedThisPass -= decision.size;
+            const restored = transitionExactGroup(provisionalGroup, group);
+            if (restored && isClientRuntimeWindowHandoffBeforePlanDispatch(error48)) {
+              throw error48;
+            }
+            return {
+              retain: restored ? leg : provisionalLeg,
+              group: restored ? group : provisionalGroup,
+              reports: [{
+                order_id: String(leg.orderId),
+                client_mutation_id: mutationId,
+                symbol: symbol2,
+                action: protectiveAction(leg),
+                status: "failed",
+                execution_metadata: {
+                  reason_code: "protective_stop_replacement_unresolved",
+                  error: getSanitizedRuntimeErrorMessage(error48) || "The stop re-place was not sent."
+                }
+              }]
+            };
+          }
+          return {
+            retain: provisionalLeg,
+            group: provisionalGroup,
+            reports: [{
+              order_id: null,
+              client_mutation_id: mutationId,
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "blocked",
+              execution_metadata: {
+                reason_code: "protective_trigger_ack_unresolved",
+                replaced_order_id: lostOrderId
+              }
+            }]
+          };
+        }
+        const acknowledgement = extractCanonicalHyperliquidOrderStateAcknowledgement(response);
+        const placedOrderId = Number(acknowledgement?.orderId);
+        if (acknowledgement == null || !Number.isSafeInteger(placedOrderId) || placedOrderId <= 0) {
+          return {
+            retain: provisionalLeg,
+            group: provisionalGroup,
+            reports: [{
+              order_id: null,
+              client_mutation_id: mutationId,
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "blocked",
+              execution_metadata: {
+                reason_code: "protective_trigger_ack_unresolved",
+                replaced_order_id: lostOrderId
+              }
+            }]
+          };
+        }
+        const { replaceJournal: _landedJournal, ...landedLeg } = provisionalLeg;
+        const placedLeg = { ...landedLeg, orderId: placedOrderId };
+        const placedGroup = {
+          ...provisionalGroup,
+          legs: provisionalGroup.legs.map((candidate) => candidate.orderId === clientOrderId ? placedLeg : candidate)
+        };
+        const bound = transitionExactGroup(provisionalGroup, placedGroup);
+        if (bound && leg.isTrailing) {
+          replaceTrackedTrailingStop(profileId, symbol2, leg.orderId, {
+            orderId: placedOrderId,
+            size: decision.size,
+            triggerPrice,
+            isLong: group.isLong,
+            positionTpsl: false
+          });
+        }
+        return {
+          retain: bound ? placedLeg : provisionalLeg,
+          group: bound ? placedGroup : provisionalGroup,
+          reports: [{
+            order_id: String(placedOrderId),
+            client_mutation_id: mutationId,
+            symbol: symbol2,
+            action: protectiveAction(leg),
+            status: "executed",
+            execution_metadata: {
+              reason_code: decision.reasonCode,
+              replaced_order_id: lostOrderId,
+              trigger_price: triggerPrice,
+              protected_size: decision.size,
+              live_position_size: livePositionSize2,
+              position_tpsl: false,
+              ...acknowledgement.state === "fulfilled" ? { acknowledgement_state: "fulfilled" } : {}
+            }
+          }]
+        };
+      };
       groupLoop: for (let groupIndex = 0; groupIndex < inspectedGroups.length; groupIndex += 1) {
         const inspected = inspectedGroups[groupIndex];
         let durableGroup = inspected.group;
@@ -96498,7 +97252,25 @@ var init_runtime_execution = __esm({
         for (let entryIndex = 0; entryIndex < inspected.legs.length; entryIndex += 1) {
           const entry = inspected.legs[entryIndex];
           const { leg, openOrder, state: state2 } = entry;
-          if (state2 === "fulfilled" || state2 === "terminal" && (groupFulfilled || exposure <= 0)) {
+          if (state2 === "not_landed") {
+            removeTrackedTrailingStop(profileId, symbol2, leg.orderId);
+            reports.push({
+              order_id: null,
+              client_mutation_id: leg.replaceJournal?.mutationId,
+              symbol: symbol2,
+              action: protectiveAction(leg),
+              status: "failed",
+              execution_metadata: {
+                reason_code: STOP_REPLACEMENT_NOT_LANDED,
+                replaced_order_id: leg.replacedOrderId,
+                trigger_price: leg.triggerPrice,
+                protected_size: leg.size
+              }
+            });
+            continue;
+          }
+          const botEndedLeg = inspected.legs.some((candidate) => candidate.state === "fulfilled") || inspected.group.cleanupRequired === true || exposure <= 0;
+          if (state2 === "fulfilled" || state2 === "terminal" && botEndedLeg) {
             if (leg.replacement != null) {
               retainedLegs.push(leg);
               reports.push(pendingProtectiveReplacementReport(symbol2, leg));
@@ -96508,16 +97280,15 @@ var init_runtime_execution = __esm({
             continue;
           }
           if (state2 === "terminal") {
-            retainedLegs.push(leg);
-            reports.push({
-              order_id: String(leg.orderId),
-              symbol: symbol2,
-              action: protectiveAction(leg),
-              status: "failed",
-              execution_metadata: {
-                reason_code: "protective_terminal_without_confirmed_sibling_fill"
-              }
-            });
+            const lost = await resolveLostClientProtectiveLeg(
+              durableGroup,
+              leg,
+              inspected.group.cleanupRequired === true,
+              entry.terminalStatus
+            );
+            if (lost.retain) retainedLegs.push(lost.retain);
+            if (lost.group) durableGroup = lost.group;
+            reports.push(...lost.reports);
             continue;
           }
           const mustCancel = groupFulfilled || exposure <= 0 || durableGroup.isLong !== liveIsLong;
@@ -96552,7 +97323,7 @@ var init_runtime_execution = __esm({
           const liveSide = String(openOrder.side).trim().toLowerCase();
           const sideMatches = inspected.group.isLong ? liveSide === "a" || liveSide === "sell" : liveSide === "b" || liveSide === "buy";
           const liveTriggerKind = openOrder.trigger_kind;
-          const trusted = String(openOrder.coin).trim().toUpperCase() === symbol2.trim().toUpperCase() && sideMatches && openOrder.reduce_only && openOrder.is_trigger && Number.isFinite(liveOrderSize) && liveOrderSize > 0 && Number.isFinite(liveTriggerPrice) && liveTriggerPrice > 0 && liveTriggerKind === leg.kind && openOrder.is_position_tpsl === (leg.positionTpsl === true) && liveOrderSize === leg.size && liveTriggerPrice === leg.triggerPrice;
+          const trusted = String(openOrder.coin).trim().toUpperCase() === symbol2.trim().toUpperCase() && sideMatches && openOrder.reduce_only && openOrder.is_trigger && Number.isFinite(liveOrderSize) && liveOrderSize > 0 && Number.isFinite(liveTriggerPrice) && liveTriggerPrice > 0 && liveTriggerKind === leg.kind && observedProtectiveGroupingMatches(openOrder.is_position_tpsl, leg.positionTpsl) && liveOrderSize === leg.size && liveTriggerPrice === leg.triggerPrice;
           if (!trusted) {
             const reservedUntrustedExposure = Number.isFinite(liveOrderSize) && liveOrderSize > 0 ? Math.max(leg.size, liveOrderSize) : leg.size;
             remainingByKind[leg.kind] = Math.max(
@@ -96969,7 +97740,7 @@ var init_runtime_execution = __esm({
         const triggerPrice = Number(liveOrder.trigger_px);
         const size = Number(liveOrder.sz);
         const liveSide = String(liveOrder.side).trim().toLowerCase();
-        const isTrustedProtectiveOrder = String(liveOrder.coin).trim().toUpperCase() === symbol2.trim().toUpperCase() && (isLong ? liveSide === "a" || liveSide === "sell" : liveSide === "b" || liveSide === "buy") && liveOrder.reduce_only && liveOrder.is_trigger && liveOrder.trigger_kind === "sl" && liveOrder.is_position_tpsl === record5.positionTpsl && Number.isFinite(size) && size > 0 && Number.isFinite(triggerPrice) && triggerPrice > 0;
+        const isTrustedProtectiveOrder = String(liveOrder.coin).trim().toUpperCase() === symbol2.trim().toUpperCase() && (isLong ? liveSide === "a" || liveSide === "sell" : liveSide === "b" || liveSide === "buy") && liveOrder.reduce_only && liveOrder.is_trigger && liveOrder.trigger_kind === "sl" && observedProtectiveGroupingMatches(liveOrder.is_position_tpsl, record5.positionTpsl) && Number.isFinite(size) && size > 0 && Number.isFinite(triggerPrice) && triggerPrice > 0;
         if (isTrustedProtectiveOrder && triggerPrice === record5.triggerPrice && size === record5.size) {
           eligible.push(record5);
         } else {
@@ -97483,10 +98254,18 @@ var init_runtime_execution = __esm({
       }
     };
     clientExecutionMutations = /* @__PURE__ */ new Map();
+    CLIENT_EXECUTION_QUEUE_TIMEOUT_MESSAGE = "Another exchange action for this profile is still in progress.";
     withClientExecutionMutation = async (request, work) => {
       const key = String(request.profileId).trim();
-      const previous = clientExecutionMutations.get(key);
-      const pending3 = (previous ?? Promise.resolve()).catch(() => void 0).then(() => {
+      const previous = clientExecutionMutations.get(key) ?? Promise.resolve();
+      let abandoned = false;
+      let startTurn;
+      const turn = new Promise((resolve14) => {
+        startTurn = resolve14;
+      });
+      const pending3 = previous.catch(() => void 0).then(async () => {
+        if (abandoned) return void 0;
+        startTurn();
         throwIfAborted2(request.signal);
         if (request.shouldCancelBeforeExchangeOrderDispatch?.()) {
           throw new Error(CLIENT_RUNTIME_WINDOW_HANDOFF_BEFORE_PLAN_DISPATCH);
@@ -97494,12 +98273,46 @@ var init_runtime_execution = __esm({
         return work();
       });
       clientExecutionMutations.set(key, pending3);
+      const waitMs = runtime_policy_generated_default2.trading.engine.client_runtime.execution_mutation_queue.wait_seconds * 1e3;
       try {
+        await new Promise((resolve14, reject) => {
+          const signal = request.signal;
+          const finish = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+          };
+          const giveUp = (reason) => {
+            abandoned = true;
+            finish();
+            reject(reason);
+          };
+          const onAbort = () => giveUp(
+            signal?.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted.", "AbortError")
+          );
+          const timer = setTimeout(() => giveUp(new Error(CLIENT_EXECUTION_QUEUE_TIMEOUT_MESSAGE)), waitMs);
+          if (signal?.aborted) {
+            onAbort();
+            return;
+          }
+          signal?.addEventListener("abort", onAbort, { once: true });
+          void turn.then(() => {
+            finish();
+            resolve14();
+          });
+        });
         return await pending3;
       } finally {
-        if (clientExecutionMutations.get(key) === pending3) clientExecutionMutations.delete(key);
+        void pending3.finally(() => {
+          if (clientExecutionMutations.get(key) === pending3) clientExecutionMutations.delete(key);
+        }).catch(() => void 0);
       }
     };
+    withClientProtectivePlanSetMutation = (request, symbol2, work) => withClientProtectivePlanSetLock(
+      request.profileId,
+      symbol2,
+      () => withClientExecutionMutation(request, work),
+      request.signal
+    );
     allocateServerExecutionCapacity = async (authority, plans) => {
       if (plans.length === 0) return [];
       try {
@@ -97518,12 +98331,7 @@ var init_runtime_execution = __esm({
       }
     };
     withClientProtectiveAdoptionMutation = (profileId, work, signal) => withClientExecutionMutation({ profileId: String(profileId).trim(), signal }, work);
-    executeClientRuntimeDecisionLocked = (input) => withClientExecutionMutation(input, () => withClientProtectivePlanSetLock(
-      input.profileId,
-      input.executionContext.symbol,
-      () => executeClientRuntimeDecisionUnlocked(input),
-      input.signal
-    ));
+    executeClientRuntimeDecisionLocked = (input) => withClientProtectivePlanSetMutation(input, input.executionContext.symbol, () => executeClientRuntimeDecisionUnlocked(input));
     SERVER_AUDIT_RECORDED_ELSEWHERE = /* @__PURE__ */ new Set([
       "suppressed_duplicate_decision",
       "same_intent_cooldown",
@@ -97671,7 +98479,7 @@ var init_runtime_execution = __esm({
         await sleep2(Math.min(pollMs, remaining), input.signal);
       }
     };
-    maintainClientRuntimeTrailingStops = (request) => withClientExecutionMutation(request, () => withClientProtectivePlanSetLock(request.profileId, request.executionContext.symbol, async () => {
+    maintainClientRuntimeTrailingStops = (request) => withClientProtectivePlanSetMutation(request, request.executionContext.symbol, async () => {
       const context = request.executionContext;
       const capturedAt = Date.parse(context.decisionSnapshotCapturedAt ?? "");
       const maxAge = Number(context.executionFreshnessMaxAgeSeconds) * 1e3;
@@ -97708,7 +98516,7 @@ var init_runtime_execution = __esm({
         }
       };
       return tightenClientTrailingStops({ request: guardedRequest, currentPositionSize: context.currentPositionSize, currentPrice: context.lastPrice });
-    }, request.signal));
+    });
     listPendingClientProtectiveSymbols = (profileId) => {
       const storage3 = resolveClientRuntimeProtectionStorage();
       if (!storage3) return [];
@@ -97829,7 +98637,10 @@ var init_runtime_execution = __esm({
                 order_id: String(leg.orderId),
                 trigger_price: String(leg.triggerPrice),
                 size: String(leg.size),
-                is_trailing: leg.isTrailing
+                is_trailing: leg.isTrailing,
+                // A stop re-placed once stays re-placed once under the server.
+                ...leg.replacedOrderId != null ? { replaced_order_id: String(leg.replacedOrderId) } : {},
+                ...leg.userCancelledOrderId != null ? { user_cancelled_order_id: String(leg.userCancelledOrderId) } : {}
               })),
               ...group.pendingEntry && group.legs.length === 0 ? [
                 ...group.pendingEntry.stopLoss.enabled ? [{
@@ -97975,7 +98786,7 @@ var init_runtime_execution = __esm({
       for (const symbol2 of listPendingClientProtectiveSymbols(profileId)) {
         throwIfAborted2(input.signal);
         const retired = [];
-        const reports = await withClientExecutionMutation({ profileId, signal: input.signal }, () => withClientProtectivePlanSetLock(profileId, symbol2, async () => {
+        const reports = await withClientProtectivePlanSetMutation({ profileId, signal: input.signal }, symbol2, async () => {
           const groups = readFreshClientProtectiveGroups(profileId, symbol2);
           if (hasClientProtectiveGroupReadFailure(profileId, symbol2)) {
             return [{
@@ -98009,7 +98820,7 @@ var init_runtime_execution = __esm({
               input.reportsStale !== false
             )
           ];
-        }, input.signal));
+        });
         results.push({ symbol: symbol2, reports, ...retired.length > 0 ? { retired } : {} });
       }
       return results;
@@ -99008,13 +99819,13 @@ var init_runtime_execution = __esm({
             const livePositionSize = Number(liveSnapshot.size);
             const liveDirectionMatches = Number.isFinite(livePositionSize) && (isLong ? livePositionSize > 0 : livePositionSize < 0);
             const kind = triggerInput.isTakeProfit ? "tp" : "sl";
-            const alreadyProtected = [
-              ...readClientProtectiveGroups(
+            const alreadyProtected = (liveDirectionMatches ? (await storedClientProtectiveCover(
+              input,
+              readClientProtectiveGroups(
                 String(input.profileId).trim(),
                 input.executionContext.symbol
-              ).flatMap((group) => group.legs),
-              ...activeLegs
-            ].filter((leg2) => leg2.kind === kind).reduce((total, leg2) => total + leg2.size, 0);
+              ).flatMap((group) => group.legs)
+            ))[kind] : 0) + activeLegs.filter((leg2) => leg2.kind === kind).reduce((total, leg2) => total + leg2.size, 0);
             const liveExposure = Math.abs(livePositionSize);
             const availableExposure = Math.max(0, liveExposure - alreadyProtected);
             const legSize = roundAssetSize(
@@ -99380,9 +100191,12 @@ var init_runtime_execution = __esm({
       let maxOrderNotional = 0;
       let minOrderNotional = 0;
       let executionReferencePrice = Number(intent.source_price);
+      let dispatchedOrder = null;
       if (reconciliation && typeof reconciliation === "object" && !Array.isArray(reconciliation)) {
+        const record5 = reconciliation;
+        const copiedNowServed = typeof record5.copied_now === "number" && Number.isFinite(record5.copied_now);
         desiredPosition = Number(
-          reconciliation.desired_destination_position_after
+          record5.target_space === "copied" ? copiedNowServed ? record5.copied_target_after : Number.NaN : record5.desired_destination_position_after
         );
         maxOrderNotional = Number(
           reconciliation.max_order_notional_usdc
@@ -99427,6 +100241,11 @@ var init_runtime_execution = __esm({
           if (!Number.isFinite(executionReferencePrice) || executionReferencePrice <= 0) {
             throw new Error("Copy Trading private-node execution mark was unavailable.");
           }
+          desiredPosition = positionSpaceCopyTarget(
+            reconciliation,
+            desiredPosition,
+            actualPosition
+          );
           const liveDelta = desiredPosition - actualPosition;
           const tolerance = Math.max(1e-12, Math.abs(desiredPosition) * 1e-9);
           if (Math.abs(liveDelta) <= tolerance) {
@@ -99535,6 +100354,13 @@ var init_runtime_execution = __esm({
           intent.sanitized_metadata?.client_mutation_id,
           intent.sanitized_metadata?.client_order_id
         );
+        dispatchedOrder = {
+          quantized_size: destinationSize,
+          ...desiredPosition != null && Number.isFinite(desiredPosition) && actualPosition != null && Number.isFinite(actualPosition) ? {
+            desired_destination_position_after: desiredPosition,
+            actual_destination_position: actualPosition
+          } : {}
+        };
         const response = await executeClientMarketOrder({
           profileId: String(input.profileId),
           runtimeSessionId: input.runtimeSessionId,
@@ -99565,6 +100391,7 @@ var init_runtime_execution = __esm({
           signal: input.signal,
           onExchangeOrderDispatched: () => input.onExchangeOrderDispatched?.("action")
         });
+        const filledSize = _extractFilledSize(response);
         return {
           status: "executed",
           orderId: _extractOrderId(response),
@@ -99577,7 +100404,14 @@ var init_runtime_execution = __esm({
             quantized_size: destinationSize,
             sz_decimals: sizePrecision.sizeDecimals,
             rounding_mode: sizePrecision.roundingMode,
-            execution_reference_price: executionReferencePrice
+            execution_reference_price: executionReferencePrice,
+            // The server records the executed change in the copied-position
+            // ledger from these values.
+            ...filledSize != null ? { filled_size: filledSize } : {},
+            ...desiredPosition != null && Number.isFinite(desiredPosition) && actualPosition != null && Number.isFinite(actualPosition) ? {
+              desired_destination_position_after: desiredPosition,
+              actual_destination_position: actualPosition
+            } : {}
           }
         };
       } catch (error48) {
@@ -99587,7 +100421,10 @@ var init_runtime_execution = __esm({
         return {
           status: "failed",
           orderId: null,
-          message: error48 instanceof Error ? error48.message : "Copy Trading intent execution failed."
+          message: error48 instanceof Error ? error48.message : "Copy Trading intent execution failed.",
+          // When the order reached the exchange after all, the server recovers it
+          // from the durable mutation and records this order in the ledger.
+          ...dispatchedOrder ? { executionMetadata: dispatchedOrder } : {}
         };
       }
     };
@@ -101887,7 +102724,7 @@ var require_react = __commonJS({
 });
 
 // lib/runtime/client-runtime-status-store.ts
-var import_react, finiteOrNull, readMode, orderKey, sameOwnerSeries, hasGenerations, compareClientRuntimeStatusOrder, sameGenerations, LIVENESS_CLOCK_FIELDS, sameValue, sameVisibleState, definedFields, ClientRuntimeStatusStore, clientRuntimeStatusStore;
+var import_react, finiteOrNull2, readMode, orderKey, sameOwnerSeries, hasGenerations, compareClientRuntimeStatusOrder, sameGenerations, LIVENESS_CLOCK_FIELDS, sameValue, sameVisibleState, definedFields, ClientRuntimeStatusStore, clientRuntimeStatusStore;
 var init_client_runtime_status_store = __esm({
   "lib/runtime/client-runtime-status-store.ts"() {
     "use strict";
@@ -101896,7 +102733,7 @@ var init_client_runtime_status_store = __esm({
     init_define_VTX_PI_MODEL_POLICY();
     import_react = __toESM(require_react(), 1);
     init_status_contract();
-    finiteOrNull = (value) => {
+    finiteOrNull2 = (value) => {
       const parsed = Number(value);
       return value === null || value === void 0 || value === "" || !Number.isFinite(parsed) ? null : parsed;
     };
@@ -101905,9 +102742,9 @@ var init_client_runtime_status_store = __esm({
       return normalized === "client" || normalized === "server" ? normalized : null;
     };
     orderKey = (status) => ({
-      owner: finiteOrNull(status.owner_generation),
-      intent: finiteOrNull(status.intent_generation),
-      time: finiteOrNull(status.server_time),
+      owner: finiteOrNull2(status.owner_generation),
+      intent: finiteOrNull2(status.intent_generation),
+      time: finiteOrNull2(status.server_time),
       mode: readMode(status.execution_mode)
     });
     sameOwnerSeries = (left, right) => left.mode === null || right.mode === null || left.mode === right.mode;
@@ -103659,7 +104496,7 @@ var init_constraint_contract = __esm({
 });
 
 // lib/runtime/client-account-report.ts
-var sumPositionUnrealizedPnl2, resolveTotalUnrealizedPnl2, buildPromptParityAccountContext, finiteOrNull2, buildClientExchangeSnapshot;
+var sumPositionUnrealizedPnl2, resolveTotalUnrealizedPnl2, buildPromptParityAccountContext, finiteOrNull3, buildClientExchangeSnapshot;
 var init_client_account_report = __esm({
   "lib/runtime/client-account-report.ts"() {
     "use strict";
@@ -103709,7 +104546,7 @@ var init_client_account_report = __esm({
       }
       return context;
     };
-    finiteOrNull2 = (value) => {
+    finiteOrNull3 = (value) => {
       const parsed = Number(value);
       return Number.isFinite(parsed) ? parsed : null;
     };
@@ -103718,17 +104555,17 @@ var init_client_account_report = __esm({
       captured_at: input.capturedAt,
       wallet_address: input.walletAddress,
       symbol: input.symbol,
-      mark_price: finiteOrNull2(input.markPrice),
+      mark_price: finiteOrNull3(input.markPrice),
       effective_taker_rates: input.effectiveTakerRates,
       account_summary: {
-        account_value: finiteOrNull2(input.accountSummary.account_value),
+        account_value: finiteOrNull3(input.accountSummary.account_value),
         perp_dex_accounts: input.accountSummary.perp_dex_accounts,
-        total_margin_used: finiteOrNull2(input.accountSummary.total_margin_used),
-        available_margin: finiteOrNull2(input.accountSummary.available_margin),
-        withdrawable: finiteOrNull2(input.accountSummary.withdrawable),
-        cross_margin_ratio: finiteOrNull2(input.accountSummary.cross_margin_ratio),
-        maintenance_margin: finiteOrNull2(input.accountSummary.maintenance_margin),
-        cross_account_leverage: finiteOrNull2(input.accountSummary.cross_account_leverage),
+        total_margin_used: finiteOrNull3(input.accountSummary.total_margin_used),
+        available_margin: finiteOrNull3(input.accountSummary.available_margin),
+        withdrawable: finiteOrNull3(input.accountSummary.withdrawable),
+        cross_margin_ratio: finiteOrNull3(input.accountSummary.cross_margin_ratio),
+        maintenance_margin: finiteOrNull3(input.accountSummary.maintenance_margin),
+        cross_account_leverage: finiteOrNull3(input.accountSummary.cross_account_leverage),
         total_unrealized_pnl: resolveTotalUnrealizedPnl2(input.accountSummary, input.positions),
         account_mode: typeof input.accountSummary.account_mode === "string" ? input.accountSummary.account_mode : typeof input.accountSummary.accountMode === "string" ? input.accountSummary.accountMode : null,
         mode_source: typeof input.accountSummary.mode_source === "string" ? input.accountSummary.mode_source : typeof input.accountSummary.modeSource === "string" ? input.accountSummary.modeSource : null
@@ -103736,13 +104573,13 @@ var init_client_account_report = __esm({
       positions: input.positions.map((position) => ({
         symbol: normalizeHyperliquidMarketSymbol(position.symbol),
         size: Number(position.size) || 0,
-        entry_price: finiteOrNull2(position.entry_price),
-        unrealized_pnl: finiteOrNull2(position.unrealized_pnl),
-        realized_pnl: finiteOrNull2(position.realized_pnl),
-        leverage: finiteOrNull2(position.leverage),
-        margin_used: finiteOrNull2(position.margin_used),
-        liquidation_price: finiteOrNull2(position.liquidation_price),
-        funding_usdc: finiteOrNull2(position.funding_usdc)
+        entry_price: finiteOrNull3(position.entry_price),
+        unrealized_pnl: finiteOrNull3(position.unrealized_pnl),
+        realized_pnl: finiteOrNull3(position.realized_pnl),
+        leverage: finiteOrNull3(position.leverage),
+        margin_used: finiteOrNull3(position.margin_used),
+        liquidation_price: finiteOrNull3(position.liquidation_price),
+        funding_usdc: finiteOrNull3(position.funding_usdc)
       }))
     });
   }
@@ -116917,42 +117754,44 @@ var init_engine = __esm({
             this._deviceSecrets = postClaimSecretsState.normalized;
           }
           this._assertStartAttemptActive(startController, "post_claim_hydration");
-          const bindingPreferences = await this._awaitStartStage(
-            getFreshPreferences(
-              void 0,
-              Number(profileId),
-              void 0,
-              false,
-              { schedulerInstanceId: this._instanceId }
-            ),
-            startController,
-            "signer_binding_preferences"
-          );
-          const bindingWalletAddress = String(
-            bindingPreferences.preferences?.hyperliquid_wallet_address || ""
-          ).trim();
-          const bindingSigningKey = String(
-            this._deviceSecrets?.hyperliquidSigningKey || ""
-          ).trim();
-          if (!bindingSigningKey) {
-            throw new Error("Missing Hyperliquid signing key after runtime start.");
-          }
-          const bindingConfig = await this._awaitStartStage(
-            getLLMConfig(void 0, Number(profileId)),
-            startController,
-            "signer_binding_config"
-          );
-          await this._awaitStartStage(
-            assertBrowserHyperliquidSignerWalletBinding({
-              // Start authorizes trading: never held behind panel reads.
-              publicRequestPriority: "trading_execute",
-              signingKey: bindingSigningKey,
-              walletAddress: bindingWalletAddress,
-              config: bindingConfig
-            }),
-            startController,
-            "signer_binding"
-          );
+          if (this._expectedExecutionMode !== "server") {
+            const bindingPreferences = await this._awaitStartStage(
+              getFreshPreferences(
+                void 0,
+                Number(profileId),
+                void 0,
+                false,
+                { schedulerInstanceId: this._instanceId }
+              ),
+              startController,
+              "signer_binding_preferences"
+            );
+            const bindingWalletAddress = String(
+              bindingPreferences.preferences?.hyperliquid_wallet_address || ""
+            ).trim();
+            const bindingSigningKey = String(
+              this._deviceSecrets?.hyperliquidSigningKey || ""
+            ).trim();
+            if (!bindingSigningKey) {
+              throw new Error("Missing Hyperliquid signing key after runtime start.");
+            }
+            const bindingConfig = await this._awaitStartStage(
+              getLLMConfig(void 0, Number(profileId)),
+              startController,
+              "signer_binding_config"
+            );
+            await this._awaitStartStage(
+              assertBrowserHyperliquidSignerWalletBinding({
+                // Start authorizes trading: never held behind panel reads.
+                publicRequestPriority: "trading_execute",
+                signingKey: bindingSigningKey,
+                walletAddress: bindingWalletAddress,
+                config: bindingConfig
+              }),
+              startController,
+              "signer_binding"
+            );
+          }
           this._assertStartAttemptActive(startController, "signer_binding");
           if (this._mode === "trader" && options.claimKind === "explicit") {
             clearClientRuntimeKillswitchBlock(profileId);