@liquiditytech/rapidx-cli 1.0.30 → 1.0.32

package/dist/cli/commands/account.js

@@ -2,33 +2,36 @@ import { executeRapidXCapability, findCapabilityById, normalizeUnknownError, pub
 import { writeCliAudit } from "../audit.js";
 import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
-const ACCOUNT_CAPABILITY_BY_ACTION = {
-    overview: "account.overview",
-    balance: "account.balance",
-    "set-position-mode": "account.set-position-mode"
+const PORTFOLIO_CAPABILITY_BY_ACTION = {
+    overview: "portfolio.overview",
+    assets: "portfolio.assets",
+    statement: "portfolio.statement",
+    "user-fee-rate": "portfolio.user-fee-rate",
+    "position-bracket": "portfolio.position-bracket",
+    "set-position-mode": "portfolio.set-position-mode"
 };
-export async function runAccountCommand(action, input) {
-    const capabilityId = ACCOUNT_CAPABILITY_BY_ACTION[action];
+export async function runPortfolioCommand(action, input) {
+    const capabilityId = PORTFOLIO_CAPABILITY_BY_ACTION[action];
     if (!capabilityId) {
-        return fail("RCLI12001", `Unknown account command: ${action}`, "FAIL", `rapidx account ${action}`);
+        return fail("RCLI12001", `Unknown portfolio command: ${action}`, "FAIL", `rapidx portfolio ${action}`);
     }
     const capability = findCapabilityById(capabilityId);
     if (!capability) {
-        return fail("RCLI30002", `Missing capability: ${capabilityId}`, "FAIL", `rapidx account ${action}`);
+        return fail("RCLI30002", `Missing capability: ${capabilityId}`, "FAIL", `rapidx portfolio ${action}`);
     }
-    const blocked = enforceCliPreviewGate(capability, input, `rapidx account ${action}`);
+    const blocked = enforceCliPreviewGate(capability, input, `rapidx portfolio ${action}`);
     if (blocked) {
         return blocked;
     }
     try {
         const data = await executeRapidXCapability(capabilityId, input);
         const auditId = capability.operationType === "TRADE_WRITE"
-            ? writeCliAudit("trade-write", "PASS", { command: `rapidx account ${action}`, capabilityId })
+            ? writeCliAudit("trade-write", "PASS", { command: `rapidx portfolio ${action}`, capabilityId })
             : undefined;
-        return ok(data, `rapidx account ${action}`, "PASS", "real_tool_call", auditId);
+        return ok(data, `rapidx portfolio ${action}`, "PASS", "real_tool_call", auditId);
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI01001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx account ${action}`, publicErrorDetails(productError));
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx portfolio ${action}`, publicErrorDetails(productError));
     }
 }

package/dist/cli/commands/algo.js

@@ -4,9 +4,10 @@ import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
 const ALGO_CAPABILITY_BY_ACTION = {
     place: "algo.place",
-    amend: "algo.amend",
+    replace: "algo.replace",
     cancel: "algo.cancel",
-    list: "algo.list"
+    "open-orders": "algo.open-orders",
+    query: "algo.query"
 };
 export async function runAlgoCommand(action, input) {
     const capabilityId = ALGO_CAPABILITY_BY_ACTION[action];

package/dist/cli/commands/index.js

@@ -1,6 +1,6 @@
 import { checkInvocationMode } from "../invocation-checker.js";
 import { fail, ok } from "../envelope.js";
-import { runAccountCommand } from "./account.js";
+import { runPortfolioCommand } from "./account.js";
 import { runAlgoCommand } from "./algo.js";
 import { runAuthCheck } from "./auth.js";
 import { runConfigCommand } from "./config.js";
@@ -54,20 +54,20 @@ export async function dispatchCli(parsed) {
     if (domain === "market") {
         return runMarketCommand(action ?? "get-ticker", parsed.input);
     }
-    if (domain === "account") {
-        return runAccountCommand(action ?? "overview", parsed.input);
+    if (domain === "portfolio") {
+        return runPortfolioCommand(action ?? "overview", parsed.input);
     }
     if (domain === "order") {
-        return runOrderCommand(action ?? "list", parsed.input);
+        return runOrderCommand(action ?? "open-orders", parsed.input);
     }
     if (domain === "trade") {
         return runTradeCommand(action ?? "preview", parsed.input);
     }
     if (domain === "position") {
-        return runPositionCommand(action ?? "list", parsed.input);
+        return runPositionCommand(action ?? "query", parsed.input);
     }
     if (domain === "algo") {
-        return runAlgoCommand(subAction ?? action ?? "list", parsed.input);
+        return runAlgoCommand(subAction ?? action ?? "open-orders", parsed.input);
     }
     return fail("RCLI12001", `Unknown command: ${parsed.command}`);
 }

package/dist/cli/commands/order.js

@@ -73,8 +73,8 @@ export async function runOrderCommand(action, input) {
     }
 }
 function previewTargetForAction(action) {
-    if (action === "amend-preview") {
-        return "order.amend";
+    if (action === "replace-preview") {
+        return "order.replace";
     }
     if (action === "cancel-preview") {
         return "order.cancel";

package/dist/cli/commands/position.js

@@ -3,9 +3,11 @@ import { writeCliAudit } from "../audit.js";
 import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
 const POSITION_CAPABILITY_BY_ACTION = {
-    list: "position.list",
+    query: "position.query",
     history: "position.history",
+    "get-leverage": "position.get-leverage",
     close: "position.close",
+    "close-all": "position.close-all",
     "set-leverage": "position.set-leverage"
 };
 export async function runPositionCommand(action, input) {

package/dist/cli/help.js

@@ -18,7 +18,7 @@ export function formatCliHelp() {
         "",
         "Domains:",
         "  schema, doctor, auth, config, update, self-check, invocation",
-        "  market, account, order, trade, position, algo",
+        "  market, portfolio, order, trade, position, algo",
         "",
         "Use --input for structured JSON. Named options such as --symbol and --depth are also accepted for simple inputs."
     ].join("\n");

package/dist/core/client/capability-executor.js

@@ -19,50 +19,65 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
     }
     const client = options.client ?? new RapidXClient();
     switch (capabilityId) {
-        case "account.overview":
+        case "portfolio.overview":
             return client.get("/api/v1/trading/account");
-        case "account.balance":
-            return executeAccountBalanceCapability(client, input);
-        case "account.set-position-mode":
+        case "portfolio.assets":
+            return client.get("/api/v1/trading/portfolio/assets", optionalParams(input, ["exchangeType", "page", "pageSize"]));
+        case "portfolio.statement":
+            return client.get("/api/v1/trading/statement", statementParams(input));
+        case "portfolio.user-fee-rate":
+            return client.get("/api/v1/trading/userFeeRate");
+        case "portfolio.position-bracket":
+            return client.get("/api/v1/trading/positionBracket", symbolQueryParams(input));
+        case "portfolio.set-position-mode":
             return client.post("/api/v1/trading/account", {
                 positionMode: String(input.mode),
                 exchangeType: String(input.exchange)
             });
         case "order.place":
             return client.post("/api/v1/trading/order", orderPlaceBody(input));
-        case "order.amend":
+        case "order.replace":
             return client.put("/api/v1/trading/order", orderAmendBody(input));
         case "order.cancel":
             return executeOrderCancelCapability(client, input);
-        case "order.get":
+        case "order.cancel-all":
+            return client.delete("/api/v1/trading/cancelAll", cancelAllOrdersBody(input));
+        case "order.query":
             return client.get("/api/v1/trading/order", orderReadParams(input));
-        case "order.list":
-            return client.get("/api/v1/trading/orders", { pageSize: stringValue(input.pageSize, "1000"), ...optionalParams(input, ["symbol"]) });
+        case "order.open-orders":
+            return client.get("/api/v1/trading/orders", orderListParams(input, "1000"));
         case "order.history":
-            return client.get("/api/v1/trading/history/orders", { pageSize: stringValue(input.pageSize, "100"), ...optionalParams(input, ["symbol", "startTime", "endTime"]) });
-        case "position.list":
+            return client.get("/api/v1/trading/history/orders", orderListParams(input, "100"));
+        case "order.executions":
+            return client.get("/api/v1/trading/executions", executionParams(input));
+        case "position.query":
             return executePositionListCapability(client, input);
         case "position.history":
             return client.get("/api/v1/trading/history/position", {
                 pageSize: stringValue(input.pageSize, "100"),
                 ...positionHistoryParams(input)
             });
+        case "position.get-leverage":
+            return client.get("/api/v1/trading/perp/leverage", symbolQueryParams(input));
         case "position.close":
             return executePositionCloseCapability(client, input);
+        case "position.close-all":
+            return client.delete("/api/v1/trading/positions", closeAllPositionsBody(input));
         case "position.set-leverage":
             return client.post("/api/v1/trading/position/leverage", compactObject({
                 sym: String(input.symbol),
-                leverage: String(input.leverage),
-                positionSide: input.positionSide
+                leverage: String(input.leverage)
             }));
         case "algo.place":
             return client.post("/api/v1/algo/order", algoPlaceBody(input));
-        case "algo.amend":
+        case "algo.replace":
             return client.put("/api/v1/algo/order", algoAmendBody(input));
         case "algo.cancel":
             return client.delete("/api/v1/algo/order", optionalParams(input, ["algoOrderId", "clientOrderId"]));
-        case "algo.list":
+        case "algo.open-orders":
             return client.get("/api/v1/algo/openOrders", algoListParams(input));
+        case "algo.query":
+            return client.get("/api/v1/algo/order", optionalParams(input, ["algoOrderId", "clientOrderId", "attachedOrderId"]));
         default:
             throw new ProductError({
                 code: "RCORE30002",
@@ -133,14 +148,6 @@ async function executeMarketCapability(capabilityId, input, fetchFn) {
             throw new ProductError({ code: "RCORE30002", status: "FAIL", message: `Unknown market capability: ${capabilityId}` });
     }
 }
-function executeAccountBalanceCapability(client, input) {
-    const mode = String(input.mode ?? "portfolio").toLowerCase();
-    const params = optionalParams(input, ["currency"]);
-    if (mode === "account") {
-        return client.get("/api/v1/account/balance", params);
-    }
-    return client.get("/api/v1/trading/portfolio/assets", params);
-}
 async function executePositionListCapability(client, input) {
     const params = {};
     if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
@@ -160,7 +167,7 @@ async function executePositionCloseCapability(client, input) {
             positionSide: input.positionSide,
             maxNotional: input.maxNotional
         }),
-        readbackNote: "position.close uses RapidX close-position API; order.get reduceOnly may not reflect this close-position request. Verify final exposure with position.list.",
+        readbackNote: "position.close uses RapidX close-position API; order.query reduceOnly may not reflect this close-position request. Verify final exposure with position.query.",
         response
     };
 }
@@ -173,8 +180,8 @@ async function executeOrderCancelCapability(client, input) {
         terminalStateConfirmed,
         ...compactObject({ lastObservedOrderState }),
         recommendedAction: terminalStateConfirmed
-            ? "verify final status with order/get or order/list when needed"
-            : "poll order/get until CANCELED, REJECTED, EXPIRED, or timeout",
+            ? "verify final status with order/query or order/open-orders when needed"
+            : "poll order/query until CANCELED, REJECTED, EXPIRED, or timeout",
         response
     };
 }
@@ -286,9 +293,59 @@ function orderCancelBody(input) {
     assertValidOrderId(input.orderId);
     return optionalParams(input, ["orderId", "clientOrderId"]);
 }
+function cancelAllOrdersBody(input) {
+    const body = optionalParams(input, ["exchangeType"]);
+    if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
+        body.sym = String(input.symbol);
+    }
+    return body;
+}
 function orderReadParams(input) {
     assertOrderLookupReference(input);
-    return optionalParams(input, ["orderId", "clientOrderId", "symbol"]);
+    return {
+        ...optionalParams(input, ["orderId", "clientOrderId"]),
+        ...symbolQueryParams(input)
+    };
+}
+function orderListParams(input, defaultPageSize) {
+    return {
+        pageSize: stringValue(input.pageSize, defaultPageSize),
+        ...mappedOptionalParams(input, [
+            ["symbol", "sym"],
+            ["exchange", "exchange"],
+            ["businessType", "businessType"],
+            ["startTime", "begin"],
+            ["endTime", "end"],
+            ["page", "page"],
+            ["filterExecuted", "filterExecuted"]
+        ])
+    };
+}
+function executionParams(input) {
+    return mappedOptionalParams(input, [
+        ["orderId", "orderId"],
+        ["symbol", "sym"],
+        ["exchange", "exchange"],
+        ["businessType", "businessType"],
+        ["startTime", "begin"],
+        ["endTime", "end"],
+        ["limit", "limit"]
+    ]);
+}
+function statementParams(input) {
+    return mappedOptionalParams(input, [
+        ["coin", "coin"],
+        ["symbol", "sym"],
+        ["statementType", "statementType"],
+        ["exchange", "exchange"],
+        ["startTime", "startTime"],
+        ["endTime", "endTime"],
+        ["page", "page"],
+        ["pageSize", "pageSize"]
+    ]);
+}
+function symbolQueryParams(input) {
+    return mappedOptionalParams(input, [["symbol", "sym"]]);
 }
 function positionCloseBody(input) {
     const body = {
@@ -299,6 +356,14 @@ function positionCloseBody(input) {
     }
     return body;
 }
+function closeAllPositionsBody(input) {
+    return compactObject({
+        symList: input.symbolList,
+        positionSide: input.positionSide,
+        closeAllPos: input.closeAllPositions === undefined ? undefined : input.closeAllPositions === true ? "true" : "false",
+        exchangeType: input.exchangeType
+    });
+}
 function algoPlaceBody(input) {
     const body = {
         ...orderPlaceBody(input),
@@ -329,14 +394,21 @@ function algoAmendBody(input) {
     return body;
 }
 function algoListParams(input) {
-    const params = {};
-    if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
-        params.sym = String(input.symbol);
-    }
-    return params;
+    return mappedOptionalParams(input, [
+        ["symbol", "sym"],
+        ["exchange", "exchange"],
+        ["businessType", "businessType"],
+        ["startTime", "begin"],
+        ["endTime", "end"],
+        ["page", "page"],
+        ["pageSize", "pageSize"]
+    ]);
 }
 function positionHistoryParams(input) {
-    const params = optionalParams(input, ["startTime", "endTime"]);
+    const params = mappedOptionalParams(input, [
+        ["startTime", "begin"],
+        ["endTime", "end"]
+    ]);
     if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
         params.sym = String(input.symbol);
     }
@@ -469,6 +541,11 @@ function appendMappedOptionalParams(target, input, mappings) {
         }
     }
 }
+function mappedOptionalParams(input, mappings) {
+    const result = {};
+    appendMappedOptionalParams(result, input, mappings);
+    return result;
+}
 function omitKeys(input, keys) {
     const blocked = new Set(keys);
     return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));

package/dist/core/client/rapid-x-client.js

@@ -65,12 +65,11 @@ export class RapidXClient {
                     await delay(this.readOnlyRetryDelayMs * (2 ** (attempt - 1)));
                     continue;
                 }
-                const hint = upstreamHttpErrorHint(path, response.status, text);
                 throw new ProductError({
-                    code: upstreamHttpErrorCode(path, response.status, text),
-                    status: upstreamHttpErrorStatus(path, response.status, text),
-                    message: hint ? `RapidX upstream error ${response.status}. ${hint}` : `RapidX upstream error ${response.status}`,
-                    details: { upstreamStatus: response.status, status: response.status, body: text.slice(0, 500), attempts: attempt, ...(hint ? { hint } : {}) }
+                    code: upstreamHttpErrorCode(response.status),
+                    status: upstreamHttpErrorStatus(response.status),
+                    message: `RapidX upstream error ${response.status}`,
+                    details: { upstreamStatus: response.status, status: response.status, body: text.slice(0, 500), attempts: attempt }
                 });
             }
             if (!text) {
@@ -111,16 +110,7 @@ function resolveBaseUrl(explicitBaseUrl) {
 function firstNonEmpty(...values) {
     return values.find((value) => value !== undefined && value.length > 0);
 }
-function upstreamHttpErrorHint(path, status, body) {
-    if (isAccountBalanceScopeError(path, status, body)) {
-        return "account balance mode=account requires account-level credentials; portfolio keys should use mode=portfolio.";
-    }
-    return undefined;
-}
-function upstreamHttpErrorCode(path, status, body) {
-    if (isAccountBalanceScopeError(path, status, body)) {
-        return CORE_ERRORS.PERMISSION_SCOPE_ERROR;
-    }
+function upstreamHttpErrorCode(status) {
     if (status === 404) {
         return CORE_ERRORS.NOT_FOUND;
     }
@@ -132,28 +122,12 @@ function upstreamHttpErrorCode(path, status, body) {
     }
     return CORE_ERRORS.INVALID_CREDENTIAL;
 }
-function upstreamHttpErrorStatus(path, status, body) {
-    if (isAccountBalanceScopeError(path, status, body)) {
-        return "PERMISSION_SCOPE_ERROR";
-    }
+function upstreamHttpErrorStatus(status) {
     if (status === 404) {
         return "NOT_FOUND";
     }
     return "FAIL";
 }
-function isAccountBalanceScopeError(path, status, body) {
-    if (path !== "/api/v1/account/balance" || status < 400) {
-        return false;
-    }
-    if (status >= 500) {
-        return true;
-    }
-    const lowerBody = body.toLowerCase();
-    return lowerBody.includes("account-level")
-        || lowerBody.includes("permission scope")
-        || lowerBody.includes("credential scope")
-        || (lowerBody.includes("portfolio") && lowerBody.includes("account"));
-}
 function delay(ms) {
     if (ms <= 0) {
         return Promise.resolve();

package/dist/core/contracts/capabilities.js

@@ -17,28 +17,36 @@ export const CAPABILITIES = [
     { capabilityId: "market.mark-price", cliCommand: "rapidx market get-mark-price", mcpTool: "rapidx/market/get-mark-price", operationType: "READ", riskLevel: "read", inputSchema: "SymbolInput", outputSchema: "MarkPrice", previewRequired: false },
     { capabilityId: "market.symbol-info", cliCommand: "rapidx market get-symbol-info", mcpTool: "rapidx/market/get-symbol-info", operationType: "READ", riskLevel: "read", inputSchema: "SymbolInput", outputSchema: "SymbolInfo", previewRequired: false },
     { capabilityId: "market.open-interest", cliCommand: "rapidx market get-open-interest", mcpTool: "rapidx/market/get-open-interest", operationType: "READ", riskLevel: "read", inputSchema: "SymbolInput", outputSchema: "OpenInterest", previewRequired: false },
-    { capabilityId: "account.overview", cliCommand: "rapidx account overview", mcpTool: "rapidx/account/overview", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "EmptyInput", outputSchema: "AccountOverview", previewRequired: false },
-    { capabilityId: "account.balance", cliCommand: "rapidx account balance", mcpTool: "rapidx/account/balance", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "AccountBalanceInput", outputSchema: "AccountBalance", previewRequired: false },
-    { capabilityId: "account.set-position-mode", cliCommand: "rapidx account set-position-mode", mcpTool: "rapidx/account/set-position-mode", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "SetPositionModeInput", outputSchema: "SetPositionModeResult", previewRequired: true },
+    { capabilityId: "portfolio.overview", cliCommand: "rapidx portfolio overview", mcpTool: "rapidx/portfolio/overview", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "EmptyInput", outputSchema: "PortfolioOverview", previewRequired: false },
+    { capabilityId: "portfolio.assets", cliCommand: "rapidx portfolio assets", mcpTool: "rapidx/portfolio/assets", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "PortfolioAssetsInput", outputSchema: "PortfolioAssets", previewRequired: false },
+    { capabilityId: "portfolio.statement", cliCommand: "rapidx portfolio statement", mcpTool: "rapidx/portfolio/statement", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "StatementInput", outputSchema: "StatementResult", previewRequired: false },
+    { capabilityId: "portfolio.user-fee-rate", cliCommand: "rapidx portfolio user-fee-rate", mcpTool: "rapidx/portfolio/user-fee-rate", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "EmptyInput", outputSchema: "UserFeeRate", previewRequired: false },
+    { capabilityId: "portfolio.position-bracket", cliCommand: "rapidx portfolio position-bracket", mcpTool: "rapidx/portfolio/position-bracket", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "PositionBracketInput", outputSchema: "PositionBracket", previewRequired: false },
+    { capabilityId: "portfolio.set-position-mode", cliCommand: "rapidx portfolio set-position-mode", mcpTool: "rapidx/portfolio/set-position-mode", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "SetPositionModeInput", outputSchema: "SetPositionModeResult", previewRequired: true },
     { capabilityId: "trade.preview", cliCommand: "rapidx trade preview", mcpTool: "rapidx/trade/preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "TradePreviewInput", outputSchema: "TradePreviewResult", previewRequired: false },
     { capabilityId: "order.preview", cliCommand: "rapidx order preview", mcpTool: "rapidx/order/preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "PreviewOrderInput", outputSchema: "PreviewOrderResult", previewRequired: false },
     { capabilityId: "order.place-preview", cliCommand: "rapidx order place-preview", mcpTool: "rapidx/order/place-preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "PreviewOrderInput", outputSchema: "PreviewOrderResult", previewRequired: false },
-    { capabilityId: "order.amend-preview", cliCommand: "rapidx order amend-preview", mcpTool: "rapidx/order/amend-preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AmendOrderPreviewInput", outputSchema: "TradePreviewResult", previewRequired: false },
+    { capabilityId: "order.replace-preview", cliCommand: "rapidx order replace-preview", mcpTool: "rapidx/order/replace-preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "ReplaceOrderPreviewInput", outputSchema: "TradePreviewResult", previewRequired: false },
     { capabilityId: "order.cancel-preview", cliCommand: "rapidx order cancel-preview", mcpTool: "rapidx/order/cancel-preview", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "CancelOrderPreviewInput", outputSchema: "TradePreviewResult", previewRequired: false },
     { capabilityId: "order.place", cliCommand: "rapidx order place", mcpTool: "rapidx/order/place", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "PlaceOrderInput", outputSchema: "OrderStatusResult", previewRequired: true },
-    { capabilityId: "order.amend", cliCommand: "rapidx order amend", mcpTool: "rapidx/order/amend", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AmendOrderInput", outputSchema: "OrderStatusResult", previewRequired: true },
+    { capabilityId: "order.replace", cliCommand: "rapidx order replace", mcpTool: "rapidx/order/replace", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "ReplaceOrderInput", outputSchema: "OrderStatusResult", previewRequired: true },
     { capabilityId: "order.cancel", cliCommand: "rapidx order cancel", mcpTool: "rapidx/order/cancel", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "CancelOrderInput", outputSchema: "OrderStatusResult", previewRequired: true },
-    { capabilityId: "order.get", cliCommand: "rapidx order get", mcpTool: "rapidx/order/get", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "OrderLookupInput", outputSchema: "OrderStatusResult", previewRequired: false },
-    { capabilityId: "order.list", cliCommand: "rapidx order list", mcpTool: "rapidx/order/list", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "OrderListInput", outputSchema: "OrderList", previewRequired: false },
+    { capabilityId: "order.cancel-all", cliCommand: "rapidx order cancel-all", mcpTool: "rapidx/order/cancel-all", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "CancelAllOrdersInput", outputSchema: "CancelAllOrdersResult", previewRequired: true },
+    { capabilityId: "order.query", cliCommand: "rapidx order query", mcpTool: "rapidx/order/query", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "OrderLookupInput", outputSchema: "OrderStatusResult", previewRequired: false },
+    { capabilityId: "order.open-orders", cliCommand: "rapidx order open-orders", mcpTool: "rapidx/order/open-orders", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "OrderListInput", outputSchema: "OrderList", previewRequired: false },
     { capabilityId: "order.history", cliCommand: "rapidx order history", mcpTool: "rapidx/order/history", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "OrderHistoryInput", outputSchema: "OrderHistory", previewRequired: false },
-    { capabilityId: "position.list", cliCommand: "rapidx position list", mcpTool: "rapidx/position/list", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "PositionListInput", outputSchema: "PositionList", previewRequired: false },
+    { capabilityId: "order.executions", cliCommand: "rapidx order executions", mcpTool: "rapidx/order/executions", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "ExecutionListInput", outputSchema: "ExecutionList", previewRequired: false },
+    { capabilityId: "position.query", cliCommand: "rapidx position query", mcpTool: "rapidx/position/query", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "PositionListInput", outputSchema: "PositionList", previewRequired: false },
     { capabilityId: "position.history", cliCommand: "rapidx position history", mcpTool: "rapidx/position/history", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "PositionHistoryInput", outputSchema: "PositionHistory", previewRequired: false },
+    { capabilityId: "position.get-leverage", cliCommand: "rapidx position get-leverage", mcpTool: "rapidx/position/get-leverage", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "SymbolInput", outputSchema: "PositionLeverage", previewRequired: false },
     { capabilityId: "position.close", cliCommand: "rapidx position close", mcpTool: "rapidx/position/close", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "ClosePositionInput", outputSchema: "ClosePositionResult", previewRequired: true },
+    { capabilityId: "position.close-all", cliCommand: "rapidx position close-all", mcpTool: "rapidx/position/close-all", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "CloseAllPositionsInput", outputSchema: "CloseAllPositionsResult", previewRequired: true },
     { capabilityId: "position.set-leverage", cliCommand: "rapidx position set-leverage", mcpTool: "rapidx/position/set-leverage", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "SetLeverageInput", outputSchema: "SetLeverageResult", previewRequired: true },
     { capabilityId: "algo.place", cliCommand: "rapidx algo place", mcpTool: "rapidx/algo/place", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AlgoPlaceInput", outputSchema: "AlgoOrderStatus", previewRequired: true },
-    { capabilityId: "algo.amend", cliCommand: "rapidx algo amend", mcpTool: "rapidx/algo/amend", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AlgoAmendInput", outputSchema: "AlgoOrderStatus", previewRequired: true },
+    { capabilityId: "algo.replace", cliCommand: "rapidx algo replace", mcpTool: "rapidx/algo/replace", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AlgoReplaceInput", outputSchema: "AlgoOrderStatus", previewRequired: true },
     { capabilityId: "algo.cancel", cliCommand: "rapidx algo cancel", mcpTool: "rapidx/algo/cancel", operationType: "TRADE_WRITE", riskLevel: "trade-write", inputSchema: "AlgoCancelInput", outputSchema: "AlgoOrderStatus", previewRequired: true },
-    { capabilityId: "algo.list", cliCommand: "rapidx algo list", mcpTool: "rapidx/algo/list", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "AlgoListInput", outputSchema: "AlgoList", previewRequired: false },
+    { capabilityId: "algo.open-orders", cliCommand: "rapidx algo open-orders", mcpTool: "rapidx/algo/open-orders", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "AlgoListInput", outputSchema: "AlgoList", previewRequired: false },
+    { capabilityId: "algo.query", cliCommand: "rapidx algo query", mcpTool: "rapidx/algo/query", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "AlgoLookupInput", outputSchema: "AlgoOrderStatus", previewRequired: false },
     { capabilityId: "trading.verify", cliCommand: "rapidx self-check trade-verify", mcpTool: "rapidx/trading-verification", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "TradingVerificationInput", outputSchema: "TradingVerificationReport", previewRequired: false, containsRealOrder: true, requiresExplicitHumanConfirmation: true, confirmationMode: "internal-preview-and-parameter-bound-consent" },
     { capabilityId: "trading.verify-live", cliCommand: "rapidx trade verify-live", mcpTool: "rapidx/trade/verify-live", operationType: "TRADE_WRITE", riskLevel: "critical-trade-write", inputSchema: "TradingVerificationInput", outputSchema: "TradingVerificationReport", previewRequired: false, containsRealOrder: true, requiresExplicitHumanConfirmation: true, confirmationMode: "internal-preview-and-parameter-bound-consent" },
     { capabilityId: "invocation.check", cliCommand: "rapidx invocation check", operationType: "DIAGNOSTIC", riskLevel: "read", inputSchema: "InvocationCheckInput", outputSchema: "InvocationCompliance", previewRequired: false }

package/dist/core/contracts/compatibility.js

@@ -1,7 +1,7 @@
 import { SCHEMA_VERSION } from "./types.js";
 import { RAPIDX_VERSION } from "../version.js";
 export const RAPIDX_SKILLS_DISTRIBUTION = "github";
-export const RAPIDX_SKILLS_VERSION = "1.0.4";
+export const RAPIDX_SKILLS_VERSION = "1.0.6";
 export const RAPIDX_SKILLS_SCHEMA_VERSION = "1.0.0";
 export function buildCompatibilityReport(input = {}) {
     const checks = [

package/dist/core/contracts/input-schema.js

@@ -85,13 +85,24 @@ const targetCapabilityIdSchema = {
 };
 const orderIdSchema = {
     type: "string",
-    description: "RapidX order id returned by order.place, order.list, or order.get.",
+    description: "RapidX order id returned by order.place, order.open-orders, or order.query.",
     examples: ["2173374713391199"]
 };
-const accountBalanceModeSchema = {
+const exchangeTypeSchema = { type: "string", description: "RapidX exchange type, for example BINANCE or OKX." };
+const businessTypeSchema = { type: "string", description: "RapidX business type, for example PERP." };
+const pageSchema = { type: "number", description: "1-based page number." };
+const pageSizeSchema = { type: "number", description: "Page size." };
+const startTimeSchema = { type: "string", description: "Start timestamp accepted by the RapidX API." };
+const endTimeSchema = { type: "string", description: "End timestamp accepted by the RapidX API." };
+const coinSchema = { type: "string", description: "Asset coin, for example USDT." };
+const statementTypeSchema = { type: "string", description: "RapidX statement type filter." };
+const filterExecutedSchema = { type: "boolean", description: "Whether to filter executed order history where the endpoint supports it." };
+const closeAllPositionsSchema = { type: "boolean", description: "When true, requests RapidX to close all positions allowed by the provided filters." };
+const symbolListSchema = { type: "string", description: "Comma-separated RapidX symbols for close-all position requests." };
+const closeAllPositionSideSchema = {
     type: "string",
-    enum: ["portfolio", "account"],
-    description: "Balance source. portfolio uses /api/v1/trading/portfolio/assets; account uses /api/v1/account/balance."
+    enum: ["LONG", "SHORT", "NONE"],
+    description: "Position side for close-all. Use NONE only when the RapidX close-all endpoint accepts it for one-way mode."
 };
 const positionSideSchema = {
     type: "string",
@@ -114,8 +125,10 @@ export function inputSchemaForName(name) {
             return objectSchema({ symbol: symbolSchema, depth: numberSchema }, ["symbol"]);
         case "KlinesInput":
             return objectSchema({ symbol: symbolSchema, interval: stringSchema, limit: numberSchema }, ["symbol"]);
-        case "AccountBalanceInput":
-            return objectSchema({ mode: accountBalanceModeSchema, currency: stringSchema });
+        case "PortfolioAssetsInput":
+            return objectSchema({ exchangeType: exchangeTypeSchema, page: pageSchema, pageSize: pageSizeSchema });
+        case "PositionBracketInput":
+            return objectSchema({ symbol: symbolSchema }, ["symbol"]);
         case "OrderLookupInput":
             return {
                 ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, symbol: symbolSchema }),
@@ -123,12 +136,16 @@ export function inputSchemaForName(name) {
             };
         case "OrderListInput":
         case "OrderHistoryInput":
-            return objectSchema({ symbol: symbolSchema, pageSize: numberSchema, startTime: stringSchema, endTime: stringSchema });
+            return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema, filterExecuted: filterExecutedSchema });
+        case "ExecutionListInput":
+            return objectSchema({ orderId: orderIdSchema, symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, limit: numberSchema, startTime: startTimeSchema, endTime: endTimeSchema });
+        case "StatementInput":
+            return objectSchema({ coin: coinSchema, symbol: symbolSchema, statementType: statementTypeSchema, exchange: stringSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
         case "PositionListInput":
         case "AlgoListInput":
-            return objectSchema({ symbol: symbolSchema });
+            return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
         case "PositionHistoryInput":
-            return objectSchema({ symbol: symbolSchema, pageSize: numberSchema, startTime: stringSchema, endTime: stringSchema });
+            return objectSchema({ symbol: symbolSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
         case "TradePreviewInput":
             return objectSchema({
                 targetCapabilityId: targetCapabilityIdSchema,
@@ -184,7 +201,7 @@ export function inputSchemaForName(name) {
                 ]),
                 oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
             };
-        case "AmendOrderPreviewInput":
+        case "ReplaceOrderPreviewInput":
             return {
                 ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...automationProperties(), ...compatibilityProperties() }),
                 allOf: [
@@ -197,7 +214,7 @@ export function inputSchemaForName(name) {
                 ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...automationProperties(), ...compatibilityProperties() }),
                 anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
             };
-        case "AmendOrderInput":
+        case "ReplaceOrderInput":
             return {
                 ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]),
                 allOf: [
@@ -210,10 +227,14 @@ export function inputSchemaForName(name) {
                 ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]),
                 anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
             };
+        case "CancelAllOrdersInput":
+            return objectSchema({ exchangeType: exchangeTypeSchema, symbol: symbolSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]);
         case "ClosePositionInput":
             return objectSchema({ symbol: symbolSchema, positionSide: positionSideSchema, reduceOnly: closePositionReduceOnlySchema, maxNotional: maxNotionalSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "reduceOnly", "maxNotional", "previewId", "continueConsentId"]);
+        case "CloseAllPositionsInput":
+            return objectSchema({ symbolList: symbolListSchema, positionSide: closeAllPositionSideSchema, closeAllPositions: closeAllPositionsSchema, exchangeType: exchangeTypeSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]);
         case "SetLeverageInput":
-            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, positionSide: positionSideSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "leverage", "previewId", "continueConsentId"]);
+            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "leverage", "previewId", "continueConsentId"]);
         case "SetPositionModeInput":
             return objectSchema({ mode: { type: "string", enum: ["BOTH", "NET"] }, exchange: stringSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["mode", "exchange", "previewId", "continueConsentId"]);
         case "AlgoPlaceInput":
@@ -242,7 +263,7 @@ export function inputSchemaForName(name) {
                 ]),
                 anyOf: [{ required: ["quantity"] }, { required: ["amount"] }, { required: ["conditionType"] }]
             };
-        case "AlgoAmendInput":
+        case "AlgoReplaceInput":
             return objectSchema({
                 algoOrderId: stringSchema,
                 clientOrderId: clientOrderIdSchema,
@@ -257,6 +278,11 @@ export function inputSchemaForName(name) {
             }, ["previewId", "continueConsentId"]);
         case "AlgoCancelInput":
             return objectSchema({ algoOrderId: stringSchema, clientOrderId: clientOrderIdSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]);
+        case "AlgoLookupInput":
+            return {
+                ...objectSchema({ algoOrderId: stringSchema, clientOrderId: clientOrderIdSchema, attachedOrderId: stringSchema }),
+                anyOf: [{ required: ["algoOrderId"] }, { required: ["clientOrderId"] }, { required: ["attachedOrderId"] }]
+            };
         case "TradingVerificationInput":
             return objectSchema({
                 symbol: symbolSchema,

package/dist/core/safety/policy.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { buildCompatibilityReport } from "../contracts/compatibility.js";
 import { ProductError } from "../errors/product-error.js";
-const TRADING_DOMAINS = new Set(["account", "order", "position", "algo"]);
+const TRADING_DOMAINS = new Set(["portfolio", "order", "position", "algo"]);
 export function defaultSafetyPolicy() {
     const policy = {
         readOnly: process.env.RAPIDX_READ_ONLY === "true",
@@ -72,7 +72,7 @@ export function evaluateSafety(capability, input, policy, state = makeSafetyStat
             return { allowed: false, code: "RCORE00001", reason: "leverage must be an integer from 1 to 125.", paramsHash };
         }
     }
-    if (capability.capabilityId === "account.set-position-mode") {
+    if (capability.capabilityId === "portfolio.set-position-mode") {
         const mode = String(input.mode ?? "");
         if (mode !== "BOTH" && mode !== "NET") {
             return { allowed: false, code: "RCORE00001", reason: "mode must be BOTH or NET.", paramsHash };
@@ -124,7 +124,7 @@ function requiredTradeFields(capability, input) {
                 requireString(input, "algoType", missing);
             }
             break;
-        case "order.amend":
+        case "order.replace":
             requireOneOf(input, ["orderId", "clientOrderId"], "orderId or clientOrderId", missing);
             if (!hasString(input, "price") && !hasString(input, "quantity")) {
                 missing.push("price or quantity");
@@ -146,11 +146,15 @@ function requiredTradeFields(capability, input) {
                 missing.push("leverage");
             }
             break;
-        case "account.set-position-mode":
+        case "order.cancel-all":
+            break;
+        case "position.close-all":
+            break;
+        case "portfolio.set-position-mode":
             requireString(input, "mode", missing);
             requireString(input, "exchange", missing);
             break;
-        case "algo.amend":
+        case "algo.replace":
             requireOneOf(input, ["algoOrderId", "clientOrderId"], "algoOrderId or clientOrderId", missing);
             break;
         case "algo.cancel":

package/dist/core/self-check/live-read-only-probes.js

@@ -8,10 +8,10 @@ export function buildLiveReadOnlySelfCheck(input = {}) {
     const symbol = typeof input.symbol === "string" ? input.symbol : "BINANCE_PERP_BTC_USDT";
     const probes = {
         publicMarket: async () => executeRapidXCapability("market.ticker", { symbol }),
-        credentialAuth: async () => executeRapidXCapability("account.overview", {}),
-        accountRead: async () => executeRapidXCapability("account.balance", {}),
-        orderRead: async () => executeRapidXCapability("order.list", {}),
-        positionRead: async () => executeRapidXCapability("position.list", {})
+        credentialAuth: async () => executeRapidXCapability("portfolio.overview", {}),
+        accountRead: async () => executeRapidXCapability("portfolio.assets", {}),
+        orderRead: async () => executeRapidXCapability("order.open-orders", {}),
+        positionRead: async () => executeRapidXCapability("position.query", {})
     };
     return { credential, probes };
 }

package/dist/core/self-check/live-trading-verification-probes.js

@@ -77,7 +77,7 @@ async function buildMarketRules(input) {
     };
 }
 async function queryOrder(order) {
-    const result = await executeRapidXCapability("order.get", { orderId: order.orderId });
+    const result = await executeRapidXCapability("order.query", { orderId: order.orderId });
     const data = extractDataObject(result);
     const requestId = stringField(data, "clientOrderId") ?? order.requestId;
     return {
@@ -89,8 +89,8 @@ async function queryOrder(order) {
 async function cleanupCheck(input) {
     const symbol = typeof input.symbol === "string" ? input.symbol : "BINANCE_PERP_BTC_USDT";
     const [ordersResult, positionsResult] = await Promise.all([
-        executeRapidXCapability("order.list", { symbol, pageSize: 20 }),
-        executeRapidXCapability("position.list", { symbol })
+        executeRapidXCapability("order.open-orders", { symbol, pageSize: 20 }),
+        executeRapidXCapability("position.query", { symbol })
     ]);
     const orders = extractList(extractDataObject(ordersResult));
     const positions = extractArrayData(positionsResult);

package/dist/core/trading/preview-preflight.js

@@ -11,8 +11,8 @@ export async function runPreviewPreflight(capabilityId, input, options = {}) {
             return validateOrderPlacementPreflight(input, options);
         case "order.cancel":
             return validateOrderMutationPreflight(input, "cancel", options);
-        case "order.amend":
-            return validateOrderMutationPreflight(input, "amend", options);
+        case "order.replace":
+            return validateOrderMutationPreflight(input, "replace", options);
         case "position.close":
             return validatePositionClosePreflight(input, options);
         default:
@@ -50,7 +50,7 @@ async function validateOrderMutationPreflight(input, action, options) {
         throw new ProductError({
             code: "RCORE22004",
             status: "BLOCKED",
-            message: "ORDER_NOT_FOUND: order.get did not return an order for preview preflight."
+            message: "ORDER_NOT_FOUND: order.query did not return an order for preview preflight."
         });
     }
     const state = normalizeOrderState(order.orderState ?? order.state ?? order.status);

package/dist/core/trading/preview.js

@@ -238,7 +238,7 @@ function makeRequestSummary(capabilityId, params) {
             positionSide: params.positionSide
         });
     }
-    if (capabilityId === "account.set-position-mode") {
+    if (capabilityId === "portfolio.set-position-mode") {
         return compactRecord({
             action: "set_position_mode",
             mode: params.mode,
@@ -274,7 +274,7 @@ function makeRiskNotes(capabilityId, params, automation) {
     if (capabilityId === "position.close") {
         notes.push("Do not pass side or quantity for position.close; RapidX determines BUY or SELL from the current position and closes the target symbol/positionSide.");
         notes.push("position.close uses the RapidX close-position API and may execute as a market close with slippage.");
-        notes.push("order.get reduceOnly may not reflect the close-position API request; verify final exposure with position.list.");
+        notes.push("order.query reduceOnly may not reflect the close-position API request; verify final exposure with position.query.");
     }
     return notes;
 }

package/dist/core/trading/trading-verification.js

@@ -95,18 +95,18 @@ export async function runTradingVerification(rawInput, probes = {}) {
     }
     steps.push({ name: "query", status: "PASS", toolOrCommandEvidence: `${queried.orderId}:${queried.status}` });
     let currentOrder = queried;
-    if (probes.amendOrder) {
-        currentOrder = await probes.amendOrder(currentOrder);
-        steps.push({ name: "amend", status: currentOrder.status === "UNKNOWN" ? "NOT_VERIFIED" : "PASS", toolOrCommandEvidence: `${currentOrder.orderId}:${currentOrder.status}` });
+    if (probes.replaceOrder) {
+        currentOrder = await probes.replaceOrder(currentOrder);
+        steps.push({ name: "replace", status: currentOrder.status === "UNKNOWN" ? "NOT_VERIFIED" : "PASS", toolOrCommandEvidence: `${currentOrder.orderId}:${currentOrder.status}` });
         if (currentOrder.status === "UNKNOWN") {
-            return { submittedRealOrder: true, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE23001", errorStage: "amend", lastObservedOrderState: currentOrder.status };
+            return { submittedRealOrder: true, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE23001", errorStage: "replace", lastObservedOrderState: currentOrder.status };
         }
     }
     else {
         steps.push({
-            name: "amend",
+            name: "replace",
             status: "EXPECTED_ERROR",
-            toolOrCommandEvidence: "optional verify-live amend check skipped; order.amend remains available outside verify-live"
+            toolOrCommandEvidence: "optional verify-live replace check skipped; order.replace remains available outside verify-live"
         });
     }
     if (!probes.cancelOrder) {
@@ -122,7 +122,7 @@ export async function runTradingVerification(rawInput, probes = {}) {
     steps.push({ name: "cancel", status: "PASS", toolOrCommandEvidence: cancelConfirmation.evidence });
     if (!probes.cleanupCheck) {
         steps.push({ name: "cleanup-check", status: "NOT_VERIFIED", toolOrCommandEvidence: "cleanupCheck probe missing" });
-        return { submittedRealOrder: true, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE24002", errorStage: "cleanup-check", recommendedAction: "Query order/list and position/list before retrying verify-live." };
+        return { submittedRealOrder: true, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE24002", errorStage: "cleanup-check", recommendedAction: "Query order/open-orders and position/query before retrying verify-live." };
     }
     const cleanupConfirmation = await confirmCleanup(currentOrder, probes);
     if (!cleanupConfirmation.confirmed) {
@@ -254,7 +254,7 @@ function cleanupFailureReport(steps, previewId, errorStage, lastObservedOrderSta
         errorStage,
         ...(lastObservedOrderState ? { lastObservedOrderState } : {}),
         expectedOrderStates: ["CANCELED", "EXPIRED", "REJECTED"],
-        recommendedAction: "Query order/get, order/list, and position/list before retrying; do not submit another verification until cleanup is confirmed."
+        recommendedAction: "Query order/query, order/open-orders, and position/query before retrying; do not submit another verification until cleanup is confirmed."
     };
 }
 function quantityForNotional(minNotional, price) {

package/dist/core/version.js

@@ -1 +1 @@
-export const RAPIDX_VERSION = "1.0.30";
+export const RAPIDX_VERSION = "1.0.32";

package/dist/mcp/tool-runner.js

@@ -136,8 +136,8 @@ export async function runMcpTool(toolName, input = {}) {
     }
 }
 function concretePreviewTargetForTool(toolName) {
-    if (toolName === "rapidx/order/amend-preview") {
-        return "order.amend";
+    if (toolName === "rapidx/order/replace-preview") {
+        return "order.replace";
     }
     if (toolName === "rapidx/order/cancel-preview") {
         return "order.cancel";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liquiditytech/rapidx-cli",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "RapidX CLI, MCP server mode, registry, and release assets.",
   "type": "module",
   "private": false,

package/packages/distribution/docs/cli.md

@@ -17,9 +17,9 @@ Supported conventions:
 - Use stdin JSON when the host supports it.
 - Do not create bridge scripts.
 - Use `rapidx order place-preview` for `order.place`.
-- Use `rapidx order amend-preview` for `order.amend`.
+- Use `rapidx order replace-preview` for `order.replace`.
 - Use `rapidx order cancel-preview` for `order.cancel`.
-- Use `rapidx trade preview` with `targetCapabilityId` for non-order trade writes, including position, account, and algo writes.
+- Use `rapidx trade preview` with `targetCapabilityId` for non-order trade writes, including position, portfolio, and algo writes.
 - `rapidx trade preview` input is flat JSON; do not wrap target parameters under `params`.
 - CLI preview ids are stored in the local CLI preview store. Do not submit MCP-created preview ids through CLI.
 - Treat `maxNotional` as a safety upper bound, not as the target order amount. Check symbol `minNotional` before increasing a requested amount.
@@ -32,28 +32,28 @@ rapidx schema --json
 rapidx update check --json
 rapidx self-check --read-only --json
 rapidx self-check --read-only --check-updates --json
-rapidx account balance --input '{"mode":"portfolio"}' --json
-rapidx account balance --input '{"mode":"account"}' --json
+rapidx portfolio overview --json
+rapidx portfolio assets --input '{"exchangeType":"BINANCE"}' --json
 rapidx order place-preview --input @/absolute/path/order-preview.json --json
-rapidx order amend-preview --input @/absolute/path/order-amend-preview.json --json
+rapidx order replace-preview --input @/absolute/path/order-replace-preview.json --json
 rapidx order cancel-preview --input @/absolute/path/order-cancel-preview.json --json
 rapidx trade preview --input @/absolute/path/trade-preview.json --json
 rapidx position history --input @/absolute/path/position-history.json --json
-rapidx account set-position-mode --input @/absolute/path/set-position-mode.json --json
+rapidx portfolio set-position-mode --input @/absolute/path/set-position-mode.json --json
 ```
 
 `rapidx update check --json` reads the RapidX release manifest and caches the result locally. Use it during setup, review, or session startup. Trade submit paths should not perform a fresh network update check.
 
 `rapidx schema --json` returns `capabilities` plus `inputSchemas`. Agents should read the concrete input schema before constructing write inputs.
 
-`rapidx account balance` defaults to `mode=portfolio` and reads `/api/v1/trading/portfolio/assets`. `mode=account` reads `/api/v1/account/balance` and requires credentials with account-level permission.
+`rapidx portfolio assets` reads `/api/v1/trading/portfolio/assets`. It is the canonical CLI command for portfolio asset balances.
 
-`rapidx account set-position-mode` is a trade write. Use it only when the user explicitly asks to change account position mode. It requires a matching preview token and a `continueConsentId` before execution.
+`rapidx portfolio set-position-mode` is a trade write. Use it only when the user explicitly asks to change account position mode. It requires a matching preview token and a `continueConsentId` before execution.
 
-`rapidx order cancel` is asynchronous. A successful response can mean cancel accepted but not terminal. Poll `rapidx order get --json` when `terminalStateConfirmed=false`.
+`rapidx order cancel` is asynchronous. A successful response can mean cancel accepted but not terminal. Poll `rapidx order query --json` when `terminalStateConfirmed=false`.
 
-When using `orderId`, pass the RapidX 16-digit numeric order id. Invalid `orderId` format is rejected locally as `INVALID_INPUT`. `clientOrderId` can be used instead and does not need to satisfy the `orderId` format. Preview commands for amend/cancel perform a RapidX readback after local format validation; valid-but-missing orders return `NOT_FOUND` or a blocked non-open state.
+When using `orderId`, pass the RapidX 16-digit numeric order id. Invalid `orderId` format is rejected locally as `INVALID_INPUT`. `clientOrderId` can be used instead and does not need to satisfy the `orderId` format. Preview commands for replace/cancel perform a RapidX readback after local format validation; valid-but-missing orders return `NOT_FOUND` or a blocked non-open state.
 
 Automation mode still uses preview. Pass `automationMode=true` and the user's exact `automationConsentText` to preview only when the user has enabled automation in chat for the current scope.
 
-`rapidx position close` is a close-position action. Do not pass `side` or `quantity`; RapidX determines BUY or SELL from the current position and closes the target symbol/positionSide. Use a reduce-only order flow for partial closes. Verify the final exposure with `rapidx position list --json`, and do not rely only on `order get` to interpret the close intent.
+`rapidx position close` is a close-position action. Do not pass `side` or `quantity`; RapidX determines BUY or SELL from the current position and closes the target symbol/positionSide. Use a reduce-only order flow for partial closes. Verify the final exposure with `rapidx position query --json`, and do not rely only on `order query` to interpret the close intent.

package/packages/distribution/docs/mcp.md

@@ -28,14 +28,14 @@ Key trading tools:
 - `rapidx/update/check` reads the RapidX release manifest and returns current/latest CLI version, minimum write version, skills update advice, and upgrade commands.
 - `rapidx/self-check` can include update state when called with `{"checkUpdates": true}`.
 - `rapidx/order/preview` creates preview tokens for `order.place`.
-- `rapidx/order/place-preview`, `rapidx/order/amend-preview`, and `rapidx/order/cancel-preview` are concrete order preview aliases. Preview responses include `confirmation.submitToken`; pass it as `continueConsentId` when submitting the matching write tool.
-- `rapidx/trade/preview` creates preview tokens for non-place trade writes by `targetCapabilityId`, including position, account, and algo writes.
+- `rapidx/order/place-preview`, `rapidx/order/replace-preview`, and `rapidx/order/cancel-preview` are concrete order preview aliases. Preview responses include `confirmation.submitToken`; pass it as `continueConsentId` when submitting the matching write tool.
+- `rapidx/trade/preview` creates preview tokens for non-place trade writes by `targetCapabilityId`, including position, portfolio, and algo writes.
 - Preview ids are local to the running MCP server. Do not submit a CLI-created preview id through MCP, and do not submit an MCP-created preview id through CLI.
-- `rapidx/order/cancel` returns cancel acceptance plus terminal-state guidance. Poll `rapidx/order/get` when `terminalStateConfirmed=false`.
+- `rapidx/order/cancel` returns cancel acceptance plus terminal-state guidance. Poll `rapidx/order/query` when `terminalStateConfirmed=false`.
 - Automation mode still uses preview. Set `automationMode=true` and pass the user's exact `automationConsentText` only when the user has enabled automation in chat for the current scope.
 - `rapidx/position/history` reads historical positions.
 - Hedge-mode order placement and verification use `positionSide="LONG"` or `positionSide="SHORT"` in the order or verify-live input. Do not use account mode switching as a substitute for order-level `positionSide`.
-- `rapidx/account/set-position-mode` changes account position mode and requires preview plus explicit continuation consent. Use it only when the user explicitly asks to change account position mode.
+- `rapidx/portfolio/set-position-mode` changes account position mode and requires preview plus explicit continuation consent. Use it only when the user explicitly asks to change account position mode.
 - `rapidx/trade/verify-live` runs the optional small real-trade verification flow with `explicitUserConsent` and parameter-bound `acceptedRiskText`; it creates its own internal preview and does not accept an external `previewId`. If `positionSide` is provided, `acceptedRiskText` must include that position side. `rapidx/trading-verification` remains supported as a compatibility alias.
 
 Agents must discover the full tool list through `rapidx/tools` and must not invent tool names.

package/packages/distribution/docs/quickstart.md

@@ -111,15 +111,15 @@ Do not treat a missing real call as success. The correct status is `NOT_VERIFIED
 rapidx schema --json
 ```
 
-For trade writes, create a preview before submit. Use `rapidx order place-preview` for `order.place`, `rapidx order amend-preview` for `order.amend`, and `rapidx order cancel-preview` for `order.cancel`. Use flat JSON with `rapidx trade preview` and `targetCapabilityId` for non-order writes such as `position.set-leverage`, `position.close`, or `account.set-position-mode`.
+For trade writes, create a preview before submit. Use `rapidx order place-preview` for `order.place`, `rapidx order replace-preview` for `order.replace`, and `rapidx order cancel-preview` for `order.cancel`. Use flat JSON with `rapidx trade preview` and `targetCapabilityId` for non-order writes such as `position.set-leverage`, `position.close`, or `portfolio.set-position-mode`.
 
-`rapidx schema --json` and `rapidx/tools` return concrete `inputSchemas`. For hedge-mode orders, use `positionSide="LONG"` or `positionSide="SHORT"` in the order or verify-live input. Use `account.set-position-mode` only when the user explicitly asks to change account mode.
+`rapidx schema --json` and `rapidx/tools` return concrete `inputSchemas`. For hedge-mode orders, use `positionSide="LONG"` or `positionSide="SHORT"` in the order or verify-live input. Use `portfolio.set-position-mode` only when the user explicitly asks to change account mode.
 
 For clearer order flows, prefer the explicit aliases:
 
 ```bash
 rapidx order place-preview --input '{"symbol":"BINANCE_PERP_BTC_USDT","side":"BUY","orderType":"LIMIT","price":"65000","quantity":"0.001","maxNotional":"100","clientOrderId":"example-001"}' --json
-rapidx order amend-preview --input '{"orderId":"<order-id>","price":"64900"}' --json
+rapidx order replace-preview --input '{"orderId":"<order-id>","price":"64900"}' --json
 rapidx order cancel-preview --input '{"orderId":"<order-id>"}' --json
 rapidx trade preview --input '{"targetCapabilityId":"position.set-leverage","symbol":"BINANCE_PERP_BTC_USDT","leverage":5}' --json
 ```
@@ -128,10 +128,10 @@ When submitting the actual write, pass the returned `previewId` and use `confirm
 
 Preview ids are runtime-local. Submit MCP previews through the same MCP server runtime, and submit CLI previews through the same CLI preview store.
 
-`order.cancel` is asynchronous. If the cancel result says `terminalStateConfirmed=false`, poll `order get` until a terminal state before claiming that the order is cancelled.
+`order.cancel` is asynchronous. If the cancel result says `terminalStateConfirmed=false`, poll `order query` until a terminal state before claiming that the order is cancelled.
 
 For automation, keep the preview-first flow. Use `automationMode=true` and the user's exact `automationConsentText` only after the user has enabled RapidX automation mode in chat for the current scope.
 
-`maxNotional` is a safety upper bound, not the target order amount. If a requested amount is below the symbol `minNotional`, ask the user to confirm the larger amount before submitting. For `position.close`, do not pass `side` or `quantity`; RapidX determines the close side from the current position and closes the target symbol/positionSide. Use a reduce-only order flow for partial closes, then check final exposure with `position list`.
+`maxNotional` is a safety upper bound, not the target order amount. If a requested amount is below the symbol `minNotional`, ask the user to confirm the larger amount before submitting. For `position.close`, do not pass `side` or `quantity`; RapidX determines the close side from the current position and closes the target symbol/positionSide. Use a reduce-only order flow for partial closes, then check final exposure with `position query`.
 
 Use `rapidx trade verify-live --json` only when the user explicitly authorizes a small real-trade verification. Include `acceptedRiskText` that names the exact symbol, side, positionSide when provided, maxNotional, real-order risk, and cancel cleanup behavior. The older `rapidx self-check trade-verify --json` command remains supported for compatibility.

package/packages/distribution/docs/self-check.md

@@ -1,6 +1,6 @@
 # Self-check
 
-Read-only self-check verifies discovery, schema compatibility, public market access, credential auth, account or balance read, order list, and position list when probes are available.
+Read-only self-check verifies discovery, schema compatibility, public market access, credential auth, portfolio assets, order open-orders, and position query when probes are available.
 
 The self-check must never submit an order.
 

package/packages/distribution/docs/tools.md

@@ -12,17 +12,19 @@ The canonical source is `rapidx schema --json` or `rapidx/tools`.
 
 - `rapidx/order/preview`: preview for `order.place`.
 - `rapidx/order/place-preview`: explicit alias for `order.place` preview. It returns `previewId` plus `confirmation.submitToken`.
-- `rapidx/order/amend-preview`: explicit alias for `order.amend` preview. Submit `rapidx/order/amend` with unchanged parameters, `previewId`, and `continueConsentId=confirmation.submitToken`.
+- `rapidx/order/replace-preview`: explicit alias for `order.replace` preview. Submit `rapidx/order/replace` with unchanged parameters, `previewId`, and `continueConsentId=confirmation.submitToken`.
 - `rapidx/order/cancel-preview`: explicit alias for `order.cancel` preview. Submit `rapidx/order/cancel` with unchanged parameters, `previewId`, and `continueConsentId=confirmation.submitToken`.
-- `rapidx/trade/preview`: generic preview for non-place trade writes, including position writes, account writes, and algo writes. Pass `targetCapabilityId`, then submit the target tool with unchanged parameters, `previewId`, and `continueConsentId`.
+- `rapidx/trade/preview`: generic preview for non-place trade writes, including position writes, portfolio writes, and algo writes. Pass `targetCapabilityId`, then submit the target tool with unchanged parameters, `previewId`, and `continueConsentId`.
 
 ## Read Tools
 
 - Market reads: ticker, orderbook, klines, funding rate, mark price, symbol info, and open interest.
-- Account reads: overview and balance.
-- Order reads: get, list, and history.
-- Position reads: list and position history.
-- Algo reads: list.
+- Portfolio reads: overview, assets, statement, user fee rate, and position bracket.
+- Order reads: query, open-orders, history, and executions.
+- Position reads: query, position history, and get-leverage.
+- Algo reads: open-orders and query.
+
+`open-orders` means current non-terminal orders, not "open an order". These orders may still be fillable, replaceable, or cancelable. `algo/open-orders` means current non-terminal algo orders such as conditional or TPSL orders that have not triggered, been canceled, or otherwise ended.
 
 ## Symbol Format
 
@@ -38,26 +40,26 @@ Public market adapters may call venue APIs with official venue symbols such as `
 
 ## Write Tools
 
-- Order writes: place, amend, and cancel.
-- Position writes: close and set leverage.
-- Account writes: set position mode.
-- Algo writes: place, amend, and cancel.
+- Order writes: place, replace, cancel, and cancel-all.
+- Position writes: close, close-all, and set leverage.
+- Portfolio writes: set position mode.
+- Algo writes: place, replace, and cancel.
 - Live verification: `rapidx/trade/verify-live` is the clearer alias for the small real-trade verification flow. It submits a real verification order and requires `acceptedRiskText` bound to the exact symbol, side, maxNotional, real-order risk, and cancel cleanup behavior. If `positionSide` is provided, `acceptedRiskText` must include it. `rapidx/trading-verification` remains supported for compatibility.
 
 All write tools require preview where the schema marks `previewRequired: true`.
 MARKET order writes are allowed after preview and consent. Preview includes immediate-execution and slippage risk notes; do not replace MARKET with a synthetic limit strategy unless the user explicitly asks for that order style.
 
-For hedge-mode order placement, pass `positionSide="LONG"` or `positionSide="SHORT"` on the order or verify-live input. Use `account.set-position-mode` only when the user explicitly asks to change the account position mode.
+For hedge-mode order placement, pass `positionSide="LONG"` or `positionSide="SHORT"` on the order or verify-live input. Use `portfolio.set-position-mode` only when the user explicitly asks to change the account position mode.
 
 Preview ids are runtime-local. A preview created by MCP must be submitted through the same MCP server runtime. A preview created by CLI must be submitted through the same CLI preview store. Do not mix MCP preview ids with CLI submit commands, or the reverse.
 
-`order.cancel` is asynchronous. A successful cancel response means the cancel request was accepted; it may not prove a terminal order state yet. The response includes `cancelAccepted`, `terminalStateConfirmed`, `lastObservedOrderState`, and `recommendedAction`. Poll `order.get` until `CANCELED`, `REJECTED`, `EXPIRED`, or timeout when `terminalStateConfirmed=false`.
+`order.cancel` is asynchronous. A successful cancel response means the cancel request was accepted; it may not prove a terminal order state yet. The response includes `cancelAccepted`, `terminalStateConfirmed`, `lastObservedOrderState`, and `recommendedAction`. Poll `order.query` until `CANCELED`, `REJECTED`, `EXPIRED`, or timeout when `terminalStateConfirmed=false`.
 
-Order identifiers use two validation layers. If `orderId` is provided, RapidX validates it locally as a 16-digit numeric id and returns `INVALID_INPUT` before any upstream call when the format is wrong. If `clientOrderId` is provided instead, do not apply `orderId` validation. For `order.get`, `order.amend-preview`, and `order.cancel-preview`, a syntactically valid `orderId` or `clientOrderId` is checked through RapidX readback; missing or non-open orders return `NOT_FOUND` or `BLOCKED` depending on the observed state.
+Order identifiers use two validation layers. If `orderId` is provided, RapidX validates it locally as a 16-digit numeric id and returns `INVALID_INPUT` before any upstream call when the format is wrong. If `clientOrderId` is provided instead, do not apply `orderId` validation. For `order.query`, `order.replace-preview`, and `order.cancel-preview`, a syntactically valid `orderId` or `clientOrderId` is checked through RapidX readback; missing or non-open orders return `NOT_FOUND` or `BLOCKED` depending on the observed state.
 
 For automation, keep preview-first execution. Set `automationMode=true` and pass the user's exact `automationConsentText` only when the user has explicitly enabled RapidX automation mode in chat. The preview response still returns `confirmation.submitToken`; automation mode only means the agent may use that submit token without asking for another per-order chat confirmation within the authorized scope.
 
-For TPSL or conditional algo orders, use `rapidx/trade/preview` with `targetCapabilityId="algo.place"`, then submit `rapidx/algo/place`. `conditionType="ENTIRE_CLOSE_POSITION"` may use `orderType="MARKET"` without `quantity` or `amount`; provide at least one take-profit or stop-loss trigger and verify with `rapidx/algo/list`.
+For TPSL or conditional algo orders, use `rapidx/trade/preview` with `targetCapabilityId="algo.place"`, then submit `rapidx/algo/place`. `conditionType="ENTIRE_CLOSE_POSITION"` may use `orderType="MARKET"` without `quantity` or `amount`; provide at least one take-profit or stop-loss trigger and verify with `rapidx/algo/open-orders`.
 
 ## Result Statuses
 

package/packages/distribution/docs/trading-verification.md

@@ -10,7 +10,7 @@ The expected flow is:
 4. internal preview with `maxNotional`
 5. post-only limit submit
 6. order query
-7. amend when supported
+7. replace check when supported
 8. cancel
 9. cleanup-check
 

package/packages/distribution/manifests/offline-manifest.json

@@ -1,25 +1,25 @@
 {
-  "version": "1.0.30",
+  "version": "1.0.32",
   "artifacts": [
     {
       "name": "rapidx-mcp-registry",
       "path": "packages/distribution/registry/rapidx.mcp.json",
       "channel": "offline",
-      "checksum": "sha256:ad2ef7cf5eae5cadf3d6901574a93219a90dd2b53f0412ee354984ed30edf004",
+      "checksum": "sha256:b75ee5a765902c45f13614cdaf906633590456480fe91174ecee2422048aaf93",
       "status": "ready"
     },
     {
       "name": "rapidx-quickstart-doc",
       "path": "packages/distribution/docs/quickstart.md",
       "channel": "offline",
-      "checksum": "sha256:f1771cbc6e3da39b47afac839ca89fc063bede11ac9d8078b215145953c0145c",
+      "checksum": "sha256:e7cb18db9ce37a94ff1489d951f23b5f0407fd9e1f28f47f8ec13681f5760ccc",
       "status": "ready"
     },
     {
       "name": "rapidx-tools-doc",
       "path": "packages/distribution/docs/tools.md",
       "channel": "offline",
-      "checksum": "sha256:fc80e63eabc8407c74b01ed707187505c90497af53a25f201c07e13ef948bf18",
+      "checksum": "sha256:d7e378d95127c2c62bb8db3a58cfa8a5f80ab2cf523ee530144ddfb9cca7bd96",
       "status": "ready"
     }
   ]

package/packages/distribution/registry/rapidx.mcp.json

@@ -1,7 +1,7 @@
 {
   "name": "rapidx",
   "packageName": "@liquiditytech/rapidx-cli",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "command": "rapidx",
   "args": ["mcp", "serve"],
   "launchCommand": "rapidx",