@liquiditytech/rapidx-cli 1.0.31 → 1.0.33

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/commands/update.js

@@ -13,6 +13,9 @@ export async function runUpdateCommand(action, input) {
     if (typeof input.maxCacheAgeSeconds === "number") {
         updateInput.maxCacheAgeSeconds = input.maxCacheAgeSeconds;
     }
+    if (typeof input.installedSkillsVersion === "string") {
+        updateInput.installedSkillsVersion = input.installedSkillsVersion;
+    }
     const result = await checkForUpdate(updateInput);
     return ok(result, "rapidx update check --json", envelopeStatusForUpdate(result.status));
 }

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.5";
+export const RAPIDX_SKILLS_VERSION = "1.0.8";
 export const RAPIDX_SKILLS_SCHEMA_VERSION = "1.0.0";
 export function buildCompatibilityReport(input = {}) {
     const checks = [